source: git/Singular/ipassign.cc @ 762bfd

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