source: git/Singular/subexpr.cc @ 237b3e4

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