source: git/Singular/subexpr.cc @ 75f10d

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