source: git/Singular/ipassign.cc @ 0c1144

spielwiese
Last change on this file since 0c1144 was 0c1144, checked in by Hans Schönemann <hannes@…>, 24 years ago
*hannes: fixed list-assignment-bug git-svn-id: file:///usr/local/Singular/svn/trunk@2994 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 33.5 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: ipassign.cc,v 1.48 1999-04-19 13:04:56 Singular Exp $ */
5
6/*
7* ABSTRACT: interpreter:
8*           assignment of expressions and lists to objects or lists
9*/
10
11#include <stdlib.h>
12#include <string.h>
13#include <ctype.h>
14
15#include "mod2.h"
16#include "tok.h"
17#include "ipid.h"
18#include "intvec.h"
19#include "mmemory.h"
20#include "febase.h"
21#include "polys.h"
22#include "ideals.h"
23#include "matpol.h"
24#include "kstd1.h"
25#include "timer.h"
26#include "ring.h"
27#include "subexpr.h"
28#include "numbers.h"
29#include "lists.h"
30#include "longalg.h"
31#include "stairc.h"
32#include "maps.h"
33#include "syz.h"
34#include "weight.h"
35#include "ipconv.h"
36#include "attrib.h"
37#include "silink.h"
38#include "ipshell.h"
39
40/*=================== proc =================*/
41#ifdef SRING
42static BOOLEAN jjALTVARS(leftv res, leftv a)
43{
44  pAltVars=(int)a->Data();
45  pSRING=(pAltVars<=pVariables);
46  pSDRING=pSDRING||pSRING;
47  currRing->partN=pAltVars;
48  return FALSE;
49}
50#endif
51static BOOLEAN jjECHO(leftv res, leftv a)
52{
53  si_echo=(int)a->Data();
54  return FALSE;
55}
56static BOOLEAN jjPAGELENGTH(leftv res, leftv a)
57{
58  pagelength=(int)a->Data();
59  return FALSE;
60}
61static BOOLEAN jjPRINTLEVEL(leftv res, leftv a)
62{
63  printlevel=(int)a->Data();
64  return FALSE;
65}
66static BOOLEAN jjCOLMAX(leftv res, leftv a)
67{
68  colmax=(int)a->Data();
69  return FALSE;
70}
71static BOOLEAN jjTIMER(leftv res, leftv a)
72{
73  timerv=(int)a->Data();
74  initTimer();
75  return FALSE;
76}
77#ifdef HAVE_RTIMER
78static BOOLEAN jjRTIMER(leftv res, leftv a)
79{
80  rtimerv=(int)a->Data();
81  initRTimer();
82  return FALSE;
83}
84#endif
85static BOOLEAN jjMAXDEG(leftv res, leftv a)
86{
87  Kstd1_deg=(int)a->Data();
88  if (Kstd1_deg!=0)
89    test |=Sy_bit(24);
90  else
91    test &=(~Sy_bit(24));
92  return FALSE;
93}
94static BOOLEAN jjMAXMULT(leftv res, leftv a)
95{
96  Kstd1_mu=(int)a->Data();
97  if (Kstd1_mu!=0)
98    test |=Sy_bit(23);
99  else
100    test &=(~Sy_bit(23));
101  return FALSE;
102}
103static BOOLEAN jjTRACE(leftv res, leftv a)
104{
105  traceit=(int)a->Data();
106  return FALSE;
107}
108static BOOLEAN jjSHORTOUT(leftv res, leftv a)
109{
110#ifdef HAVE_TCL
111  if (!tclmode)
112#endif
113    pShortOut=(int)a->Data();
114  return FALSE;
115}
116static BOOLEAN jjMINPOLY(leftv res, leftv a)
117{
118  if ((currRing->parameter!=NULL)
119  && ((rPar(currRing)>1)
120    || (rField_is_GF())))
121  {
122    WerrorS("no minpoly allowed");
123    return TRUE;
124  }
125  if (currRing->minpoly!=NULL)
126  {
127    WerrorS("minpoly already set");
128    return TRUE;
129  }
130  number p=(number)a->CopyD(NUMBER_CMD);
131  if (!nIsZero(p))
132  {
133    nNormalize(p);
134    currRing->minpoly=p;
135    naMinimalPoly=((lnumber)currRing->minpoly)->z;
136  }
137  else
138  {
139    naMinimalPoly=NULL;
140  }
141  return FALSE;
142}
143static BOOLEAN jjNOETHER(leftv res, leftv a)
144{
145  poly p=(poly)a->CopyD(POLY_CMD);
146  pDelete(&ppNoether);
147  ppNoether=p;
148  return FALSE;
149}
150/*=================== proc =================*/
151static void jiAssignAttr(leftv l,leftv r)
152{
153  // get the attribute of th right side
154  // and set it to l
155  leftv rv=r->LData();
156  if (rv!=NULL)
157  {
158    if (rv->e==NULL)
159    {
160      if (rv->attribute!=NULL)
161      {
162        attr la;
163        if (r->rtyp!=IDHDL)
164        {
165          la=rv->attribute;
166          rv->attribute=NULL;
167        }
168        else
169        {
170          la=rv->attribute->Copy();
171        }
172        l->attribute=la;
173      }
174      l->flag=rv->flag;
175    }
176  }
177  if (l->rtyp==IDHDL)
178  {
179    idhdl h=(idhdl)l->data;
180    IDATTR(h)=l->attribute;
181    IDFLAG(h)=l->flag;
182  }
183}
184static BOOLEAN jiA_INT(leftv res, leftv a, Subexpr e)
185{
186  if (e==NULL)
187  {
188    res->data=(void *)a->Data();
189    jiAssignAttr(res,a);
190  }
191  else
192  {
193    int i=e->start-1;
194    if (i<0)
195    {
196      Werror("index[%d] must be positive",i+1);
197      return TRUE;
198    }
199    intvec *iv=(intvec *)res->data;
200    if (e->next==NULL)
201    {
202      if (i>=iv->length())
203      {
204        intvec *iv1=new intvec(i+1);
205        (*iv1)[i]=(int)a->Data();
206        intvec *ivn=ivAdd(iv,iv1);
207        delete iv;
208        delete iv1;
209        res->data=(void *)ivn;
210      }
211      else
212        (*iv)[i]=(int)a->Data();
213    }
214    else
215    {
216      int c=e->next->start;
217      if ((i>=iv->rows())||(c<1)||(c>iv->cols()))
218      {
219        Werror("wrong range [%d,%d] in intmat (%d,%d)",i+1,c,iv->rows(),iv->cols());
220        return TRUE;
221      }
222      else
223        IMATELEM(*iv,i+1,c) = (int)a->Data();
224    }
225  }
226  return FALSE;
227}
228static BOOLEAN jiA_NUMBER(leftv res, leftv a, Subexpr e)
229{
230  number p=(number)a->CopyD(NUMBER_CMD);
231  if (res->data!=NULL) nDelete((number *)&res->data);
232  nNormalize(p);
233  res->data=(void *)p;
234  jiAssignAttr(res,a);
235  return FALSE;
236}
237static BOOLEAN jiA_LIST_RES(leftv res, leftv a,Subexpr e)
238{
239  syStrategy r=(syStrategy)a->CopyD();
240  if (res->data!=NULL) ((lists)res->data)->Clean();
241  res->data=(void *)syConvRes(r);
242  //jiAssignAttr(res,a);
243  return FALSE;
244}
245static BOOLEAN jiA_LIST(leftv res, leftv a,Subexpr e)
246{
247  lists l=(lists)a->CopyD();
248  if (res->data!=NULL) ((lists)res->data)->Clean();
249  res->data=(void *)l;
250  jiAssignAttr(res,a);
251  return FALSE;
252}
253static BOOLEAN jiA_POLY(leftv res, leftv a,Subexpr e)
254{
255  poly p=(poly)a->CopyD(POLY_CMD);
256  pNormalize(p);
257  if (e==NULL)
258  {
259    if (res->data!=NULL) pDelete((poly*)&res->data);
260    res->data=(void*)p;
261    jiAssignAttr(res,a);
262  }
263  else
264  {
265    int i,j;
266    matrix m=(matrix)res->data;
267    i=e->start;
268    if (e->next==NULL)
269    {
270      j=i; i=1;
271      // for all ideal like data types: check indices
272      if (j>MATCOLS(m))
273      {
274        pEnlargeSet(&(m->m),MATCOLS(m),j-MATCOLS(m));
275        MATCOLS(m)=j;
276      }
277      else if (j<=0)
278      {
279        Werror("index[%d] must be positive",j/*e->start*/);
280        return TRUE;
281      }
282    }
283    else
284    {
285      // for matrices: indices are correct (see ipExprArith3(..,'['..) )
286      j=e->next->start;
287    }
288    pDelete(&MATELEM(m,i,j));
289    MATELEM(m,i,j)=p;
290    /* for module: update rank */
291    if ((p!=NULL) && (pGetComp(p)!=0))
292    {
293      m->rank=max(m->rank,pMaxComp(p));
294    }
295  }
296  return FALSE;
297}
298static BOOLEAN jiA_1x1MATRIX(leftv res, leftv a,Subexpr e)
299{
300  if ((res->rtyp!=MATRIX_CMD) /*|| (e!=NULL) - TRUE because of type poly */)
301     return TRUE;
302  matrix am=(matrix)a->CopyD(MATRIX_CMD);
303  if ((MATROWS(am)!=1) || (MATCOLS(am)!=1))
304  {
305    idDelete((ideal *)&am);
306    return TRUE;
307  }
308  matrix m=(matrix)res->data;
309  // indices are correct (see ipExprArith3(..,'['..) )
310  int i=e->start;
311  int j=e->next->start;
312  pDelete(&MATELEM(m,i,j));
313  pNormalize(MATELEM(am,1,1));
314  MATELEM(m,i,j)=MATELEM(am,1,1);
315  MATELEM(am,1,1)=NULL;
316  idDelete((ideal *)&am);
317  return FALSE;
318}
319static BOOLEAN jiA_STRING(leftv res, leftv a, Subexpr e)
320{
321  if (e==NULL)
322  {
323    FreeL((ADDRESS)res->data);
324    res->data=(void *)a->CopyD(STRING_CMD);
325    jiAssignAttr(res,a);
326  }
327  else
328  {
329    char *s=(char *)res->data;
330    if ((e->start>0)&&(e->start<=(int)strlen(s)))
331      s[e->start-1]=(char)(*((char *)a->Data()));
332    else
333    {
334      Werror("string index %d out of range 1..%d",e->start,strlen(s));
335      return TRUE;
336    }
337  }
338  return FALSE;
339}
340static BOOLEAN jiA_PROC(leftv res, leftv a, Subexpr e)
341{
342  extern procinfo *iiInitSingularProcinfo(procinfo *pi, char *libname,
343                                          char *procname, int line,
344                                          long pos, BOOLEAN pstatic=FALSE);
345  extern void piCleanUp(procinfov pi);
346
347  if(res->data!=NULL) piCleanUp((procinfo *)res->data);
348  if(a->rtyp==STRING_CMD)
349  {
350    res->data = (void *)Alloc0(sizeof(procinfo));
351    ((procinfo *)(res->data))->language=LANG_NONE;
352    iiInitSingularProcinfo((procinfo *)res->data,"",res->name,0,0);
353    ((procinfo *)res->data)->data.s.body=(char *)a->CopyD(STRING_CMD);
354  }
355  else
356    res->data=(void *)a->CopyD(PROC_CMD);
357  jiAssignAttr(res,a);
358  return FALSE;
359}
360static BOOLEAN jiA_INTVEC(leftv res, leftv a, Subexpr e)
361{
362  if (res->data!=NULL) delete ((intvec *)res->data);
363  res->data=(void *)a->CopyD(INTVEC_CMD);
364  jiAssignAttr(res,a);
365  return FALSE;
366}
367static BOOLEAN jiA_IDEAL(leftv res, leftv a, Subexpr e)
368{
369  if (res->data!=NULL) idDelete((ideal*)&res->data);
370  res->data=(void *)a->CopyD(MATRIX_CMD);
371  jiAssignAttr(res,a);
372  return FALSE;
373}
374static BOOLEAN jiA_RESOLUTION(leftv res, leftv a, Subexpr e)
375{
376  if (res->data!=NULL) syKillComputation((syStrategy)res->data);
377  res->data=(void *)a->CopyD(RESOLUTION_CMD);
378  jiAssignAttr(res,a);
379  return FALSE;
380}
381static BOOLEAN jiA_MODUL_P(leftv res, leftv a, Subexpr e)
382{
383  if (res->data!=NULL) idDelete((ideal*)&res->data);
384  ideal I=idInit(1,1);
385  I->m[0]=(poly)a->CopyD();
386  if (I->m[0]!=NULL) pSetComp(I->m[0],1);
387  res->data=(void *)I;
388  return FALSE;
389}
390static BOOLEAN jiA_IDEAL_M(leftv res, leftv a, Subexpr e)
391{
392  if (res->data!=NULL) idDelete((ideal*)&res->data);
393  matrix m=(matrix)a->CopyD(MATRIX_CMD);
394  IDELEMS((ideal)m)=MATROWS(m)*MATCOLS(m);
395  ((ideal)m)->rank=1;
396  MATROWS(m)=1;
397  res->data=(void *)m;
398  return FALSE;
399}
400static BOOLEAN jiA_LINK(leftv res, leftv a, Subexpr e)
401{
402  si_link l=(si_link)res->data;
403
404  if (l!=NULL) slCleanUp(l);
405
406  if (a->Typ() == STRING_CMD)
407  {
408    if (l == NULL)
409    {
410      l = (si_link) Alloc0(sizeof(sip_link));
411      res->data = (void *) l;
412    }
413    return slInit(l, (char *) a->Data());
414  }
415  else if (a->Typ() == LINK_CMD)
416  {
417    if (l != NULL) Free(l, sizeof(sip_link));
418    res->data = slCopy((si_link)a->Data());
419    return FALSE;
420  }
421  return TRUE;
422}
423static BOOLEAN jiA_MAP(leftv res, leftv a, Subexpr e)
424{
425  if (res->data!=NULL)
426  {
427    FreeL((ADDRESS)((map)res->data)->preimage);
428    ((map)res->data)->preimage=NULL;
429    idDelete((ideal*)&res->data);
430  }
431  res->data=(void *)a->CopyD();
432  jiAssignAttr(res,a);
433  return FALSE;
434}
435static BOOLEAN jiA_MAP_ID(leftv res, leftv a, Subexpr e)
436{
437  map f=(map)res->data;
438  char *rn=f->preimage; // save the old/already assigned preimage ring name
439  f->preimage=NULL;
440  idDelete((ideal *)&f);
441  res->data=(void *)a->CopyD(IDEAL_CMD);
442  f=(map)res->data;
443  f->preimage = rn;
444  return FALSE;
445}
446static BOOLEAN jiA_QRING(leftv res, leftv a,Subexpr e)
447{
448  // the follwing can only happen, if:
449  //   - the left side is of type qring AND not an id
450  if ((e!=NULL)||(res->rtyp!=IDHDL))
451  {
452    WerrorS("qring_id expected");
453    return TRUE;
454  }
455  ring qr;
456  int i,j;
457  int *pi;
458
459  assumeStdFlag(a);
460  qr=(ring)res->Data();
461  ring qrr=rCopy(currRing);
462  memcpy4(qr,qrr,sizeof(ip_sring));
463  Free((ADDRESS)qrr,sizeof(ip_sring));
464  if (qr->qideal!=NULL) idDelete(&qr->qideal);
465  qr->qideal = (ideal)a->CopyD(IDEAL_CMD);
466  //currRing=qr;
467  //currRingHdl=(idhdl)res->data;
468  //currQuotient=qr->qideal;
469  rSetHdl((idhdl)res->data,TRUE);
470  return FALSE;
471}
472static BOOLEAN jiA_RING(leftv res, leftv a, Subexpr e)
473{
474  BOOLEAN have_id=TRUE;
475  if ((e!=NULL)||(res->rtyp!=IDHDL))
476  {
477    //WerrorS("id expected");
478    //return TRUE;
479    have_id=FALSE;
480  }
481  ring r=(ring)a->Data();
482  if (have_id)
483  {
484    idhdl rl=(idhdl)res->data;
485    if (&IDRING(rl)!=NULL) rKill(rl);
486    IDRING(rl)=r;
487    if ((IDLEV((idhdl)a->data)!=myynest) && (r==currRing))
488      currRingHdl=(idhdl)res->data;
489  }
490  else
491  {
492    if (e==NULL) res->data=(char *)r;
493    else
494    {
495      WerrorS("id expected");
496      return TRUE;
497    }
498  }
499  r->ref++;
500  return FALSE;
501}
502static BOOLEAN jiA_PACKAGE(leftv res, leftv a, Subexpr e)
503{
504  res->data=(void *)a->CopyD(PACKAGE_CMD);
505  jiAssignAttr(res,a);
506  return FALSE;
507}
508/*=================== table =================*/
509struct sValAssign dAssign[]=
510{
511// proc         res             arg
512 {jiA_IDEAL,    IDEAL_CMD,      IDEAL_CMD }
513,{jiA_IDEAL_M,  IDEAL_CMD,      MATRIX_CMD }
514,{jiA_RESOLUTION,RESOLUTION_CMD,RESOLUTION_CMD }
515,{jiA_INT,      INT_CMD,        INT_CMD }
516,{jiA_IDEAL,    MATRIX_CMD,     MATRIX_CMD }
517,{jiA_MAP_ID,   MAP_CMD,        IDEAL_CMD }
518,{jiA_MAP,      MAP_CMD,        MAP_CMD }
519,{jiA_IDEAL,    MODUL_CMD,      MODUL_CMD }
520,{jiA_MODUL_P,  MODUL_CMD,      POLY_CMD }
521,{jiA_POLY,     POLY_CMD,       POLY_CMD }
522,{jiA_1x1MATRIX,POLY_CMD,       MATRIX_CMD }
523,{jiA_QRING,    QRING_CMD,      IDEAL_CMD }
524,{jiA_RING,     RING_CMD,       RING_CMD }
525,{jiA_RING,     QRING_CMD,      QRING_CMD }
526,{jiA_STRING,   STRING_CMD,     STRING_CMD }
527,{jiA_PROC,     PROC_CMD,       STRING_CMD }
528,{jiA_PROC,     PROC_CMD,       PROC_CMD }
529,{jiA_POLY,     VECTOR_CMD,     VECTOR_CMD }
530,{jiA_INTVEC,   INTVEC_CMD,     INTVEC_CMD }
531,{jiA_INTVEC,   INTMAT_CMD,     INTMAT_CMD }
532,{jiA_NUMBER,   NUMBER_CMD,     NUMBER_CMD }
533,{jiA_LIST_RES, LIST_CMD,       RESOLUTION_CMD }
534,{jiA_LIST,     LIST_CMD,       LIST_CMD }
535,{jiA_LINK,     LINK_CMD,       STRING_CMD }
536,{jiA_LINK,     LINK_CMD,       LINK_CMD }
537,{jiA_PACKAGE,  PACKAGE_CMD,    PACKAGE_CMD }
538,{NULL,         0,              0 }
539};
540struct sValAssign_sys dAssign_sys[]=
541{
542// sysvars:
543 {jjECHO,       VECHO,          INT_CMD }
544#ifdef SRING
545,{jjALTVARS,    VALTVARS,       INT_CMD }
546#endif
547,{jjPAGELENGTH, VPAGELENGTH,    INT_CMD }
548,{jjPRINTLEVEL, VPRINTLEVEL,    INT_CMD }
549,{jjCOLMAX,     VCOLMAX,        INT_CMD }
550,{jjTIMER,      VTIMER,         INT_CMD }
551#ifdef HAVE_RTIMER
552,{jjRTIMER,     VRTIMER,        INT_CMD }
553#endif
554,{jjMAXDEG,     VMAXDEG,        INT_CMD }
555,{jjMAXMULT,    VMAXMULT,       INT_CMD }
556,{jjTRACE,      TRACE,          INT_CMD }
557,{jjSHORTOUT,   VSHORTOUT,      INT_CMD }
558,{jjMINPOLY,    VMINPOLY,       NUMBER_CMD }
559,{jjNOETHER,    VNOETHER,       POLY_CMD }
560,{NULL,         0,              0 }
561};
562/*=================== operations ============================*/
563/*2
564* assign a = b
565*/
566static BOOLEAN jiAssign_1(leftv l, leftv r)
567{
568  int rt=r->Typ();
569  if (rt==0)
570  {
571    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
572    return TRUE;
573  }
574
575  int lt=l->Typ();
576  if((lt==0)/*&&(l->name!=NULL)*/)
577  {
578    if (!errorreported) Werror("left side `%s` is undefined",l->Fullname());
579    return TRUE;
580  }
581  if((rt==DEF_CMD)||(rt==NONE))
582  {
583    if (!errorreported) WerrorS("right side is not a datum");
584    return TRUE;
585  }
586
587  int i=0;
588  BOOLEAN nok=FALSE;
589
590  if (lt==DEF_CMD)
591  {
592    if (l->rtyp==IDHDL)
593    {
594      IDTYP((idhdl)l->data)=rt;
595    }
596    else if (l->name!=NULL)
597    {
598      sleftv ll;
599      iiDeclCommand(&ll,l,myynest,rt,&IDROOT);
600      memcpy(l,&ll,sizeof(sleftv));
601    }
602    else
603    {
604      l->rtyp=rt;
605    }
606    lt=rt;
607  }
608  else
609  {
610    if ((l->data==r->data)&&(l->e==NULL)&&(r->e==NULL))
611      return FALSE;
612  }
613  leftv ld=l;
614  if ((l->rtyp==IDHDL)&&(lt!=QRING_CMD)&&(lt!=RING_CMD))
615    ld=(leftv)l->data;
616  while (((dAssign[i].res!=lt)
617      || (dAssign[i].arg!=rt))
618    && (dAssign[i].res!=0)) i++;
619  if (dAssign[i].res!=0)
620  {
621    BOOLEAN b;
622    b=dAssign[i].p(ld,r,l->e);
623    if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
624    {
625      l->flag=ld->flag;
626      l->attribute=ld->attribute;
627    }
628    return b;
629  }
630  // implicite type conversion ----------------------------------------------
631  if (dAssign[i].res==0)
632  {
633    int ri;
634    leftv rn = (leftv)Alloc0(sizeof(sleftv));
635    BOOLEAN failed=FALSE;
636    i=0;
637    while ((dAssign[i].res!=lt)
638      && (dAssign[i].res!=0)) i++;
639    while (dAssign[i].res==lt)
640    {
641      if ((ri=iiTestConvert(rt,dAssign[i].arg))!=0)
642      {
643        failed= iiConvert(rt,dAssign[i].arg,ri,r,rn);
644        if(!failed)
645        {
646          failed= dAssign[i].p(ld,rn,l->e);
647        }
648        // everything done, clean up temp. variables
649        rn->CleanUp();
650        Free((ADDRESS)rn,sizeof(sleftv));
651        if (failed)
652        {
653          // leave loop, goto error handling
654          break;
655        }
656        else
657        {
658          if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
659          {
660            l->flag=ld->flag;
661            l->attribute=ld->attribute;
662          }
663          // everything ok, return
664          return FALSE;
665        }
666     }
667     i++;
668    }
669    // error handling ---------------------------------------------------
670    if (!errorreported)
671    {
672      Werror("`%s` = `%s` is not supported"
673             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
674      if (BVERBOSE(V_SHOW_USE))
675      {
676        i=0;
677        while ((dAssign[i].res!=lt)
678          && (dAssign[i].res!=0)) i++;
679        while (dAssign[i].res==lt)
680        {
681          Werror("expected `%s` = `%s`"
682              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign[i].arg));
683          i++;
684        }
685      }
686    }
687  }
688  return TRUE;
689}
690/*2
691* assign sys_var = val
692*/
693static BOOLEAN iiAssign_sys(leftv l, leftv r)
694{
695  int rt=r->Typ();
696
697  if (rt==0)
698  {
699    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
700    return TRUE;
701  }
702  int i=0;
703  int lt=l->rtyp;
704  while (((dAssign_sys[i].res!=lt)
705      || (dAssign_sys[i].arg!=rt))
706    && (dAssign_sys[i].res!=0)) i++;
707  if (dAssign_sys[i].res!=0)
708  {
709    if (!dAssign_sys[i].p(l,r))
710    {
711      // everything ok, clean up
712      return FALSE;
713    }
714  }
715  // implicite type conversion ----------------------------------------------
716  if (dAssign_sys[i].res==0)
717  {
718    int ri;
719    leftv rn = (leftv)Alloc0(sizeof(sleftv));
720    BOOLEAN failed=FALSE;
721    i=0;
722    while ((dAssign_sys[i].res!=lt)
723      && (dAssign_sys[i].res!=0)) i++;
724    while (dAssign_sys[i].res==lt)
725    {
726      if ((ri=iiTestConvert(rt,dAssign_sys[i].arg))!=0)
727      {
728        failed= ((iiConvert(rt,dAssign_sys[i].arg,ri,r,rn))
729            || (dAssign_sys[i].p(l,rn)));
730        // everything done, clean up temp. variables
731        rn->CleanUp();
732        Free((ADDRESS)rn,sizeof(sleftv));
733        if (failed)
734        {
735          // leave loop, goto error handling
736          break;
737        }
738        else
739        {
740          // everything ok, return
741          return FALSE;
742        }
743     }
744     i++;
745    }
746    // error handling ---------------------------------------------------
747    if(!errorreported)
748    {
749      Werror("`%s` = `%s` is not supported"
750             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
751      if (BVERBOSE(V_SHOW_USE))
752      {
753        i=0;
754        while ((dAssign_sys[i].res!=lt)
755          && (dAssign_sys[i].res!=0)) i++;
756        while (dAssign_sys[i].res==lt)
757        {
758          Werror("expected `%s` = `%s`"
759              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign_sys[i].arg));
760          i++;
761        }
762      }
763    }
764  }
765  return TRUE;
766}
767static BOOLEAN jiA_INTVEC_L(leftv l,leftv r)
768{
769  /* right side is intvec, left side is list (of int)*/
770  BOOLEAN nok;
771  int i=0;
772  leftv l1=l;
773  leftv h;
774  sleftv t;
775  intvec *iv=(intvec *)r->Data();
776  memset(&t,0,sizeof(sleftv));
777  t.rtyp=INT_CMD;
778  while ((i<iv->length())&&(l!=NULL))
779  {
780    t.data=(char *)(*iv)[i];
781    h=l->next;
782    l->next=NULL;
783    nok=jiAssign_1(l,&t);
784    if (nok) return TRUE;
785    i++;
786    l=h;
787  }
788  l1->CleanUp();
789  r->CleanUp();
790  return FALSE;
791}
792static BOOLEAN jiA_VECTOR_L(leftv l,leftv r)
793{
794  /* right side is vector, left side is list (of poly)*/
795  BOOLEAN nok;
796  leftv l1=l;
797  ideal I=idVec2Ideal((poly)r->Data());
798  leftv h;
799  sleftv t;
800  int i=0;
801  while (l!=NULL)
802  {
803    memset(&t,0,sizeof(sleftv));
804    t.rtyp=POLY_CMD;
805    if (i>=IDELEMS(I))
806    {
807      t.data=NULL;
808    }
809    else
810    {
811      t.data=(char *)I->m[i];
812      I->m[i]=NULL;
813    }
814    h=l->next;
815    l->next=NULL;
816    nok=jiAssign_1(l,&t);
817    t.CleanUp();
818    if (nok)
819    {
820      idDelete(&I);
821      return TRUE;
822    }
823    i++;
824    l=h;
825  }
826  idDelete(&I);
827  l1->CleanUp();
828  r->CleanUp();
829  return FALSE;
830}
831static BOOLEAN jjA_L_LIST(leftv l, leftv r)
832/* left side: list, has to be a "real" variable
833*  right side: expression list
834*/
835{
836  int sl = r->listLength();
837  lists L=(lists)Alloc(sizeof(slists));
838  lists oldL;
839  leftv h=NULL,o_r=r;
840  int i;
841  int rt;
842
843  L->Init(sl);
844  for (i=0;i<sl;i++)
845  {
846    if (h!=NULL) { /* e.g. not in the first step:
847                   * h is the pointer to the old sleftv,
848                   * r is the pointer to the next sleftv
849                   * (in this moment) */
850                   h->next=r;
851                 }
852    h=r;
853    r=r->next;
854    h->next=NULL;
855    rt=h->Typ();
856    if ((rt==0)||(rt==NONE)||(rt==DEF_CMD))
857    {
858      L->Clean();
859      Werror("`%s` is undefined",h->Fullname());
860      goto err;
861    }
862    //if ((rt==RING_CMD)||(rt==QRING_CMD))
863    //{
864    //  L->m[i].rtyp=rt;
865    //  L->m[i].data=h->Data();
866    //  ((ring)L->m[i].data)->ref++;
867    //}
868    //else
869      L->m[i].Copy(h);
870      if(errorreported)
871      {
872        L->Clean();
873        goto err;
874      }
875  }
876  oldL=(lists)l->Data(); oldL->Clean();
877  if (l->rtyp==IDHDL)
878  {
879    IDLIST((idhdl)l->data)=L;
880#ifdef HAVE_NAMESPACES
881    if (l->req_packhdl != NULL)
882    {
883      //Print("jjA_L_LIST: -1 \n");
884      namespaceroot->push( IDPACKAGE(l->req_packhdl), IDID((idhdl)l));
885      ipMoveId((idhdl)l->data);
886      namespaceroot->pop();
887    }
888    else
889#endif /* HAVE_NAMESPACES */
890      ipMoveId((idhdl)l->data);
891  }
892  else
893  {
894    l->LData()->data=L;
895  }
896err:
897  o_r->CleanUp();
898  return errorreported;
899}
900static BOOLEAN jjA_L_INTVEC(leftv l,leftv r,intvec *iv)
901{
902  /* left side is intvec/intmat, right side is list (of int,intvec,intmat)*/
903  leftv hh=r;
904  int i = 0;
905  while (hh!=NULL)
906  {
907    if (i>=iv->length()) break;
908    if (hh->Typ() == INT_CMD)
909    {
910      (*iv)[i++] = (int)(hh->Data());
911    }
912    else if ((hh->Typ() == INTVEC_CMD)
913            ||(hh->Typ() == INTMAT_CMD))
914    {
915      intvec *ivv = (intvec *)(hh->Data());
916      int ll = 0,l = min(ivv->length(),iv->length());
917      for (; l>0; l--)
918      {
919        (*iv)[i++] = (*ivv)[ll++];
920      }
921    }
922    else
923    {
924      delete iv;
925      return TRUE;
926    }
927    hh = hh->next;
928  }
929  if (IDINTVEC((idhdl)l->data)!=NULL) delete IDINTVEC((idhdl)l->data);
930  IDINTVEC((idhdl)l->data)=iv;
931  return FALSE;
932}
933static BOOLEAN jjA_L_STRING(leftv l,leftv r)
934{
935  /* left side is string, right side is list of string*/
936  leftv hh=r;
937  int sl = 1;
938  char *s;
939  char *t;
940  int tl;
941  /* find the length */
942  while (hh!=NULL)
943  {
944    if (hh->Typ()!= STRING_CMD)
945    {
946      return TRUE;
947    }
948    sl += strlen((char *)hh->Data());
949    hh = hh->next;
950  }
951  s = (char * )AllocL(sl);
952  sl=0;
953  hh = r;
954  while (hh!=NULL)
955  {
956    t=(char *)hh->Data();
957    tl=strlen(t);
958    memcpy(s+sl,t,tl);
959    sl+=tl;
960    hh = hh->next;
961  }
962  s[sl]='\0';
963  FreeL((ADDRESS)IDDATA((idhdl)(l->data)));
964  IDDATA((idhdl)(l->data))=s;
965  return FALSE;
966}
967static BOOLEAN jjA_LIST_L(leftv l,leftv r)
968{
969  /*left side are something, right side are lists*/
970  /*e.g. a,b,c=l */
971  //int ll=l->listLength();
972  if (l->listLength()==1) return jiAssign_1(l,r);
973  BOOLEAN nok;
974  sleftv t;
975  leftv h;
976  lists L=(lists)r->Data();
977  int rl=L->nr;
978  int i=0;
979
980  memset(&t,0,sizeof(sleftv));
981  while ((i<=rl)&&(l!=NULL))
982  {
983    memset(&t,0,sizeof(sleftv));
984    t.Copy(&L->m[i]);
985    h=l->next;
986    l->next=NULL;
987    nok=jiAssign_1(l,&t);
988    if (nok) return TRUE;
989    i++;
990    l=h;
991  }
992  r->CleanUp();
993  return FALSE;
994}
995static BOOLEAN jiA_MATRIX_L(leftv l,leftv r)
996{
997  /* right side is matrix, left side is list (of poly)*/
998  BOOLEAN nok=FALSE;
999  int i;
1000  matrix m=(matrix)r->CopyD(MATRIX_CMD);
1001  leftv h;
1002  leftv ol=l;
1003  leftv o_r=r;
1004  sleftv t;
1005  memset(&t,0,sizeof(sleftv));
1006  t.rtyp=POLY_CMD;
1007  loop
1008  {
1009    i=0;
1010    while ((i<MATROWS(m)*MATCOLS(m))&&(l!=NULL))
1011    {
1012      t.data=(char *)m->m[i];
1013      m->m[i]=NULL;
1014      h=l->next;
1015      l->next=NULL;
1016      nok=jiAssign_1(l,&t);
1017      l->next=h;
1018      if (nok)
1019      {
1020        idDelete((ideal *)&m);
1021        goto ende;
1022      }
1023      i++;
1024      l=h;
1025    }
1026    idDelete((ideal *)&m);
1027    h=r;
1028    r=r->next;
1029    if (l==NULL)
1030    {
1031      if (r!=NULL)
1032      {
1033        Warn("list length mismatch in assign (l>r)");
1034        nok=TRUE;
1035      }
1036      break;
1037    }
1038    else if (r==NULL)
1039    {
1040      Warn("list length mismatch in assign (l<r)");
1041      nok=TRUE;
1042      break;
1043    }
1044    if ((r->Typ()==IDEAL_CMD)||(r->Typ()==MATRIX_CMD))
1045      m=(matrix)r->CopyD(MATRIX_CMD);
1046    else if (r->Typ()==POLY_CMD)
1047    {
1048      m=mpNew(1,1);
1049      MATELEM(m,1,1)=(poly)r->CopyD(POLY_CMD);
1050    }
1051    else
1052    {
1053      nok=TRUE;
1054      break;
1055    }
1056  }
1057ende:
1058  o_r->CleanUp();
1059  ol->CleanUp();
1060  return nok;
1061}
1062static BOOLEAN jiA_STRING_L(leftv l,leftv r)
1063{
1064  /*left side are strings, right side is a string*/
1065  /*e.g. s[2..3]="12" */
1066  /*the case s=t[1..4] is handled in iiAssign,
1067  * the case s[2..3]=t[3..4] is handled in iiAssgn_rec*/
1068  int ll=l->listLength();
1069  int rl=r->listLength();
1070  BOOLEAN nok=FALSE;
1071  sleftv t;
1072  leftv h,l1=l;
1073  int i=0;
1074  char *ss;
1075  char *s=(char *)r->Data();
1076  int sl=strlen(s);
1077
1078  memset(&t,0,sizeof(sleftv));
1079  t.rtyp=STRING_CMD;
1080  while ((i<sl)&&(l!=NULL))
1081  {
1082    ss=(char *)AllocL(2);
1083    ss[1]='\0';
1084    ss[0]=s[i];
1085    t.data=ss;
1086    h=l->next;
1087    l->next=NULL;
1088    nok=jiAssign_1(l,&t);
1089    if (nok)
1090    {
1091      break;
1092    }
1093    i++;
1094    l=h;
1095  }
1096  r->CleanUp();
1097  l1->CleanUp();
1098  return nok;
1099}
1100static BOOLEAN jiAssign_list(leftv l, leftv r)
1101{
1102  int i=l->e->start-1;
1103  if (i<0)
1104  {
1105    Werror("index[%d] must be positive",i+1);
1106    return TRUE;
1107  }
1108  if(l->attribute!=NULL)
1109  {
1110    atKillAll((idhdl)l);
1111    l->attribute=NULL;
1112  }
1113  l->flag=0;
1114  lists li;
1115  if (l->rtyp==IDHDL)
1116  {
1117    li=IDLIST((idhdl)l->data);
1118  }
1119  else
1120  {
1121    li=(lists)l->data;
1122  }
1123  if (i>li->nr)
1124  {
1125    li->m=(leftv)ReAlloc(li->m,(li->nr+1)*sizeof(sleftv),(i+1)*sizeof(sleftv));
1126    memset(&(li->m[li->nr+1]),0,(i-li->nr)*sizeof(sleftv));
1127    int j=li->nr+1;
1128    for(;j<=i;j++)
1129      li->m[j].rtyp=DEF_CMD;
1130    li->nr=i;
1131  }
1132  leftv ld=&(li->m[i]);
1133  ld->e=l->e->next;
1134  BOOLEAN b;
1135  if ((ld->rtyp!=LIST_CMD)
1136  &&(ld->e==NULL)
1137  &&(ld->Typ()!=r->Typ()))
1138  {
1139    sleftv tmp;
1140    memset(&tmp,0,sizeof(sleftv));
1141    tmp.rtyp=DEF_CMD;
1142    b=iiAssign(&tmp,r);
1143    ld->CleanUp();
1144    memcpy(ld,&tmp,sizeof(sleftv));
1145  }
1146  else
1147  {
1148    b=iiAssign(ld,r);
1149    l->e->next=ld->e;
1150    ld->e=NULL;
1151  }
1152  return b;
1153}
1154static BOOLEAN jiAssign_rec(leftv l, leftv r)
1155{
1156  leftv l1=l;
1157  leftv r1=r;
1158  leftv lrest;
1159  leftv rrest;
1160  BOOLEAN b;
1161  do
1162  {
1163    lrest=l->next;
1164    rrest=r->next;
1165    l->next=NULL;
1166    r->next=NULL;
1167    b=iiAssign(l,r);
1168    l->next=lrest;
1169    r->next=rrest;
1170    l=lrest;
1171    r=rrest;
1172  } while  ((!b)&&(l!=NULL));
1173  l1->CleanUp();
1174  r1->CleanUp();
1175  return b;
1176}
1177BOOLEAN iiAssign(leftv l, leftv r)
1178{
1179  int ll=l->listLength();
1180  int rl;
1181  int lt=l->Typ();
1182  int rt=NONE;
1183  BOOLEAN b;
1184
1185  if(l->attribute!=NULL)
1186  {
1187    if (l->rtyp==IDHDL)
1188    {
1189      atKillAll((idhdl)l->data);
1190      l->attribute=NULL;
1191    }
1192    else
1193      atKillAll((idhdl)l);
1194  }
1195  if(l->rtyp==IDHDL)
1196  {
1197    IDFLAG((idhdl)l->data)=0;
1198  }
1199  l->flag=0;
1200  if (ll==1)
1201  {
1202    /* l[..] = ... */
1203    if((l->e!=NULL)
1204    && (((l->rtyp==IDHDL) && (IDTYP((idhdl)l->data)==LIST_CMD))
1205      || (l->rtyp==LIST_CMD)))
1206    {
1207       b=jiAssign_list(l,r);
1208       if(!b)
1209       {
1210         //Print("jjA_L_LIST: - 2 \n");
1211         if((l->rtyp==IDHDL) && (l->data!=NULL))
1212         {
1213#ifdef HAVE_NAMESPACES
1214           //if (IDTYP((idhdl)l->data)==LIST_CMD)
1215           if ((l->req_packhdl)!= NULL)
1216           {
1217             namespaceroot->push( IDPACKAGE(l->req_packhdl) , IDID(l->req_packhdl));
1218             ipMoveId((idhdl)l->data);
1219             namespaceroot->pop();
1220           }
1221           else
1222#endif /* HAVE_NAMESPACES */
1223             ipMoveId((idhdl)l->data);
1224           l->attribute=IDATTR((idhdl)l->data);
1225           l->flag=IDFLAG((idhdl)l->data);
1226         }
1227       }
1228       r->CleanUp();
1229       Subexpr h;
1230       while (l->e!=NULL)
1231       {
1232         h=l->e->next;
1233         Free((ADDRESS)l->e,sizeof(*(l->e)));
1234         l->e=h;
1235       }
1236       return b;
1237    }
1238    rl=r->listLength();
1239    if (rl==1)
1240    {
1241      /* system variables = ... */
1242      if(((l->rtyp>=VECHO)&&(l->rtyp<=VPRINTLEVEL))
1243      ||((l->rtyp>=VALTVARS)&&(l->rtyp<=VMINPOLY)))
1244      {
1245        b=iiAssign_sys(l,r);
1246        r->CleanUp();
1247        //l->CleanUp();
1248        return b;
1249      }
1250      rt=r->Typ();
1251      /* a = ... */
1252      if ((lt!=MATRIX_CMD)
1253      &&(lt!=INTMAT_CMD)
1254      &&((lt==rt)||(lt!=LIST_CMD)))
1255      {
1256        b=jiAssign_1(l,r);
1257        if (l->rtyp==IDHDL)
1258        {
1259          if ((lt==DEF_CMD)||(lt==LIST_CMD))
1260          {
1261#ifdef HAVE_NAMESPACES
1262            //Print("jjA_L_LIST: - 3 \n");
1263            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
1264            {
1265              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
1266                                   IDID(l->req_packhdl));
1267              ipMoveId((idhdl)l->data);
1268              namespaceroot->pop();
1269            }
1270            else
1271#endif /* HAVE_NAMESPACES */
1272              ipMoveId((idhdl)l->data);
1273          }
1274          l->attribute=IDATTR((idhdl)l->data);
1275          l->flag=IDFLAG((idhdl)l->data);
1276          l->CleanUp();
1277        }
1278        r->CleanUp();
1279        return b;
1280      }
1281      if (((lt!=LIST_CMD)
1282        &&((rt==MATRIX_CMD)
1283          ||(rt==INTMAT_CMD)
1284          ||(rt==INTVEC_CMD)
1285          ||(rt==MODUL_CMD)))
1286      ||((lt==LIST_CMD)
1287        &&(rt==RESOLUTION_CMD))
1288      )
1289      {
1290        b=jiAssign_1(l,r);
1291        if((l->rtyp==IDHDL)&&(l->data!=NULL))
1292        {
1293          if ((lt==DEF_CMD) || (lt==LIST_CMD))
1294          {
1295            //Print("ipAssign - 3.0\n");
1296#ifdef HAVE_NAMESPACES
1297            //Print("jjA_L_LIST: - 4 \n");
1298            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
1299            {
1300              // Print("==========>ipAssign() - 3\n");
1301              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
1302                                   IDID(l->req_packhdl));
1303              ipMoveId((idhdl)l->data);
1304              namespaceroot->pop();
1305            }
1306            else
1307#endif /* HAVE_NAMESPACES */
1308              ipMoveId((idhdl)l->data);
1309          }
1310          l->attribute=IDATTR((idhdl)l->data);
1311          l->flag=IDFLAG((idhdl)l->data);
1312        }
1313        r->CleanUp();
1314        Subexpr h;
1315        while (l->e!=NULL)
1316        {
1317          h=l->e->next;
1318          Free((ADDRESS)l->e,sizeof(*(l->e)));
1319          l->e=h;
1320        }
1321        return b;
1322      }
1323    }
1324    if (rt==NONE) rt=r->Typ();
1325  }
1326  else if (ll==(rl=r->listLength()))
1327  {
1328    b=jiAssign_rec(l,r);
1329    return b;
1330  }
1331  else
1332  {
1333    if (rt==NONE) rt=r->Typ();
1334    if (rt==INTVEC_CMD)
1335      return jiA_INTVEC_L(l,r);
1336    else if (rt==VECTOR_CMD)
1337      return jiA_VECTOR_L(l,r);
1338    else if ((rt==IDEAL_CMD)||(rt==MATRIX_CMD))
1339      return jiA_MATRIX_L(l,r);
1340    else if ((rt==STRING_CMD)&&(rl==1))
1341      return jiA_STRING_L(l,r);
1342    Werror("length of lists in assignment does not match (l:%d,r:%d)",
1343      ll,rl);
1344    return TRUE;
1345  }
1346
1347  leftv hh=r;
1348  BOOLEAN nok=FALSE;
1349  BOOLEAN map_assign=FALSE;
1350  switch (lt)
1351  {
1352    case INTVEC_CMD:
1353      nok=jjA_L_INTVEC(l,r,new intvec(exprlist_length(r)));
1354      break;
1355    case INTMAT_CMD:
1356    {
1357      nok=jjA_L_INTVEC(l,r,new intvec(IDINTVEC((idhdl)l->data)));
1358      break;
1359    }
1360    case MAP_CMD:
1361    {
1362      // first element in the list sl (r) must be a ring
1363      if (((rt == RING_CMD)||(rt == QRING_CMD))&&(r->e==NULL))
1364      {
1365        FreeL((ADDRESS)IDMAP((idhdl)l->data)->preimage);
1366        IDMAP((idhdl)l->data)->preimage = mstrdup (r->Fullname());
1367        /* advance the expressionlist to get the next element after the ring */
1368        hh = r->next;
1369        //r=hh;
1370      }
1371      else
1372      {
1373        WerrorS("expected ring-name");
1374        nok=TRUE;
1375        break;
1376      }
1377      if (hh==NULL) /* map-assign: map f=r; */
1378      {
1379        WerrorS("expected image ideal");
1380        nok=TRUE;
1381        break;
1382      }
1383      if ((hh->next==NULL)&&(hh->Typ()==IDEAL_CMD))
1384        return jiAssign_1(l,hh); /* map-assign: map f=r,i; */
1385      //no break, handle the rest like an ideal:
1386      map_assign=TRUE;
1387    }
1388    case MATRIX_CMD:
1389    case IDEAL_CMD:
1390    case MODUL_CMD:
1391    {
1392      sleftv t;
1393      matrix olm = (matrix)l->Data();
1394      int rk=olm->rank;
1395      char *pr=((map)olm)->preimage;
1396      BOOLEAN module_assign=(/*l->Typ()*/ lt==MODUL_CMD);
1397      matrix lm ;
1398      int  num;
1399      int j,k;
1400      int i=0;
1401      int mtyp=MATRIX_CMD; /*Type of left side object*/
1402      int etyp=POLY_CMD;   /*Type of elements of left side object*/
1403
1404      if (lt /*l->Typ()*/==MATRIX_CMD)
1405      {
1406        num=olm->cols()*olm->rows();
1407        lm=mpNew(olm->rows(),olm->cols());
1408      }
1409      else /* IDEAL_CMD or MODUL_CMD */
1410      {
1411        num=exprlist_length(hh);
1412        lm=(matrix)idInit(num,1);
1413        rk=1;
1414        if (module_assign)
1415        {
1416          mtyp=MODUL_CMD;
1417          etyp=VECTOR_CMD;
1418        }
1419      }
1420
1421      int ht;
1422      loop
1423      {
1424        if (hh==NULL)
1425          break;
1426        else
1427        {
1428          matrix rm;
1429          ht=hh->Typ();
1430          if ((j=iiTestConvert(ht,etyp))!=0)
1431          {
1432            nok=iiConvert(ht,etyp,j,hh,&t);
1433            hh->next=t.next;
1434            if (nok) break;
1435            lm->m[i]=(poly)t.CopyD(etyp);
1436            if (module_assign) rk=max(rk,pMaxComp(lm->m[i]));
1437            i++;
1438          }
1439          else
1440          if ((j=iiTestConvert(ht,mtyp))!=0)
1441          {
1442            nok=iiConvert(ht,mtyp,j,hh,&t);
1443            hh->next=t.next;
1444            if (nok) break;
1445            rm = (matrix)t.CopyD(mtyp);
1446            if (module_assign)
1447            {
1448              j = min(num,rm->cols());
1449              rk=max(rk,rm->rank);
1450            }
1451            else
1452              j = min(num-i,rm->rows() * rm->cols());
1453            for(k=0;k<j;k++,i++)
1454            {
1455              lm->m[i]=rm->m[k];
1456              rm->m[k]=NULL;
1457            }
1458            idDelete((ideal *)&rm);
1459          }
1460          else
1461          {
1462            nok=TRUE;
1463            break;
1464          }
1465          t.next=NULL;t.CleanUp();
1466          if (i==num) break;
1467          hh=hh->next;
1468        }
1469      }
1470      if (nok)
1471        idDelete((ideal *)&lm);
1472      else
1473      {
1474        idDelete((ideal *)&olm);
1475        if (module_assign)   lm->rank=rk;
1476        else if (map_assign) ((map)lm)->preimage=pr;
1477#ifdef DRING
1478        else if (pDRING)
1479        {
1480          int i=IDELEMS(lm)-1;
1481          while (i>=0)
1482          {
1483            pdSetDFlagP(lm->m[i],1);
1484            i--;
1485          }
1486        }
1487#endif
1488        l=l->LData();
1489        if (l->rtyp==IDHDL)
1490          IDMATRIX((idhdl)l->data)=lm;
1491        else
1492          l->data=(char *)lm;
1493      }
1494      break;
1495    }
1496    case STRING_CMD:
1497      nok=jjA_L_STRING(l,r);
1498      break;
1499    case LIST_CMD:
1500      nok=jjA_L_LIST(l,r);
1501      break;
1502    case NONE:
1503    case 0:
1504      Werror("cannot assign to %s",l->Fullname());
1505      nok=TRUE;
1506      break;
1507    default:
1508      WerrorS("assign not impl.");
1509      nok=TRUE;
1510      break;
1511  } /* end switch: typ */
1512  if (nok && (!errorreported)) WerrorS("incompatible type in list assignment");
1513  r->CleanUp();
1514  return nok;
1515}
Note: See TracBrowser for help on using the repository browser.