source: git/Singular/subexpr.cc @ 7ddcb2

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