source: git/Singular/ipassign.cc @ 810491

fieker-DuValspielwiese
Last change on this file since 810491 was 810491, checked in by Oleksandr Motsak <motsak@…>, 10 years ago
Fix including "libpolys/" and removal of unnecessary header includes + minor cleanup
  • Property mode set to 100644
File size: 47.1 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT: interpreter:
6*           assignment of expressions and lists to objects or lists
7*/
8
9#include <stdlib.h>
10#include <string.h>
11#include <ctype.h>
12
13
14#include <kernel/mod2.h>
15
16#include <misc/auxiliary.h>
17#include <omalloc/omalloc.h>
18
19#define TRANSEXT_PRIVATES
20#include <polys/ext_fields/transext.h>
21
22#include <misc/options.h>
23#include <misc/intvec.h>
24
25#include <coeffs/coeffs.h>
26#include <coeffs/numbers.h>
27#include <coeffs/bigintmat.h>
28
29
30#include <polys/ext_fields/algext.h>
31
32#include <polys/monomials/ring.h>
33#include <polys/matpol.h>
34#include <polys/monomials/maps.h>
35#include <polys/nc/nc.h>
36#include <polys/nc/sca.h>
37#include <polys/prCopy.h>
38
39#include <kernel/polys.h>
40#include <kernel/ideals.h>
41#include <kernel/GBEngine/kstd1.h>
42#include <kernel/oswrapper/timer.h>
43#include <kernel/combinatorics/stairc.h>
44#include <kernel/GBEngine/syz.h>
45
46//#include "weight.h"
47#include "tok.h"
48#include "ipid.h"
49#include "idrec.h"
50#include "subexpr.h"
51#include "lists.h"
52#include "ipconv.h"
53#include "attrib.h"
54#include "links/silink.h"
55#include "ipshell.h"
56#include "blackbox.h"
57
58#include <Singular/number2.h>
59
60
61/*=================== proc =================*/
62static BOOLEAN jjECHO(leftv, leftv a)
63{
64  si_echo=(int)((long)(a->Data()));
65  return FALSE;
66}
67static BOOLEAN jjPRINTLEVEL(leftv, leftv a)
68{
69  printlevel=(int)((long)(a->Data()));
70  return FALSE;
71}
72static BOOLEAN jjCOLMAX(leftv, leftv a)
73{
74  colmax=(int)((long)(a->Data()));
75  return FALSE;
76}
77static BOOLEAN jjTIMER(leftv, leftv a)
78{
79  timerv=(int)((long)(a->Data()));
80  initTimer();
81  return FALSE;
82}
83#ifdef HAVE_GETTIMEOFDAY
84static BOOLEAN jjRTIMER(leftv, leftv a)
85{
86  rtimerv=(int)((long)(a->Data()));
87  initRTimer();
88  return FALSE;
89}
90#endif
91static BOOLEAN jjMAXDEG(leftv, leftv a)
92{
93  Kstd1_deg=(int)((long)(a->Data()));
94  if (Kstd1_deg!=0)
95    si_opt_1 |=Sy_bit(OPT_DEGBOUND);
96  else
97    si_opt_1 &=(~Sy_bit(OPT_DEGBOUND));
98  return FALSE;
99}
100static BOOLEAN jjMAXMULT(leftv, leftv a)
101{
102  Kstd1_mu=(int)((long)(a->Data()));
103  if (Kstd1_mu!=0)
104    si_opt_1 |=Sy_bit(OPT_MULTBOUND);
105  else
106    si_opt_1 &=(~Sy_bit(OPT_MULTBOUND));
107  return FALSE;
108}
109static BOOLEAN jjTRACE(leftv, leftv a)
110{
111  traceit=(int)((long)(a->Data()));
112  return FALSE;
113}
114static BOOLEAN jjSHORTOUT(leftv, leftv a)
115{
116  if (currRing != NULL)
117  {
118    BOOLEAN shortOut = (BOOLEAN)((long)a->Data());
119#if HAVE_CAN_SHORT_OUT
120    if (!shortOut)
121      currRing->ShortOut = 0;
122    else
123    {
124      if (currRing->CanShortOut)
125        currRing->ShortOut = 1;
126    }
127#else
128    currRing->ShortOut = shortOut;
129    coeffs cf = currRing->cf;
130    while (nCoeff_is_Extension(cf)) {
131      cf->extRing->ShortOut = shortOut;
132      assume(cf->extRing != NULL);
133      cf = cf->extRing->cf;
134    }
135#endif
136  }
137  return FALSE;
138}
139static void jjMINPOLY_red(idhdl h)
140{
141  switch(IDTYP(h))
142  {
143    case NUMBER_CMD:
144    {
145      number n=(number)IDDATA(h);
146      number one = nInit(1);
147      number nn=nMult(n,one);
148      nDelete(&n);nDelete(&one);
149      IDDATA(h)=(char*)nn;
150      break;
151    }
152    case VECTOR_CMD:
153    case POLY_CMD:
154    {
155      poly p=(poly)IDDATA(h);
156      IDDATA(h)=(char*)p_MinPolyNormalize(p, currRing);
157      break;
158    }
159    case IDEAL_CMD:
160    case MODUL_CMD:
161    case MAP_CMD:
162    case MATRIX_CMD:
163    {
164      int i;
165      ideal I=(ideal)IDDATA(h);
166      for(i=IDELEMS(I)-1;i>=0;i--)
167             I->m[i]=p_MinPolyNormalize(I->m[i], currRing);
168      break;
169    }
170    case LIST_CMD:
171    {
172      lists L=(lists)IDDATA(h);
173      int i=L->nr;
174      for(;i>=0;i--)
175      {
176        jjMINPOLY_red((idhdl)&(L->m[i]));
177      }
178    }
179    default:
180    //case RESOLUTION_CMD:
181       Werror("type %d too complex...set minpoly before",IDTYP(h)); break;
182  }
183}
184static BOOLEAN jjMINPOLY(leftv, leftv a)
185{
186  if( !nCoeff_is_transExt(currRing->cf) && (currRing->idroot == NULL) && n_IsZero((number)a->Data(), currRing->cf) )
187  {
188#ifndef SING_NDEBUG
189    WarnS("Set minpoly over non-transcendental ground field to 0?!");
190    Warn("in >>%s<<",my_yylinebuf);
191#endif
192    return FALSE;
193  }
194
195
196  if ( !nCoeff_is_transExt(currRing->cf) )
197  {
198    WarnS("Trying to set minpoly over non-transcendental ground field...");
199    if(!nCoeff_is_algExt(currRing->cf) )
200    {
201      WerrorS("cannot set minpoly for these coeffients");
202      return TRUE;
203    }
204  }
205  if ((rVar(currRing->cf->extRing)!=1)
206  && !n_IsZero((number)a->Data(), currRing->cf) )
207  {
208    WerrorS("only univarite minpoly allowed");
209    return TRUE;
210  }
211
212  if ( currRing->idroot != NULL )
213  {
214//    return TRUE;
215#ifndef SING_NDEBUG
216    idhdl p = currRing->idroot;
217
218    WarnS("no minpoly allowed if there are local objects belonging to the basering: ");
219
220    while(p != NULL)
221    {
222      PrintS(p->String(TRUE)); PrintLn();
223      p = p->next;
224    }
225#endif
226  }
227
228//  assume (currRing->idroot==NULL);
229
230  number p = (number)a->CopyD(NUMBER_CMD);
231  n_Normalize(p, currRing->cf);
232
233  if (n_IsZero(p, currRing->cf))
234  {
235    n_Delete(&p, currRing);
236    if( nCoeff_is_transExt(currRing->cf) )
237    {
238#ifndef SING_NDEBUG
239      WarnS("minpoly is already 0...");
240#endif
241      return FALSE;
242    }
243    WarnS("cannot set minpoly to 0 / alg. extension?");
244    return TRUE;
245  }
246
247  // remove all object currently in the ring
248  while(currRing->idroot!=NULL)
249  {
250#ifndef SING_NDEBUG
251    Warn("killing a local object due to minpoly change: %s", IDID(currRing->idroot));
252#endif
253    killhdl2(currRing->idroot,&(currRing->idroot),currRing);
254  }
255
256  AlgExtInfo A;
257
258  A.r = rCopy(currRing->cf->extRing); // Copy  ground field!
259  // if minpoly was already set:
260  if( currRing->cf->extRing->qideal != NULL ) id_Delete(&(A.r->qideal),A.r);
261  ideal q = idInit(1,1);
262  if ((p==NULL) ||(NUM((fraction)p)==NULL))
263  {
264    Werror("Could not construct the alg. extension: minpoly==0");
265    // cleanup A: TODO
266    rDelete( A.r );
267    return TRUE;
268  }
269  if (DEN((fraction)(p)) != NULL) // minpoly must be a fraction with poly numerator...!!
270  {
271    poly z=NUM((fraction)p);
272    poly n=DEN((fraction)(p));
273    z=p_Mult_nn(z,pGetCoeff(n),currRing->cf->extRing);
274    NUM((fraction)p)=z;
275    DEN((fraction)(p))=NULL;
276    p_Delete(&n,currRing->cf->extRing);
277  }
278
279  q->m[0] = NUM((fraction)p);
280  A.r->qideal = q;
281
282#if 0
283  PrintS("\nTrying to conver the currRing into an algebraic field: ");
284  PrintS("Ground poly. ring: \n");
285  rWrite( A.r );
286  PrintS("\nGiven MinPOLY: ");
287  p_Write( A.i->m[0], A.r );
288#endif
289
290  // :(
291//  NUM((fractionObject *)p) = NULL; // makes 0/ NULL fraction - which should not happen!
292//  n_Delete(&p, currRing->cf); // doesn't expect 0/ NULL :(
293  if(true)
294  {
295    extern omBin fractionObjectBin;
296    NUM((fractionObject *)p) = NULL; // not necessary, but still...
297    omFreeBin((ADDRESS)p, fractionObjectBin);
298  }
299
300
301  coeffs new_cf = nInitChar(n_algExt, &A);
302
303  if (new_cf==NULL)
304  {
305    Werror("Could not construct the alg. extension: llegal minpoly?");
306    // cleanup A: TODO
307    rDelete( A.r );
308    return TRUE;
309  }
310  else
311  {
312    nKillChar(currRing->cf); currRing->cf=new_cf;
313  }
314
315  return FALSE;
316}
317static BOOLEAN jjNOETHER(leftv, leftv a)
318{
319  poly p=(poly)a->CopyD(POLY_CMD);
320  pDelete(&(currRing->ppNoether));
321  (currRing->ppNoether)=p;
322  return FALSE;
323}
324/*=================== proc =================*/
325static void jiAssignAttr(leftv l,leftv r)
326{
327  // get the attribute of th right side
328  // and set it to l
329  leftv rv=r->LData();
330  if (rv!=NULL)
331  {
332    if (rv->e==NULL)
333    {
334      if (rv->attribute!=NULL)
335      {
336        attr la;
337        if (r->rtyp!=IDHDL)
338        {
339          la=rv->attribute;
340          rv->attribute=NULL;
341        }
342        else
343        {
344          la=rv->attribute->Copy();
345        }
346        l->attribute=la;
347      }
348      l->flag=rv->flag;
349    }
350  }
351  if (l->rtyp==IDHDL)
352  {
353    idhdl h=(idhdl)l->data;
354    IDATTR(h)=l->attribute;
355    IDFLAG(h)=l->flag;
356  }
357}
358static BOOLEAN jiA_INT(leftv res, leftv a, Subexpr e)
359{
360  if (e==NULL)
361  {
362    res->data=(void *)a->Data();
363    jiAssignAttr(res,a);
364  }
365  else
366  {
367    int i=e->start-1;
368    if (i<0)
369    {
370      Werror("index[%d] must be positive",i+1);
371      return TRUE;
372    }
373    intvec *iv=(intvec *)res->data;
374    if (e->next==NULL)
375    {
376      if (i>=iv->length())
377      {
378        intvec *iv1=new intvec(i+1);
379        (*iv1)[i]=(int)((long)(a->Data()));
380        intvec *ivn=ivAdd(iv,iv1);
381        delete iv;
382        delete iv1;
383        res->data=(void *)ivn;
384      }
385      else
386        (*iv)[i]=(int)((long)(a->Data()));
387    }
388    else
389    {
390      int c=e->next->start;
391      if ((i>=iv->rows())||(c<1)||(c>iv->cols()))
392      {
393        Werror("wrong range [%d,%d] in intmat %s(%d,%d)",i+1,c,res->Name(),iv->rows(),iv->cols());
394        return TRUE;
395      }
396      else
397        IMATELEM(*iv,i+1,c) = (int)((long)(a->Data()));
398    }
399  }
400  return FALSE;
401}
402static BOOLEAN jiA_NUMBER(leftv res, leftv a, Subexpr)
403{
404  number p=(number)a->CopyD(NUMBER_CMD);
405  if (res->data!=NULL) nDelete((number *)&res->data);
406  nNormalize(p);
407  res->data=(void *)p;
408  jiAssignAttr(res,a);
409  return FALSE;
410}
411#ifdef SINGULAR_4_1
412static BOOLEAN jiA_NUMBER2(leftv res, leftv a, Subexpr e)
413{
414  number2 n=(number2)a->CopyD(CNUMBER_CMD);
415  if (e==NULL)
416  {
417    if (res->data!=NULL)
418    {
419      number2 nn=(number2)res->data;
420      n2Delete(nn);
421    }
422    res->data=(void *)n;
423    jiAssignAttr(res,a);
424  }
425  else
426  {
427    int i=e->start-1;
428    if (i<0)
429    {
430      Werror("index[%d] must be positive",i+1);
431      return TRUE;
432    }
433    bigintmat *iv=(bigintmat *)res->data;
434    if (e->next==NULL)
435    {
436      WerrorS("only one index given");
437      return TRUE;
438    }
439    else
440    {
441      int c=e->next->start;
442      if ((i>=iv->rows())||(c<1)||(c>iv->cols()))
443      {
444        Werror("wrong range [%d,%d] in cmatrix %s(%d,%d)",i+1,c,res->Name(),iv->rows(),iv->cols());
445        return TRUE;
446      }
447      else if (iv->basecoeffs()==n->cf)
448      {
449        n_Delete((number *)&BIMATELEM(*iv,i+1,c),iv->basecoeffs());
450        BIMATELEM(*iv,i+1,c) = n->n;
451      }
452      else
453      {
454        WerrorS("different base");
455        return TRUE;
456      }
457    }
458  }
459  jiAssignAttr(res,a);
460  return FALSE;
461}
462#endif
463static BOOLEAN jiA_BIGINT(leftv res, leftv a, Subexpr e)
464{
465  number p=(number)a->CopyD(BIGINT_CMD);
466  if (e==NULL)
467  {
468    if (res->data!=NULL) n_Delete((number *)&res->data,coeffs_BIGINT);
469    res->data=(void *)p;
470  }
471  else
472  {
473    int i=e->start-1;
474    if (i<0)
475    {
476      Werror("index[%d] must be positive",i+1);
477      return TRUE;
478    }
479    bigintmat *iv=(bigintmat *)res->data;
480    if (e->next==NULL)
481    {
482      WerrorS("only one index given");
483      return TRUE;
484    }
485    else
486    {
487      int c=e->next->start;
488      if ((i>=iv->rows())||(c<1)||(c>iv->cols()))
489      {
490        Werror("wrong range [%d,%d] in bigintmat %s(%d,%d)",i+1,c,res->Name(),iv->rows(),iv->cols());
491        return TRUE;
492      }
493      else
494      {
495        n_Delete((number *)&BIMATELEM(*iv,i+1,c),iv->basecoeffs());
496        BIMATELEM(*iv,i+1,c) = p;
497      }
498    }
499  }
500  jiAssignAttr(res,a);
501  return FALSE;
502}
503static BOOLEAN jiA_LIST_RES(leftv res, leftv a,Subexpr)
504{
505  syStrategy r=(syStrategy)a->CopyD(RESOLUTION_CMD);
506  if (res->data!=NULL) ((lists)res->data)->Clean();
507  int add_row_shift = 0;
508  intvec *weights=(intvec*)atGet(a,"isHomog",INTVEC_CMD);
509  if (weights!=NULL)  add_row_shift=weights->min_in();
510  res->data=(void *)syConvRes(r,TRUE,add_row_shift);
511  //jiAssignAttr(res,a);
512  return FALSE;
513}
514static BOOLEAN jiA_LIST(leftv res, leftv a,Subexpr)
515{
516  lists l=(lists)a->CopyD(LIST_CMD);
517  if (res->data!=NULL) ((lists)res->data)->Clean();
518  res->data=(void *)l;
519  jiAssignAttr(res,a);
520  return FALSE;
521}
522static BOOLEAN jiA_POLY(leftv res, leftv a,Subexpr e)
523{
524  poly p=(poly)a->CopyD(POLY_CMD);
525  pNormalize(p);
526  if (e==NULL)
527  {
528    if (res->data!=NULL) pDelete((poly*)&res->data);
529    res->data=(void*)p;
530    jiAssignAttr(res,a);
531    if (TEST_V_QRING && (currRing->qideal!=NULL) && (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingP(res);
532  }
533  else
534  {
535    int i,j;
536    matrix m=(matrix)res->data;
537    i=e->start;
538    if (e->next==NULL)
539    {
540      j=i; i=1;
541      // for all ideal like data types: check indices
542      if (j>MATCOLS(m))
543      {
544        if (TEST_V_ALLWARN)
545        {
546          Warn("increase ideal %d -> %d in %s",MATCOLS(m),j,my_yylinebuf);
547        }
548        pEnlargeSet(&(m->m),MATCOLS(m),j-MATCOLS(m));
549        MATCOLS(m)=j;
550      }
551      else if (j<=0)
552      {
553        Werror("index[%d] must be positive",j/*e->start*/);
554        return TRUE;
555      }
556    }
557    else
558    {
559      // for matrices: indices are correct (see ipExprArith3(..,'['..) )
560      j=e->next->start;
561    }
562    pDelete(&MATELEM(m,i,j));
563    MATELEM(m,i,j)=p;
564    /* for module: update rank */
565    if ((p!=NULL) && (pGetComp(p)!=0))
566    {
567      m->rank=si_max(m->rank,pMaxComp(p));
568    }
569    if (TEST_V_QRING) jjNormalizeQRingP(res);
570  }
571  return FALSE;
572}
573static BOOLEAN jiA_1x1INTMAT(leftv res, leftv a,Subexpr e)
574{
575  if (/*(*/ res->rtyp!=INTMAT_CMD /*)*/) /*|| (e!=NULL) - TRUE because of type int */
576  {
577    // no error message: assignment simply fails
578    return TRUE;
579  }
580  intvec* am=(intvec*)a->CopyD(INTMAT_CMD);
581  if ((am->rows()!=1) || (am->cols()!=1))
582  {
583    WerrorS("must be 1x1 intmat");
584    delete am;
585    return TRUE;
586  }
587  intvec* m=(intvec *)res->data;
588  // indices are correct (see ipExprArith3(..,'['..) )
589  int i=e->start;
590  int j=e->next->start;
591  IMATELEM(*m,i,j)=IMATELEM(*am,1,1);
592  delete am;
593  return FALSE;
594}
595static BOOLEAN jiA_1x1MATRIX(leftv res, leftv a,Subexpr e)
596{
597  if (/*(*/ res->rtyp!=MATRIX_CMD /*)*/) /*|| (e!=NULL) - TRUE because of type poly */
598  {
599    // no error message: assignment simply fails
600    return TRUE;
601  }
602  matrix am=(matrix)a->CopyD(MATRIX_CMD);
603  if ((MATROWS(am)!=1) || (MATCOLS(am)!=1))
604  {
605    WerrorS("must be 1x1 matrix");
606    idDelete((ideal *)&am);
607    return TRUE;
608  }
609  matrix m=(matrix)res->data;
610  // indices are correct (see ipExprArith3(..,'['..) )
611  int i=e->start;
612  int j=e->next->start;
613  pDelete(&MATELEM(m,i,j));
614  pNormalize(MATELEM(am,1,1));
615  MATELEM(m,i,j)=MATELEM(am,1,1);
616  MATELEM(am,1,1)=NULL;
617  idDelete((ideal *)&am);
618  return FALSE;
619}
620static BOOLEAN jiA_STRING(leftv res, leftv a, Subexpr e)
621{
622  if (e==NULL)
623  {
624    void* tmp = res->data;
625    res->data=(void *)a->CopyD(STRING_CMD);
626    jiAssignAttr(res,a);
627    omfree(tmp);
628  }
629  else
630  {
631    char *s=(char *)res->data;
632    if ((e->start>0)&&(e->start<=(int)strlen(s)))
633      s[e->start-1]=(char)(*((char *)a->Data()));
634    else
635    {
636      Werror("string index %d out of range 1..%d",e->start,(int)strlen(s));
637      return TRUE;
638    }
639  }
640  return FALSE;
641}
642static BOOLEAN jiA_PROC(leftv res, leftv a, Subexpr)
643{
644  extern procinfo *iiInitSingularProcinfo(procinfo *pi, const char *libname,
645                                          const char *procname, int line,
646                                          long pos, BOOLEAN pstatic=FALSE);
647  if(res->data!=NULL) piKill((procinfo *)res->data);
648  if(a->Typ()==STRING_CMD)
649  {
650    res->data = (void *)omAlloc0Bin(procinfo_bin);
651    ((procinfo *)(res->data))->language=LANG_NONE;
652    iiInitSingularProcinfo((procinfo *)res->data,"",res->name,0,0);
653    ((procinfo *)res->data)->data.s.body=(char *)a->CopyD(STRING_CMD);
654  }
655  else
656    res->data=(void *)a->CopyD(PROC_CMD);
657  jiAssignAttr(res,a);
658  return FALSE;
659}
660static BOOLEAN jiA_INTVEC(leftv res, leftv a, Subexpr)
661{
662  //if ((res->data==NULL) || (res->Typ()==a->Typ()))
663  {
664    if (res->data!=NULL) delete ((intvec *)res->data);
665    res->data=(void *)a->CopyD(INTVEC_CMD);
666    jiAssignAttr(res,a);
667    return FALSE;
668  }
669#if 0
670  else
671  {
672    intvec *r=(intvec *)(res->data);
673    intvec *s=(intvec *)(a->Data());
674    int i=si_min(r->length(), s->length())-1;
675    for(;i>=0;i--)
676    {
677      (*r)[i]=(*s)[i];
678    }
679    return FALSE; //(r->length()< s->length());
680  }
681#endif
682}
683static BOOLEAN jiA_BIGINTMAT(leftv res, leftv a, Subexpr)
684{
685  if (res->data!=NULL) delete ((bigintmat *)res->data);
686  res->data=(void *)a->CopyD(BIGINTMAT_CMD);
687  jiAssignAttr(res,a);
688  return FALSE;
689}
690static BOOLEAN jiA_IDEAL(leftv res, leftv a, Subexpr)
691{
692  if (res->data!=NULL) idDelete((ideal*)&res->data);
693  res->data=(void *)a->CopyD(MATRIX_CMD);
694  if (a->rtyp==IDHDL) id_Normalize((ideal)a->Data(), currRing);
695  else                id_Normalize((ideal)res->data, currRing);
696  jiAssignAttr(res,a);
697  if (((res->rtyp==IDEAL_CMD)||(res->rtyp==MODUL_CMD))
698  && (IDELEMS((ideal)(res->data))==1)
699  && (currRing->qideal==NULL)
700  && (!rIsPluralRing(currRing))
701  )
702  {
703    setFlag(res,FLAG_STD);
704  }
705  if (TEST_V_QRING && (currRing->qideal!=NULL)&& (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingId(res);
706  return FALSE;
707}
708static BOOLEAN jiA_RESOLUTION(leftv res, leftv a, Subexpr)
709{
710  if (res->data!=NULL) syKillComputation((syStrategy)res->data);
711  res->data=(void *)a->CopyD(RESOLUTION_CMD);
712  jiAssignAttr(res,a);
713  return FALSE;
714}
715static BOOLEAN jiA_MODUL_P(leftv res, leftv a, Subexpr)
716{
717  if (res->data!=NULL) idDelete((ideal*)&res->data);
718  ideal I=idInit(1,1);
719  I->m[0]=(poly)a->CopyD(POLY_CMD);
720  if (I->m[0]!=NULL) pSetCompP(I->m[0],1);
721  pNormalize(I->m[0]);
722  res->data=(void *)I;
723  if (TEST_V_QRING && (currRing->qideal!=NULL))
724  {
725    if (hasFlag(a,FLAG_QRING)) setFlag(res,FLAG_QRING);
726    else                       jjNormalizeQRingId(res);
727  }
728  return FALSE;
729}
730static BOOLEAN jiA_IDEAL_M(leftv res, leftv a, Subexpr)
731{
732  if (res->data!=NULL) idDelete((ideal*)&res->data);
733  matrix m=(matrix)a->CopyD(MATRIX_CMD);
734  IDELEMS((ideal)m)=MATROWS(m)*MATCOLS(m);
735  ((ideal)m)->rank=1;
736  MATROWS(m)=1;
737  id_Normalize((ideal)m, currRing);
738  res->data=(void *)m;
739  if (TEST_V_QRING && (currRing->qideal!=NULL)) jjNormalizeQRingId(res);
740  return FALSE;
741}
742static BOOLEAN jiA_LINK(leftv res, leftv a, Subexpr)
743{
744  si_link l=(si_link)res->data;
745
746  if (l!=NULL) slCleanUp(l);
747
748  if (a->Typ() == STRING_CMD)
749  {
750    if (l == NULL)
751    {
752      l = (si_link) omAlloc0Bin(sip_link_bin);
753      res->data = (void *) l;
754    }
755    return slInit(l, (char *) a->Data());
756  }
757  else if (a->Typ() == LINK_CMD)
758  {
759    if (l != NULL) omFreeBin(l, sip_link_bin);
760    res->data = slCopy((si_link)a->Data());
761    return FALSE;
762  }
763  return TRUE;
764}
765// assign map -> map
766static BOOLEAN jiA_MAP(leftv res, leftv a, Subexpr)
767{
768  if (res->data!=NULL)
769  {
770    omFree((ADDRESS)((map)res->data)->preimage);
771    ((map)res->data)->preimage=NULL;
772    idDelete((ideal*)&res->data);
773  }
774  res->data=(void *)a->CopyD(MAP_CMD);
775  jiAssignAttr(res,a);
776  return FALSE;
777}
778// assign ideal -> map
779static BOOLEAN jiA_MAP_ID(leftv res, leftv a, Subexpr)
780{
781  map f=(map)res->data;
782  char *rn=f->preimage; // save the old/already assigned preimage ring name
783  f->preimage=NULL;
784  idDelete((ideal *)&f);
785  res->data=(void *)a->CopyD(IDEAL_CMD);
786  f=(map)res->data;
787  id_Normalize((ideal)f, currRing);
788  f->preimage = rn;
789  return FALSE;
790}
791static BOOLEAN jiA_QRING(leftv res, leftv a,Subexpr e)
792{
793  // the follwing can only happen, if:
794  //   - the left side is of type qring AND not an id
795  if ((e!=NULL)||(res->rtyp!=IDHDL))
796  {
797    WerrorS("qring_id expected");
798    return TRUE;
799  }
800  assume(res->Data()==NULL);
801
802  coeffs newcf = currRing->cf;
803#ifdef HAVE_RINGS
804  ideal id = (ideal)a->Data(); //?
805  const int cpos = idPosConstant(id);
806  if(rField_is_Ring(currRing))
807    if (cpos >= 0)
808    {
809        newcf = n_CoeffRingQuot1(p_GetCoeff(id->m[cpos], currRing), currRing->cf);
810        if(newcf == NULL)
811          return TRUE;
812    }
813#endif
814  //qr=(ring)res->Data();
815  //if (qr!=NULL) omFreeBin((ADDRESS)qr, ip_sring_bin);
816  ring qr = rCopy(currRing);
817  assume(qr->cf == currRing->cf);
818
819  if ( qr->cf != newcf )
820  {
821    nKillChar ( qr->cf ); // ???
822    qr->cf = newcf;
823  }
824                 // we have to fill it, but the copy also allocates space
825  idhdl h=(idhdl)res->data; // we have res->rtyp==IDHDL
826  IDRING(h)=qr;
827
828  ideal qid;
829
830#ifdef HAVE_RINGS
831  if((rField_is_Ring(currRing)) && (cpos != -1))
832    {
833      int i, j;
834      int *perm = (int *)omAlloc0((qr->N+1)*sizeof(int));
835
836      for(i=qr->N;i>0;i--)
837        perm[i]=i;
838
839      nMapFunc nMap = n_SetMap(currRing->cf, newcf);
840      qid = idInit(IDELEMS(id)-1,1);
841      for(i = 0, j = 0; i<IDELEMS(id); i++)
842        if( i != cpos )
843          qid->m[j++] = p_PermPoly(id->m[i], perm, currRing, qr, nMap, NULL, 0);
844    }
845    else
846#endif
847      qid = idrCopyR(id,currRing,qr);
848
849  idSkipZeroes(qid);
850  //idPrint(qid);
851  if ((idElem(qid)>1) || rIsSCA(currRing) || (currRing->qideal!=NULL))
852    assumeStdFlag(a);
853
854  if (currRing->qideal!=NULL) /* we are already in a qring! */
855  {
856    ideal tmp=idSimpleAdd(qid,currRing->qideal);
857    // both ideals should be GB, so dSimpleAdd is sufficient
858    idDelete(&qid);
859    qid=tmp;
860    // delete the qr copy of quotient ideal!!!
861    idDelete(&qr->qideal);
862  }
863  if (idElem(qid)==0)
864  {
865    qr->qideal = NULL;
866    id_Delete(&qid,currRing);
867    IDTYP(h)=RING_CMD;
868  }
869  else
870    qr->qideal = qid;
871
872  // qr is a copy of currRing with the new qideal!
873  #ifdef HAVE_PLURAL
874  if(rIsPluralRing(currRing) &&(qr->qideal!=NULL))
875  {
876    if (!hasFlag(a,FLAG_TWOSTD))
877    {
878      Warn("%s is no twosided standard basis",a->Name());
879    }
880
881    if( nc_SetupQuotient(qr, currRing) )
882    {
883//      WarnS("error in nc_SetupQuotient");
884    }
885  }
886  #endif
887  //rWrite(qr);
888  rSetHdl((idhdl)res->data);
889  return FALSE;
890}
891
892static BOOLEAN jiA_RING(leftv res, leftv a, Subexpr e)
893{
894  BOOLEAN have_id=TRUE;
895  if ((e!=NULL)||(res->rtyp!=IDHDL))
896  {
897    //WerrorS("id expected");
898    //return TRUE;
899    have_id=FALSE;
900  }
901  ring r=(ring)a->Data();
902  if (have_id)
903  {
904    idhdl rl=(idhdl)res->data;
905    if (IDRING(rl)!=NULL) rKill(rl);
906    IDRING(rl)=r;
907    if ((IDLEV((idhdl)a->data)!=myynest) && (r==currRing))
908      currRingHdl=(idhdl)res->data;
909  }
910  else
911  {
912    if (e==NULL) res->data=(char *)r;
913    else
914    {
915      WerrorS("id expected");
916      return TRUE;
917    }
918  }
919  r->ref++;
920  jiAssignAttr(res,a);
921  return FALSE;
922}
923static BOOLEAN jiA_PACKAGE(leftv res, leftv a, Subexpr)
924{
925  res->data=(void *)a->CopyD(PACKAGE_CMD);
926  jiAssignAttr(res,a);
927  return FALSE;
928}
929static BOOLEAN jiA_DEF(leftv res, leftv a, Subexpr e)
930{
931  res->data=(void *)0;
932  return FALSE;
933}
934#ifdef SINGULAR_4_1
935static BOOLEAN jiA_CRING(leftv res, leftv a, Subexpr e)
936{
937  res->data=(void *)a->CopyD(CRING_CMD);
938  jiAssignAttr(res,a);
939  return FALSE;
940}
941#endif
942
943/*=================== table =================*/
944#define IPASSIGN
945#define D(A)     A
946#define NULL_VAL NULL
947#include "table.h"
948/*=================== operations ============================*/
949/*2
950* assign a = b
951*/
952static BOOLEAN jiAssign_1(leftv l, leftv r)
953{
954  int rt=r->Typ();
955  if (rt==0)
956  {
957    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
958    return TRUE;
959  }
960
961  int lt=l->Typ();
962  if (/*(*/ lt==0 /*)*/) /*&&(l->name!=NULL)*/
963  {
964    if (!errorreported) Werror("left side `%s` is undefined",l->Fullname());
965    return TRUE;
966  }
967  if(rt==NONE)
968  {
969    WarnS("right side is not a datum, assignment ignored");
970    // if (!errorreported)
971    //   WerrorS("right side is not a datum");
972    //return TRUE;
973    return FALSE;
974  }
975
976  int i=0;
977  if (lt==DEF_CMD)
978  {
979    if (TEST_V_ALLWARN
980    && (rt!=RING_CMD)
981    && (rt!=QRING_CMD)
982    && (l->name!=NULL)
983    && (l->e==NULL)
984    && (iiCurrArgs==NULL) /* not in proc header */
985    )
986    {
987      Warn("use `%s` instead of `def`",Tok2Cmdname(rt));
988    }
989    if (l->rtyp==IDHDL)
990    {
991      IDTYP((idhdl)l->data)=rt;
992    }
993    else if (l->name!=NULL)
994    {
995      sleftv ll;
996      iiDeclCommand(&ll,l,myynest,rt,&IDROOT);
997      memcpy(l,&ll,sizeof(sleftv));
998    }
999    else
1000    {
1001      l->rtyp=rt;
1002    }
1003    lt=rt;
1004  }
1005  else
1006  {
1007    if ((l->data==r->data)&&(l->e==NULL)&&(r->e==NULL))
1008      return FALSE;
1009  }
1010  leftv ld=l;
1011  if ((l->rtyp==IDHDL)&&(lt!=QRING_CMD)&&(lt!=RING_CMD))
1012    ld=(leftv)l->data;
1013  if (lt>MAX_TOK)
1014  {
1015    blackbox *bb=getBlackboxStuff(lt);
1016#ifdef BLACKBOX_DEVEL
1017    Print("bb-assign: bb=%lx\n",bb);
1018#endif
1019    return (bb==NULL) || bb->blackbox_Assign(l,r);
1020  }
1021  while (((dAssign[i].res!=lt)
1022      || (dAssign[i].arg!=rt))
1023    && (dAssign[i].res!=0)) i++;
1024  if (dAssign[i].res!=0)
1025  {
1026    if (traceit&TRACE_ASSIGN) Print("assign %s=%s\n",Tok2Cmdname(lt),Tok2Cmdname(rt));
1027    BOOLEAN b;
1028    b=dAssign[i].p(ld,r,l->e);
1029    if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
1030    {
1031      l->flag=ld->flag;
1032      l->attribute=ld->attribute;
1033    }
1034    return b;
1035  }
1036  // implicite type conversion ----------------------------------------------
1037  if (dAssign[i].res==0)
1038  {
1039    int ri;
1040    leftv rn = (leftv)omAlloc0Bin(sleftv_bin);
1041    BOOLEAN failed=FALSE;
1042    i=0;
1043    while ((dAssign[i].res!=lt)
1044      && (dAssign[i].res!=0)) i++;
1045    while (dAssign[i].res==lt)
1046    {
1047      if ((ri=iiTestConvert(rt,dAssign[i].arg))!=0)
1048      {
1049        failed= iiConvert(rt,dAssign[i].arg,ri,r,rn);
1050        if(!failed)
1051        {
1052          failed= dAssign[i].p(ld,rn,l->e);
1053          if (traceit&TRACE_ASSIGN)
1054            Print("assign %s=%s ok? %d\n",Tok2Cmdname(lt),Tok2Cmdname(rn->rtyp),!failed);
1055        }
1056        // everything done, clean up temp. variables
1057        rn->CleanUp();
1058        omFreeBin((ADDRESS)rn, sleftv_bin);
1059        if (failed)
1060        {
1061          // leave loop, goto error handling
1062          break;
1063        }
1064        else
1065        {
1066          if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
1067          {
1068            l->flag=ld->flag;
1069            l->attribute=ld->attribute;
1070          }
1071          // everything ok, return
1072          return FALSE;
1073        }
1074     }
1075     i++;
1076    }
1077    // error handling ---------------------------------------------------
1078    if (!errorreported)
1079    {
1080      if ((l->rtyp==IDHDL) && (l->e==NULL))
1081        Werror("`%s`(%s) = `%s` is not supported",
1082          Tok2Cmdname(lt),l->Name(),Tok2Cmdname(rt));
1083      else
1084         Werror("`%s` = `%s` is not supported"
1085             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
1086      if (BVERBOSE(V_SHOW_USE))
1087      {
1088        i=0;
1089        while ((dAssign[i].res!=lt)
1090          && (dAssign[i].res!=0)) i++;
1091        while (dAssign[i].res==lt)
1092        {
1093          Werror("expected `%s` = `%s`"
1094              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign[i].arg));
1095          i++;
1096        }
1097      }
1098    }
1099  }
1100  return TRUE;
1101}
1102/*2
1103* assign sys_var = val
1104*/
1105static BOOLEAN iiAssign_sys(leftv l, leftv r)
1106{
1107  int rt=r->Typ();
1108
1109  if (rt==0)
1110  {
1111    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
1112    return TRUE;
1113  }
1114  int i=0;
1115  int lt=l->rtyp;
1116  while (((dAssign_sys[i].res!=lt)
1117      || (dAssign_sys[i].arg!=rt))
1118    && (dAssign_sys[i].res!=0)) i++;
1119  if (dAssign_sys[i].res!=0)
1120  {
1121    if (!dAssign_sys[i].p(l,r))
1122    {
1123      // everything ok, clean up
1124      return FALSE;
1125    }
1126  }
1127  // implicite type conversion ----------------------------------------------
1128  if (dAssign_sys[i].res==0)
1129  {
1130    int ri;
1131    leftv rn = (leftv)omAlloc0Bin(sleftv_bin);
1132    BOOLEAN failed=FALSE;
1133    i=0;
1134    while ((dAssign_sys[i].res!=lt)
1135      && (dAssign_sys[i].res!=0)) i++;
1136    while (dAssign_sys[i].res==lt)
1137    {
1138      if ((ri=iiTestConvert(rt,dAssign_sys[i].arg))!=0)
1139      {
1140        failed= ((iiConvert(rt,dAssign_sys[i].arg,ri,r,rn))
1141            || (dAssign_sys[i].p(l,rn)));
1142        // everything done, clean up temp. variables
1143        rn->CleanUp();
1144        omFreeBin((ADDRESS)rn, sleftv_bin);
1145        if (failed)
1146        {
1147          // leave loop, goto error handling
1148          break;
1149        }
1150        else
1151        {
1152          // everything ok, return
1153          return FALSE;
1154        }
1155     }
1156     i++;
1157    }
1158    // error handling ---------------------------------------------------
1159    if(!errorreported)
1160    {
1161      Werror("`%s` = `%s` is not supported"
1162             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
1163      if (BVERBOSE(V_SHOW_USE))
1164      {
1165        i=0;
1166        while ((dAssign_sys[i].res!=lt)
1167          && (dAssign_sys[i].res!=0)) i++;
1168        while (dAssign_sys[i].res==lt)
1169        {
1170          Werror("expected `%s` = `%s`"
1171              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign_sys[i].arg));
1172          i++;
1173        }
1174      }
1175    }
1176  }
1177  return TRUE;
1178}
1179static BOOLEAN jiA_INTVEC_L(leftv l,leftv r)
1180{
1181  /* right side is intvec, left side is list (of int)*/
1182  BOOLEAN nok;
1183  int i=0;
1184  leftv l1=l;
1185  leftv h;
1186  sleftv t;
1187  intvec *iv=(intvec *)r->Data();
1188  memset(&t,0,sizeof(sleftv));
1189  t.rtyp=INT_CMD;
1190  while ((i<iv->length())&&(l!=NULL))
1191  {
1192    t.data=(char *)(long)(*iv)[i];
1193    h=l->next;
1194    l->next=NULL;
1195    nok=jiAssign_1(l,&t);
1196    l->next=h;
1197    if (nok) return TRUE;
1198    i++;
1199    l=h;
1200  }
1201  l1->CleanUp();
1202  r->CleanUp();
1203  return FALSE;
1204}
1205static BOOLEAN jiA_VECTOR_L(leftv l,leftv r)
1206{
1207  /* right side is vector, left side is list (of poly)*/
1208  BOOLEAN nok;
1209  leftv l1=l;
1210  ideal I=idVec2Ideal((poly)r->Data());
1211  leftv h;
1212  sleftv t;
1213  int i=0;
1214  while (l!=NULL)
1215  {
1216    memset(&t,0,sizeof(sleftv));
1217    t.rtyp=POLY_CMD;
1218    if (i>=IDELEMS(I))
1219    {
1220      t.data=NULL;
1221    }
1222    else
1223    {
1224      t.data=(char *)I->m[i];
1225      I->m[i]=NULL;
1226    }
1227    h=l->next;
1228    l->next=NULL;
1229    nok=jiAssign_1(l,&t);
1230    l->next=h;
1231    t.CleanUp();
1232    if (nok)
1233    {
1234      idDelete(&I);
1235      return TRUE;
1236    }
1237    i++;
1238    l=h;
1239  }
1240  idDelete(&I);
1241  l1->CleanUp();
1242  r->CleanUp();
1243  //if (TEST_V_QRING && (currRing->qideal!=NULL)) jjNormalizeQRingP(l);
1244  return FALSE;
1245}
1246static BOOLEAN jjA_L_LIST(leftv l, leftv r)
1247/* left side: list/def, has to be a "real" variable
1248*  right side: expression list
1249*/
1250{
1251  int sl = r->listLength();
1252  lists L=(lists)omAllocBin(slists_bin);
1253  lists oldL;
1254  leftv h=NULL,o_r=r;
1255  int i;
1256  int rt;
1257
1258  L->Init(sl);
1259  for (i=0;i<sl;i++)
1260  {
1261    if (h!=NULL) { /* e.g. not in the first step:
1262                   * h is the pointer to the old sleftv,
1263                   * r is the pointer to the next sleftv
1264                   * (in this moment) */
1265                   h->next=r;
1266                 }
1267    h=r;
1268    r=r->next;
1269    h->next=NULL;
1270    rt=h->Typ();
1271    if ((rt==0)||(rt==NONE)||(rt==DEF_CMD))
1272    {
1273      L->Clean();
1274      Werror("`%s` is undefined",h->Fullname());
1275      //listall();
1276      goto err;
1277    }
1278    //if ((rt==RING_CMD)||(rt==QRING_CMD))
1279    //{
1280    //  L->m[i].rtyp=rt;
1281    //  L->m[i].data=h->Data();
1282    //  ((ring)L->m[i].data)->ref++;
1283    //}
1284    //else
1285      L->m[i].CleanUp();
1286      L->m[i].Copy(h);
1287      if(errorreported)
1288      {
1289        L->Clean();
1290        goto err;
1291      }
1292  }
1293  oldL=(lists)l->Data();
1294  if (oldL!=NULL) oldL->Clean();
1295  if (l->rtyp==IDHDL)
1296  {
1297    IDLIST((idhdl)l->data)=L;
1298    IDTYP((idhdl)l->data)=LIST_CMD; // was possibly DEF_CMD
1299    if (lRingDependend(L)) ipMoveId((idhdl)l->data);
1300  }
1301  else
1302  {
1303    l->LData()->data=L;
1304    if ((l->e!=NULL) && (l->rtyp==DEF_CMD))
1305      l->rtyp=LIST_CMD;
1306  }
1307err:
1308  o_r->CleanUp();
1309  return errorreported;
1310}
1311static BOOLEAN jjA_L_INTVEC(leftv l,leftv r,intvec *iv)
1312{
1313  /* left side is intvec/intmat, right side is list (of int,intvec,intmat)*/
1314  leftv hh=r;
1315  int i = 0;
1316  while (hh!=NULL)
1317  {
1318    if (i>=iv->length())
1319    {
1320      if (traceit&TRACE_ASSIGN)
1321      {
1322        Warn("expression list length(%d) does not match intmat size(%d)",
1323             iv->length()+exprlist_length(hh),iv->length());
1324      }
1325      break;
1326    }
1327    if (hh->Typ() == INT_CMD)
1328    {
1329      (*iv)[i++] = (int)((long)(hh->Data()));
1330    }
1331    else if ((hh->Typ() == INTVEC_CMD)
1332            ||(hh->Typ() == INTMAT_CMD))
1333    {
1334      intvec *ivv = (intvec *)(hh->Data());
1335      int ll = 0,l = si_min(ivv->length(),iv->length());
1336      for (; l>0; l--)
1337      {
1338        (*iv)[i++] = (*ivv)[ll++];
1339      }
1340    }
1341    else
1342    {
1343      delete iv;
1344      return TRUE;
1345    }
1346    hh = hh->next;
1347  }
1348  if (l->rtyp==IDHDL)
1349  {
1350    if (IDINTVEC((idhdl)l->data)!=NULL) delete IDINTVEC((idhdl)l->data);
1351    IDINTVEC((idhdl)l->data)=iv;
1352  }
1353  else
1354  {
1355    if (l->data!=NULL) delete ((intvec*)l->data);
1356    l->data=(char*)iv;
1357  }
1358  return FALSE;
1359}
1360static BOOLEAN jjA_L_BIGINTMAT(leftv l,leftv r,bigintmat *bim)
1361{
1362  /* left side is bigintmat, right side is list (of int,intvec,intmat)*/
1363  leftv hh=r;
1364  int i = 0;
1365  if (bim->length()==0) { WerrorS("bigintmat is 1x0"); delete bim; return TRUE; }
1366  while (hh!=NULL)
1367  {
1368    if (i>=bim->cols()*bim->rows())
1369    {
1370      if (traceit&TRACE_ASSIGN)
1371      {
1372        Warn("expression list length(%d) does not match bigintmat size(%d x %d)",
1373              exprlist_length(hh),bim->rows(),bim->cols());
1374      }
1375      break;
1376    }
1377    if (hh->Typ() == INT_CMD)
1378    {
1379      number tp = n_Init((int)((long)(hh->Data())), coeffs_BIGINT);
1380      bim->set(i++, tp);
1381      n_Delete(&tp, coeffs_BIGINT);
1382    }
1383    else if (hh->Typ() == BIGINT_CMD)
1384    {
1385      bim->set(i++, (number)(hh->Data()));
1386    }
1387    /*
1388    ((hh->Typ() == INTVEC_CMD)
1389            ||(hh->Typ() == INTMAT_CMD))
1390    {
1391      intvec *ivv = (intvec *)(hh->Data());
1392      int ll = 0,l = si_min(ivv->length(),iv->length());
1393      for (; l>0; l--)
1394      {
1395        (*iv)[i++] = (*ivv)[ll++];
1396      }
1397    }*/
1398    else
1399    {
1400      delete bim;
1401      return TRUE;
1402    }
1403    hh = hh->next;
1404  }
1405  if (IDBIMAT((idhdl)l->data)!=NULL) delete IDBIMAT((idhdl)l->data);
1406  IDBIMAT((idhdl)l->data)=bim;
1407  return FALSE;
1408}
1409static BOOLEAN jjA_L_STRING(leftv l,leftv r)
1410{
1411  /* left side is string, right side is list of string*/
1412  leftv hh=r;
1413  int sl = 1;
1414  char *s;
1415  char *t;
1416  int tl;
1417  /* find the length */
1418  while (hh!=NULL)
1419  {
1420    if (hh->Typ()!= STRING_CMD)
1421    {
1422      return TRUE;
1423    }
1424    sl += strlen((char *)hh->Data());
1425    hh = hh->next;
1426  }
1427  s = (char * )omAlloc(sl);
1428  sl=0;
1429  hh = r;
1430  while (hh!=NULL)
1431  {
1432    t=(char *)hh->Data();
1433    tl=strlen(t);
1434    memcpy(s+sl,t,tl);
1435    sl+=tl;
1436    hh = hh->next;
1437  }
1438  s[sl]='\0';
1439  omFree((ADDRESS)IDDATA((idhdl)(l->data)));
1440  IDDATA((idhdl)(l->data))=s;
1441  return FALSE;
1442}
1443static BOOLEAN jiA_MATRIX_L(leftv l,leftv r)
1444{
1445  /* right side is matrix, left side is list (of poly)*/
1446  BOOLEAN nok=FALSE;
1447  int i;
1448  matrix m=(matrix)r->CopyD(MATRIX_CMD);
1449  leftv h;
1450  leftv ol=l;
1451  leftv o_r=r;
1452  sleftv t;
1453  memset(&t,0,sizeof(sleftv));
1454  t.rtyp=POLY_CMD;
1455  int mxn=MATROWS(m)*MATCOLS(m);
1456  loop
1457  {
1458    i=0;
1459    while ((i<mxn /*MATROWS(m)*MATCOLS(m)*/)&&(l!=NULL))
1460    {
1461      t.data=(char *)m->m[i];
1462      m->m[i]=NULL;
1463      h=l->next;
1464      l->next=NULL;
1465      idhdl hh=NULL;
1466      if ((l->rtyp==IDHDL)&&(l->Typ()==DEF_CMD)) hh=(idhdl)l->data;
1467      nok=jiAssign_1(l,&t);
1468      if (hh!=NULL) { ipMoveId(hh);hh=NULL;}
1469      l->next=h;
1470      if (nok)
1471      {
1472        idDelete((ideal *)&m);
1473        goto ende;
1474      }
1475      i++;
1476      l=h;
1477    }
1478    idDelete((ideal *)&m);
1479    h=r;
1480    r=r->next;
1481    if (l==NULL)
1482    {
1483      if (r!=NULL)
1484      {
1485        Warn("list length mismatch in assign (l>r)");
1486        nok=TRUE;
1487      }
1488      break;
1489    }
1490    else if (r==NULL)
1491    {
1492      Warn("list length mismatch in assign (l<r)");
1493      nok=TRUE;
1494      break;
1495    }
1496    if ((r->Typ()==IDEAL_CMD)||(r->Typ()==MATRIX_CMD))
1497    {
1498      m=(matrix)r->CopyD(MATRIX_CMD);
1499      mxn=MATROWS(m)*MATCOLS(m);
1500    }
1501    else if (r->Typ()==POLY_CMD)
1502    {
1503      m=mpNew(1,1);
1504      MATELEM(m,1,1)=(poly)r->CopyD(POLY_CMD);
1505      pNormalize(MATELEM(m,1,1));
1506      mxn=1;
1507    }
1508    else
1509    {
1510      nok=TRUE;
1511      break;
1512    }
1513  }
1514ende:
1515  o_r->CleanUp();
1516  ol->CleanUp();
1517  return nok;
1518}
1519static BOOLEAN jiA_STRING_L(leftv l,leftv r)
1520{
1521  /*left side are strings, right side is a string*/
1522  /*e.g. s[2..3]="12" */
1523  /*the case s=t[1..4] is handled in iiAssign,
1524  * the case s[2..3]=t[3..4] is handled in iiAssgn_rec*/
1525  BOOLEAN nok=FALSE;
1526  sleftv t;
1527  leftv h,l1=l;
1528  int i=0;
1529  char *ss;
1530  char *s=(char *)r->Data();
1531  int sl=strlen(s);
1532
1533  memset(&t,0,sizeof(sleftv));
1534  t.rtyp=STRING_CMD;
1535  while ((i<sl)&&(l!=NULL))
1536  {
1537    ss=(char *)omAlloc(2);
1538    ss[1]='\0';
1539    ss[0]=s[i];
1540    t.data=ss;
1541    h=l->next;
1542    l->next=NULL;
1543    nok=jiAssign_1(l,&t);
1544    if (nok)
1545    {
1546      break;
1547    }
1548    i++;
1549    l=h;
1550  }
1551  r->CleanUp();
1552  l1->CleanUp();
1553  return nok;
1554}
1555static BOOLEAN jiAssign_list(leftv l, leftv r)
1556{
1557  int i=l->e->start-1;
1558  if (i<0)
1559  {
1560    Werror("index[%d] must be positive",i+1);
1561    return TRUE;
1562  }
1563  if(l->attribute!=NULL)
1564  {
1565    atKillAll((idhdl)l);
1566    l->attribute=NULL;
1567  }
1568  l->flag=0;
1569  lists li;
1570  if (l->rtyp==IDHDL)
1571  {
1572    li=IDLIST((idhdl)l->data);
1573  }
1574  else
1575  {
1576    li=(lists)l->data;
1577  }
1578  if (i>li->nr)
1579  {
1580    if (TEST_V_ALLWARN)
1581    {
1582      Warn("increase list %d -> %d in %s",li->nr,i,my_yylinebuf);
1583    }
1584    li->m=(leftv)omreallocSize(li->m,(li->nr+1)*sizeof(sleftv),(i+1)*sizeof(sleftv));
1585    memset(&(li->m[li->nr+1]),0,(i-li->nr)*sizeof(sleftv));
1586    int j=li->nr+1;
1587    for(;j<=i;j++)
1588      li->m[j].rtyp=DEF_CMD;
1589    li->nr=i;
1590  }
1591  leftv ld=&(li->m[i]);
1592  ld->e=l->e->next;
1593  BOOLEAN b;
1594  if (/*(ld->rtyp!=LIST_CMD)
1595  &&*/(ld->e==NULL)
1596  && (ld->Typ()!=r->Typ()))
1597  {
1598    sleftv tmp;
1599    memset(&tmp,0,sizeof(sleftv));
1600    tmp.rtyp=DEF_CMD;
1601    b=iiAssign(&tmp,r);
1602    ld->CleanUp();
1603    memcpy(ld,&tmp,sizeof(sleftv));
1604  }
1605  else if ((ld->e==NULL)
1606  && (ld->Typ()==r->Typ())
1607  && (ld->Typ()<MAX_TOK))
1608  {
1609    sleftv tmp;
1610    memset(&tmp,0,sizeof(sleftv));
1611    tmp.rtyp=r->Typ();
1612    tmp.data=(char*)idrecDataInit(r->Typ());
1613    b=iiAssign(&tmp,r);
1614    ld->CleanUp();
1615    memcpy(ld,&tmp,sizeof(sleftv));
1616  }
1617  else
1618  {
1619    b=iiAssign(ld,r);
1620    if (l->e!=NULL) l->e->next=ld->e;
1621    ld->e=NULL;
1622  }
1623  return b;
1624}
1625static BOOLEAN jiAssign_rec(leftv l, leftv r)
1626{
1627  leftv l1=l;
1628  leftv r1=r;
1629  leftv lrest;
1630  leftv rrest;
1631  BOOLEAN b;
1632  do
1633  {
1634    lrest=l->next;
1635    rrest=r->next;
1636    l->next=NULL;
1637    r->next=NULL;
1638    b=iiAssign(l,r);
1639    l->next=lrest;
1640    r->next=rrest;
1641    l=lrest;
1642    r=rrest;
1643  } while  ((!b)&&(l!=NULL));
1644  l1->CleanUp();
1645  r1->CleanUp();
1646  return b;
1647}
1648BOOLEAN iiAssign(leftv l, leftv r)
1649{
1650  if (errorreported) return TRUE;
1651  int ll=l->listLength();
1652  int rl;
1653  int lt=l->Typ();
1654  int rt=NONE;
1655  BOOLEAN b;
1656  if (l->rtyp==ALIAS_CMD)
1657  {
1658    Werror("`%s` is read-only",l->Name());
1659  }
1660
1661  if (l->rtyp==IDHDL)
1662  {
1663    atKillAll((idhdl)l->data);
1664    IDFLAG((idhdl)l->data)=0;
1665    l->attribute=NULL;
1666  }
1667  else if (l->attribute!=NULL)
1668    atKillAll((idhdl)l);
1669  l->flag=0;
1670  if (ll==1)
1671  {
1672    /* l[..] = ... */
1673    if(l->e!=NULL)
1674    {
1675      BOOLEAN like_lists=0;
1676      blackbox *bb=NULL;
1677      int bt;
1678      if (((bt=l->rtyp)>MAX_TOK)
1679      || ((l->rtyp==IDHDL) && ((bt=IDTYP((idhdl)l->data))>MAX_TOK)))
1680      {
1681        bb=getBlackboxStuff(bt);
1682        like_lists=BB_LIKE_LIST(bb); // bb like a list
1683      }
1684      else if (((l->rtyp==IDHDL) && (IDTYP((idhdl)l->data)==LIST_CMD))
1685        || (l->rtyp==LIST_CMD))
1686      {
1687        like_lists=2; // bb in a list
1688      }
1689      if(like_lists)
1690      {
1691        if (traceit&TRACE_ASSIGN) PrintS("assign list[..]=...or similiar\n");
1692        if (like_lists==1)
1693        {
1694          // check blackbox/newtype type:
1695          if(bb->blackbox_CheckAssign(bb,l,r)) return TRUE;
1696        }
1697        b=jiAssign_list(l,r);
1698        if((!b) && (like_lists==2))
1699        {
1700          //Print("jjA_L_LIST: - 2 \n");
1701          if((l->rtyp==IDHDL) && (l->data!=NULL))
1702          {
1703            ipMoveId((idhdl)l->data);
1704            l->attribute=IDATTR((idhdl)l->data);
1705            l->flag=IDFLAG((idhdl)l->data);
1706          }
1707        }
1708        r->CleanUp();
1709        Subexpr h;
1710        while (l->e!=NULL)
1711        {
1712          h=l->e->next;
1713          omFreeBin((ADDRESS)l->e, sSubexpr_bin);
1714          l->e=h;
1715        }
1716        return b;
1717      }
1718    }
1719    if (lt>MAX_TOK)
1720    {
1721      blackbox *bb=getBlackboxStuff(lt);
1722#ifdef BLACKBOX_DEVEL
1723      Print("bb-assign: bb=%lx\n",bb);
1724#endif
1725      return (bb==NULL) || bb->blackbox_Assign(l,r);
1726    }
1727    // end of handling elems of list and similiar
1728    rl=r->listLength();
1729    if (rl==1)
1730    {
1731      /* system variables = ... */
1732      if(((l->rtyp>=VECHO)&&(l->rtyp<=VPRINTLEVEL))
1733      ||((l->rtyp>=VALTVARS)&&(l->rtyp<=VMINPOLY)))
1734      {
1735        b=iiAssign_sys(l,r);
1736        r->CleanUp();
1737        //l->CleanUp();
1738        return b;
1739      }
1740      rt=r->Typ();
1741      /* a = ... */
1742      if ((lt!=MATRIX_CMD)
1743      &&(lt!=BIGINTMAT_CMD)
1744      &&(lt!=CMATRIX_CMD)
1745      &&(lt!=INTMAT_CMD)
1746      &&((lt==rt)||(lt!=LIST_CMD)))
1747      {
1748        b=jiAssign_1(l,r);
1749        if (l->rtyp==IDHDL)
1750        {
1751          if ((lt==DEF_CMD)||(lt==LIST_CMD))
1752          {
1753            ipMoveId((idhdl)l->data);
1754          }
1755          l->attribute=IDATTR((idhdl)l->data);
1756          l->flag=IDFLAG((idhdl)l->data);
1757          l->CleanUp();
1758        }
1759        r->CleanUp();
1760        return b;
1761      }
1762      if (((lt!=LIST_CMD)
1763        &&((rt==MATRIX_CMD)
1764          ||(rt==BIGINTMAT_CMD)
1765          ||(rt==CMATRIX_CMD)
1766          ||(rt==INTMAT_CMD)
1767          ||(rt==INTVEC_CMD)
1768          ||(rt==MODUL_CMD)))
1769      ||((lt==LIST_CMD)
1770        &&(rt==RESOLUTION_CMD))
1771      )
1772      {
1773        b=jiAssign_1(l,r);
1774        if((l->rtyp==IDHDL)&&(l->data!=NULL))
1775        {
1776          if ((lt==DEF_CMD) || (lt==LIST_CMD))
1777          {
1778            //Print("ipAssign - 3.0\n");
1779            ipMoveId((idhdl)l->data);
1780          }
1781          l->attribute=IDATTR((idhdl)l->data);
1782          l->flag=IDFLAG((idhdl)l->data);
1783        }
1784        r->CleanUp();
1785        Subexpr h;
1786        while (l->e!=NULL)
1787        {
1788          h=l->e->next;
1789          omFreeBin((ADDRESS)l->e, sSubexpr_bin);
1790          l->e=h;
1791        }
1792        return b;
1793      }
1794    }
1795    if (rt==NONE) rt=r->Typ();
1796  }
1797  else if (ll==(rl=r->listLength()))
1798  {
1799    b=jiAssign_rec(l,r);
1800    return b;
1801  }
1802  else
1803  {
1804    if (rt==NONE) rt=r->Typ();
1805    if (rt==INTVEC_CMD)
1806      return jiA_INTVEC_L(l,r);
1807    else if (rt==VECTOR_CMD)
1808      return jiA_VECTOR_L(l,r);
1809    else if ((rt==IDEAL_CMD)||(rt==MATRIX_CMD))
1810      return jiA_MATRIX_L(l,r);
1811    else if ((rt==STRING_CMD)&&(rl==1))
1812      return jiA_STRING_L(l,r);
1813    Werror("length of lists in assignment does not match (l:%d,r:%d)",
1814      ll,rl);
1815    return TRUE;
1816  }
1817
1818  leftv hh=r;
1819  BOOLEAN nok=FALSE;
1820  BOOLEAN map_assign=FALSE;
1821  switch (lt)
1822  {
1823    case INTVEC_CMD:
1824      nok=jjA_L_INTVEC(l,r,new intvec(exprlist_length(r)));
1825      break;
1826    case INTMAT_CMD:
1827    {
1828      nok=jjA_L_INTVEC(l,r,new intvec(IDINTVEC((idhdl)l->data)));
1829      break;
1830    }
1831    case BIGINTMAT_CMD:
1832    {
1833      nok=jjA_L_BIGINTMAT(l, r, new bigintmat(IDBIMAT((idhdl)l->data)));
1834      break;
1835    }
1836    case MAP_CMD:
1837    {
1838      // first element in the list sl (r) must be a ring
1839      if (((rt == RING_CMD)||(rt == QRING_CMD))&&(r->e==NULL))
1840      {
1841        omFree((ADDRESS)IDMAP((idhdl)l->data)->preimage);
1842        IDMAP((idhdl)l->data)->preimage = omStrDup (r->Fullname());
1843        /* advance the expressionlist to get the next element after the ring */
1844        hh = r->next;
1845        //r=hh;
1846      }
1847      else
1848      {
1849        WerrorS("expected ring-name");
1850        nok=TRUE;
1851        break;
1852      }
1853      if (hh==NULL) /* map-assign: map f=r; */
1854      {
1855        WerrorS("expected image ideal");
1856        nok=TRUE;
1857        break;
1858      }
1859      if ((hh->next==NULL)&&(hh->Typ()==IDEAL_CMD))
1860        return jiAssign_1(l,hh); /* map-assign: map f=r,i; */
1861      //no break, handle the rest like an ideal:
1862      map_assign=TRUE;
1863    }
1864    case MATRIX_CMD:
1865    case IDEAL_CMD:
1866    case MODUL_CMD:
1867    {
1868      sleftv t;
1869      matrix olm = (matrix)l->Data();
1870      int rk=olm->rank;
1871      char *pr=((map)olm)->preimage;
1872      BOOLEAN module_assign=(/*l->Typ()*/ lt==MODUL_CMD);
1873      matrix lm ;
1874      int  num;
1875      int j,k;
1876      int i=0;
1877      int mtyp=MATRIX_CMD; /*Type of left side object*/
1878      int etyp=POLY_CMD;   /*Type of elements of left side object*/
1879
1880      if (lt /*l->Typ()*/==MATRIX_CMD)
1881      {
1882        num=olm->cols()*olm->rows();
1883        lm=mpNew(olm->rows(),olm->cols());
1884        int el;
1885        if ((traceit&TRACE_ASSIGN) && (num!=(el=exprlist_length(hh))))
1886        {
1887          Warn("expression list length(%d) does not match matrix size(%d)",el,num);
1888        }
1889      }
1890      else /* IDEAL_CMD or MODUL_CMD */
1891      {
1892        num=exprlist_length(hh);
1893        lm=(matrix)idInit(num,1);
1894        rk=1;
1895        if (module_assign)
1896        {
1897          mtyp=MODUL_CMD;
1898          etyp=VECTOR_CMD;
1899        }
1900      }
1901
1902      int ht;
1903      loop
1904      {
1905        if (hh==NULL)
1906          break;
1907        else
1908        {
1909          matrix rm;
1910          ht=hh->Typ();
1911          if ((j=iiTestConvert(ht,etyp))!=0)
1912          {
1913            nok=iiConvert(ht,etyp,j,hh,&t);
1914            hh->next=t.next;
1915            if (nok) break;
1916            lm->m[i]=(poly)t.CopyD(etyp);
1917            pNormalize(lm->m[i]);
1918            if (module_assign) rk=si_max(rk,(int)pMaxComp(lm->m[i]));
1919            i++;
1920          }
1921          else
1922          if ((j=iiTestConvert(ht,mtyp))!=0)
1923          {
1924            nok=iiConvert(ht,mtyp,j,hh,&t);
1925            hh->next=t.next;
1926            if (nok) break;
1927            rm = (matrix)t.CopyD(mtyp);
1928            if (module_assign)
1929            {
1930              j = si_min(num,rm->cols());
1931              rk=si_max(rk,(int)rm->rank);
1932            }
1933            else
1934              j = si_min(num-i,rm->rows() * rm->cols());
1935            for(k=0;k<j;k++,i++)
1936            {
1937              lm->m[i]=rm->m[k];
1938              pNormalize(lm->m[i]);
1939              rm->m[k]=NULL;
1940            }
1941            idDelete((ideal *)&rm);
1942          }
1943          else
1944          {
1945            nok=TRUE;
1946            break;
1947          }
1948          t.next=NULL;t.CleanUp();
1949          if (i==num) break;
1950          hh=hh->next;
1951        }
1952      }
1953      if (nok)
1954        idDelete((ideal *)&lm);
1955      else
1956      {
1957        idDelete((ideal *)&olm);
1958        if (module_assign)   lm->rank=rk;
1959        else if (map_assign) ((map)lm)->preimage=pr;
1960        l=l->LData();
1961        if (l->rtyp==IDHDL)
1962          IDMATRIX((idhdl)l->data)=lm;
1963        else
1964          l->data=(char *)lm;
1965      }
1966      break;
1967    }
1968    case STRING_CMD:
1969      nok=jjA_L_STRING(l,r);
1970      break;
1971    //case DEF_CMD:
1972    case LIST_CMD:
1973      nok=jjA_L_LIST(l,r);
1974      break;
1975    case NONE:
1976    case 0:
1977      Werror("cannot assign to %s",l->Fullname());
1978      nok=TRUE;
1979      break;
1980    default:
1981      WerrorS("assign not impl.");
1982      nok=TRUE;
1983      break;
1984  } /* end switch: typ */
1985  if (nok && (!errorreported)) WerrorS("incompatible type in list assignment");
1986  r->CleanUp();
1987  return nok;
1988}
1989void jjNormalizeQRingId(leftv I)
1990{
1991  if ((currRing->qideal!=NULL) && (!hasFlag(I,FLAG_QRING)))
1992  {
1993    if (I->e==NULL)
1994    {
1995      ideal I0=(ideal)I->Data();
1996      switch (I->Typ())
1997      {
1998        case IDEAL_CMD:
1999        case MODUL_CMD:
2000        {
2001          ideal F=idInit(1,1);
2002          ideal II=kNF(F,currRing->qideal,I0);
2003          idDelete(&F);
2004          if (I->rtyp!=IDHDL)
2005          {
2006            idDelete((ideal*)&(I0));
2007            I->data=II;
2008          }
2009          else
2010          {
2011            idhdl h=(idhdl)I->data;
2012            idDelete((ideal*)&IDIDEAL(h));
2013            IDIDEAL(h)=II;
2014            setFlag(h,FLAG_QRING);
2015          }
2016          break;
2017        }
2018        default: break;
2019      }
2020      setFlag(I,FLAG_QRING);
2021    }
2022  }
2023}
2024void jjNormalizeQRingP(leftv I)
2025{
2026  if ((currRing->qideal!=NULL) && (!hasFlag(I,FLAG_QRING)))
2027  {
2028    poly p=(poly)I->Data();
2029    if ((I->e==NULL) && (p!=NULL))
2030    {
2031      ideal F=idInit(1,1);
2032      poly II=kNF(F,currRing->qideal,p);
2033      idDelete(&F);
2034      if ((I->rtyp==POLY_CMD)
2035      || (I->rtyp==VECTOR_CMD))
2036      {
2037        pDelete(&p);
2038        I->data=II;
2039      }
2040      else if (I->rtyp==IDHDL)
2041      {
2042        pDelete(&p);
2043        idhdl h=(idhdl)I->data;
2044        IDPOLY(h)=II;
2045        setFlag(h,FLAG_QRING);
2046      }
2047      else
2048      {
2049        pDelete(&II);
2050      }
2051    }
2052    setFlag(I,FLAG_QRING);
2053  }
2054}
2055BOOLEAN jjIMPORTFROM(leftv, leftv u, leftv v)
2056{
2057  //Print("importfrom %s::%s ->.\n",v->Name(),u->Name() );
2058  assume(u->Typ()==PACKAGE_CMD);
2059  char *vn=(char *)v->Name();
2060  idhdl h=((package)(u->Data()))->idroot->get(vn /*v->Name()*/, myynest);
2061  if (h!=NULL)
2062  {
2063    //check for existence
2064    if (((package)(u->Data()))==basePack)
2065    {
2066      WarnS("source and destination packages are identical");
2067      return FALSE;
2068    }
2069    idhdl t=basePack->idroot->get(vn /*v->Name()*/, myynest);
2070    if (t!=NULL)
2071    {
2072      Warn("redefining `%s`",vn);
2073      killhdl(t);
2074    }
2075    sleftv tmp_expr;
2076    if (iiDeclCommand(&tmp_expr,v,myynest,DEF_CMD,&IDROOT)) return TRUE;
2077    sleftv h_expr;
2078    memset(&h_expr,0,sizeof(h_expr));
2079    h_expr.rtyp=IDHDL;
2080    h_expr.data=h;
2081    h_expr.name=vn;
2082    return iiAssign(&tmp_expr,&h_expr);
2083  }
2084  else
2085  {
2086    Werror("`%s` not found in `%s`",v->Name(), u->Name());
2087    return TRUE;
2088  }
2089  return FALSE;
2090}
Note: See TracBrowser for help on using the repository browser.