source: git/Singular/subexpr.cc @ b117e8

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