source: git/Singular/ipassign.cc @ 512a2b

spielwiese
Last change on this file since 512a2b was 512a2b, checked in by Olaf Bachmann <obachman@…>, 24 years ago
p_polys.h git-svn-id: file:///usr/local/Singular/svn/trunk@4606 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 33.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: ipassign.cc,v 1.59 2000-09-18 09:19:04 obachman 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 "omalloc.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  number p=(number)a->CopyD(NUMBER_CMD);
119  if (nIsZero(p))
120  {
121    currRing->minpoly=NULL;
122    naMinimalPoly=NULL;
123  }
124  else
125  {
126    if ((rPar(currRing)!=1)
127      || (rField_is_GF()))
128    {
129      WerrorS("no minpoly allowed");
130      return TRUE;
131    }
132    if (currRing->minpoly!=NULL)
133    {
134      WerrorS("minpoly already set");
135      return TRUE;
136    }
137    nNormalize(p);
138    currRing->minpoly=p;
139    naMinimalPoly=((lnumber)currRing->minpoly)->z;
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(RESOLUTION_CMD);
240  if (res->data!=NULL) ((lists)res->data)->Clean();
241  res->data=(void *)syConvRes(r,TRUE);
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(LIST_CMD);
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    void* tmp = res->data;
324    res->data=(void *)a->CopyD(STRING_CMD);
325    jiAssignAttr(res,a);
326    //OB: ???   
327    omfree(tmp);
328  }
329  else
330  {
331    char *s=(char *)res->data;
332    if ((e->start>0)&&(e->start<=(int)strlen(s)))
333      s[e->start-1]=(char)(*((char *)a->Data()));
334    else
335    {
336      Werror("string index %d out of range 1..%d",e->start,strlen(s));
337      return TRUE;
338    }
339  }
340  return FALSE;
341}
342static BOOLEAN jiA_PROC(leftv res, leftv a, Subexpr e)
343{
344  extern procinfo *iiInitSingularProcinfo(procinfo *pi, char *libname,
345                                          char *procname, int line,
346                                          long pos, BOOLEAN pstatic=FALSE);
347  extern void piCleanUp(procinfov pi);
348
349  if(res->data!=NULL) piCleanUp((procinfo *)res->data);
350  if(a->rtyp==STRING_CMD)
351  {
352    res->data = (void *)omAlloc0Bin(procinfo_bin);
353    ((procinfo *)(res->data))->language=LANG_NONE;
354    iiInitSingularProcinfo((procinfo *)res->data,"",res->name,0,0);
355    ((procinfo *)res->data)->data.s.body=(char *)a->CopyD(STRING_CMD);
356  }
357  else
358    res->data=(void *)a->CopyD(PROC_CMD);
359  jiAssignAttr(res,a);
360  return FALSE;
361}
362static BOOLEAN jiA_INTVEC(leftv res, leftv a, Subexpr e)
363{
364  if (res->data!=NULL) delete ((intvec *)res->data);
365  res->data=(void *)a->CopyD(INTVEC_CMD);
366  jiAssignAttr(res,a);
367  return FALSE;
368}
369static BOOLEAN jiA_IDEAL(leftv res, leftv a, Subexpr e)
370{
371  if (res->data!=NULL) idDelete((ideal*)&res->data);
372  res->data=(void *)a->CopyD(MATRIX_CMD);
373  jiAssignAttr(res,a);
374  return FALSE;
375}
376static BOOLEAN jiA_RESOLUTION(leftv res, leftv a, Subexpr e)
377{
378  if (res->data!=NULL) syKillComputation((syStrategy)res->data);
379  res->data=(void *)a->CopyD(RESOLUTION_CMD);
380  jiAssignAttr(res,a);
381  return FALSE;
382}
383static BOOLEAN jiA_MODUL_P(leftv res, leftv a, Subexpr e)
384{
385  if (res->data!=NULL) idDelete((ideal*)&res->data);
386  ideal I=idInit(1,1);
387  I->m[0]=(poly)a->CopyD(POLY_CMD);
388  if (I->m[0]!=NULL) pSetCompP(I->m[0],1);
389  res->data=(void *)I;
390  return FALSE;
391}
392static BOOLEAN jiA_IDEAL_M(leftv res, leftv a, Subexpr e)
393{
394  if (res->data!=NULL) idDelete((ideal*)&res->data);
395  matrix m=(matrix)a->CopyD(MATRIX_CMD);
396  IDELEMS((ideal)m)=MATROWS(m)*MATCOLS(m);
397  ((ideal)m)->rank=1;
398  MATROWS(m)=1;
399  res->data=(void *)m;
400  return FALSE;
401}
402static BOOLEAN jiA_LINK(leftv res, leftv a, Subexpr e)
403{
404  si_link l=(si_link)res->data;
405
406  if (l!=NULL) slCleanUp(l);
407
408  if (a->Typ() == STRING_CMD)
409  {
410    if (l == NULL)
411    {
412      l = (si_link) omAlloc0Bin(sip_link_bin);
413      res->data = (void *) l;
414    }
415    return slInit(l, (char *) a->Data());
416  }
417  else if (a->Typ() == LINK_CMD)
418  {
419    if (l != NULL) omFreeBin(l, sip_link_bin);
420    res->data = slCopy((si_link)a->Data());
421    return FALSE;
422  }
423  return TRUE;
424}
425// assign map -> map
426static BOOLEAN jiA_MAP(leftv res, leftv a, Subexpr e)
427{
428  if (res->data!=NULL)
429  {
430    omFree((ADDRESS)((map)res->data)->preimage);
431    ((map)res->data)->preimage=NULL;
432    idDelete((ideal*)&res->data);
433  }
434  res->data=(void *)a->CopyD(MAP_CMD);
435  jiAssignAttr(res,a);
436  return FALSE;
437}
438// assign ideal -> map
439static BOOLEAN jiA_MAP_ID(leftv res, leftv a, Subexpr e)
440{
441  map f=(map)res->data;
442  char *rn=f->preimage; // save the old/already assigned preimage ring name
443  f->preimage=NULL;
444  idDelete((ideal *)&f);
445  res->data=(void *)a->CopyD(IDEAL_CMD);
446  f=(map)res->data;
447  f->preimage = rn;
448  return FALSE;
449}
450static BOOLEAN jiA_QRING(leftv res, leftv a,Subexpr e)
451{
452  // the follwing can only happen, if:
453  //   - the left side is of type qring AND not an id
454  if ((e!=NULL)||(res->rtyp!=IDHDL))
455  {
456    WerrorS("qring_id expected");
457    return TRUE;
458  }
459  ring qr;
460  int i,j;
461  int *pi;
462
463  assumeStdFlag(a);
464  qr=(ring)res->Data();
465  ring qrr=rCopy(currRing);
466  memcpy4(qr,qrr,sizeof(ip_sring));
467  omFreeBin((ADDRESS)qrr, ip_sring_bin);
468  if (qr->qideal!=NULL) idDelete(&qr->qideal);
469  qr->qideal = (ideal)a->CopyD(IDEAL_CMD);
470  //currRing=qr;
471  //currRingHdl=(idhdl)res->data;
472  //currQuotient=qr->qideal;
473  rSetHdl((idhdl)res->data,TRUE);
474  return FALSE;
475}
476static BOOLEAN jiA_RING(leftv res, leftv a, Subexpr e)
477{
478  BOOLEAN have_id=TRUE;
479  if ((e!=NULL)||(res->rtyp!=IDHDL))
480  {
481    //WerrorS("id expected");
482    //return TRUE;
483    have_id=FALSE;
484  }
485  ring r=(ring)a->Data();
486  if (have_id)
487  {
488    idhdl rl=(idhdl)res->data;
489    if (&IDRING(rl)!=NULL) rKill(rl);
490    IDRING(rl)=r;
491    if ((IDLEV((idhdl)a->data)!=myynest) && (r==currRing))
492      currRingHdl=(idhdl)res->data;
493  }
494  else
495  {
496    if (e==NULL) res->data=(char *)r;
497    else
498    {
499      WerrorS("id expected");
500      return TRUE;
501    }
502  }
503  r->ref++;
504  return FALSE;
505}
506static BOOLEAN jiA_PACKAGE(leftv res, leftv a, Subexpr e)
507{
508  res->data=(void *)a->CopyD(PACKAGE_CMD);
509  jiAssignAttr(res,a);
510  return FALSE;
511}
512/*=================== table =================*/
513struct sValAssign dAssign[]=
514{
515// proc         res             arg
516 {jiA_IDEAL,    IDEAL_CMD,      IDEAL_CMD }
517,{jiA_IDEAL_M,  IDEAL_CMD,      MATRIX_CMD }
518,{jiA_RESOLUTION,RESOLUTION_CMD,RESOLUTION_CMD }
519,{jiA_INT,      INT_CMD,        INT_CMD }
520,{jiA_IDEAL,    MATRIX_CMD,     MATRIX_CMD }
521,{jiA_MAP_ID,   MAP_CMD,        IDEAL_CMD }
522,{jiA_MAP,      MAP_CMD,        MAP_CMD }
523,{jiA_IDEAL,    MODUL_CMD,      MODUL_CMD }
524,{jiA_MODUL_P,  MODUL_CMD,      POLY_CMD }
525,{jiA_POLY,     POLY_CMD,       POLY_CMD }
526,{jiA_1x1MATRIX,POLY_CMD,       MATRIX_CMD }
527,{jiA_QRING,    QRING_CMD,      IDEAL_CMD }
528,{jiA_RING,     RING_CMD,       RING_CMD }
529,{jiA_RING,     QRING_CMD,      QRING_CMD }
530,{jiA_STRING,   STRING_CMD,     STRING_CMD }
531,{jiA_PROC,     PROC_CMD,       STRING_CMD }
532,{jiA_PROC,     PROC_CMD,       PROC_CMD }
533,{jiA_POLY,     VECTOR_CMD,     VECTOR_CMD }
534,{jiA_INTVEC,   INTVEC_CMD,     INTVEC_CMD }
535,{jiA_INTVEC,   INTMAT_CMD,     INTMAT_CMD }
536,{jiA_NUMBER,   NUMBER_CMD,     NUMBER_CMD }
537,{jiA_LIST_RES, LIST_CMD,       RESOLUTION_CMD }
538,{jiA_LIST,     LIST_CMD,       LIST_CMD }
539,{jiA_LINK,     LINK_CMD,       STRING_CMD }
540,{jiA_LINK,     LINK_CMD,       LINK_CMD }
541,{jiA_PACKAGE,  PACKAGE_CMD,    PACKAGE_CMD }
542,{NULL,         0,              0 }
543};
544struct sValAssign_sys dAssign_sys[]=
545{
546// sysvars:
547 {jjECHO,       VECHO,          INT_CMD }
548#ifdef SRING
549,{jjALTVARS,    VALTVARS,       INT_CMD }
550#endif
551,{jjPAGELENGTH, VPAGELENGTH,    INT_CMD }
552,{jjPRINTLEVEL, VPRINTLEVEL,    INT_CMD }
553,{jjCOLMAX,     VCOLMAX,        INT_CMD }
554,{jjTIMER,      VTIMER,         INT_CMD }
555#ifdef HAVE_RTIMER
556,{jjRTIMER,     VRTIMER,        INT_CMD }
557#endif
558,{jjMAXDEG,     VMAXDEG,        INT_CMD }
559,{jjMAXMULT,    VMAXMULT,       INT_CMD }
560,{jjTRACE,      TRACE,          INT_CMD }
561,{jjSHORTOUT,   VSHORTOUT,      INT_CMD }
562,{jjMINPOLY,    VMINPOLY,       NUMBER_CMD }
563,{jjNOETHER,    VNOETHER,       POLY_CMD }
564,{NULL,         0,              0 }
565};
566/*=================== operations ============================*/
567/*2
568* assign a = b
569*/
570static BOOLEAN jiAssign_1(leftv l, leftv r)
571{
572  int rt=r->Typ();
573  if (rt==0)
574  {
575    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
576    return TRUE;
577  }
578
579  int lt=l->Typ();
580  if((lt==0)/*&&(l->name!=NULL)*/)
581  {
582    if (!errorreported) Werror("left side `%s` is undefined",l->Fullname());
583    return TRUE;
584  }
585  if((rt==DEF_CMD)||(rt==NONE))
586  {
587    WarnS("right side is not a datum, assignment ignored");
588    // if (!errorreported)
589    //   WerrorS("right side is not a datum");
590    //return TRUE;
591    return FALSE;
592  }
593
594  int i=0;
595  BOOLEAN nok=FALSE;
596
597  if (lt==DEF_CMD)
598  {
599    if (l->rtyp==IDHDL)
600    {
601      IDTYP((idhdl)l->data)=rt;
602    }
603    else if (l->name!=NULL)
604    {
605      sleftv ll;
606      iiDeclCommand(&ll,l,myynest,rt,&IDROOT);
607      memcpy(l,&ll,sizeof(sleftv));
608    }
609    else
610    {
611      l->rtyp=rt;
612    }
613    lt=rt;
614  }
615  else
616  {
617    if ((l->data==r->data)&&(l->e==NULL)&&(r->e==NULL))
618      return FALSE;
619  }
620  leftv ld=l;
621  if ((l->rtyp==IDHDL)&&(lt!=QRING_CMD)&&(lt!=RING_CMD))
622    ld=(leftv)l->data;
623  while (((dAssign[i].res!=lt)
624      || (dAssign[i].arg!=rt))
625    && (dAssign[i].res!=0)) i++;
626  if (dAssign[i].res!=0)
627  {
628    BOOLEAN b;
629    b=dAssign[i].p(ld,r,l->e);
630    if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
631    {
632      l->flag=ld->flag;
633      l->attribute=ld->attribute;
634    }
635    return b;
636  }
637  // implicite type conversion ----------------------------------------------
638  if (dAssign[i].res==0)
639  {
640    int ri;
641    leftv rn = (leftv)omAlloc0Bin(sleftv_bin);
642    BOOLEAN failed=FALSE;
643    i=0;
644    while ((dAssign[i].res!=lt)
645      && (dAssign[i].res!=0)) i++;
646    while (dAssign[i].res==lt)
647    {
648      if ((ri=iiTestConvert(rt,dAssign[i].arg))!=0)
649      {
650        failed= iiConvert(rt,dAssign[i].arg,ri,r,rn);
651        if(!failed)
652        {
653          failed= dAssign[i].p(ld,rn,l->e);
654        }
655        // everything done, clean up temp. variables
656        rn->CleanUp();
657        omFreeBin((ADDRESS)rn, sleftv_bin);
658        if (failed)
659        {
660          // leave loop, goto error handling
661          break;
662        }
663        else
664        {
665          if(l!=ld) /* i.e. l is IDHDL, l->data is ld */
666          {
667            l->flag=ld->flag;
668            l->attribute=ld->attribute;
669          }
670          // everything ok, return
671          return FALSE;
672        }
673     }
674     i++;
675    }
676    // error handling ---------------------------------------------------
677    if (!errorreported)
678    {
679      Werror("`%s` = `%s` is not supported"
680             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
681      if (BVERBOSE(V_SHOW_USE))
682      {
683        i=0;
684        while ((dAssign[i].res!=lt)
685          && (dAssign[i].res!=0)) i++;
686        while (dAssign[i].res==lt)
687        {
688          Werror("expected `%s` = `%s`"
689              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign[i].arg));
690          i++;
691        }
692      }
693    }
694  }
695  return TRUE;
696}
697/*2
698* assign sys_var = val
699*/
700static BOOLEAN iiAssign_sys(leftv l, leftv r)
701{
702  int rt=r->Typ();
703
704  if (rt==0)
705  {
706    if (!errorreported) Werror("`%s` is undefined",r->Fullname());
707    return TRUE;
708  }
709  int i=0;
710  int lt=l->rtyp;
711  while (((dAssign_sys[i].res!=lt)
712      || (dAssign_sys[i].arg!=rt))
713    && (dAssign_sys[i].res!=0)) i++;
714  if (dAssign_sys[i].res!=0)
715  {
716    if (!dAssign_sys[i].p(l,r))
717    {
718      // everything ok, clean up
719      return FALSE;
720    }
721  }
722  // implicite type conversion ----------------------------------------------
723  if (dAssign_sys[i].res==0)
724  {
725    int ri;
726    leftv rn = (leftv)omAlloc0Bin(sleftv_bin);
727    BOOLEAN failed=FALSE;
728    i=0;
729    while ((dAssign_sys[i].res!=lt)
730      && (dAssign_sys[i].res!=0)) i++;
731    while (dAssign_sys[i].res==lt)
732    {
733      if ((ri=iiTestConvert(rt,dAssign_sys[i].arg))!=0)
734      {
735        failed= ((iiConvert(rt,dAssign_sys[i].arg,ri,r,rn))
736            || (dAssign_sys[i].p(l,rn)));
737        // everything done, clean up temp. variables
738        rn->CleanUp();
739        omFreeBin((ADDRESS)rn, sleftv_bin);
740        if (failed)
741        {
742          // leave loop, goto error handling
743          break;
744        }
745        else
746        {
747          // everything ok, return
748          return FALSE;
749        }
750     }
751     i++;
752    }
753    // error handling ---------------------------------------------------
754    if(!errorreported)
755    {
756      Werror("`%s` = `%s` is not supported"
757             ,Tok2Cmdname(lt),Tok2Cmdname(rt));
758      if (BVERBOSE(V_SHOW_USE))
759      {
760        i=0;
761        while ((dAssign_sys[i].res!=lt)
762          && (dAssign_sys[i].res!=0)) i++;
763        while (dAssign_sys[i].res==lt)
764        {
765          Werror("expected `%s` = `%s`"
766              ,Tok2Cmdname(lt),Tok2Cmdname(dAssign_sys[i].arg));
767          i++;
768        }
769      }
770    }
771  }
772  return TRUE;
773}
774static BOOLEAN jiA_INTVEC_L(leftv l,leftv r)
775{
776  /* right side is intvec, left side is list (of int)*/
777  BOOLEAN nok;
778  int i=0;
779  leftv l1=l;
780  leftv h;
781  sleftv t;
782  intvec *iv=(intvec *)r->Data();
783  memset(&t,0,sizeof(sleftv));
784  t.rtyp=INT_CMD;
785  while ((i<iv->length())&&(l!=NULL))
786  {
787    t.data=(char *)(*iv)[i];
788    h=l->next;
789    l->next=NULL;
790    nok=jiAssign_1(l,&t);
791    if (nok) return TRUE;
792    i++;
793    l=h;
794  }
795  l1->CleanUp();
796  r->CleanUp();
797  return FALSE;
798}
799static BOOLEAN jiA_VECTOR_L(leftv l,leftv r)
800{
801  /* right side is vector, left side is list (of poly)*/
802  BOOLEAN nok;
803  leftv l1=l;
804  ideal I=idVec2Ideal((poly)r->Data());
805  leftv h;
806  sleftv t;
807  int i=0;
808  while (l!=NULL)
809  {
810    memset(&t,0,sizeof(sleftv));
811    t.rtyp=POLY_CMD;
812    if (i>=IDELEMS(I))
813    {
814      t.data=NULL;
815    }
816    else
817    {
818      t.data=(char *)I->m[i];
819      I->m[i]=NULL;
820    }
821    h=l->next;
822    l->next=NULL;
823    nok=jiAssign_1(l,&t);
824    t.CleanUp();
825    if (nok)
826    {
827      idDelete(&I);
828      return TRUE;
829    }
830    i++;
831    l=h;
832  }
833  idDelete(&I);
834  l1->CleanUp();
835  r->CleanUp();
836  return FALSE;
837}
838static BOOLEAN jjA_L_LIST(leftv l, leftv r)
839/* left side: list, has to be a "real" variable
840*  right side: expression list
841*/
842{
843  int sl = r->listLength();
844  lists L=(lists)omAllocBin(slists_bin);
845  lists oldL;
846  leftv h=NULL,o_r=r;
847  int i;
848  int rt;
849
850  L->Init(sl);
851  for (i=0;i<sl;i++)
852  {
853    if (h!=NULL) { /* e.g. not in the first step:
854                   * h is the pointer to the old sleftv,
855                   * r is the pointer to the next sleftv
856                   * (in this moment) */
857                   h->next=r;
858                 }
859    h=r;
860    r=r->next;
861    h->next=NULL;
862    rt=h->Typ();
863    if ((rt==0)||(rt==NONE)||(rt==DEF_CMD))
864    {
865      L->Clean();
866      Werror("`%s` is undefined",h->Fullname());
867      goto err;
868    }
869    //if ((rt==RING_CMD)||(rt==QRING_CMD))
870    //{
871    //  L->m[i].rtyp=rt;
872    //  L->m[i].data=h->Data();
873    //  ((ring)L->m[i].data)->ref++;
874    //}
875    //else
876      L->m[i].Copy(h);
877      if(errorreported)
878      {
879        L->Clean();
880        goto err;
881      }
882  }
883  oldL=(lists)l->Data(); oldL->Clean();
884  if (l->rtyp==IDHDL)
885  {
886    IDLIST((idhdl)l->data)=L;
887#ifdef HAVE_NAMESPACES
888    if (l->req_packhdl != NULL)
889    {
890      //Print("jjA_L_LIST: -1 \n");
891      namespaceroot->push( IDPACKAGE(l->req_packhdl), IDID((idhdl)l));
892      ipMoveId((idhdl)l->data);
893      namespaceroot->pop();
894    }
895    else
896#endif /* HAVE_NAMESPACES */
897      ipMoveId((idhdl)l->data);
898  }
899  else
900  {
901    l->LData()->data=L;
902  }
903err:
904  o_r->CleanUp();
905  return errorreported;
906}
907static BOOLEAN jjA_L_INTVEC(leftv l,leftv r,intvec *iv)
908{
909  /* left side is intvec/intmat, right side is list (of int,intvec,intmat)*/
910  leftv hh=r;
911  int i = 0;
912  while (hh!=NULL)
913  {
914    if (i>=iv->length()) break;
915    if (hh->Typ() == INT_CMD)
916    {
917      (*iv)[i++] = (int)(hh->Data());
918    }
919    else if ((hh->Typ() == INTVEC_CMD)
920            ||(hh->Typ() == INTMAT_CMD))
921    {
922      intvec *ivv = (intvec *)(hh->Data());
923      int ll = 0,l = min(ivv->length(),iv->length());
924      for (; l>0; l--)
925      {
926        (*iv)[i++] = (*ivv)[ll++];
927      }
928    }
929    else
930    {
931      delete iv;
932      return TRUE;
933    }
934    hh = hh->next;
935  }
936  if (IDINTVEC((idhdl)l->data)!=NULL) delete IDINTVEC((idhdl)l->data);
937  IDINTVEC((idhdl)l->data)=iv;
938  return FALSE;
939}
940static BOOLEAN jjA_L_STRING(leftv l,leftv r)
941{
942  /* left side is string, right side is list of string*/
943  leftv hh=r;
944  int sl = 1;
945  char *s;
946  char *t;
947  int tl;
948  /* find the length */
949  while (hh!=NULL)
950  {
951    if (hh->Typ()!= STRING_CMD)
952    {
953      return TRUE;
954    }
955    sl += strlen((char *)hh->Data());
956    hh = hh->next;
957  }
958  s = (char * )omAlloc(sl);
959  sl=0;
960  hh = r;
961  while (hh!=NULL)
962  {
963    t=(char *)hh->Data();
964    tl=strlen(t);
965    memcpy(s+sl,t,tl);
966    sl+=tl;
967    hh = hh->next;
968  }
969  s[sl]='\0';
970  omFree((ADDRESS)IDDATA((idhdl)(l->data)));
971  IDDATA((idhdl)(l->data))=s;
972  return FALSE;
973}
974static BOOLEAN jjA_LIST_L(leftv l,leftv r)
975{
976  /*left side are something, right side are lists*/
977  /*e.g. a,b,c=l */
978  //int ll=l->listLength();
979  if (l->listLength()==1) return jiAssign_1(l,r);
980  BOOLEAN nok;
981  sleftv t;
982  leftv h;
983  lists L=(lists)r->Data();
984  int rl=L->nr;
985  int i=0;
986
987  memset(&t,0,sizeof(sleftv));
988  while ((i<=rl)&&(l!=NULL))
989  {
990    memset(&t,0,sizeof(sleftv));
991    t.Copy(&L->m[i]);
992    h=l->next;
993    l->next=NULL;
994    nok=jiAssign_1(l,&t);
995    if (nok) return TRUE;
996    i++;
997    l=h;
998  }
999  r->CleanUp();
1000  return FALSE;
1001}
1002static BOOLEAN jiA_MATRIX_L(leftv l,leftv r)
1003{
1004  /* right side is matrix, left side is list (of poly)*/
1005  BOOLEAN nok=FALSE;
1006  int i;
1007  matrix m=(matrix)r->CopyD(MATRIX_CMD);
1008  leftv h;
1009  leftv ol=l;
1010  leftv o_r=r;
1011  sleftv t;
1012  memset(&t,0,sizeof(sleftv));
1013  t.rtyp=POLY_CMD;
1014  loop
1015  {
1016    i=0;
1017    while ((i<MATROWS(m)*MATCOLS(m))&&(l!=NULL))
1018    {
1019      t.data=(char *)m->m[i];
1020      m->m[i]=NULL;
1021      h=l->next;
1022      l->next=NULL;
1023      nok=jiAssign_1(l,&t);
1024      l->next=h;
1025      if (nok)
1026      {
1027        idDelete((ideal *)&m);
1028        goto ende;
1029      }
1030      i++;
1031      l=h;
1032    }
1033    idDelete((ideal *)&m);
1034    h=r;
1035    r=r->next;
1036    if (l==NULL)
1037    {
1038      if (r!=NULL)
1039      {
1040        Warn("list length mismatch in assign (l>r)");
1041        nok=TRUE;
1042      }
1043      break;
1044    }
1045    else if (r==NULL)
1046    {
1047      Warn("list length mismatch in assign (l<r)");
1048      nok=TRUE;
1049      break;
1050    }
1051    if ((r->Typ()==IDEAL_CMD)||(r->Typ()==MATRIX_CMD))
1052      m=(matrix)r->CopyD(MATRIX_CMD);
1053    else if (r->Typ()==POLY_CMD)
1054    {
1055      m=mpNew(1,1);
1056      MATELEM(m,1,1)=(poly)r->CopyD(POLY_CMD);
1057    }
1058    else
1059    {
1060      nok=TRUE;
1061      break;
1062    }
1063  }
1064ende:
1065  o_r->CleanUp();
1066  ol->CleanUp();
1067  return nok;
1068}
1069static BOOLEAN jiA_STRING_L(leftv l,leftv r)
1070{
1071  /*left side are strings, right side is a string*/
1072  /*e.g. s[2..3]="12" */
1073  /*the case s=t[1..4] is handled in iiAssign,
1074  * the case s[2..3]=t[3..4] is handled in iiAssgn_rec*/
1075  int ll=l->listLength();
1076  int rl=r->listLength();
1077  BOOLEAN nok=FALSE;
1078  sleftv t;
1079  leftv h,l1=l;
1080  int i=0;
1081  char *ss;
1082  char *s=(char *)r->Data();
1083  int sl=strlen(s);
1084
1085  memset(&t,0,sizeof(sleftv));
1086  t.rtyp=STRING_CMD;
1087  while ((i<sl)&&(l!=NULL))
1088  {
1089    ss=(char *)omAlloc(2);
1090    ss[1]='\0';
1091    ss[0]=s[i];
1092    t.data=ss;
1093    h=l->next;
1094    l->next=NULL;
1095    nok=jiAssign_1(l,&t);
1096    if (nok)
1097    {
1098      break;
1099    }
1100    i++;
1101    l=h;
1102  }
1103  r->CleanUp();
1104  l1->CleanUp();
1105  return nok;
1106}
1107static BOOLEAN jiAssign_list(leftv l, leftv r)
1108{
1109  int i=l->e->start-1;
1110  if (i<0)
1111  {
1112    Werror("index[%d] must be positive",i+1);
1113    return TRUE;
1114  }
1115  if(l->attribute!=NULL)
1116  {
1117    atKillAll((idhdl)l);
1118    l->attribute=NULL;
1119  }
1120  l->flag=0;
1121  lists li;
1122  if (l->rtyp==IDHDL)
1123  {
1124    li=IDLIST((idhdl)l->data);
1125  }
1126  else
1127  {
1128    li=(lists)l->data;
1129  }
1130  if (i>li->nr)
1131  {
1132    li->m=(leftv)omreallocSize(li->m,(li->nr+1)*sizeof(sleftv),(i+1)*sizeof(sleftv));
1133    memset(&(li->m[li->nr+1]),0,(i-li->nr)*sizeof(sleftv));
1134    int j=li->nr+1;
1135    for(;j<=i;j++)
1136      li->m[j].rtyp=DEF_CMD;
1137    li->nr=i;
1138  }
1139  leftv ld=&(li->m[i]);
1140  ld->e=l->e->next;
1141  BOOLEAN b;
1142  if ((ld->rtyp!=LIST_CMD)
1143  &&(ld->e==NULL)
1144  &&(ld->Typ()!=r->Typ()))
1145  {
1146    sleftv tmp;
1147    memset(&tmp,0,sizeof(sleftv));
1148    tmp.rtyp=DEF_CMD;
1149    b=iiAssign(&tmp,r);
1150    ld->CleanUp();
1151    memcpy(ld,&tmp,sizeof(sleftv));
1152  }
1153  else
1154  {
1155    b=iiAssign(ld,r);
1156    l->e->next=ld->e;
1157    ld->e=NULL;
1158  }
1159  return b;
1160}
1161static BOOLEAN jiAssign_rec(leftv l, leftv r)
1162{
1163  leftv l1=l;
1164  leftv r1=r;
1165  leftv lrest;
1166  leftv rrest;
1167  BOOLEAN b;
1168  do
1169  {
1170    lrest=l->next;
1171    rrest=r->next;
1172    l->next=NULL;
1173    r->next=NULL;
1174    b=iiAssign(l,r);
1175    l->next=lrest;
1176    r->next=rrest;
1177    l=lrest;
1178    r=rrest;
1179  } while  ((!b)&&(l!=NULL));
1180  l1->CleanUp();
1181  r1->CleanUp();
1182  return b;
1183}
1184BOOLEAN iiAssign(leftv l, leftv r)
1185{
1186  int ll=l->listLength();
1187  int rl;
1188  int lt=l->Typ();
1189  int rt=NONE;
1190  BOOLEAN b;
1191
1192  if(l->attribute!=NULL)
1193  {
1194    if (l->rtyp==IDHDL)
1195    {
1196      atKillAll((idhdl)l->data);
1197      l->attribute=NULL;
1198    }
1199    else
1200      atKillAll((idhdl)l);
1201  }
1202  if(l->rtyp==IDHDL)
1203  {
1204    IDFLAG((idhdl)l->data)=0;
1205  }
1206  l->flag=0;
1207  if (ll==1)
1208  {
1209    /* l[..] = ... */
1210    if((l->e!=NULL)
1211    && (((l->rtyp==IDHDL) && (IDTYP((idhdl)l->data)==LIST_CMD))
1212      || (l->rtyp==LIST_CMD)))
1213    {
1214       b=jiAssign_list(l,r);
1215       if(!b)
1216       {
1217         //Print("jjA_L_LIST: - 2 \n");
1218         if((l->rtyp==IDHDL) && (l->data!=NULL))
1219         {
1220#ifdef HAVE_NAMESPACES
1221           //if (IDTYP((idhdl)l->data)==LIST_CMD)
1222           if ((l->req_packhdl)!= NULL)
1223           {
1224             namespaceroot->push( IDPACKAGE(l->req_packhdl) , IDID(l->req_packhdl));
1225             ipMoveId((idhdl)l->data);
1226             namespaceroot->pop();
1227           }
1228           else
1229#endif /* HAVE_NAMESPACES */
1230             ipMoveId((idhdl)l->data);
1231           l->attribute=IDATTR((idhdl)l->data);
1232           l->flag=IDFLAG((idhdl)l->data);
1233         }
1234       }
1235       r->CleanUp();
1236       Subexpr h;
1237       while (l->e!=NULL)
1238       {
1239         h=l->e->next;
1240         omFreeBin((ADDRESS)l->e, sSubexpr_bin);
1241         l->e=h;
1242       }
1243       return b;
1244    }
1245    rl=r->listLength();
1246    if (rl==1)
1247    {
1248      /* system variables = ... */
1249      if(((l->rtyp>=VECHO)&&(l->rtyp<=VPRINTLEVEL))
1250      ||((l->rtyp>=VALTVARS)&&(l->rtyp<=VMINPOLY)))
1251      {
1252        b=iiAssign_sys(l,r);
1253        r->CleanUp();
1254        //l->CleanUp();
1255        return b;
1256      }
1257      rt=r->Typ();
1258      /* a = ... */
1259      if ((lt!=MATRIX_CMD)
1260      &&(lt!=INTMAT_CMD)
1261      &&((lt==rt)||(lt!=LIST_CMD)))
1262      {
1263        b=jiAssign_1(l,r);
1264        if (l->rtyp==IDHDL)
1265        {
1266          if ((lt==DEF_CMD)||(lt==LIST_CMD))
1267          {
1268#ifdef HAVE_NAMESPACES
1269            //Print("jjA_L_LIST: - 3 \n");
1270            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
1271            {
1272              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
1273                                   IDID(l->req_packhdl));
1274              ipMoveId((idhdl)l->data);
1275              namespaceroot->pop();
1276            }
1277            else
1278#endif /* HAVE_NAMESPACES */
1279              ipMoveId((idhdl)l->data);
1280          }
1281          l->attribute=IDATTR((idhdl)l->data);
1282          l->flag=IDFLAG((idhdl)l->data);
1283          l->CleanUp();
1284        }
1285        r->CleanUp();
1286        return b;
1287      }
1288      if (((lt!=LIST_CMD)
1289        &&((rt==MATRIX_CMD)
1290          ||(rt==INTMAT_CMD)
1291          ||(rt==INTVEC_CMD)
1292          ||(rt==MODUL_CMD)))
1293      ||((lt==LIST_CMD)
1294        &&(rt==RESOLUTION_CMD))
1295      )
1296      {
1297        b=jiAssign_1(l,r);
1298        if((l->rtyp==IDHDL)&&(l->data!=NULL))
1299        {
1300          if ((lt==DEF_CMD) || (lt==LIST_CMD))
1301          {
1302            //Print("ipAssign - 3.0\n");
1303#ifdef HAVE_NAMESPACES
1304            //Print("jjA_L_LIST: - 4 \n");
1305            if (lt==LIST_CMD && (l->req_packhdl)!= NULL)
1306            {
1307              // Print("==========>ipAssign() - 3\n");
1308              namespaceroot->push( IDPACKAGE(l->req_packhdl) ,
1309                                   IDID(l->req_packhdl));
1310              ipMoveId((idhdl)l->data);
1311              namespaceroot->pop();
1312            }
1313            else
1314#endif /* HAVE_NAMESPACES */
1315              ipMoveId((idhdl)l->data);
1316          }
1317          l->attribute=IDATTR((idhdl)l->data);
1318          l->flag=IDFLAG((idhdl)l->data);
1319        }
1320        r->CleanUp();
1321        Subexpr h;
1322        while (l->e!=NULL)
1323        {
1324          h=l->e->next;
1325          omFreeBin((ADDRESS)l->e, sSubexpr_bin);
1326          l->e=h;
1327        }
1328        return b;
1329      }
1330    }
1331    if (rt==NONE) rt=r->Typ();
1332  }
1333  else if (ll==(rl=r->listLength()))
1334  {
1335    b=jiAssign_rec(l,r);
1336    return b;
1337  }
1338  else
1339  {
1340    if (rt==NONE) rt=r->Typ();
1341    if (rt==INTVEC_CMD)
1342      return jiA_INTVEC_L(l,r);
1343    else if (rt==VECTOR_CMD)
1344      return jiA_VECTOR_L(l,r);
1345    else if ((rt==IDEAL_CMD)||(rt==MATRIX_CMD))
1346      return jiA_MATRIX_L(l,r);
1347    else if ((rt==STRING_CMD)&&(rl==1))
1348      return jiA_STRING_L(l,r);
1349    Werror("length of lists in assignment does not match (l:%d,r:%d)",
1350      ll,rl);
1351    return TRUE;
1352  }
1353
1354  leftv hh=r;
1355  BOOLEAN nok=FALSE;
1356  BOOLEAN map_assign=FALSE;
1357  switch (lt)
1358  {
1359    case INTVEC_CMD:
1360      nok=jjA_L_INTVEC(l,r,new intvec(exprlist_length(r)));
1361      break;
1362    case INTMAT_CMD:
1363    {
1364      nok=jjA_L_INTVEC(l,r,new intvec(IDINTVEC((idhdl)l->data)));
1365      break;
1366    }
1367    case MAP_CMD:
1368    {
1369      // first element in the list sl (r) must be a ring
1370      if (((rt == RING_CMD)||(rt == QRING_CMD))&&(r->e==NULL))
1371      {
1372        omFree((ADDRESS)IDMAP((idhdl)l->data)->preimage);
1373        IDMAP((idhdl)l->data)->preimage = omStrDup (r->Fullname());
1374        /* advance the expressionlist to get the next element after the ring */
1375        hh = r->next;
1376        //r=hh;
1377      }
1378      else
1379      {
1380        WerrorS("expected ring-name");
1381        nok=TRUE;
1382        break;
1383      }
1384      if (hh==NULL) /* map-assign: map f=r; */
1385      {
1386        WerrorS("expected image ideal");
1387        nok=TRUE;
1388        break;
1389      }
1390      if ((hh->next==NULL)&&(hh->Typ()==IDEAL_CMD))
1391        return jiAssign_1(l,hh); /* map-assign: map f=r,i; */
1392      //no break, handle the rest like an ideal:
1393      map_assign=TRUE;
1394    }
1395    case MATRIX_CMD:
1396    case IDEAL_CMD:
1397    case MODUL_CMD:
1398    {
1399      sleftv t;
1400      matrix olm = (matrix)l->Data();
1401      int rk=olm->rank;
1402      char *pr=((map)olm)->preimage;
1403      BOOLEAN module_assign=(/*l->Typ()*/ lt==MODUL_CMD);
1404      matrix lm ;
1405      int  num;
1406      int j,k;
1407      int i=0;
1408      int mtyp=MATRIX_CMD; /*Type of left side object*/
1409      int etyp=POLY_CMD;   /*Type of elements of left side object*/
1410
1411      if (lt /*l->Typ()*/==MATRIX_CMD)
1412      {
1413        num=olm->cols()*olm->rows();
1414        lm=mpNew(olm->rows(),olm->cols());
1415      }
1416      else /* IDEAL_CMD or MODUL_CMD */
1417      {
1418        num=exprlist_length(hh);
1419        lm=(matrix)idInit(num,1);
1420        rk=1;
1421        if (module_assign)
1422        {
1423          mtyp=MODUL_CMD;
1424          etyp=VECTOR_CMD;
1425        }
1426      }
1427
1428      int ht;
1429      loop
1430      {
1431        if (hh==NULL)
1432          break;
1433        else
1434        {
1435          matrix rm;
1436          ht=hh->Typ();
1437          if ((j=iiTestConvert(ht,etyp))!=0)
1438          {
1439            nok=iiConvert(ht,etyp,j,hh,&t);
1440            hh->next=t.next;
1441            if (nok) break;
1442            lm->m[i]=(poly)t.CopyD(etyp);
1443            if (module_assign) rk=max(rk,pMaxComp(lm->m[i]));
1444            i++;
1445          }
1446          else
1447          if ((j=iiTestConvert(ht,mtyp))!=0)
1448          {
1449            nok=iiConvert(ht,mtyp,j,hh,&t);
1450            hh->next=t.next;
1451            if (nok) break;
1452            rm = (matrix)t.CopyD(mtyp);
1453            if (module_assign)
1454            {
1455              j = min(num,rm->cols());
1456              rk=max(rk,rm->rank);
1457            }
1458            else
1459              j = min(num-i,rm->rows() * rm->cols());
1460            for(k=0;k<j;k++,i++)
1461            {
1462              lm->m[i]=rm->m[k];
1463              rm->m[k]=NULL;
1464            }
1465            idDelete((ideal *)&rm);
1466          }
1467          else
1468          {
1469            nok=TRUE;
1470            break;
1471          }
1472          t.next=NULL;t.CleanUp();
1473          if (i==num) break;
1474          hh=hh->next;
1475        }
1476      }
1477      if (nok)
1478        idDelete((ideal *)&lm);
1479      else
1480      {
1481        idDelete((ideal *)&olm);
1482        if (module_assign)   lm->rank=rk;
1483        else if (map_assign) ((map)lm)->preimage=pr;
1484#ifdef DRING
1485        else if (pDRING)
1486        {
1487          int i=IDELEMS(lm)-1;
1488          while (i>=0)
1489          {
1490            pdSetDFlagP(lm->m[i],1);
1491            i--;
1492          }
1493        }
1494#endif
1495        l=l->LData();
1496        if (l->rtyp==IDHDL)
1497          IDMATRIX((idhdl)l->data)=lm;
1498        else
1499          l->data=(char *)lm;
1500      }
1501      break;
1502    }
1503    case STRING_CMD:
1504      nok=jjA_L_STRING(l,r);
1505      break;
1506    case LIST_CMD:
1507      nok=jjA_L_LIST(l,r);
1508      break;
1509    case NONE:
1510    case 0:
1511      Werror("cannot assign to %s",l->Fullname());
1512      nok=TRUE;
1513      break;
1514    default:
1515      WerrorS("assign not impl.");
1516      nok=TRUE;
1517      break;
1518  } /* end switch: typ */
1519  if (nok && (!errorreported)) WerrorS("incompatible type in list assignment");
1520  r->CleanUp();
1521  return nok;
1522}
Note: See TracBrowser for help on using the repository browser.