source: git/Singular/subexpr.cc @ ff7e529

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