source: git/Singular/subexpr.cc @ 84a6a7

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