source: git/Singular/subexpr.cc @ 5ca9807

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