source: git/Singular/subexpr.cc @ c232af

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