source: git/Singular/subexpr.cc @ 5dfa8c

spielwiese
Last change on this file since 5dfa8c was 0e051f, checked in by Hans Schönemann <hannes@…>, 14 years ago
structs.h simplified git-svn-id: file:///usr/local/Singular/svn/trunk@12750 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 36.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT: handling of leftv
6*/
7/* $Id$ */
8
9#include <stdlib.h>
10#include <stdio.h>
11#include <string.h>
12#include <ctype.h>
13#include <unistd.h>
14
15#include "mod2.h"
16#include "intvec.h"
17#include "tok.h"
18#include "options.h"
19#include "ipid.h"
20#include "intvec.h"
21#include <omalloc.h>
22#include "febase.h"
23#include "polys.h"
24#include "ideals.h"
25#include "maps.h"
26#include "matpol.h"
27#include "kstd1.h"
28#include "timer.h"
29#include "ring.h"
30#include "ffields.h"
31#include "numbers.h"
32#include "longrat.h"
33#include "ipshell.h"
34#include "lists.h"
35#include "attrib.h"
36#include "silink.h"
37#include "syz.h"
38#include "attrib.h"
39#include "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))
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 IDHDL:
833        return IDTYP((idhdl)data);
834      case VECHO:
835      case VPAGELENGTH:
836      case VPRINTLEVEL:
837      case VCOLMAX:
838      case VTIMER:
839#ifdef HAVE_RTIMER
840      case VRTIMER:
841#endif
842      case VOICE:
843      case VMAXDEG:
844      case VMAXMULT:
845      case TRACE:
846      case VSHORTOUT:
847        return INT_CMD;
848      case LIB_CMD:
849        return STRING_CMD;
850      case VMINPOLY:
851        return NUMBER_CMD;
852      case VNOETHER:
853        return POLY_CMD;
854      //case COMMAND:
855      //  return COMMAND;
856      default:
857        return rtyp;
858    }
859  }
860  int r=0;
861  int t=rtyp;
862  if (t==IDHDL) t=IDTYP((idhdl)data);
863  switch (t)
864  {
865    case INTVEC_CMD:
866    case INTMAT_CMD:
867      r=INT_CMD;
868      break;
869    case IDEAL_CMD:
870    case MATRIX_CMD:
871    case MAP_CMD:
872      r=POLY_CMD;
873      break;
874    case MODUL_CMD:
875      r=VECTOR_CMD;
876      break;
877    case STRING_CMD:
878      r=STRING_CMD;
879      break;
880    case LIST_CMD:
881    {
882      lists l;
883      if (rtyp==IDHDL) l=IDLIST((idhdl)data);
884      else             l=(lists)data;
885      if ((0<e->start)&&(e->start<=l->nr+1))
886      {
887        Subexpr tmp=l->m[e->start-1].e;
888        l->m[e->start-1].e=e->next;
889        r=l->m[e->start-1].Typ();
890        e->next=l->m[e->start-1].e;
891        l->m[e->start-1].e=tmp;
892      }
893      else
894      {
895        //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
896        r=NONE;
897      }
898      break;
899    }
900    default:
901      Werror("cannot index type %d",t);
902  }
903  return r;
904}
905
906int  sleftv::LTyp()
907{
908  lists l=NULL;
909  int r;
910  if (rtyp==LIST_CMD)
911    l=(lists)data;
912  else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
913    l=IDLIST((idhdl)data);
914  else
915    return Typ();
916  //if (l!=NULL)
917  {
918    if ((e!=NULL) && (e->next!=NULL))
919    {
920      if ((0<e->start)&&(e->start<=l->nr+1))
921      {
922        l->m[e->start-1].e=e->next;
923        r=l->m[e->start-1].LTyp();
924        l->m[e->start-1].e=NULL;
925      }
926      else
927      {
928        //Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
929        r=NONE;
930      }
931      return r;
932    }
933    return LIST_CMD;
934  }
935  return Typ();
936}
937
938void sleftv::SetData(void* what)
939{
940  if (rtyp == IDHDL)
941  {
942    IDDATA((idhdl)data) = (char *)what;
943  }
944  else
945  {
946    data = what;
947  }
948}
949
950void * sleftv::Data()
951{
952  if ((rtyp!=IDHDL) && iiCheckRing(rtyp))
953     return NULL;
954  if (e==NULL)
955  {
956    switch (rtyp)
957    {
958      case VECHO:      return (void *)si_echo;
959      case VPAGELENGTH:return (void *)pagelength;
960      case VPRINTLEVEL:return (void *)printlevel;
961      case VCOLMAX:    return (void *)colmax;
962      case VTIMER:     return (void *)getTimer();
963#ifdef HAVE_RTIMER
964      case VRTIMER:    return (void *)getRTimer();
965#endif
966      case VOICE:      return (void *)(myynest+1);
967      case VMAXDEG:    return (void *)Kstd1_deg;
968      case VMAXMULT:   return (void *)Kstd1_mu;
969      case TRACE:      return (void *)traceit;
970      case VSHORTOUT:  return (void *)(currRing != NULL ? currRing->ShortOut : 0);
971      case VMINPOLY:   if (currRing != NULL &&
972                           (currRing->minpoly!=NULL)&&(!rField_is_GF()))
973                       /* Q(a), Fp(a), but not GF(q) */
974                         return (void *)currRing->minpoly;
975                       else
976                         return (void *)nNULL;
977      case VNOETHER:   return (void *) ppNoether;
978      case LIB_CMD:    {
979                         return (void *)sNoName;
980                       }
981      case IDHDL:
982        return IDDATA((idhdl)data);
983      case POINTER_CMD:
984        return IDDATA((idhdl)data);
985      case COMMAND:
986        //return NULL;
987      default:
988        return data;
989    }
990  }
991  /* e != NULL : */
992  int t=rtyp;
993  void *d=data;
994  if (t==IDHDL)
995  {
996    t=((idhdl)data)->typ;
997    d=IDDATA((idhdl)data);
998  }
999  if (iiCheckRing(t))
1000    return NULL;
1001  char *r=NULL;
1002  int index=e->start;
1003  switch (t)
1004  {
1005    case INTVEC_CMD:
1006    {
1007      intvec *iv=(intvec *)d;
1008      if ((index<1)||(index>iv->length()))
1009      {
1010        if (!errorreported)
1011          Werror("wrong range[%d] in intvec(%d)",index,iv->length());
1012      }
1013      else
1014        r=(char *)((*iv)[index-1]);
1015      break;
1016    }
1017    case INTMAT_CMD:
1018    {
1019      intvec *iv=(intvec *)d;
1020      if ((index<1)
1021         ||(index>iv->rows())
1022         ||(e->next->start<1)
1023         ||(e->next->start>iv->cols()))
1024      {
1025        if (!errorreported)
1026        Werror("wrong range[%d,%d] in intmat(%dx%d)",index,e->next->start,
1027                                                     iv->rows(),iv->cols());
1028      }
1029      else
1030        r=(char *)(IMATELEM((*iv),index,e->next->start));
1031      break;
1032    }
1033    case IDEAL_CMD:
1034    case MODUL_CMD:
1035    case MAP_CMD:
1036    {
1037      ideal I=(ideal)d;
1038      if ((index<1)||(index>IDELEMS(I)))
1039      {
1040        if (!errorreported)
1041          Werror("wrong range[%d] in ideal/module(%d)",index,IDELEMS(I));
1042      }
1043      else
1044        r=(char *)I->m[index-1];
1045      break;
1046    }
1047    case STRING_CMD:
1048    {
1049      // this was a memory leak
1050      // we evalute it, cleanup and replace this leftv by it's evalutated form
1051      // the evalutated form will be build in tmp
1052      sleftv tmp;
1053      tmp.Init();
1054      tmp.rtyp=STRING_CMD;
1055      r=(char *)omAllocBin(size_two_bin);
1056      if ((index>0)&& (index<=(int)strlen((char *)d)))
1057      {
1058        r[0]=*(((char *)d)+index-1);
1059        r[1]='\0';
1060      }
1061      else
1062      {
1063        r[0]='\0';
1064      }
1065      tmp.data=r;
1066      if ((rtyp==IDHDL)||(rtyp==STRING_CMD))
1067      {
1068        tmp.next=next; next=NULL;
1069        //if (rtyp==STRING_CMD) { omFree((ADDRESS)data); }
1070        //data=NULL;
1071        d=NULL;
1072        CleanUp();
1073        memcpy(this,&tmp,sizeof(tmp));
1074      }
1075      // and, remember, r is also the result...
1076      else
1077      {
1078        // ???
1079        // here we still have a memory leak...
1080        // example: list L="123","456";
1081        // L[1][2];
1082        // therefore, it should never happen:
1083        assume(0);
1084        // but if it happens: here is the temporary fix:
1085        // omMarkAsStaticAddr(r);
1086      }
1087      break;
1088    }
1089    case MATRIX_CMD:
1090    {
1091      if ((index<1)
1092         ||(index>MATROWS((matrix)d))
1093         ||(e->next->start<1)
1094         ||(e->next->start>MATCOLS((matrix)d)))
1095      {
1096        if (!errorreported)
1097          Werror("wrong range[%d,%d] in intmat(%dx%d)",
1098                  index,e->next->start,
1099                  MATROWS((matrix)d),MATCOLS((matrix)d));
1100      }
1101      else
1102        r=(char *)MATELEM((matrix)d,index,e->next->start);
1103      break;
1104    }
1105    case LIST_CMD:
1106    {
1107      lists l=(lists)d;
1108      if ((0<index)&&(index<=l->nr+1))
1109      {
1110        if ((e->next!=NULL)
1111        && (l->m[index-1].rtyp==STRING_CMD))
1112        // string[..].Data() modifies sleftv, so let's do it ourself
1113        {
1114          char *dd=(char *)l->m[index-1].data;
1115          int j=e->next->start-1;
1116          r=(char *)omAllocBin(size_two_bin);
1117          if ((j>=0) && (j<(int)strlen(dd)))
1118          {
1119            r[0]=*(dd+j);
1120            r[1]='\0';
1121          }
1122          else
1123          {
1124            r[0]='\0';
1125          }
1126        }
1127        else
1128        {
1129          Subexpr tmp=l->m[index-1].e;
1130          l->m[index-1].e=e->next;
1131          r=(char *)l->m[index-1].Data();
1132          e->next=l->m[index-1].e;
1133          l->m[index-1].e=tmp;
1134        }
1135      }
1136      else //if (!errorreported)
1137        Werror("wrong range[%d] in list(%d)",index,l->nr+1);
1138      break;
1139    }
1140#ifdef TEST
1141    default:
1142      Werror("cannot index type %s(%d)",Tok2Cmdname(t),t);
1143#endif
1144  }
1145  return r;
1146}
1147
1148attr * sleftv::Attribute()
1149{
1150  if (e==NULL) return &attribute;
1151  if ((rtyp==LIST_CMD)
1152  ||((rtyp==IDHDL)&&(IDTYP((idhdl)data)==LIST_CMD)))
1153  {
1154    leftv v=LData();
1155    return &(v->attribute);
1156  }
1157  return NULL;
1158}
1159
1160leftv sleftv::LData()
1161{
1162  if (e!=NULL)
1163  {
1164    lists l=NULL;
1165
1166    if (rtyp==LIST_CMD)
1167      l=(lists)data;
1168    if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1169      l=IDLIST((idhdl)data);
1170    if (l!=NULL)
1171    {
1172      if ((0>=e->start)||(e->start>l->nr+1))
1173        return NULL;
1174      if (e->next!=NULL)
1175      {
1176        l->m[e->start-1].e=e->next;
1177        leftv r=l->m[e->start-1].LData();
1178        l->m[e->start-1].e=NULL;
1179        return r;
1180      }
1181      return &(l->m[e->start-1]);
1182    }
1183  }
1184  return this;
1185}
1186
1187leftv sleftv::LHdl()
1188{
1189  if (e!=NULL)
1190  {
1191    lists l=NULL;
1192
1193    if (rtyp==LIST_CMD)
1194      l=(lists)data;
1195    if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1196      l=IDLIST((idhdl)data);
1197    if (l!=NULL)
1198    {
1199      if ((0>=e->start)||(e->start>l->nr+1))
1200        return NULL;
1201      if (e->next!=NULL)
1202      {
1203        l->m[e->start-1].e=e->next;
1204        leftv r=l->m[e->start-1].LHdl();
1205        l->m[e->start-1].e=NULL;
1206        return r;
1207      }
1208      return &(l->m[e->start-1]);
1209    }
1210  }
1211  return this;
1212}
1213
1214BOOLEAN assumeStdFlag(leftv h)
1215{
1216  if ((h->e!=NULL)&&(h->LTyp()==LIST_CMD))
1217  {
1218    return assumeStdFlag(h->LData());
1219  }
1220  if (!hasFlag(h,FLAG_STD))
1221  {
1222    if (!TEST_VERB_NSB)
1223      Warn("%s is no standard basis",h->Name());
1224    return FALSE;
1225  }
1226  return TRUE;
1227}
1228
1229/*2
1230* transforms a name (as an string created by omAlloc or omStrDup)
1231* into an expression (sleftv), deletes the string
1232* utility for grammar and iparith
1233*/
1234void syMake(leftv v,const char * id, idhdl packhdl)
1235{
1236  /* resolv an identifier: (to DEF_CMD, if siq>0)
1237  * 1) reserved id: done by scanner
1238  * 2) `basering` / 'Current`
1239  * 3) existing identifier, local
1240  * 4) ringvar, local ring
1241  * 5) existing identifier, global
1242  * 6) monom (resp. number), local ring: consisting of:
1243  * 6') ringvar, global ring
1244  * 6'') monom (resp. number), local ring
1245  * 7) monom (resp. number), non-local ring
1246  * 8) basering
1247  * 9) `_`
1248  * 10) everything else is of type 0
1249  */
1250#ifdef TEST
1251  if ((*id<' ')||(*id>(char)126))
1252  {
1253    Print("wrong id :%s:\n",id);
1254  }
1255#endif
1256  idhdl save_ring=currRingHdl;
1257  v->Init();
1258  if(packhdl != NULL)
1259  {
1260  //  Print("setting req_packhdl to %s\n",IDID(packhdl));
1261    v->req_packhdl = IDPACKAGE(packhdl);
1262  }
1263  else v->req_packhdl = currPack;
1264//  if (v->req_packhdl!=basePack)
1265//    Print("search %s in %s\n",id,v->req_packhdl->libname);
1266  idhdl h=NULL;
1267#ifdef SIQ
1268  if (siq<=0)
1269#endif
1270  {
1271    if (!isdigit(id[0]))
1272    {
1273      if (strcmp(id,"basering")==0)
1274      {
1275        if (currRingHdl!=NULL)
1276        {
1277          if (id!=IDID(currRingHdl)) omFree((ADDRESS)id);
1278          h=currRingHdl;
1279          goto id_found;
1280        }
1281        else
1282        {
1283          v->name = id;
1284          return; /* undefined */
1285        }
1286      }
1287      else if (strcmp(id,"Current")==0)
1288      {
1289        if (currPackHdl!=NULL)
1290        {
1291          omFree((ADDRESS)id);
1292          h=currPackHdl;
1293          goto id_found;
1294        }
1295        else
1296        {
1297          v->name = id;
1298          return; /* undefined */
1299        }
1300      }
1301      if(v->req_packhdl!=currPack)
1302      {
1303        h=v->req_packhdl->idroot->get(id,myynest);
1304      }
1305      else
1306      h=ggetid(id);
1307      /* 3) existing identifier, local */
1308      if ((h!=NULL) && (IDLEV(h)==myynest))
1309      {
1310        if (id!=IDID(h)) omFree((ADDRESS)id);
1311        goto id_found;
1312      }
1313    }
1314    if (yyInRingConstruction)
1315    {
1316      currRingHdl=NULL;
1317    }
1318    /* 4. local ring: ringvar */
1319    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
1320    /*&& (!yyInRingConstruction)*/)
1321    {
1322      int vnr;
1323      if ((vnr=rIsRingVar(id))>=0)
1324      {
1325        poly p=pOne();
1326        pSetExp(p,vnr+1,1);
1327        pSetm(p);
1328        v->data = (void *)p;
1329        v->name = id;
1330        v->rtyp = POLY_CMD;
1331        return;
1332      }
1333    }
1334    /* 5. existing identifier, global */
1335    if (h!=NULL)
1336    {
1337      if (id!=IDID(h)) omFree((ADDRESS)id);
1338      goto id_found;
1339    }
1340    /* 6. local ring: number/poly */
1341    if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1342    {
1343      BOOLEAN ok=FALSE;
1344      /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
1345      poly p = pmInit(id,ok);
1346      if (ok)
1347      {
1348        if (p==NULL)
1349        {
1350          v->data = (void *)nInit(0);
1351          v->rtyp = NUMBER_CMD;
1352          #ifdef HAVE_PLURAL
1353          // in this case we may have monomials equal to 0 in p_Read
1354          v->name = id;
1355          #else
1356          omFree((ADDRESS)id);
1357          #endif
1358        }
1359        else if (pIsConstant(p))
1360        {
1361          v->data = pGetCoeff(p);
1362          pGetCoeff(p)=NULL;
1363          pLmFree(p);
1364          v->rtyp = NUMBER_CMD;
1365          v->name = id;
1366        }
1367        else
1368        {
1369          v->data = p;
1370          v->rtyp = POLY_CMD;
1371          v->name = id;
1372        }
1373        return;
1374      }
1375    }
1376    /* 7. non-local ring: number/poly */
1377    {
1378      BOOLEAN ok=FALSE;
1379      poly p = ((currRing!=NULL)     /* ring required */
1380               && (currRingHdl!=NULL)
1381               /*&& (!yyInRingConstruction) - not in decl */
1382               && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1383                     ? pmInit(id,ok) : (poly)NULL;
1384      if (ok)
1385      {
1386        if (p==NULL)
1387        {
1388          v->data = (void *)nInit(0);
1389          v->rtyp = NUMBER_CMD;
1390          #ifdef HAVE_PLURAL
1391          // in this case we may have monomials equal to 0 in p_Read
1392          v->name = id;
1393          #else
1394          omFree((ADDRESS)id);
1395          #endif
1396        }
1397        else
1398        if (pIsConstant(p))
1399        {
1400          v->data = pGetCoeff(p);
1401          pGetCoeff(p)=NULL;
1402          pLmFree(p);
1403          v->rtyp = NUMBER_CMD;
1404          v->name = id;
1405        }
1406        else
1407        {
1408          v->data = p;
1409          v->rtyp = POLY_CMD;
1410          v->name = id;
1411        }
1412        return;
1413      }
1414    }
1415    /* 8. basering ? */
1416    if ((myynest>1)&&(currRingHdl!=NULL))
1417    {
1418      if (strcmp(id,IDID(currRingHdl))==0)
1419      {
1420        if (IDID(currRingHdl)!=id) omFree((ADDRESS)id);
1421        h=currRingHdl;
1422        goto id_found;
1423      }
1424    }
1425    if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
1426    {
1427      h=basePack->idroot->get(id,myynest);
1428      if (h!=NULL)
1429      {
1430        if (id!=IDID(h)) omFree((ADDRESS)id);
1431        v->req_packhdl=basePack;
1432        goto id_found;
1433      }
1434    }
1435  }
1436#ifdef SIQ
1437  else
1438    v->rtyp=DEF_CMD;
1439#endif
1440  /* 9: _ */
1441  if (strcmp(id,"_")==0)
1442  {
1443    omFree((ADDRESS)id);
1444    v->Copy(&sLastPrinted);
1445  }
1446  else
1447  {
1448    /* 10: everything else */
1449    /* v->rtyp = UNKNOWN;*/
1450    v->name = id;
1451  }
1452  currRingHdl=save_ring;
1453  return;
1454id_found: // we have an id (in h) found, to set the data in from h
1455  v->rtyp = IDHDL;
1456  v->data = (char *)h;
1457  v->flag = IDFLAG(h);
1458  v->name = IDID(h);
1459  v->attribute=IDATTR(h);
1460  currRingHdl=save_ring;
1461}
1462
1463int sleftv::Eval()
1464{
1465  BOOLEAN nok=FALSE;
1466  leftv nn=next;
1467  next=NULL;
1468  if(rtyp==IDHDL)
1469  {
1470    int t=Typ();
1471    if (t!=PROC_CMD)
1472    {
1473      void *d=CopyD(t);
1474      data=d;
1475      rtyp=t;
1476      name=NULL;
1477      e=NULL;
1478    }
1479  }
1480  else if (rtyp==COMMAND)
1481  {
1482    command d=(command)data;
1483    if(d->op==PROC_CMD) //assume d->argc==2
1484    {
1485      char *what=(char *)(d->arg1.Data());
1486      idhdl h=ggetid(what);
1487      if((h!=NULL)&&(IDTYP(h)==PROC_CMD))
1488      {
1489        nok=d->arg2.Eval();
1490        if(!nok)
1491        {
1492          leftv r=iiMake_proc(h,req_packhdl,&d->arg2);
1493          if (r!=NULL)
1494            memcpy(this,r,sizeof(sleftv));
1495          else
1496            nok=TRUE;
1497        }
1498      }
1499      else nok=TRUE;
1500    }
1501    else if (d->op=='=') //assume d->argc==2
1502    {
1503      if ((d->arg1.rtyp!=IDHDL)&&(d->arg1.rtyp!=DEF_CMD))
1504      {
1505        nok=d->arg1.Eval();
1506      }
1507      if (!nok)
1508      {
1509        const char *n=d->arg1.name;
1510        nok=(n == NULL) || d->arg2.Eval();
1511        if (!nok)
1512        {
1513          int save_typ=d->arg1.rtyp;
1514          omCheckAddr((ADDRESS)n);
1515          if (d->arg1.rtyp!=IDHDL)
1516          syMake(&d->arg1,n);
1517          omCheckAddr((ADDRESS)d->arg1.name);
1518          if (d->arg1.rtyp==IDHDL)
1519          {
1520            n=omStrDup(IDID((idhdl)d->arg1.data));
1521            killhdl((idhdl)d->arg1.data);
1522            d->arg1.Init();
1523            //d->arg1.data=NULL;
1524            d->arg1.name=n;
1525          }
1526          d->arg1.rtyp=DEF_CMD;
1527          sleftv t;
1528          if(save_typ!=PROC_CMD) save_typ=d->arg2.rtyp;
1529          if (::RingDependend(d->arg2.rtyp))
1530            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&currRing->idroot);
1531          else
1532            nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&IDROOT);
1533          memcpy(&d->arg1,&t,sizeof(sleftv));
1534          omCheckAddr((ADDRESS)d->arg1.name);
1535          nok=nok||iiAssign(&d->arg1,&d->arg2);
1536          omCheckIf(d->arg1.name != NULL,  // OB: ????
1537                    omCheckAddr((ADDRESS)d->arg1.name));
1538          if (!nok)
1539          {
1540            memset(&d->arg1,0,sizeof(sleftv));
1541            this->CleanUp();
1542            rtyp=NONE;
1543          }
1544        }
1545      }
1546      else nok=TRUE;
1547    }
1548    else if (d->argc==1)
1549    {
1550      nok=d->arg1.Eval();
1551      nok=nok||iiExprArith1(this,&d->arg1,d->op);
1552    }
1553    else if(d->argc==2)
1554    {
1555      nok=d->arg1.Eval();
1556      nok=nok||d->arg2.Eval();
1557      nok=nok||iiExprArith2(this,&d->arg1,d->op,&d->arg2);
1558    }
1559    else if(d->argc==3)
1560    {
1561      nok=d->arg1.Eval();
1562      nok=nok||d->arg2.Eval();
1563      nok=nok||d->arg3.Eval();
1564      nok=nok||iiExprArith3(this,d->op,&d->arg1,&d->arg2,&d->arg3);
1565    }
1566    else if(d->argc!=0)
1567    {
1568      nok=d->arg1.Eval();
1569      nok=nok||iiExprArithM(this,&d->arg1,d->op);
1570    }
1571    else // d->argc == 0
1572    {
1573      nok = iiExprArithM(this, NULL, d->op);
1574    }
1575  }
1576  else if (((rtyp==0)||(rtyp==DEF_CMD))
1577    &&(name!=NULL))
1578  {
1579     syMake(this,name);
1580  }
1581#ifdef MDEBUG
1582  switch(Typ())
1583  {
1584    case NUMBER_CMD:
1585#ifdef LDEBUG
1586      nTest((number)Data());
1587#endif
1588      break;
1589    case BIGINT_CMD:
1590#ifdef LDEBUG
1591      nlTest((number)Data());
1592#endif
1593      break;
1594    case POLY_CMD:
1595      pTest((poly)Data());
1596      break;
1597    case IDEAL_CMD:
1598    case MODUL_CMD:
1599    case MATRIX_CMD:
1600      {
1601        ideal id=(ideal)Data();
1602        omCheckAddrSize(id,sizeof(*id));
1603        int i=id->ncols*id->nrows-1;
1604        for(;i>=0;i--) pTest(id->m[i]);
1605      }
1606      break;
1607  }
1608#endif
1609  if (nn!=NULL) nok=nok||nn->Eval();
1610  next=nn;
1611  return nok;
1612}
1613
1614const char *iiSleftv2name(leftv v)
1615{
1616  return(v->name);
1617}
1618
1619void * sattr::CopyA()
1620{
1621  omCheckAddrSize(this,sizeof(sattr));
1622  return s_internalCopy(atyp,data);
1623}
1624
Note: See TracBrowser for help on using the repository browser.