source: git/Singular/subexpr.cc @ 200e65d

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