source: git/Singular/subexpr.cc @ 018dec

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