source: git/Singular/ipassign.cc @ 9f12b01

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