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

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