source: git/Singular/subexpr.cc @ 4c9cf1

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