source: git/Singular/subexpr.cc @ 3907ab

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