source: git/Singular/subexpr.cc @ f9bb68

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