source: git/Singular/subexpr.cc @ bceefc

spielwiese
Last change on this file since bceefc was bceefc, checked in by Hans Schoenemann <hannes@…>, 10 years ago
chg: toward ring-indep. numbers
  • Property mode set to 100644
File size: 42.9 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        data=NULL;
957        return NUMBER_CMD;
958      case VNOETHER:
959        data=NULL;
960        return POLY_CMD;
961      //case COMMAND:
962      //  return COMMAND;
963      default:
964        return rtyp;
965    }
966  }
967  int r=0;
968  int t=rtyp;
969  if (t==IDHDL) t=IDTYP((idhdl)data);
970  else if (t==ALIAS_CMD) { idhdl h=(idhdl)IDDATA((idhdl)data); t=IDTYP(h); }
971  switch (t)
972  {
973    case INTVEC_CMD:
974    case INTMAT_CMD:
975      r=INT_CMD;
976      break;
977    case BIGINTMAT_CMD:
978      r=BIGINT_CMD;
979      break;
980    case IDEAL_CMD:
981    case MATRIX_CMD:
982    case MAP_CMD:
983      r=POLY_CMD;
984      break;
985    case MODUL_CMD:
986      r=VECTOR_CMD;
987      break;
988    case STRING_CMD:
989      r=STRING_CMD;
990      break;
991    default:
992    {
993      blackbox *b=NULL;
994      if (t>MAX_TOK)
995      {
996        b=getBlackboxStuff(t);
997      }
998      if ((t==LIST_CMD)||((b!=NULL)&&BB_LIKE_LIST(b)))
999      {
1000        lists l;
1001        if (rtyp==IDHDL) l=IDLIST((idhdl)data);
1002        else if (rtyp==ALIAS_CMD)
1003        {
1004          idhdl h=(idhdl)data;
1005          l=(lists)(((idhdl)h->data.ustring)->data.ustring);
1006        }
1007        else             l=(lists)data;
1008        if ((0<e->start)&&(e->start<=l->nr+1))
1009        {
1010          Subexpr tmp=l->m[e->start-1].e;
1011          l->m[e->start-1].e=e->next;
1012          r=l->m[e->start-1].Typ();
1013          e->next=l->m[e->start-1].e;
1014          l->m[e->start-1].e=tmp;
1015        }
1016        else
1017        {
1018          //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
1019          r=NONE;
1020        }
1021      }
1022      else
1023        Werror("cannot index type %s(%d)",Tok2Cmdname(t),t);
1024      break;
1025    }
1026  }
1027  return r;
1028}
1029
1030int  sleftv::LTyp()
1031{
1032  lists l=NULL;
1033  int r;
1034  if (rtyp==LIST_CMD)
1035    l=(lists)data;
1036  else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1037    l=IDLIST((idhdl)data);
1038  else
1039    return Typ();
1040  //if (l!=NULL)
1041  {
1042    if ((e!=NULL) && (e->next!=NULL))
1043    {
1044      if ((0<e->start)&&(e->start<=l->nr+1))
1045      {
1046        l->m[e->start-1].e=e->next;
1047        r=l->m[e->start-1].LTyp();
1048        l->m[e->start-1].e=NULL;
1049      }
1050      else
1051      {
1052        //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
1053        r=NONE;
1054      }
1055      return r;
1056    }
1057    return LIST_CMD;
1058  }
1059  return Typ();
1060}
1061
1062void * sleftv::Data()
1063{
1064  if ((rtyp!=IDHDL) && iiCheckRing(rtyp))
1065     return NULL;
1066  if (e==NULL)
1067  {
1068    switch (rtyp)
1069    {
1070      case ALIAS_CMD:
1071      {
1072        idhdl h=(idhdl)data;
1073        return  ((idhdl)h->data.ustring)->data.ustring;
1074      }
1075      case VECHO:      return (void *)(long)si_echo;
1076      case VPRINTLEVEL:return (void *)(long)printlevel;
1077      case VCOLMAX:    return (void *)(long)colmax;
1078      case VTIMER:     return (void *)(long)getTimer();
1079      case VRTIMER:    return (void *)(long)getRTimer();
1080      case VOICE:      return (void *)(long)(myynest+1);
1081      case VMAXDEG:    return (void *)(long)Kstd1_deg;
1082      case VMAXMULT:   return (void *)(long)Kstd1_mu;
1083      case TRACE:      return (void *)(long)traceit;
1084      case VSHORTOUT:  return (void *)(long)(currRing != NULL ? currRing->ShortOut : 0);
1085      case VMINPOLY:
1086        if ( (currRing != NULL)  && nCoeff_is_algExt(currRing->cf) && !nCoeff_is_GF(currRing->cf))
1087        {
1088          /* Q(a), Fp(a), but not GF(q) */
1089          const ring A = currRing->cf->extRing;
1090
1091          assume( A != NULL );
1092          assume( A->qideal != NULL );
1093
1094          return (void *)A->qideal->m[0];
1095        }
1096        else
1097          return (void *)currRing->cf->nNULL;
1098
1099      case VNOETHER:   return (void *) (currRing->ppNoether);
1100      case IDHDL:
1101        return IDDATA((idhdl)data);
1102      case POINTER_CMD:
1103        return IDDATA((idhdl)data);
1104      case COMMAND:
1105        //return NULL;
1106      default:
1107        return data;
1108    }
1109  }
1110  /* e != NULL : */
1111  int t=rtyp;
1112  void *d=data;
1113  if (t==IDHDL)
1114  {
1115    t=((idhdl)data)->typ;
1116    d=IDDATA((idhdl)data);
1117  }
1118  else if (t==ALIAS_CMD)
1119  {
1120    idhdl h=(idhdl)IDDATA((idhdl)data);
1121    t=IDTYP(h);
1122    d=IDDATA(h);
1123  }
1124  if (iiCheckRing(t))
1125    return NULL;
1126  char *r=NULL;
1127  int index=e->start;
1128  switch (t)
1129  {
1130    case INTVEC_CMD:
1131    {
1132      intvec *iv=(intvec *)d;
1133      if ((index<1)||(index>iv->length()))
1134      {
1135        if (!errorreported)
1136          Werror("wrong range[%d] in intvec(%d)",index,iv->length());
1137      }
1138      else
1139        r=(char *)(long)((*iv)[index-1]);
1140      break;
1141    }
1142    case INTMAT_CMD:
1143    {
1144      intvec *iv=(intvec *)d;
1145      if ((index<1)
1146         ||(index>iv->rows())
1147         ||(e->next->start<1)
1148         ||(e->next->start>iv->cols()))
1149      {
1150        if (!errorreported)
1151        Werror("wrong range[%d,%d] in intmat(%dx%d)",index,e->next->start,
1152                                                     iv->rows(),iv->cols());
1153      }
1154      else
1155        r=(char *)(long)(IMATELEM((*iv),index,e->next->start));
1156      break;
1157    }
1158    case BIGINTMAT_CMD:
1159    {
1160      bigintmat *m=(bigintmat *)d;
1161      if ((index<1)
1162         ||(index>m->rows())
1163         ||(e->next->start<1)
1164         ||(e->next->start>m->cols()))
1165      {
1166        if (!errorreported)
1167        Werror("wrong range[%d,%d] in bigintmat(%dx%d)",index,e->next->start,
1168                                                     m->rows(),m->cols());
1169      }
1170      else
1171        r=(char *)(BIMATELEM((*m),index,e->next->start));
1172      break;
1173    }
1174    case IDEAL_CMD:
1175    case MODUL_CMD:
1176    case MAP_CMD:
1177    {
1178      ideal I=(ideal)d;
1179      if ((index<1)||(index>IDELEMS(I)))
1180      {
1181        if (!errorreported)
1182          Werror("wrong range[%d] in ideal/module(%d)",index,IDELEMS(I));
1183      }
1184      else
1185        r=(char *)I->m[index-1];
1186      break;
1187    }
1188    case STRING_CMD:
1189    {
1190      // this was a memory leak
1191      // we evalute it, cleanup and replace this leftv by it's evalutated form
1192      // the evalutated form will be build in tmp
1193      sleftv tmp;
1194      tmp.Init();
1195      tmp.rtyp=STRING_CMD;
1196      r=(char *)omAllocBin(size_two_bin);
1197      if ((index>0)&& (index<=(int)strlen((char *)d)))
1198      {
1199        r[0]=*(((char *)d)+index-1);
1200        r[1]='\0';
1201      }
1202      else
1203      {
1204        r[0]='\0';
1205      }
1206      tmp.data=r;
1207      if ((rtyp==IDHDL)||(rtyp==STRING_CMD))
1208      {
1209        tmp.next=next; next=NULL;
1210        //if (rtyp==STRING_CMD) { omFree((ADDRESS)data); }
1211        //data=NULL;
1212        d=NULL;
1213        CleanUp();
1214        memcpy(this,&tmp,sizeof(tmp));
1215      }
1216      // and, remember, r is also the result...
1217      else
1218      {
1219        // ???
1220        // here we still have a memory leak...
1221        // example: list L="123","456";
1222        // L[1][2];
1223        // therefore, it should never happen:
1224        assume(0);
1225        // but if it happens: here is the temporary fix:
1226        // omMarkAsStaticAddr(r);
1227      }
1228      break;
1229    }
1230    case MATRIX_CMD:
1231    {
1232      if ((index<1)
1233         ||(index>MATROWS((matrix)d))
1234         ||(e->next->start<1)
1235         ||(e->next->start>MATCOLS((matrix)d)))
1236      {
1237        if (!errorreported)
1238          Werror("wrong range[%d,%d] in intmat(%dx%d)",
1239                  index,e->next->start,
1240                  MATROWS((matrix)d),MATCOLS((matrix)d));
1241      }
1242      else
1243        r=(char *)MATELEM((matrix)d,index,e->next->start);
1244      break;
1245    }
1246    default:
1247    {
1248      blackbox *b=NULL;
1249      if (t>MAX_TOK)
1250      {
1251        b=getBlackboxStuff(t);
1252      }
1253      if ((t==LIST_CMD)||((b!=NULL)&&(BB_LIKE_LIST(b))))
1254      {
1255        lists l=(lists)d;
1256        if ((0<index)&&(index<=l->nr+1))
1257        {
1258          if ((e->next!=NULL)
1259          && (l->m[index-1].rtyp==STRING_CMD))
1260          // string[..].Data() modifies sleftv, so let's do it ourself
1261          {
1262            char *dd=(char *)l->m[index-1].data;
1263            int j=e->next->start-1;
1264            r=(char *)omAllocBin(size_two_bin);
1265            if ((j>=0) && (j<(int)strlen(dd)))
1266            {
1267              r[0]=*(dd+j);
1268              r[1]='\0';
1269            }
1270            else
1271            {
1272              r[0]='\0';
1273            }
1274          }
1275          else
1276          {
1277            Subexpr tmp=l->m[index-1].e;
1278            l->m[index-1].e=e->next;
1279            r=(char *)l->m[index-1].Data();
1280            e->next=l->m[index-1].e;
1281            l->m[index-1].e=tmp;
1282          }
1283        }
1284        else //if (!errorreported)
1285          Werror("wrong range[%d] in list(%d)",index,l->nr+1);
1286      }
1287      else
1288        Werror("cannot index type %s(%d)",Tok2Cmdname(t),t);
1289      break;
1290    }
1291  }
1292  return r;
1293}
1294
1295attr * sleftv::Attribute()
1296{
1297  if (e==NULL) return &attribute;
1298  if ((rtyp==LIST_CMD)
1299  ||((rtyp==IDHDL)&&(IDTYP((idhdl)data)==LIST_CMD)))
1300  {
1301    leftv v=LData();
1302    return &(v->attribute);
1303  }
1304  return NULL;
1305}
1306
1307leftv sleftv::LData()
1308{
1309  if (e!=NULL)
1310  {
1311    lists l=NULL;
1312
1313    if (rtyp==LIST_CMD)
1314      l=(lists)data;
1315    else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1316      l=IDLIST((idhdl)data);
1317    else if (rtyp==ALIAS_CMD)
1318    {
1319      idhdl h=(idhdl)data;
1320      l= (lists)(((idhdl)h->data.ustring)->data.ustring);
1321    }
1322    if (l!=NULL)
1323    {
1324      if ((0>=e->start)||(e->start>l->nr+1))
1325        return NULL;
1326      if (e->next!=NULL)
1327      {
1328        l->m[e->start-1].e=e->next;
1329        leftv r=l->m[e->start-1].LData();
1330        l->m[e->start-1].e=NULL;
1331        return r;
1332      }
1333      return &(l->m[e->start-1]);
1334    }
1335  }
1336  return this;
1337}
1338
1339#if 0
1340leftv sleftv::LHdl()
1341{
1342  if (e!=NULL)
1343  {
1344    lists l=NULL;
1345
1346    if (rtyp==LIST_CMD)
1347      l=(lists)data;
1348    if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1349      l=IDLIST((idhdl)data);
1350    if (l!=NULL)
1351    {
1352      if ((0>=e->start)||(e->start>l->nr+1))
1353        return NULL;
1354      if (e->next!=NULL)
1355      {
1356        l->m[e->start-1].e=e->next;
1357        leftv r=l->m[e->start-1].LHdl();
1358        l->m[e->start-1].e=NULL;
1359        return r;
1360      }
1361      return &(l->m[e->start-1]);
1362    }
1363  }
1364  return this;
1365}
1366#endif
1367
1368BOOLEAN assumeStdFlag(leftv h)
1369{
1370  if ((h->e!=NULL)&&(h->LTyp()==LIST_CMD))
1371  {
1372    return assumeStdFlag(h->LData());
1373  }
1374  if (!hasFlag(h,FLAG_STD))
1375  {
1376    if (!TEST_VERB_NSB)
1377    {
1378      if (TEST_V_ALLWARN)
1379        Warn("%s is no standard basis in >>%s<<",h->Name(),my_yylinebuf);
1380      else
1381        Warn("%s is no standard basis",h->Name());
1382    }
1383    return FALSE;
1384  }
1385  return TRUE;
1386}
1387
1388/*2
1389* transforms a name (as an string created by omAlloc or omStrDup)
1390* into an expression (sleftv), deletes the string
1391* utility for grammar and iparith
1392*/
1393void syMake(leftv v,const char * id, idhdl packhdl)
1394{
1395  /* resolv an identifier: (to DEF_CMD, if siq>0)
1396  * 1) reserved id: done by scanner
1397  * 2) `basering` / 'Current`
1398  * 3) existing identifier, local
1399  * 4) ringvar, ringpar, local ring
1400  * 5) existing identifier, global
1401  * 6) monom (resp. number), local ring: consisting of:
1402  * 6') ringvar,  ringpar,global ring
1403  * 6'') monom (resp. number), local ring
1404  * 7) monom (resp. number), non-local ring
1405  * 8) basering
1406  * 9) `_`
1407  * 10) everything else is of type 0
1408  */
1409#ifdef TEST
1410  if ((*id<' ')||(*id>(char)126))
1411  {
1412    Print("wrong id :%s:\n",id);
1413  }
1414#endif
1415  idhdl save_ring=currRingHdl;
1416  v->Init();
1417  if(packhdl != NULL)
1418  {
1419  //  Print("setting req_packhdl to %s\n",IDID(packhdl));
1420    v->req_packhdl = IDPACKAGE(packhdl);
1421  }
1422  else v->req_packhdl = currPack;
1423//  if (v->req_packhdl!=basePack)
1424//    Print("search %s in %s\n",id,v->req_packhdl->libname);
1425  idhdl h=NULL;
1426#ifdef SIQ
1427  if (siq<=0)
1428#endif
1429  {
1430    if (!isdigit(id[0]))
1431    {
1432      if (strcmp(id,"basering")==0)
1433      {
1434        if (currRingHdl!=NULL)
1435        {
1436          if (id!=IDID(currRingHdl)) omFreeBinAddr((ADDRESS)id);
1437          h=currRingHdl;
1438          goto id_found;
1439        }
1440        else
1441        {
1442          v->name = id;
1443          return; /* undefined */
1444        }
1445      }
1446      else if (strcmp(id,"Current")==0)
1447      {
1448        if (currPackHdl!=NULL)
1449        {
1450          omFreeBinAddr((ADDRESS)id);
1451          h=currPackHdl;
1452          goto id_found;
1453        }
1454        else
1455        {
1456          v->name = id;
1457          return; /* undefined */
1458        }
1459      }
1460      if(v->req_packhdl!=currPack)
1461      {
1462        h=v->req_packhdl->idroot->get(id,myynest);
1463      }
1464      else
1465      h=ggetid(id);
1466      /* 3) existing identifier, local */
1467      if ((h!=NULL) && (IDLEV(h)==myynest))
1468      {
1469        if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1470        goto id_found;
1471      }
1472    }
1473    if (yyInRingConstruction)
1474    {
1475      currRingHdl=NULL;
1476    }
1477    /* 4. local ring: ringvar */
1478    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
1479    /*&& (!yyInRingConstruction)*/)
1480    {
1481      int vnr;
1482      if ((vnr=r_IsRingVar(id, currRing->names,currRing->N))>=0)
1483      {
1484        poly p=pOne();
1485        pSetExp(p,vnr+1,1);
1486        pSetm(p);
1487        v->data = (void *)p;
1488        v->name = id;
1489        v->rtyp = POLY_CMD;
1490        return;
1491      }
1492      if((n_NumberOfParameters(currRing->cf)>0)
1493      &&((vnr=r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1494                              n_NumberOfParameters(currRing->cf))>=0)))
1495      {
1496        BOOLEAN ok=FALSE;
1497        poly p = pmInit(id,ok);
1498        if (ok && (p!=NULL))
1499        {
1500          v->data = pGetCoeff(p);
1501          pGetCoeff(p)=NULL;
1502          pLmFree(p);
1503          v->rtyp = NUMBER_CMD;
1504          v->name = id;
1505          return;
1506        }
1507      }
1508    }
1509    /* 5. existing identifier, global */
1510    if (h!=NULL)
1511    {
1512      if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id);  /*assume strlen(id) <1000 */
1513      goto id_found;
1514    }
1515    /* 6. local ring: number/poly */
1516    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1517    {
1518      BOOLEAN ok=FALSE;
1519      /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
1520      poly p = pmInit(id,ok);
1521      if (ok)
1522      {
1523        if (p==NULL)
1524        {
1525          v->data = (void *)nInit(0);
1526          v->rtyp = NUMBER_CMD;
1527          #ifdef HAVE_PLURAL
1528          // in this case we may have monomials equal to 0 in p_Read
1529          v->name = id;
1530          #else
1531          omFreeBinAddr((ADDRESS)id);
1532          #endif
1533        }
1534        else if (pIsConstant(p))
1535        {
1536          v->data = pGetCoeff(p);
1537          pGetCoeff(p)=NULL;
1538          pLmFree(p);
1539          v->rtyp = NUMBER_CMD;
1540          v->name = id;
1541        }
1542        else
1543        {
1544          v->data = p;
1545          v->rtyp = POLY_CMD;
1546          v->name = id;
1547        }
1548        return;
1549      }
1550    }
1551    /* 7. non-local ring: number/poly */
1552    {
1553      BOOLEAN ok=FALSE;
1554      poly p = ((currRing!=NULL)     /* ring required */
1555               && (currRingHdl!=NULL)
1556               /*&& (!yyInRingConstruction) - not in decl */
1557               && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1558                     ? pmInit(id,ok) : (poly)NULL;
1559      if (ok)
1560      {
1561        if (p==NULL)
1562        {
1563          v->data = (void *)nInit(0);
1564          v->rtyp = NUMBER_CMD;
1565          #ifdef HAVE_PLURAL
1566          // in this case we may have monomials equal to 0 in p_Read
1567          v->name = id;
1568          #else
1569          omFreeBinAddr((ADDRESS)id);
1570          #endif
1571        }
1572        else
1573        if (pIsConstant(p))
1574        {
1575          v->data = pGetCoeff(p);
1576          pGetCoeff(p)=NULL;
1577          pLmFree(p);
1578          v->rtyp = NUMBER_CMD;
1579          v->name = id;
1580        }
1581        else
1582        {
1583          v->data = p;
1584          v->rtyp = POLY_CMD;
1585          v->name = id;
1586        }
1587        if (TEST_V_ALLWARN /*&& (myynest>0)*/
1588        && ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
1589          || ((n_NumberOfParameters(currRing->cf)>0)
1590             &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1591                                n_NumberOfParameters(currRing->cf))>=0))))
1592        {
1593        // WARNING: do not use ring variable names in procedures
1594          Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
1595        }
1596        return;
1597      }
1598    }
1599    /* 8. basering ? */
1600    if ((myynest>1)&&(currRingHdl!=NULL))
1601    {
1602      if (strcmp(id,IDID(currRingHdl))==0)
1603      {
1604        if (IDID(currRingHdl)!=id) omFreeBinAddr((ADDRESS)id); /*assume strlen (id) <1000 */
1605        h=currRingHdl;
1606        goto id_found;
1607      }
1608    }
1609    if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
1610    {
1611      h=basePack->idroot->get(id,myynest);
1612      if (h!=NULL)
1613      {
1614        if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1615        v->req_packhdl=basePack;
1616        goto id_found;
1617      }
1618    }
1619  }
1620#ifdef SIQ
1621  else
1622    v->rtyp=DEF_CMD;
1623#endif
1624  /* 9: _ */
1625  if (strcmp(id,"_")==0)
1626  {
1627    omFreeBinAddr((ADDRESS)id);
1628    v->Copy(&sLastPrinted);
1629  }
1630  else
1631  {
1632    /* 10: everything else */
1633    /* v->rtyp = UNKNOWN;*/
1634    v->name = id;
1635  }
1636  currRingHdl=save_ring;
1637  return;
1638id_found: // we have an id (in h) found, to set the data in from h
1639  if (IDTYP(h)!=ALIAS_CMD)
1640  {
1641    v->rtyp = IDHDL;
1642    v->flag = IDFLAG(h);
1643    v->attribute=IDATTR(h);
1644  }
1645  else
1646  {
1647    v->rtyp = ALIAS_CMD;
1648  }
1649  v->name = IDID(h);
1650  v->data = (char *)h;
1651  currRingHdl=save_ring;
1652}
1653
1654int sleftv::Eval()
1655{
1656  BOOLEAN nok=FALSE;
1657  leftv nn=next;
1658  next=NULL;
1659  if(rtyp==IDHDL)
1660  {
1661    int t=Typ();
1662    if (t!=PROC_CMD)
1663    {
1664      void *d=CopyD(t);
1665      data=d;
1666      rtyp=t;
1667      name=NULL;
1668      e=NULL;
1669    }
1670  }
1671  else if (rtyp==COMMAND)
1672  {
1673    command d=(command)data;
1674    if(d->op==PROC_CMD) //assume d->argc==2
1675    {
1676      char *what=(char *)(d->arg1.Data());
1677      idhdl h=ggetid(what);
1678      if((h!=NULL)&&(IDTYP(h)==PROC_CMD))
1679      {
1680        nok=d->arg2.Eval();
1681        if(!nok)
1682        {
1683          nok=iiMake_proc(h,req_packhdl,&d->arg2);
1684          if (!nok)
1685            memcpy(this,&iiRETURNEXPR,sizeof(sleftv));
1686        }
1687      }
1688      else nok=TRUE;
1689    }
1690    else if (d->op=='=') //assume d->argc==2
1691    {
1692      if ((d->arg1.rtyp!=IDHDL)&&(d->arg1.rtyp!=DEF_CMD))
1693      {
1694        nok=d->arg1.Eval();
1695      }
1696      if (!nok)
1697      {
1698        const char *n=d->arg1.name;
1699        nok=(n == NULL) || d->arg2.Eval();
1700        if (!nok)
1701        {
1702          int save_typ=d->arg1.rtyp;
1703          omCheckAddr((ADDRESS)n);
1704          if (d->arg1.rtyp!=IDHDL)
1705          syMake(&d->arg1,n);
1706          omCheckAddr((ADDRESS)d->arg1.name);
1707          if (d->arg1.rtyp==IDHDL)
1708          {
1709            n=omStrDup(IDID((idhdl)d->arg1.data));
1710            killhdl((idhdl)d->arg1.data);
1711            d->arg1.Init();
1712            //d->arg1.data=NULL;
1713            d->arg1.name=n;
1714          }
1715          d->arg1.rtyp=DEF_CMD;
1716          sleftv t;
1717          if(save_typ!=PROC_CMD) save_typ=d->arg2.rtyp;
1718          if (::RingDependend(d->arg2.rtyp))
1719            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&currRing->idroot);
1720          else
1721            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&IDROOT);
1722          memcpy(&d->arg1,&t,sizeof(sleftv));
1723          omCheckAddr((ADDRESS)d->arg1.name);
1724          nok=nok||iiAssign(&d->arg1,&d->arg2);
1725          omCheckIf(d->arg1.name != NULL,  // OB: ????
1726                    omCheckAddr((ADDRESS)d->arg1.name));
1727          if (!nok)
1728          {
1729            memset(&d->arg1,0,sizeof(sleftv));
1730            this->CleanUp();
1731            rtyp=NONE;
1732          }
1733        }
1734      }
1735      else nok=TRUE;
1736    }
1737    else
1738    {
1739      int toktype=iiTokType(d->op);
1740      if ((toktype==CMD_M)
1741      ||( toktype==ROOT_DECL_LIST)
1742      ||( toktype==RING_DECL_LIST))
1743      {
1744        if (d->argc <=3)
1745        {
1746          if (d->argc>=1) nok=d->arg1.Eval();
1747          if ((!nok) && (d->argc>=2))
1748          {
1749            nok=d->arg2.Eval();
1750            d->arg1.next=(leftv)omAllocBin(sleftv_bin);
1751            memcpy(d->arg1.next,&d->arg2,sizeof(sleftv));
1752            d->arg2.Init();
1753          }
1754          if ((!nok) && (d->argc==3))
1755          {
1756            nok=d->arg3.Eval();
1757            d->arg1.next->next=(leftv)omAllocBin(sleftv_bin);
1758            memcpy(d->arg1.next->next,&d->arg3,sizeof(sleftv));
1759            d->arg3.Init();
1760          }
1761          if (d->argc==0)
1762            nok=nok||iiExprArithM(this,NULL,d->op);
1763          else
1764            nok=nok||iiExprArithM(this,&d->arg1,d->op);
1765        }
1766        else
1767        {
1768          nok=d->arg1.Eval();
1769          nok=nok||iiExprArithM(this,&d->arg1,d->op);
1770        }
1771      }
1772      else if (d->argc==1)
1773      {
1774        nok=d->arg1.Eval();
1775        nok=nok||iiExprArith1(this,&d->arg1,d->op);
1776      }
1777      else if(d->argc==2)
1778      {
1779        nok=d->arg1.Eval();
1780        nok=nok||d->arg2.Eval();
1781        nok=nok||iiExprArith2(this,&d->arg1,d->op,&d->arg2);
1782      }
1783      else if(d->argc==3)
1784      {
1785        nok=d->arg1.Eval();
1786        nok=nok||d->arg2.Eval();
1787        nok=nok||d->arg3.Eval();
1788        nok=nok||iiExprArith3(this,d->op,&d->arg1,&d->arg2,&d->arg3);
1789      }
1790      else if(d->argc!=0)
1791      {
1792        nok=d->arg1.Eval();
1793        nok=nok||iiExprArithM(this,&d->arg1,d->op);
1794      }
1795      else // d->argc == 0
1796      {
1797        nok = iiExprArithM(this, NULL, d->op);
1798      }
1799    }
1800  }
1801  else if (((rtyp==0)||(rtyp==DEF_CMD))
1802    &&(name!=NULL))
1803  {
1804     syMake(this,name);
1805  }
1806#ifdef MDEBUG
1807  switch(Typ())
1808  {
1809    case NUMBER_CMD:
1810#ifdef LDEBUG
1811      nTest((number)Data());
1812#endif
1813      break;
1814    case BIGINT_CMD:
1815#ifdef LDEBUG
1816      n_Test((number)Data(),coeffs_BIGINT);
1817#endif
1818      break;
1819    case POLY_CMD:
1820      pTest((poly)Data());
1821      break;
1822    case IDEAL_CMD:
1823    case MODUL_CMD:
1824    case MATRIX_CMD:
1825      {
1826        ideal id=(ideal)Data();
1827        omCheckAddrSize(id,sizeof(*id));
1828        int i=id->ncols*id->nrows-1;
1829        for(;i>=0;i--) pTest(id->m[i]);
1830      }
1831      break;
1832  }
1833#endif
1834  if (nn!=NULL) nok=nok||nn->Eval();
1835  next=nn;
1836  return nok;
1837}
1838
1839const char *iiSleftv2name(leftv v)
1840{
1841  return(v->name);
1842}
1843
1844void * sattr::CopyA()
1845{
1846  omCheckAddrSize(this,sizeof(sattr));
1847  return s_internalCopy(atyp,data);
1848}
1849
Note: See TracBrowser for help on using the repository browser.