source: git/Singular/ipassign.cc @ 82063a

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