source: git/Singular/ipassign.cc @ 0224c8

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