source: git/Singular/subexpr.cc @ 254e61

spielwiese
Last change on this file since 254e61 was 254e61, checked in by Hans Schoenemann <hannes@…>, 10 years ago
fix: tr.#644 (string in newstruct)
  • Property mode set to 100644
File size: 44.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT: handling of leftv
6*/
7
8#include <kernel/mod2.h>
9
10#include <omalloc/omalloc.h>
11
12#include <misc/intvec.h>
13#include <misc/options.h>
14
15
16#include <coeffs/ffields.h>
17#include <coeffs/numbers.h>
18#include <coeffs/bigintmat.h>
19
20#include <polys/monomials/maps.h>
21#include <polys/matpol.h>
22#include <polys/monomials/ring.h>
23#include <kernel/polys.h>
24
25#include <coeffs/longrat.h>
26// #include <coeffs/longrat.h>
27
28#include <kernel/ideals.h>
29#include <kernel/GBEngine/kstd1.h>
30#include <kernel/oswrapper/timer.h>
31#include <kernel/GBEngine/syz.h>
32
33#include <Singular/tok.h>
34#include <Singular/ipid.h>
35#include <Singular/ipshell.h>
36#include <Singular/lists.h>
37#include <Singular/attrib.h>
38#include <Singular/links/silink.h>
39#include <Singular/attrib.h>
40#include <Singular/subexpr.h>
41#include <Singular/blackbox.h>
42#include <Singular/number2.h>
43
44#include <stdlib.h>
45#include <stdio.h>
46#include <string.h>
47#include <ctype.h>
48#include <unistd.h>
49
50omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr));
51omBin sleftv_bin = omGetSpecBin(sizeof(sleftv));
52omBin procinfo_bin = omGetSpecBin(sizeof(procinfo));
53omBin libstack_bin = omGetSpecBin(sizeof(libstack));
54static omBin size_two_bin = omGetSpecBin(2);
55
56sleftv     sLastPrinted;
57const char sNoName[]="_";
58#ifdef SIQ
59BOOLEAN siq=FALSE;
60#endif
61
62int sleftv::listLength()
63{
64  int n = 1;
65  leftv sl = next;
66  while (sl!=NULL)
67  {
68    n++;
69    sl=sl->next;
70  }
71  return n;
72}
73
74void sleftv::Print(leftv store, int spaces)
75{
76  int  t=Typ();
77  if (errorreported) return;
78#ifdef SIQ
79  if (rtyp==COMMAND)
80  {
81    command c=(command)data;
82    char ch[2];
83    ch[0]=c->op;ch[1]='\0';
84    const char *s=ch;
85    if (c->op>127) s=iiTwoOps(c->op);
86    ::Print("##command %d(%s), %d args\n",
87      c->op, s, c->argc);
88    if (c->argc>0)
89      c->arg1.Print(NULL,spaces+2);
90    if(c->argc<4)
91    {
92      if (c->argc>1)
93        c->arg2.Print(NULL,spaces+2);
94      if (c->argc>2)
95        c->arg3.Print(NULL,spaces+2);
96    }
97    PrintS("##end");
98  }
99  else
100#endif
101  {
102    const char *n=Name();
103    char *s;
104    void *d=Data();
105    if (errorreported) return;
106    if ((store!=NULL)&&(store!=this))
107      store->CleanUp();
108
109    switch (t /*=Typ()*/)
110      {
111#ifdef SINGULAR_4_1
112        case CRING_CMD:
113          crPrint((coeffs)d);
114          break;
115        case CNUMBER_CMD:
116          n2Print((number2)d);
117          break;
118        case CMATRIX_CMD: // like BIGINTMAT
119#endif
120        case BIGINTMAT_CMD:
121          ((bigintmat *)d)->pprint(80);
122          break;
123        case UNKNOWN:
124        case DEF_CMD:
125          PrintNSpaces(spaces);
126          PrintS("`");PrintS(n);PrintS("`");
127          break;
128        case PACKAGE_CMD:
129          PrintNSpaces(spaces);
130          paPrint(n,(package)d);
131          break;
132        case NONE:
133          return;
134        case INTVEC_CMD:
135        case INTMAT_CMD:
136          ((intvec *)d)->show(t,spaces);
137          break;
138        case RING_CMD:
139        case QRING_CMD:
140        {
141          PrintNSpaces(spaces);
142          const ring r = (const ring)d;
143          rWrite(r, currRing == r);
144          break;
145        }
146        case MATRIX_CMD:
147          iiWriteMatrix((matrix)d,n,2, currRing, spaces);
148          break;
149        case MODUL_CMD:
150        case IDEAL_CMD:
151          if ((TEST_V_QRING)  &&(currRing->qideal!=NULL)
152          &&(!hasFlag(this,FLAG_QRING)))
153          {
154            jjNormalizeQRingId(this);
155            d=Data();
156          }
157          // no break:
158        case MAP_CMD:
159          iiWriteMatrix((matrix)d,n,1, currRing, spaces);
160          break;
161        case POLY_CMD:
162        case VECTOR_CMD:
163          if ((TEST_V_QRING)  &&(currRing->qideal!=NULL)
164          &&(!hasFlag(this,FLAG_QRING)))
165          {
166            jjNormalizeQRingP(this);
167            d=Data();
168          }
169          PrintNSpaces(spaces);
170          pWrite0((poly)d);
171          break;
172        case RESOLUTION_CMD:
173        {
174          syStrategy tmp=(syStrategy)d;
175          syPrint(tmp,IDID(currRingHdl));
176          break;
177        }
178        case STRING_CMD:
179          PrintNSpaces(spaces);
180          PrintS((char *)d);
181          break;
182       case INT_CMD:
183          PrintNSpaces(spaces);
184          ::Print("%d",(int)(long)d);
185          break;
186       case PROC_CMD:
187         {
188           procinfov pi=(procinfov)d;
189
190           PrintNSpaces(spaces);
191           PrintS("// libname  : ");
192           PrintS(piProcinfo(pi, "libname"));
193           PrintLn();
194
195           PrintNSpaces(spaces);
196           PrintS("// procname : ");
197           PrintS(piProcinfo(pi, "procname"));
198           PrintLn();
199
200           PrintNSpaces(spaces);
201           PrintS("// type     : ");
202           PrintS(piProcinfo(pi, "type"));
203           //           ::Print("%-*.*s// ref      : %s",spaces,spaces," ",
204           //   piProcinfo(pi, "ref"));
205           break;
206         }
207       case LINK_CMD:
208          {
209            si_link l=(si_link)d;
210            PrintNSpaces(spaces);
211            ::Print("// type : %s\n", slStatus(l, "type"));
212            PrintNSpaces(spaces);
213            ::Print("// mode : %s\n", slStatus(l, "mode"));
214            PrintNSpaces(spaces);
215            ::Print("// name : %s\n", slStatus(l, "name"));
216            PrintNSpaces(spaces);
217            ::Print("// open : %s\n", slStatus(l, "open"));
218            PrintNSpaces(spaces);
219            ::Print("// read : %s\n", slStatus(l, "read"));
220            PrintNSpaces(spaces);
221            ::Print("// write: %s", slStatus(l, "write"));
222          break;
223          }
224        case NUMBER_CMD:
225        case BIGINT_CMD:
226          s=String(d);
227          if (s==NULL) return;
228          PrintNSpaces(spaces);
229          PrintS(s);
230          omFree((ADDRESS)s);
231          break;
232        case LIST_CMD:
233        {
234          lists l=(lists)d;
235          if (lSize(l)<0)
236          {
237             PrintNSpaces(spaces);
238             PrintS("empty list\n");
239          }
240          else
241          {
242            int i=0;
243            for (;i<=l->nr;i++)
244            {
245              if (l->m[i].rtyp!=DEF_CMD)
246              {
247                PrintNSpaces(spaces);
248                ::Print("[%d]:\n",i+1);
249                l->m[i].Print(NULL,spaces+3);
250              }
251            }
252          }
253          break;
254        }
255
256        default:
257          if (t>MAX_TOK)
258          {
259            blackbox * bb=getBlackboxStuff(t);
260            PrintNSpaces(spaces);
261            if (bb!=NULL) { bb->blackbox_Print(bb,d); }
262            else          { ::Print("Print: blackbox %d(bb=NULL)",t); }
263          }
264          else
265          ::Print("Print:unknown type %s(%d)", Tok2Cmdname(t),t);
266      } /* end switch: (Typ()) */
267  }
268  if (next!=NULL)
269  {
270    if (t==COMMAND) PrintLn();
271    else if (t!=LIST_CMD) PrintS(" ");
272    next->Print(NULL,spaces);
273  }
274  else if (t!=LIST_CMD)
275  {
276    PrintLn();
277  }
278#ifdef SIQ
279  if (rtyp!=COMMAND)
280#endif
281  {
282    if ((store!=NULL)
283    && (store!=this))
284    {
285      if((t/*Typ()*/!=LINK_CMD)
286      && (t/*Typ()*/!=PACKAGE_CMD)
287      && (t/*Typ()*/!=DEF_CMD)
288      )
289      {
290        store->rtyp=t/*Typ()*/;
291        store->data=CopyD();
292        if(attribute!=NULL)
293        {
294          store->attribute=CopyA();
295        }
296        store->flag=flag;
297      }
298    }
299  }
300}
301
302void sleftv::CleanUp(ring r)
303{
304  if ((name!=NULL) && (name!=sNoName) && (rtyp!=IDHDL) && (rtyp!=ALIAS_CMD))
305  {
306    //::Print("free %x (%s)\n",name,name);
307    omFree((ADDRESS)name);
308  }
309  //name=NULL;
310  //flag=0;
311  if (data!=NULL)
312  {
313     if (rtyp==IDHDL) attribute=NULL; // is only a pointer to attribute of id
314     else s_internalDelete(rtyp,data,r);
315    //data=NULL; // will be done by Init() at the end
316  }
317  if (attribute!=NULL)
318  {
319    switch (rtyp)
320    {
321      case PACKAGE_CMD:
322      case IDHDL:
323      case ANY_TYPE:
324      case VECHO:
325      case VPRINTLEVEL:
326      case VCOLMAX:
327      case VTIMER:
328      case VRTIMER:
329      case VOICE:
330      case VMAXDEG:
331      case VMAXMULT:
332      case TRACE:
333      case VSHORTOUT:
334      case VNOETHER:
335      case VMINPOLY:
336      case LIB_CMD:
337      case 0:
338        //attribute=NULL; // will be done by Init() at the end
339        break;
340      default:
341      {
342        attribute->killAll(r);
343      }
344    }
345  }
346  Subexpr h;
347  while (e!=NULL)
348  {
349    h=e->next;
350    omFreeBin((ADDRESS)e, sSubexpr_bin);
351    e=h;
352  }
353  //rtyp=NONE; // will be done by Init() at the end
354  if (next!=NULL)
355  {
356    leftv tmp_n;
357    do
358    {
359      tmp_n=next->next;
360      //next->name=NULL;
361      next->next=NULL;
362      next->CleanUp(r);
363      omFreeBin((ADDRESS)next, sleftv_bin);
364      next=tmp_n;
365    } while (next!=NULL);
366  }
367  Init();
368}
369
370BOOLEAN sleftv::RingDependend()
371{
372  int rt=Typ();
373  if(::RingDependend(rt) && (rt!=QRING_CMD))
374    return TRUE;
375  if (rt==LIST_CMD)
376    return lRingDependend((lists)Data());
377  if (this->next!=NULL)
378    return this->next->RingDependend();
379  return FALSE;
380}
381
382static inline void * s_internalCopy(const int t,  void *d)
383{
384  switch (t)
385  {
386#ifdef SINGULAR_4_1
387    case CRING_CMD:
388      {
389        coeffs cf=(coeffs)d;
390        cf->ref++;
391        return (void*)d;
392      }
393    case CNUMBER_CMD:
394      return (void*)n2Copy((number2)d);
395    case CMATRIX_CMD: // like BIGINTMAT
396#endif
397    case BIGINTMAT_CMD:
398      return (void*)bimCopy((bigintmat *)d);
399    case INTVEC_CMD:
400    case INTMAT_CMD:
401      return (void *)ivCopy((intvec *)d);
402    case MATRIX_CMD:
403      return (void *)mp_Copy((matrix)d, currRing);
404    case IDEAL_CMD:
405    case MODUL_CMD:
406      return  (void *)idCopy((ideal)d);
407    case STRING_CMD:
408        return (void *)omStrDup((char *)d);
409    case PACKAGE_CMD:
410      return  (void *)paCopy((package) d);
411    case PROC_CMD:
412      return  (void *)piCopy((procinfov) d);
413    case POLY_CMD:
414    case VECTOR_CMD:
415      return  (void *)pCopy((poly)d);
416    case INT_CMD:
417      return  d;
418    case NUMBER_CMD:
419      return  (void *)nCopy((number)d);
420    case BIGINT_CMD:
421      return  (void *)n_Copy((number)d, coeffs_BIGINT);
422    case MAP_CMD:
423      return  (void *)maCopy((map)d, currRing);
424    case LIST_CMD:
425      return  (void *)lCopy((lists)d);
426    case LINK_CMD:
427      return (void *)slCopy((si_link) d);
428    case RING_CMD:
429    case QRING_CMD:
430      {
431        ring r=(ring)d;
432        if (r!=NULL) r->ref++;
433        //Print("+  ring %d, ref %d\n",r,r->ref);
434        return d;
435      }
436    case RESOLUTION_CMD:
437      return (void*)syCopy((syStrategy)d);
438    case DEF_CMD:
439    case NONE:
440    case 0: /* type in error case */
441      break; /* error recovery: do nothing */
442    //case COMMAND:
443    default:
444    {
445      if (t>MAX_TOK)
446      {
447        blackbox *b=getBlackboxStuff(t);
448        if (b!=NULL) return b->blackbox_Copy(b,d);
449        return NULL;
450      }
451      else
452      Warn("s_internalCopy: cannot copy type %s(%d)",
453            Tok2Cmdname(t),t);
454    }
455  }
456  return NULL;
457}
458
459void s_internalDelete(const int t,  void *d, const ring r)
460{
461  assume(d!=NULL);
462  switch (t)
463  {
464#ifdef SINGULAR_4_1
465    case CRING_CMD:
466      nKillChar((coeffs)d);
467      break;
468    case CNUMBER_CMD:
469      {
470        number2 n=(number2)d;
471        n2Delete(n);
472        break;
473      }
474    case CMATRIX_CMD: //like BIGINTMAT
475#endif
476    case BIGINTMAT_CMD:
477    {
478      bigintmat *v=(bigintmat*)d;
479      delete v;
480      break;
481    }
482    case INTVEC_CMD:
483    case INTMAT_CMD:
484    {
485      intvec *v=(intvec*)d;
486      delete v;
487      break;
488    }
489    case MAP_CMD:
490    {
491      map m=(map)d;
492      omFreeBinAddr((ADDRESS)m->preimage);
493      m->preimage=NULL;
494      /* no break: continue as IDEAL*/
495    }
496    case MATRIX_CMD:
497    case IDEAL_CMD:
498    case MODUL_CMD:
499    {
500      ideal i=(ideal)d;
501      id_Delete(&i,r);
502      break;
503    }
504    case STRING_CMD:
505      omFree(d);
506      break;
507    //case PACKAGE_CMD:
508    //  return  (void *)paCopy((package) d);
509    case PROC_CMD:
510      piKill((procinfo*)d);
511      break;
512    case POLY_CMD:
513    case VECTOR_CMD:
514    {
515      poly p=(poly)d;
516      p_Delete(&p,r);
517      break;
518    }
519    case NUMBER_CMD:
520    {
521      number n=(number)d;
522      n_Delete(&n,r);
523      break;
524    }
525    case BIGINT_CMD:
526    {
527      number n=(number)d;
528      n_Delete(&n,coeffs_BIGINT);
529      break;
530    }
531    case LIST_CMD:
532    {
533      lists l=(lists)d;
534      l->Clean(r);
535      break;
536    }
537    case LINK_CMD:
538    {
539      si_link l=(si_link)d;
540      slKill(l);
541      break;
542    }
543    case RING_CMD:
544    case QRING_CMD:
545    {
546      ring R=(ring)d;
547      if ((R!=currRing)||(R->ref>=0))
548        rKill(R);
549      #ifdef TEST
550      else
551        Print("currRing? ref=%d\n",R->ref);
552      #endif
553      break;
554    }
555    case RESOLUTION_CMD:
556    {
557      syStrategy s=(syStrategy)d;
558      if (s!=NULL) syKillComputation(s,r);
559      break;
560    }
561    case COMMAND:
562    {
563     command cmd=(command)d;
564     if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp(r);
565     if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp(r);
566     if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp(r);
567     omFreeBin((ADDRESS)d, sip_command_bin);
568     break;
569    }
570    case INT_CMD:
571    case DEF_CMD:
572    case ALIAS_CMD:
573    case PACKAGE_CMD:
574    case IDHDL:
575    case NONE:
576    case ANY_TYPE:
577    case VECHO:
578    case VPRINTLEVEL:
579    case VCOLMAX:
580    case VTIMER:
581    case VRTIMER:
582    case VOICE:
583    case VMAXDEG:
584    case VMAXMULT:
585    case TRACE:
586    case VSHORTOUT:
587    case VNOETHER:
588    case VMINPOLY:
589    case LIB_CMD:
590    case 0: /* type in error case */
591      break; /* error recovery: do nothing */
592    //case COMMAND:
593    //case COMMAND:
594    default:
595    {
596      if (t>MAX_TOK)
597      {
598        blackbox *b=getBlackboxStuff(t);
599        if (b!=NULL) b->blackbox_destroy(b,d);
600        break;
601      }
602      else
603      Warn("s_internalDelete: cannot delete type %s(%d)",
604            Tok2Cmdname(t),t);
605    }
606  }
607}
608
609void * slInternalCopy(leftv source, const int t, void *d, Subexpr e)
610{
611  if (t==STRING_CMD)
612  {
613      if ((e==NULL)
614      || (source->rtyp==LIST_CMD)
615      || ((source->rtyp==IDHDL)
616          &&((IDTYP((idhdl)source->data)==LIST_CMD)
617            || (IDTYP((idhdl)source->data)>MAX_TOK)))
618      || (source->rtyp>MAX_TOK))
619        return (void *)omStrDup((char *)d);
620      else if (e->next==NULL)
621      {
622        char *s=(char*)omAllocBin(size_two_bin);
623        s[0]=*(char *)d;
624        s[1]='\0';
625        return s;
626      }
627      #ifdef TEST
628      else
629      {
630        Werror("not impl. string-op in `%s`",my_yylinebuf);
631        return NULL;
632      }
633      #endif
634  }
635  return s_internalCopy(t,d);
636}
637
638void sleftv::Copy(leftv source)
639{
640  Init();
641  rtyp=source->Typ();
642  void *d=source->Data();
643  if(!errorreported)
644  {
645    data=s_internalCopy(rtyp,d);
646    if ((source->attribute!=NULL)||(source->e!=NULL))
647      attribute=source->CopyA();
648    flag=source->flag;
649    if (source->next!=NULL)
650    {
651      next=(leftv)omAllocBin(sleftv_bin);
652      next->Copy(source->next);
653    }
654  }
655}
656
657void * sleftv::CopyD(int t)
658{
659  if ((rtyp!=IDHDL)&&(rtyp!=ALIAS_CMD)&&(e==NULL))
660  {
661    if (iiCheckRing(t)) return NULL;
662    void *x = data;
663    if (rtyp==VNOETHER) x = (void *)pCopy((currRing->ppNoether));
664    else if ((rtyp==VMINPOLY) && nCoeff_is_algExt(currRing->cf) && (!nCoeff_is_GF(currRing->cf)))
665    {
666      const ring A = currRing->cf->extRing;
667
668      assume( A != NULL );
669      assume( A->qideal != NULL );
670
671      x=(void *)p_Copy(A->qideal->m[0], A);
672    }
673    data=NULL;
674    return x;
675  }
676  void *d=Data(); // will also do a iiCheckRing
677  if ((!errorreported) && (d!=NULL)) return slInternalCopy(this,t,d,e);
678  return NULL;
679}
680
681//void * sleftv::CopyD()
682//{
683  //if ((rtyp!=IDHDL)&&(e==NULL)
684  //&&(rtyp!=VNOETHER)&&(rtyp!=LIB_CMD)&&(rtyp!=VMINPOLY))
685  //{
686  //  void *x=data;
687  //  data=NULL;
688  //  return x;
689  //}
690//  return CopyD(Typ());
691//}
692
693attr sleftv::CopyA()
694{
695  attr *a=Attribute();
696  if ((a!=NULL) && (*a!=NULL))
697    return (*a)->Copy();
698  return NULL;
699}
700
701char *  sleftv::String(void *d, BOOLEAN typed, int dim)
702{
703#ifdef SIQ
704  if (rtyp==COMMAND)
705  {
706    ::Print("##command %d\n",((command)data)->op);
707    if (((command)data)->arg1.rtyp!=0)
708      ((command)data)->arg1.Print(NULL,2);
709    if (((command)data)->arg2.rtyp!=0)
710      ((command)data)->arg2.Print(NULL,2);
711    if (((command)data)->arg3.rtyp==0)
712      ((command)data)->arg3.Print(NULL,2);
713    PrintS("##end\n");
714    return omStrDup("");
715  }
716#endif
717  if (d==NULL) d=Data();
718  if (!errorreported)
719  {
720    char *s;
721    int t=Typ();
722    switch (t /*Typ()*/)
723    {
724        case INT_CMD:
725          if (typed)
726          {
727            s=(char *)omAlloc(MAX_INT_LEN+7);
728            sprintf(s,"int(%d)",(int)(long)d);
729          }
730          else
731          {
732            s=(char *)omAlloc(MAX_INT_LEN+2);
733            sprintf(s,"%d",(int)(long)d);
734          }
735          return s;
736
737        case STRING_CMD:
738          if (d == NULL)
739          {
740            if (typed) return omStrDup("\"\"");
741            return omStrDup("");
742          }
743          if (typed)
744          {
745            s = (char*) omAlloc(strlen((char*) d) + 3);
746            sprintf(s,"\"%s\"", (char*) d);
747            return s;
748          }
749          else
750          {
751            return omStrDup((char*)d);
752          }
753
754        case POLY_CMD:
755        case VECTOR_CMD:
756          if (typed)
757          {
758            char* ps = pString((poly) d);
759            s = (char*) omAlloc(strlen(ps) + 10);
760            sprintf(s,"%s(%s)", (t /*Typ()*/ == POLY_CMD ? "poly" : "vector"), ps);
761            omFree(ps);
762            return s;
763          }
764          else
765            return pString((poly)d);
766
767        case NUMBER_CMD:
768          StringSetS((char*) (typed ? "number(" : ""));
769          if ((rtyp==IDHDL)&&(IDTYP((idhdl)data)==NUMBER_CMD))
770          {
771            nWrite(IDNUMBER((idhdl)data));
772          }
773          else if (rtyp==NUMBER_CMD)
774          {
775            number n=(number)data;
776            nWrite(n);
777            data=(char *)n;
778          }
779          else if((rtyp==VMINPOLY)&&(rField_is_GF(currRing)))
780          {
781            nfShowMipo(currRing->cf);
782          }
783          else
784          {
785            number n=nCopy((number)d);
786            nWrite(n);
787            nDelete(&n);
788          }
789          StringAppendS((char*) (typed ? ")" : ""));
790          return StringEndS();
791
792        case BIGINT_CMD:
793          {
794          StringSetS((char*) (typed ? "bigint(" : ""));
795          number nl=(number)d;
796          n_Write(nl,coeffs_BIGINT);
797          StringAppendS((char*) (typed ? ")" : ""));
798          return StringEndS();
799          }
800
801        case MATRIX_CMD:
802          s= iiStringMatrix((matrix)d,dim, currRing);
803          if (typed)
804          {
805            char* ns = (char*) omAlloc(strlen(s) + 40);
806            sprintf(ns, "matrix(ideal(%s),%d,%d)", s,
807                    ((ideal) d)->nrows, ((ideal) d)->ncols);
808            omCheckAddr(ns);
809            return ns;
810          }
811          else
812          {
813            return omStrDup(s);
814          }
815
816        case MODUL_CMD:
817        case IDEAL_CMD:
818        case MAP_CMD:
819          s= iiStringMatrix((matrix)d,dim, currRing);
820          if (typed)
821          {
822            char* ns = (char*) omAlloc(strlen(s) + 10);
823            sprintf(ns, "%s(%s)", (t/*Typ()*/==MODUL_CMD ? "module" : "ideal"), s);
824            omCheckAddr(ns);
825            return ns;
826          }
827          return omStrDup(s);
828
829        case INTVEC_CMD:
830        case INTMAT_CMD:
831        {
832          intvec *v=(intvec *)d;
833          s = v->String(dim);
834          if (typed)
835          {
836            char* ns;
837            if (t/*Typ()*/ == INTMAT_CMD)
838            {
839              ns = (char*) omAlloc(strlen(s) + 40);
840              sprintf(ns, "intmat(intvec(%s),%d,%d)", s, v->rows(), v->cols());
841            }
842            else
843            {
844              ns = (char*) omAlloc(strlen(s) + 10);
845              sprintf(ns, "intvec(%s)", s);
846            }
847            omCheckAddr(ns);
848            omFree(s);
849            return ns;
850          }
851          else
852            return s;
853        }
854        case BIGINTMAT_CMD:
855        {
856          bigintmat *bim=(bigintmat*)d;
857          s = bim->String();
858          if (typed)
859          {
860            char* ns = (char*) omAlloc0(strlen(s) + 40);
861            sprintf(ns, "bigintmat(bigintvec(%s),%d,%d)", s, bim->rows(), bim->cols());
862            omCheckAddr(ns);
863            return ns;
864          }
865          else
866            return omStrDup(s);
867        }
868
869        case RING_CMD:
870        case QRING_CMD:
871          s  = rString((ring)d);
872
873          if (typed)
874          {
875            char* ns;
876            if (t/*Typ()*/ == QRING_CMD)
877            {
878              char* id = iiStringMatrix((matrix) ((ring) d)->qideal, dim,
879                              currRing);
880              ns = (char*) omAlloc(strlen(s) + strlen(id) + 20);
881              sprintf(ns, "\"%s\";%sideal(%s)", s,(dim == 2 ? "\n" : " "), id);
882            }
883            else
884            {
885              ns = (char*) omAlloc(strlen(s) + 4);
886              sprintf(ns, "\"%s\"", s);
887            }
888            omFree(s);
889            omCheckAddr(ns);
890            return ns;
891          }
892          return s;
893        case RESOLUTION_CMD:
894        {
895          lists l = syConvRes((syStrategy)d);
896          s = lString(l, typed, dim);
897          l->Clean();
898          return s;
899        }
900
901        case PROC_CMD:
902        {
903          procinfo* pi = (procinfo*) d;
904          if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
905            s = (pi->data.s.body);
906          else
907            s = (char *)"";
908          if (typed)
909          {
910            char* ns = (char*) omAlloc(strlen(s) + 4);
911            sprintf(ns, "\"%s\"", s);
912            omCheckAddr(ns);
913            return ns;
914          }
915          return omStrDup(s);
916        }
917
918        case LINK_CMD:
919          s = slString((si_link) d);
920          if (typed)
921          {
922            char* ns = (char*) omAlloc(strlen(s) + 10);
923            sprintf(ns, "link(\"%s\")", s);
924            omFreeBinAddr(s);
925            omCheckAddr(ns);
926            return ns;
927          }
928          return s;
929
930        case LIST_CMD:
931          return lString((lists) d, typed, dim);
932
933        default:
934          if(t> MAX_TOK)
935          {
936            blackbox *bb=getBlackboxStuff(t);
937            if (bb!=NULL) return bb->blackbox_String(bb,d);
938          }
939    } /* end switch: (Typ()) */
940  }
941  return omStrDup("");
942}
943
944
945int  sleftv::Typ()
946{
947  if (e==NULL)
948  {
949    switch (rtyp)
950    {
951      case IDHDL:
952        return IDTYP((idhdl)data);
953      case ALIAS_CMD:
954         {
955           idhdl h=(idhdl)data;
956           return  ((idhdl)h->data.ustring)->typ;
957         }
958      case VECHO:
959      case VPRINTLEVEL:
960      case VCOLMAX:
961      case VTIMER:
962      case VRTIMER:
963      case VOICE:
964      case VMAXDEG:
965      case VMAXMULT:
966      case TRACE:
967      case VSHORTOUT:
968        return INT_CMD;
969      case VMINPOLY:
970        data=NULL;
971        return NUMBER_CMD;
972      case VNOETHER:
973        data=NULL;
974        return POLY_CMD;
975      //case COMMAND:
976      //  return COMMAND;
977      default:
978        return rtyp;
979    }
980  }
981  int r=0;
982  int t=rtyp;
983  void *d=data;
984  if (t==IDHDL) t=IDTYP((idhdl)data);
985  else if (t==ALIAS_CMD)
986  { idhdl h=(idhdl)IDDATA((idhdl)data); t=IDTYP(h);d=IDDATA(h); }
987  switch (t)
988  {
989#ifdef SINGULAR_4_1
990    case CMATRIX_CMD:
991    {
992      bigintmat *b=(bigintmat*)d;
993      if ((currRing!=NULL)&&(currRing->cf==b->basecoeffs()))
994        return NUMBER_CMD;
995      else
996        return CNUMBER_CMD;
997    }
998#endif
999    case INTVEC_CMD:
1000    case INTMAT_CMD:
1001      r=INT_CMD;
1002      break;
1003    case BIGINTMAT_CMD:
1004      r=BIGINT_CMD;
1005      break;
1006    case IDEAL_CMD:
1007    case MATRIX_CMD:
1008    case MAP_CMD:
1009      r=POLY_CMD;
1010      break;
1011    case MODUL_CMD:
1012      r=VECTOR_CMD;
1013      break;
1014    case STRING_CMD:
1015      r=STRING_CMD;
1016      break;
1017    default:
1018    {
1019      blackbox *b=NULL;
1020      if (t>MAX_TOK)
1021      {
1022        b=getBlackboxStuff(t);
1023      }
1024      if ((t==LIST_CMD)||((b!=NULL)&&BB_LIKE_LIST(b)))
1025      {
1026        lists l;
1027        if (rtyp==IDHDL) l=IDLIST((idhdl)data);
1028        else if (rtyp==ALIAS_CMD)
1029        {
1030          idhdl h=(idhdl)data;
1031          l=(lists)(((idhdl)h->data.ustring)->data.ustring);
1032        }
1033        else             l=(lists)data;
1034        if ((0<e->start)&&(e->start<=l->nr+1))
1035        {
1036          Subexpr tmp=l->m[e->start-1].e;
1037          l->m[e->start-1].e=e->next;
1038          r=l->m[e->start-1].Typ();
1039          e->next=l->m[e->start-1].e;
1040          l->m[e->start-1].e=tmp;
1041        }
1042        else
1043        {
1044          //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
1045          r=DEF_CMD;
1046        }
1047      }
1048      else
1049        Werror("cannot index type %s(%d)",Tok2Cmdname(t),t);
1050      break;
1051    }
1052  }
1053  return r;
1054}
1055
1056int  sleftv::LTyp()
1057{
1058  lists l=NULL;
1059  int r;
1060  if (rtyp==LIST_CMD)
1061    l=(lists)data;
1062  else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1063    l=IDLIST((idhdl)data);
1064  else
1065    return Typ();
1066  //if (l!=NULL)
1067  {
1068    if ((e!=NULL) && (e->next!=NULL))
1069    {
1070      if ((0<e->start)&&(e->start<=l->nr+1))
1071      {
1072        l->m[e->start-1].e=e->next;
1073        r=l->m[e->start-1].LTyp();
1074        l->m[e->start-1].e=NULL;
1075      }
1076      else
1077      {
1078        //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
1079        r=NONE;
1080      }
1081      return r;
1082    }
1083    return LIST_CMD;
1084  }
1085  return Typ();
1086}
1087
1088#ifdef SINGULAR_4_1
1089static snumber2 iiNumber2Data[4];
1090static int iiCmatrix_index=0;
1091#endif
1092void * sleftv::Data()
1093{
1094  if ((rtyp!=IDHDL) && iiCheckRing(rtyp))
1095     return NULL;
1096  if (e==NULL)
1097  {
1098    switch (rtyp)
1099    {
1100      case ALIAS_CMD:
1101      {
1102        idhdl h=(idhdl)data;
1103        return  ((idhdl)h->data.ustring)->data.ustring;
1104      }
1105      case VECHO:      return (void *)(long)si_echo;
1106      case VPRINTLEVEL:return (void *)(long)printlevel;
1107      case VCOLMAX:    return (void *)(long)colmax;
1108      case VTIMER:     return (void *)(long)getTimer();
1109      case VRTIMER:    return (void *)(long)getRTimer();
1110      case VOICE:      return (void *)(long)(myynest+1);
1111      case VMAXDEG:    return (void *)(long)Kstd1_deg;
1112      case VMAXMULT:   return (void *)(long)Kstd1_mu;
1113      case TRACE:      return (void *)(long)traceit;
1114      case VSHORTOUT:  return (void *)(long)(currRing != NULL ? currRing->ShortOut : 0);
1115      case VMINPOLY:
1116        if ( (currRing != NULL)  && nCoeff_is_algExt(currRing->cf) && !nCoeff_is_GF(currRing->cf))
1117        {
1118          /* Q(a), Fp(a), but not GF(q) */
1119          const ring A = currRing->cf->extRing;
1120
1121          assume( A != NULL );
1122          assume( A->qideal != NULL );
1123
1124          return (void *)A->qideal->m[0];
1125        }
1126        else
1127          return (void *)currRing->cf->nNULL;
1128
1129      case VNOETHER:   return (void *) (currRing->ppNoether);
1130      case IDHDL:
1131        return IDDATA((idhdl)data);
1132      case COMMAND:
1133        //return NULL;
1134      default:
1135        return data;
1136    }
1137  }
1138  /* e != NULL : */
1139  int t=rtyp;
1140  void *d=data;
1141  if (t==IDHDL)
1142  {
1143    t=((idhdl)data)->typ;
1144    d=IDDATA((idhdl)data);
1145  }
1146  else if (t==ALIAS_CMD)
1147  {
1148    idhdl h=(idhdl)IDDATA((idhdl)data);
1149    t=IDTYP(h);
1150    d=IDDATA(h);
1151  }
1152  if (iiCheckRing(t))
1153    return NULL;
1154  char *r=NULL;
1155  int index=e->start;
1156  switch (t)
1157  {
1158    case INTVEC_CMD:
1159    {
1160      intvec *iv=(intvec *)d;
1161      if ((index<1)||(index>iv->length()))
1162      {
1163        if (!errorreported)
1164          Werror("wrong range[%d] in intvec %s(%d)",index,this->Name(),iv->length());
1165      }
1166      else
1167        r=(char *)(long)((*iv)[index-1]);
1168      break;
1169    }
1170    case INTMAT_CMD:
1171    {
1172      intvec *iv=(intvec *)d;
1173      if ((index<1)
1174         ||(index>iv->rows())
1175         ||(e->next->start<1)
1176         ||(e->next->start>iv->cols()))
1177      {
1178        if (!errorreported)
1179        Werror("wrong range[%d,%d] in intmat %s(%dx%d)",index,e->next->start,
1180                                           this->Name(),iv->rows(),iv->cols());
1181      }
1182      else
1183        r=(char *)(long)(IMATELEM((*iv),index,e->next->start));
1184      break;
1185    }
1186    case BIGINTMAT_CMD:
1187    {
1188      bigintmat *m=(bigintmat *)d;
1189      if ((index<1)
1190         ||(index>m->rows())
1191         ||(e->next->start<1)
1192         ||(e->next->start>m->cols()))
1193      {
1194        if (!errorreported)
1195        Werror("wrong range[%d,%d] in bigintmat %s(%dx%d)",index,e->next->start,
1196                                                     this->Name(),m->rows(),m->cols());
1197      }
1198      else
1199        r=(char *)(BIMATELEM((*m),index,e->next->start));
1200      break;
1201    }
1202#ifdef SINGULAR_4_1
1203    case CMATRIX_CMD:
1204    {
1205      bigintmat *m=(bigintmat *)d;
1206      if ((index<1)
1207         ||(index>m->rows())
1208         ||(e->next->start<1)
1209         ||(e->next->start>m->cols()))
1210      {
1211        if (!errorreported)
1212        Werror("wrong range[%d,%d] in matrix %s(%dx%d)",index,e->next->start,
1213                                                     this->Name(),m->rows(),m->cols());
1214      }
1215      else
1216      {
1217        iiNumber2Data[iiCmatrix_index].cf=m->basecoeffs();
1218        iiNumber2Data[iiCmatrix_index].n=BIMATELEM((*m),index,e->next->start);
1219        r=(char*)&iiNumber2Data[iiCmatrix_index];
1220        iiCmatrix_index=(iiCmatrix_index+1) % 4;
1221      }
1222      break;
1223    }
1224#endif
1225    case IDEAL_CMD:
1226    case MODUL_CMD:
1227    case MAP_CMD:
1228    {
1229      ideal I=(ideal)d;
1230      if ((index<1)||(index>IDELEMS(I)))
1231      {
1232        if (!errorreported)
1233          Werror("wrong range[%d] in ideal/module %s(%d)",index,this->Name(),IDELEMS(I));
1234      }
1235      else
1236        r=(char *)I->m[index-1];
1237      break;
1238    }
1239    case STRING_CMD:
1240    {
1241      // this was a memory leak
1242      // we evalute it, cleanup and replace this leftv by it's evalutated form
1243      // the evalutated form will be build in tmp
1244      sleftv tmp;
1245      tmp.Init();
1246      tmp.rtyp=STRING_CMD;
1247      r=(char *)omAllocBin(size_two_bin);
1248      if ((index>0)&& (index<=(int)strlen((char *)d)))
1249      {
1250        r[0]=*(((char *)d)+index-1);
1251        r[1]='\0';
1252      }
1253      else
1254      {
1255        r[0]='\0';
1256      }
1257      tmp.data=r;
1258      if ((rtyp==IDHDL)||(rtyp==STRING_CMD))
1259      {
1260        tmp.next=next; next=NULL;
1261        //if (rtyp==STRING_CMD) { omFree((ADDRESS)data); }
1262        //data=NULL;
1263        d=NULL;
1264        CleanUp();
1265        memcpy(this,&tmp,sizeof(tmp));
1266      }
1267      // and, remember, r is also the result...
1268      else
1269      {
1270        // ???
1271        // here we still have a memory leak...
1272        // example: list L="123","456";
1273        // L[1][2];
1274        // therefore, it should never happen:
1275        assume(0);
1276        // but if it happens: here is the temporary fix:
1277        // omMarkAsStaticAddr(r);
1278      }
1279      break;
1280    }
1281    case MATRIX_CMD:
1282    {
1283      if ((index<1)
1284         ||(index>MATROWS((matrix)d))
1285         ||(e->next->start<1)
1286         ||(e->next->start>MATCOLS((matrix)d)))
1287      {
1288        if (!errorreported)
1289          Werror("wrong range[%d,%d] in matrix %s(%dx%d)",
1290                  index,e->next->start,
1291                  this->Name(),
1292                  MATROWS((matrix)d),MATCOLS((matrix)d));
1293      }
1294      else
1295        r=(char *)MATELEM((matrix)d,index,e->next->start);
1296      break;
1297    }
1298    default:
1299    {
1300      blackbox *b=NULL;
1301      if (t>MAX_TOK)
1302      {
1303        b=getBlackboxStuff(t);
1304      }
1305      if ((t==LIST_CMD)||((b!=NULL)&&(BB_LIKE_LIST(b))))
1306      {
1307        lists l=(lists)d;
1308        if ((0<index)&&(index<=l->nr+1))
1309        {
1310          if ((e->next!=NULL)
1311          && (l->m[index-1].rtyp==STRING_CMD))
1312          // string[..].Data() modifies sleftv, so let's do it ourself
1313          {
1314            char *dd=(char *)l->m[index-1].data;
1315            int j=e->next->start-1;
1316            r=(char *)omAllocBin(size_two_bin);
1317            if ((j>=0) && (j<(int)strlen(dd)))
1318            {
1319              r[0]=*(dd+j);
1320              r[1]='\0';
1321            }
1322            else
1323            {
1324              r[0]='\0';
1325            }
1326          }
1327          else
1328          {
1329            Subexpr tmp=l->m[index-1].e;
1330            l->m[index-1].e=e->next;
1331            r=(char *)l->m[index-1].Data();
1332            e->next=l->m[index-1].e;
1333            l->m[index-1].e=tmp;
1334          }
1335        }
1336        else //if (!errorreported)
1337          Werror("wrong range[%d] in list %s(%d)",index,this->Name(),l->nr+1);
1338      }
1339      else
1340        Werror("cannot index %s of type %s(%d)",this->Name(),Tok2Cmdname(t),t);
1341      break;
1342    }
1343  }
1344  return r;
1345}
1346
1347attr * sleftv::Attribute()
1348{
1349  if (e==NULL) return &attribute;
1350  if ((rtyp==LIST_CMD)
1351  ||((rtyp==IDHDL)&&(IDTYP((idhdl)data)==LIST_CMD))
1352  || (rtyp>MAX_TOK)
1353  || ((rtyp==IDHDL)&&(IDTYP((idhdl)data)>MAX_TOK)))
1354  {
1355    leftv v=LData();
1356    return &(v->attribute);
1357  }
1358  return NULL;
1359}
1360
1361leftv sleftv::LData()
1362{
1363  if (e!=NULL)
1364  {
1365    lists l=NULL;
1366    blackbox *b=getBlackboxStuff(rtyp);
1367
1368    if ((rtyp==LIST_CMD)
1369    || ((b!=NULL)&&(BB_LIKE_LIST(b))))
1370      l=(lists)data;
1371    else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1372      l=IDLIST((idhdl)data);
1373    else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)>MAX_TOK))
1374    {
1375      b=getBlackboxStuff(IDTYP((idhdl)data));
1376      if (BB_LIKE_LIST(b)) l=IDLIST((idhdl)data);
1377    }
1378    else if (rtyp==ALIAS_CMD)
1379    {
1380      idhdl h=(idhdl)data;
1381      l= (lists)(((idhdl)h->data.ustring)->data.ustring);
1382    }
1383    if (l!=NULL)
1384    {
1385      if ((0>=e->start)||(e->start>l->nr+1))
1386        return NULL;
1387      if (e->next!=NULL)
1388      {
1389        l->m[e->start-1].e=e->next;
1390        leftv r=l->m[e->start-1].LData();
1391        l->m[e->start-1].e=NULL;
1392        return r;
1393      }
1394      return &(l->m[e->start-1]);
1395    }
1396  }
1397  return this;
1398}
1399
1400#if 0
1401leftv sleftv::LHdl()
1402{
1403  if (e!=NULL)
1404  {
1405    lists l=NULL;
1406
1407    if (rtyp==LIST_CMD)
1408      l=(lists)data;
1409    if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1410      l=IDLIST((idhdl)data);
1411    if (l!=NULL)
1412    {
1413      if ((0>=e->start)||(e->start>l->nr+1))
1414        return NULL;
1415      if (e->next!=NULL)
1416      {
1417        l->m[e->start-1].e=e->next;
1418        leftv r=l->m[e->start-1].LHdl();
1419        l->m[e->start-1].e=NULL;
1420        return r;
1421      }
1422      return &(l->m[e->start-1]);
1423    }
1424  }
1425  return this;
1426}
1427#endif
1428
1429BOOLEAN assumeStdFlag(leftv h)
1430{
1431  if ((h->e!=NULL)&&(h->LTyp()==LIST_CMD))
1432  {
1433    return assumeStdFlag(h->LData());
1434  }
1435  if (!hasFlag(h,FLAG_STD))
1436  {
1437    if (!TEST_VERB_NSB)
1438    {
1439      if (TEST_V_ALLWARN)
1440        Warn("%s is no standard basis in >>%s<<",h->Name(),my_yylinebuf);
1441      else
1442        Warn("%s is no standard basis",h->Name());
1443    }
1444    return FALSE;
1445  }
1446  return TRUE;
1447}
1448
1449/*2
1450* transforms a name (as an string created by omAlloc or omStrDup)
1451* into an expression (sleftv), deletes the string
1452* utility for grammar and iparith
1453*/
1454void syMake(leftv v,const char * id, idhdl packhdl)
1455{
1456  /* resolv an identifier: (to DEF_CMD, if siq>0)
1457  * 1) reserved id: done by scanner
1458  * 2) `basering` / 'Current`
1459  * 3) existing identifier, local
1460  * 4) ringvar, ringpar, local ring
1461  * 5) existing identifier, global
1462  * 6) monom (resp. number), local ring: consisting of:
1463  * 6') ringvar,  ringpar,global ring
1464  * 6'') monom (resp. number), local ring
1465  * 7) monom (resp. number), non-local ring
1466  * 8) basering
1467  * 9) `_`
1468  * 10) everything else is of type 0
1469  */
1470#ifdef TEST
1471  if ((*id<' ')||(*id>(char)126))
1472  {
1473    Print("wrong id :%s:\n",id);
1474  }
1475#endif
1476  idhdl save_ring=currRingHdl;
1477  v->Init();
1478  if(packhdl != NULL)
1479  {
1480  //  Print("setting req_packhdl to %s\n",IDID(packhdl));
1481    v->req_packhdl = IDPACKAGE(packhdl);
1482  }
1483  else v->req_packhdl = currPack;
1484//  if (v->req_packhdl!=basePack)
1485//    Print("search %s in %s\n",id,v->req_packhdl->libname);
1486  idhdl h=NULL;
1487#ifdef SIQ
1488  if (siq<=0)
1489#endif
1490  {
1491    if (!isdigit(id[0]))
1492    {
1493      if (strcmp(id,"basering")==0)
1494      {
1495        if (currRingHdl!=NULL)
1496        {
1497          if (id!=IDID(currRingHdl)) omFreeBinAddr((ADDRESS)id);
1498          h=currRingHdl;
1499          goto id_found;
1500        }
1501        else
1502        {
1503          v->name = id;
1504          return; /* undefined */
1505        }
1506      }
1507      else if (strcmp(id,"Current")==0)
1508      {
1509        if (currPackHdl!=NULL)
1510        {
1511          omFreeBinAddr((ADDRESS)id);
1512          h=currPackHdl;
1513          goto id_found;
1514        }
1515        else
1516        {
1517          v->name = id;
1518          return; /* undefined */
1519        }
1520      }
1521      if(v->req_packhdl!=currPack)
1522      {
1523        h=v->req_packhdl->idroot->get(id,myynest);
1524      }
1525      else
1526      h=ggetid(id);
1527      /* 3) existing identifier, local */
1528      if ((h!=NULL) && (IDLEV(h)==myynest))
1529      {
1530        if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1531        goto id_found;
1532      }
1533    }
1534    if (yyInRingConstruction)
1535    {
1536      currRingHdl=NULL;
1537    }
1538    /* 4. local ring: ringvar */
1539    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
1540    /*&& (!yyInRingConstruction)*/)
1541    {
1542      int vnr;
1543      if ((vnr=r_IsRingVar(id, currRing->names,currRing->N))>=0)
1544      {
1545        poly p=pOne();
1546        pSetExp(p,vnr+1,1);
1547        pSetm(p);
1548        v->data = (void *)p;
1549        v->name = id;
1550        v->rtyp = POLY_CMD;
1551        return;
1552      }
1553      if((n_NumberOfParameters(currRing->cf)>0)
1554      &&((vnr=r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1555                              n_NumberOfParameters(currRing->cf))>=0)))
1556      {
1557        BOOLEAN ok=FALSE;
1558        poly p = pmInit(id,ok);
1559        if (ok && (p!=NULL))
1560        {
1561          v->data = pGetCoeff(p);
1562          pGetCoeff(p)=NULL;
1563          pLmFree(p);
1564          v->rtyp = NUMBER_CMD;
1565          v->name = id;
1566          return;
1567        }
1568      }
1569    }
1570    /* 5. existing identifier, global */
1571    if (h!=NULL)
1572    {
1573      if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id);  /*assume strlen(id) <1000 */
1574      goto id_found;
1575    }
1576    /* 6. local ring: number/poly */
1577    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1578    {
1579      BOOLEAN ok=FALSE;
1580      /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
1581      poly p = pmInit(id,ok);
1582      if (ok)
1583      {
1584        if (p==NULL)
1585        {
1586          v->data = (void *)nInit(0);
1587          v->rtyp = NUMBER_CMD;
1588          #ifdef HAVE_PLURAL
1589          // in this case we may have monomials equal to 0 in p_Read
1590          v->name = id;
1591          #else
1592          omFreeBinAddr((ADDRESS)id);
1593          #endif
1594        }
1595        else if (pIsConstant(p))
1596        {
1597          v->data = pGetCoeff(p);
1598          pGetCoeff(p)=NULL;
1599          pLmFree(p);
1600          v->rtyp = NUMBER_CMD;
1601          v->name = id;
1602        }
1603        else
1604        {
1605          v->data = p;
1606          v->rtyp = POLY_CMD;
1607          v->name = id;
1608        }
1609        return;
1610      }
1611    }
1612    /* 7. non-local ring: number/poly */
1613    {
1614      BOOLEAN ok=FALSE;
1615      poly p = ((currRing!=NULL)     /* ring required */
1616               && (currRingHdl!=NULL)
1617               /*&& (!yyInRingConstruction) - not in decl */
1618               && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1619                     ? pmInit(id,ok) : (poly)NULL;
1620      if (ok)
1621      {
1622        if (p==NULL)
1623        {
1624          v->data = (void *)nInit(0);
1625          v->rtyp = NUMBER_CMD;
1626          #ifdef HAVE_PLURAL
1627          // in this case we may have monomials equal to 0 in p_Read
1628          v->name = id;
1629          #else
1630          omFreeBinAddr((ADDRESS)id);
1631          #endif
1632        }
1633        else
1634        if (pIsConstant(p))
1635        {
1636          v->data = pGetCoeff(p);
1637          pGetCoeff(p)=NULL;
1638          pLmFree(p);
1639          v->rtyp = NUMBER_CMD;
1640          v->name = id;
1641        }
1642        else
1643        {
1644          v->data = p;
1645          v->rtyp = POLY_CMD;
1646          v->name = id;
1647        }
1648        if (TEST_V_ALLWARN /*&& (myynest>0)*/
1649        && ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
1650          || ((n_NumberOfParameters(currRing->cf)>0)
1651             &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1652                                n_NumberOfParameters(currRing->cf))>=0))))
1653        {
1654        // WARNING: do not use ring variable names in procedures
1655          Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
1656        }
1657        return;
1658      }
1659    }
1660    /* 8. basering ? */
1661    if ((myynest>1)&&(currRingHdl!=NULL))
1662    {
1663      if (strcmp(id,IDID(currRingHdl))==0)
1664      {
1665        if (IDID(currRingHdl)!=id) omFreeBinAddr((ADDRESS)id); /*assume strlen (id) <1000 */
1666        h=currRingHdl;
1667        goto id_found;
1668      }
1669    }
1670    if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
1671    {
1672      h=basePack->idroot->get(id,myynest);
1673      if (h!=NULL)
1674      {
1675        if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1676        v->req_packhdl=basePack;
1677        goto id_found;
1678      }
1679    }
1680  }
1681#ifdef SIQ
1682  else
1683    v->rtyp=DEF_CMD;
1684#endif
1685  /* 9: _ */
1686  if (strcmp(id,"_")==0)
1687  {
1688    omFreeBinAddr((ADDRESS)id);
1689    v->Copy(&sLastPrinted);
1690  }
1691  else
1692  {
1693    /* 10: everything else */
1694    /* v->rtyp = UNKNOWN;*/
1695    v->name = id;
1696  }
1697  currRingHdl=save_ring;
1698  return;
1699id_found: // we have an id (in h) found, to set the data in from h
1700  if (IDTYP(h)!=ALIAS_CMD)
1701  {
1702    v->rtyp = IDHDL;
1703    v->flag = IDFLAG(h);
1704    v->attribute=IDATTR(h);
1705  }
1706  else
1707  {
1708    v->rtyp = ALIAS_CMD;
1709  }
1710  v->name = IDID(h);
1711  v->data = (char *)h;
1712  currRingHdl=save_ring;
1713}
1714
1715int sleftv::Eval()
1716{
1717  BOOLEAN nok=FALSE;
1718  leftv nn=next;
1719  next=NULL;
1720  if(rtyp==IDHDL)
1721  {
1722    int t=Typ();
1723    if (t!=PROC_CMD)
1724    {
1725      void *d=CopyD(t);
1726      data=d;
1727      rtyp=t;
1728      name=NULL;
1729      e=NULL;
1730    }
1731  }
1732  else if (rtyp==COMMAND)
1733  {
1734    command d=(command)data;
1735    if(d->op==PROC_CMD) //assume d->argc==2
1736    {
1737      char *what=(char *)(d->arg1.Data());
1738      idhdl h=ggetid(what);
1739      if((h!=NULL)&&(IDTYP(h)==PROC_CMD))
1740      {
1741        nok=d->arg2.Eval();
1742        if(!nok)
1743        {
1744          nok=iiMake_proc(h,req_packhdl,&d->arg2);
1745          this->CleanUp(currRing);
1746          if (!nok)
1747          {
1748            memcpy(this,&iiRETURNEXPR,sizeof(sleftv));
1749            memset(&iiRETURNEXPR,0,sizeof(sleftv));
1750          }
1751        }
1752      }
1753      else nok=TRUE;
1754    }
1755    else if (d->op=='=') //assume d->argc==2
1756    {
1757      if ((d->arg1.rtyp!=IDHDL)&&(d->arg1.rtyp!=DEF_CMD))
1758      {
1759        nok=d->arg1.Eval();
1760      }
1761      if (!nok)
1762      {
1763        const char *n=d->arg1.name;
1764        nok=(n == NULL) || d->arg2.Eval();
1765        if (!nok)
1766        {
1767          int save_typ=d->arg1.rtyp;
1768          omCheckAddr((ADDRESS)n);
1769          if (d->arg1.rtyp!=IDHDL)
1770          syMake(&d->arg1,n);
1771          omCheckAddr((ADDRESS)d->arg1.name);
1772          if (d->arg1.rtyp==IDHDL)
1773          {
1774            n=omStrDup(IDID((idhdl)d->arg1.data));
1775            killhdl((idhdl)d->arg1.data);
1776            d->arg1.Init();
1777            //d->arg1.data=NULL;
1778            d->arg1.name=n;
1779          }
1780          d->arg1.rtyp=DEF_CMD;
1781          sleftv t;
1782          if(save_typ!=PROC_CMD) save_typ=d->arg2.rtyp;
1783          if (::RingDependend(d->arg2.rtyp))
1784            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&currRing->idroot);
1785          else
1786            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&IDROOT);
1787          memcpy(&d->arg1,&t,sizeof(sleftv));
1788          omCheckAddr((ADDRESS)d->arg1.name);
1789          nok=nok||iiAssign(&d->arg1,&d->arg2);
1790          omCheckIf(d->arg1.name != NULL,  // OB: ????
1791                    omCheckAddr((ADDRESS)d->arg1.name));
1792          if (!nok)
1793          {
1794            memset(&d->arg1,0,sizeof(sleftv));
1795            this->CleanUp();
1796            rtyp=NONE;
1797          }
1798        }
1799      }
1800      else nok=TRUE;
1801    }
1802    else
1803    {
1804      sleftv tmp;
1805      int toktype=iiTokType(d->op);
1806      if ((toktype==CMD_M)
1807      ||( toktype==ROOT_DECL_LIST)
1808      ||( toktype==RING_DECL_LIST))
1809      {
1810        if (d->argc <=3)
1811        {
1812          if (d->argc>=1) nok=d->arg1.Eval();
1813          if ((!nok) && (d->argc>=2))
1814          {
1815            nok=d->arg2.Eval();
1816            d->arg1.next=(leftv)omAllocBin(sleftv_bin);
1817            memcpy(d->arg1.next,&d->arg2,sizeof(sleftv));
1818            d->arg2.Init();
1819          }
1820          if ((!nok) && (d->argc==3))
1821          {
1822            nok=d->arg3.Eval();
1823            d->arg1.next->next=(leftv)omAllocBin(sleftv_bin);
1824            memcpy(d->arg1.next->next,&d->arg3,sizeof(sleftv));
1825            d->arg3.Init();
1826          }
1827          if (d->argc==0)
1828            nok=nok||iiExprArithM(&tmp,NULL,d->op);
1829          else
1830            nok=nok||iiExprArithM(&tmp,&d->arg1,d->op);
1831        }
1832        else
1833        {
1834          nok=d->arg1.Eval();
1835          nok=nok||iiExprArithM(&tmp,&d->arg1,d->op);
1836        }
1837      }
1838      else if (d->argc==1)
1839      {
1840        nok=d->arg1.Eval();
1841        nok=nok||iiExprArith1(&tmp,&d->arg1,d->op);
1842      }
1843      else if(d->argc==2)
1844      {
1845        nok=d->arg1.Eval();
1846        nok=nok||d->arg2.Eval();
1847        nok=nok||iiExprArith2(&tmp,&d->arg1,d->op,&d->arg2);
1848      }
1849      else if(d->argc==3)
1850      {
1851        nok=d->arg1.Eval();
1852        nok=nok||d->arg2.Eval();
1853        nok=nok||d->arg3.Eval();
1854        nok=nok||iiExprArith3(&tmp,d->op,&d->arg1,&d->arg2,&d->arg3);
1855      }
1856      else if(d->argc!=0)
1857      {
1858        nok=d->arg1.Eval();
1859        nok=nok||iiExprArithM(&tmp,&d->arg1,d->op);
1860      }
1861      else // d->argc == 0
1862      {
1863        nok = iiExprArithM(&tmp, NULL, d->op);
1864      }
1865      this->CleanUp();
1866      memcpy(this,&tmp,sizeof(tmp));
1867    }
1868  }
1869  else if (((rtyp==0)||(rtyp==DEF_CMD))
1870    &&(name!=NULL))
1871  {
1872     syMake(this,name);
1873  }
1874#ifdef MDEBUG
1875  switch(Typ())
1876  {
1877    case NUMBER_CMD:
1878#ifdef LDEBUG
1879      nTest((number)Data());
1880#endif
1881      break;
1882    case BIGINT_CMD:
1883#ifdef LDEBUG
1884      n_Test((number)Data(),coeffs_BIGINT);
1885#endif
1886      break;
1887    case POLY_CMD:
1888      pTest((poly)Data());
1889      break;
1890    case IDEAL_CMD:
1891    case MODUL_CMD:
1892    case MATRIX_CMD:
1893      {
1894        ideal id=(ideal)Data();
1895        omCheckAddrSize(id,sizeof(*id));
1896        int i=id->ncols*id->nrows-1;
1897        for(;i>=0;i--) pTest(id->m[i]);
1898      }
1899      break;
1900  }
1901#endif
1902  if (nn!=NULL) nok=nok||nn->Eval();
1903  next=nn;
1904  return nok;
1905}
1906
1907const char *iiSleftv2name(leftv v)
1908{
1909  return(v->name);
1910}
1911
1912void * sattr::CopyA()
1913{
1914  omCheckAddrSize(this,sizeof(sattr));
1915  return s_internalCopy(atyp,data);
1916}
1917
Note: See TracBrowser for help on using the repository browser.