source: git/Singular/subexpr.cc @ 49fbc3f

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