source: git/Singular/ipassign.cc @ 416465

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