source: git/Singular/iparith.cc @ c1d8f3e

fieker-DuValspielwiese
Last change on this file since c1d8f3e was c1d8f3e, checked in by Andreas Steenpass <steenpass@…>, 8 years ago
fix: handle syStrategy->length correctly in fres()
  • Property mode set to 100644
File size: 232.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4
5/*
6* ABSTRACT: table driven kernel interface, used by interpreter
7*/
8//#include <sys/time.h>
9//#include <sys/resource.h>
10//long all_farey=0L;
11//long farey_cnt=0L;
12
13#include "kernel/mod2.h"
14
15#include "omalloc/omalloc.h"
16
17#include "factory/factory.h"
18
19#include "coeffs/bigintmat.h"
20#include "coeffs/coeffs.h"
21#include "coeffs/numbers.h"
22
23#include "misc/options.h"
24#include "misc/intvec.h"
25#include "misc/sirandom.h"
26#include "misc/prime.h"
27
28#include "polys/matpol.h"
29#include "polys/monomials/maps.h"
30#include "polys/sparsmat.h"
31#include "polys/weight.h"
32#include "polys/ext_fields/transext.h"
33#include "polys/clapsing.h"
34
35#include "kernel/combinatorics/stairc.h"
36#include "kernel/combinatorics/hilb.h"
37
38#include "kernel/linear_algebra/interpolation.h"
39#include "kernel/linear_algebra/linearAlgebra.h"
40#include "kernel/linear_algebra/MinorInterface.h"
41
42#include "kernel/spectrum/GMPrat.h"
43#include "kernel/groebner_walk/walkProc.h"
44#include "kernel/oswrapper/timer.h"
45#include "kernel/fglm/fglm.h"
46
47#include "kernel/GBEngine/kstdfac.h"
48#include "kernel/GBEngine/syz.h"
49#include "kernel/GBEngine/kstd1.h"
50#include "kernel/GBEngine/units.h"
51#include "kernel/GBEngine/tgb.h"
52
53#include "kernel/preimage.h"
54#include "kernel/polys.h"
55#include "kernel/ideals.h"
56
57#include "Singular/mod_lib.h"
58#include "Singular/fevoices.h"
59#include "Singular/tok.h"
60#include "Singular/ipid.h"
61#include "Singular/sdb.h"
62#include "Singular/subexpr.h"
63#include "Singular/lists.h"
64#include "Singular/maps_ip.h"
65
66#include "Singular/ipconv.h"
67#include "Singular/ipprint.h"
68#include "Singular/attrib.h"
69#include "Singular/links/silink.h"
70#include "Singular/misc_ip.h"
71#include "Singular/linearAlgebra_ip.h"
72
73#include "Singular/number2.h"
74
75#include "Singular/fglm.h"
76
77#include "Singular/blackbox.h"
78#include "Singular/newstruct.h"
79#include "Singular/ipshell.h"
80//#include "kernel/mpr_inout.h"
81#include "reporter/si_signals.h"
82
83#include <stdlib.h>
84#include <string.h>
85#include <ctype.h>
86#include <stdio.h>
87#include <time.h>
88#include <unistd.h>
89#include <vector>
90
91ring rCompose(const lists  L, const BOOLEAN check_comp=TRUE, const long bitmask=0x7fff);
92
93// defaults for all commands: NO_PLURAL | NO_RING | ALLOW_ZERODIVISOR
94
95#ifdef HAVE_PLURAL
96  #include "kernel/GBEngine/ratgring.h"
97  #include "kernel/GBEngine/nc.h"
98  #include "polys/nc/nc.h"
99  #include "polys/nc/sca.h"
100  #define  PLURAL_MASK 3
101#else /* HAVE_PLURAL */
102  #define  PLURAL_MASK     0
103#endif /* HAVE_PLURAL */
104
105#ifdef HAVE_RINGS
106  #define RING_MASK        4
107  #define ZERODIVISOR_MASK 8
108#else
109  #define RING_MASK        0
110  #define ZERODIVISOR_MASK 0
111#endif
112#define ALLOW_PLURAL     1
113#define NO_PLURAL        0
114#define COMM_PLURAL      2
115#define ALLOW_RING       4
116#define NO_RING          0
117#define NO_ZERODIVISOR   8
118#define ALLOW_ZERODIVISOR  0
119
120#define ALLOW_ZZ (ALLOW_RING|NO_ZERODIVISOR)
121
122
123// bit 4 for warning, if used at toplevel
124#define WARN_RING        16
125// bit 5: do no try automatic conversions
126#define NO_CONVERSION    32
127
128static BOOLEAN check_valid(const int p, const int op);
129
130/*=============== types =====================*/
131struct sValCmdTab
132{
133  short cmd;
134  short start;
135};
136
137typedef sValCmdTab jjValCmdTab[];
138
139struct _scmdnames
140{
141  char *name;
142  short alias;
143  short tokval;
144  short toktype;
145};
146typedef struct _scmdnames cmdnames;
147
148struct sValCmd1
149{
150  proc1 p;
151  short cmd;
152  short res;
153  short arg;
154  short valid_for;
155};
156
157typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
158struct sValCmd2
159{
160  proc2 p;
161  short cmd;
162  short res;
163  short arg1;
164  short arg2;
165  short valid_for;
166};
167
168typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
169struct sValCmd3
170{
171  proc3 p;
172  short cmd;
173  short res;
174  short arg1;
175  short arg2;
176  short arg3;
177  short valid_for;
178};
179struct sValCmdM
180{
181  proc1 p;
182  short cmd;
183  short res;
184  short number_of_args; /* -1: any, -2: any >0, .. */
185  short valid_for;
186};
187
188typedef struct
189{
190  cmdnames *sCmds;             /**< array of existing commands */
191  struct sValCmd1 *psValCmd1;
192  struct sValCmd2 *psValCmd2;
193  struct sValCmd3 *psValCmd3;
194  struct sValCmdM *psValCmdM;
195  unsigned nCmdUsed;      /**< number of commands used */
196  unsigned nCmdAllocated; /**< number of commands-slots allocated */
197  unsigned nLastIdentifier; /**< valid indentifieres are slot 1..nLastIdentifier */
198} SArithBase;
199
200/*---------------------------------------------------------------------*
201 * File scope Variables (Variables share by several functions in
202 *                       the same file )
203 *
204 *---------------------------------------------------------------------*/
205static SArithBase sArithBase;  /**< Base entry for arithmetic */
206
207/*---------------------------------------------------------------------*
208 * Extern Functions declarations
209 *
210 *---------------------------------------------------------------------*/
211static int _gentable_sort_cmds(const void *a, const void *b);
212extern int iiArithRemoveCmd(char *szName);
213extern int iiArithAddCmd(const char *szName, short nAlias, short nTokval,
214                         short nToktype, short nPos=-1);
215
216/*============= proc =======================*/
217static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
218static Subexpr jjMakeSub(leftv e);
219
220/*============= vars ======================*/
221extern int cmdtok;
222extern BOOLEAN expected_parms;
223
224#define ii_div_by_0 "div. by 0"
225
226int iiOp; /* the current operation*/
227
228/*=================== simple helpers =================*/
229static int iin_Int(number &n,coeffs cf)
230{
231  long l=n_Int(n,cf);
232  int i=(int)l;
233  if ((long)i==l) return l;
234  return 0;
235}
236poly pHeadProc(poly p)
237{
238  return pHead(p);
239}
240
241int iiTokType(int op)
242{
243  for (unsigned i=0;i<sArithBase.nCmdUsed;i++)
244  {
245    if (sArithBase.sCmds[i].tokval==op)
246      return sArithBase.sCmds[i].toktype;
247  }
248  return 0;
249}
250
251/*=================== operations with 2 args.: static proc =================*/
252/* must be ordered: first operations for chars (infix ops),
253 * then alphabetically */
254
255static BOOLEAN jjOP_BIM_I(leftv res, leftv u, leftv v)
256{
257  bigintmat* aa= (bigintmat *)u->Data();
258  int bb = (int)(long)(v->Data());
259  if (errorreported) return TRUE;
260  bigintmat *cc=NULL;
261  switch (iiOp)
262  {
263    case '+': cc=bimAdd(aa,bb); break;
264    case '-': cc=bimSub(aa,bb); break;
265    case '*': cc=bimMult(aa,bb); break;
266  }
267  res->data=(char *)cc;
268  return cc==NULL;
269}
270static BOOLEAN jjOP_I_BIM(leftv res, leftv u, leftv v)
271{
272  return jjOP_BIM_I(res, v, u);
273}
274static BOOLEAN jjOP_BIM_BI(leftv res, leftv u, leftv v)
275{
276  bigintmat* aa= (bigintmat *)u->Data();
277  number bb = (number)(v->Data());
278  if (errorreported) return TRUE;
279  bigintmat *cc=NULL;
280  switch (iiOp)
281  {
282    case '*': cc=bimMult(aa,bb,coeffs_BIGINT); break;
283  }
284  res->data=(char *)cc;
285  return cc==NULL;
286}
287static BOOLEAN jjOP_BI_BIM(leftv res, leftv u, leftv v)
288{
289  return jjOP_BIM_BI(res, v, u);
290}
291static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
292{
293  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
294  int bb = (int)(long)(v->Data());
295  if (errorreported) return TRUE;
296  switch (iiOp)
297  {
298    case '+': (*aa) += bb; break;
299    case '-': (*aa) -= bb; break;
300    case '*': (*aa) *= bb; break;
301    case '/':
302    case INTDIV_CMD: (*aa) /= bb; break;
303    case '%': (*aa) %= bb; break;
304  }
305  res->data=(char *)aa;
306  return FALSE;
307}
308static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
309{
310  return jjOP_IV_I(res,v,u);
311}
312static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
313{
314  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
315  int bb = (int)(long)(v->Data());
316  int i=si_min(aa->rows(),aa->cols());
317  switch (iiOp)
318  {
319    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
320              break;
321    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
322              break;
323  }
324  res->data=(char *)aa;
325  return FALSE;
326}
327static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
328{
329  return jjOP_IM_I(res,v,u);
330}
331static BOOLEAN jjCOLON(leftv res, leftv u, leftv v)
332{
333  int l=(int)(long)v->Data();
334  if (l>=0)
335  {
336    int d=(int)(long)u->Data();
337    intvec *vv=new intvec(l);
338    int i;
339    for(i=l-1;i>=0;i--) { (*vv)[i]=d; }
340    res->data=(char *)vv;
341  }
342  return (l<0);
343}
344static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
345{
346  res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
347  return FALSE;
348}
349static void jjEQUAL_REST(leftv res,leftv u,leftv v);
350static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
351{
352  intvec*    a = (intvec * )(u->Data());
353  intvec*    b = (intvec * )(v->Data());
354  int r=a->compare(b);
355  switch  (iiOp)
356  {
357    case '<':
358      res->data  = (char *) (r<0);
359      break;
360    case '>':
361      res->data  = (char *) (r>0);
362      break;
363    case LE:
364      res->data  = (char *) (r<=0);
365      break;
366    case GE:
367      res->data  = (char *) (r>=0);
368      break;
369    case EQUAL_EQUAL:
370    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
371      res->data  = (char *) (r==0);
372      break;
373  }
374  jjEQUAL_REST(res,u,v);
375  if(r==-2) { WerrorS("size incompatible"); return TRUE; }
376  return FALSE;
377}
378static BOOLEAN jjCOMPARE_BIM(leftv res, leftv u, leftv v)
379{
380  bigintmat*    a = (bigintmat * )(u->Data());
381  bigintmat*    b = (bigintmat * )(v->Data());
382  int r=a->compare(b);
383  switch  (iiOp)
384  {
385    case '<':
386      res->data  = (char *) (r<0);
387      break;
388    case '>':
389      res->data  = (char *) (r>0);
390      break;
391    case LE:
392      res->data  = (char *) (r<=0);
393      break;
394    case GE:
395      res->data  = (char *) (r>=0);
396      break;
397    case EQUAL_EQUAL:
398    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
399      res->data  = (char *) (r==0);
400      break;
401  }
402  jjEQUAL_REST(res,u,v);
403  if(r==-2) { WerrorS("size incompatible"); return TRUE; }
404  return FALSE;
405}
406static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
407{
408  intvec* a = (intvec * )(u->Data());
409  int     b = (int)(long)(v->Data());
410  int r=a->compare(b);
411  switch  (iiOp)
412  {
413    case '<':
414      res->data  = (char *) (r<0);
415      break;
416    case '>':
417      res->data  = (char *) (r>0);
418      break;
419    case LE:
420      res->data  = (char *) (r<=0);
421      break;
422    case GE:
423      res->data  = (char *) (r>=0);
424      break;
425    case EQUAL_EQUAL:
426    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
427      res->data  = (char *) (r==0);
428      break;
429  }
430  jjEQUAL_REST(res,u,v);
431  return FALSE;
432}
433static BOOLEAN jjCOMPARE_MA(leftv res, leftv u, leftv v)
434{
435  //Print("in: >>%s<<\n",my_yylinebuf);
436  matrix a=(matrix)u->Data();
437  matrix b=(matrix)v->Data();
438  int r=mp_Compare(a,b,currRing);
439  switch  (iiOp)
440  {
441    case '<':
442      res->data  = (char *) (long)(r < 0);
443      break;
444    case '>':
445      res->data  = (char *) (long)(r > 0);
446      break;
447    case LE:
448      res->data  = (char *) (long)(r <= 0);
449      break;
450    case GE:
451      res->data  = (char *) (long)(r >= 0);
452      break;
453    case EQUAL_EQUAL:
454    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
455      res->data  = (char *)(long) (r == 0);
456      break;
457  }
458  jjEQUAL_REST(res,u,v);
459  return FALSE;
460}
461static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
462{
463  poly p=(poly)u->Data();
464  poly q=(poly)v->Data();
465  int r=p_Compare(p,q,currRing);
466  switch  (iiOp)
467  {
468    case '<':
469      res->data  = (char *) (r < 0);
470      break;
471    case '>':
472      res->data  = (char *) (r > 0);
473      break;
474    case LE:
475      res->data  = (char *) (r <= 0);
476      break;
477    case GE:
478      res->data  = (char *) (r >= 0);
479      break;
480    //case EQUAL_EQUAL:
481    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
482    //  res->data  = (char *) (r == 0);
483    //  break;
484  }
485  jjEQUAL_REST(res,u,v);
486  return FALSE;
487}
488static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
489{
490  char*    a = (char * )(u->Data());
491  char*    b = (char * )(v->Data());
492  int result = strcmp(a,b);
493  switch  (iiOp)
494  {
495    case '<':
496      res->data  = (char *) (result  < 0);
497      break;
498    case '>':
499      res->data  = (char *) (result  > 0);
500      break;
501    case LE:
502      res->data  = (char *) (result  <= 0);
503      break;
504    case GE:
505      res->data  = (char *) (result  >= 0);
506      break;
507    case EQUAL_EQUAL:
508    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
509      res->data  = (char *) (result  == 0);
510      break;
511  }
512  jjEQUAL_REST(res,u,v);
513  return FALSE;
514}
515static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
516{
517  if (u->Next()!=NULL)
518  {
519    u=u->next;
520    res->next = (leftv)omAllocBin(sleftv_bin);
521    return iiExprArith2(res->next,u,iiOp,v);
522  }
523  else if (v->Next()!=NULL)
524  {
525    v=v->next;
526    res->next = (leftv)omAllocBin(sleftv_bin);
527    return iiExprArith2(res->next,u,iiOp,v);
528  }
529  return FALSE;
530}
531static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
532{
533  int b=(int)(long)u->Data();
534  int e=(int)(long)v->Data();
535  int rc = 1;
536  BOOLEAN overflow=FALSE;
537  if (e >= 0)
538  {
539    if (b==0)
540    {
541      rc=(e==0);
542    }
543    else if ((e==0)||(b==1))
544    {
545      rc= 1;
546    }
547    else if (b== -1)
548    {
549      if (e&1) rc= -1;
550      else     rc= 1;
551    }
552    else
553    {
554      int oldrc;
555      while ((e--)!=0)
556      {
557        oldrc=rc;
558        rc *= b;
559        if (!overflow)
560        {
561          if(rc/b!=oldrc) overflow=TRUE;
562        }
563      }
564      if (overflow)
565        WarnS("int overflow(^), result may be wrong");
566    }
567    res->data = (char *)((long)rc);
568    if (u!=NULL) return jjOP_REST(res,u,v);
569    return FALSE;
570  }
571  else
572  {
573    WerrorS("exponent must be non-negative");
574    return TRUE;
575  }
576}
577static BOOLEAN jjPOWER_BI(leftv res, leftv u, leftv v)
578{
579  int e=(int)(long)v->Data();
580  number n=(number)u->Data();
581  if (e>=0)
582  {
583    n_Power(n,e,(number*)&res->data,coeffs_BIGINT);
584  }
585  else
586  {
587    WerrorS("exponent must be non-negative");
588    return TRUE;
589  }
590  if (u!=NULL) return jjOP_REST(res,u,v);
591  return FALSE;
592}
593static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
594{
595  int e=(int)(long)v->Data();
596  number n=(number)u->Data();
597  int d=0;
598  if (e<0)
599  {
600    n=nInvers(n);
601    e=-e;
602    d=1;
603  }
604  number r;
605  nPower(n,e,(number*)&r);
606  res->data=(char*)r;
607  if (d) nDelete(&n);
608  if (u!=NULL) return jjOP_REST(res,u,v);
609  return FALSE;
610}
611static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
612{
613  int v_i=(int)(long)v->Data();
614  if (v_i<0)
615  {
616    WerrorS("exponent must be non-negative");
617    return TRUE;
618  }
619  poly u_p=(poly)u->CopyD(POLY_CMD);
620  if ((u_p!=NULL)
621  && ((v_i!=0) &&
622      ((long)pTotaldegree(u_p) > (signed long)currRing->bitmask / (signed long)v_i/2)))
623  {
624    Werror("OVERFLOW in power(d=%ld, e=%d, max=%ld)",
625                                    pTotaldegree(u_p),v_i,currRing->bitmask/2);
626    pDelete(&u_p);
627    return TRUE;
628  }
629  res->data = (char *)pPower(u_p,v_i);
630  if (u!=NULL) return jjOP_REST(res,u,v);
631  return errorreported; /* pPower may set errorreported via Werror */
632}
633static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
634{
635  res->data = (char *)id_Power((ideal)(u->Data()),(int)(long)(v->Data()), currRing);
636  if (u!=NULL) return jjOP_REST(res,u,v);
637  return FALSE;
638}
639static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
640{
641  u=u->next;
642  v=v->next;
643  if (u==NULL)
644  {
645    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
646    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
647    {
648      do
649      {
650        if (res->next==NULL)
651          res->next = (leftv)omAlloc0Bin(sleftv_bin);
652        leftv tmp_v=v->next;
653        v->next=NULL;
654        BOOLEAN b=iiExprArith1(res->next,v,'-');
655        v->next=tmp_v;
656        if (b)
657          return TRUE;
658        v=tmp_v;
659        res=res->next;
660      } while (v!=NULL);
661      return FALSE;
662    }
663    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
664    {
665      res->next = (leftv)omAlloc0Bin(sleftv_bin);
666      res=res->next;
667      res->data = v->CopyD();
668      res->rtyp = v->Typ();
669      v=v->next;
670      if (v==NULL) return FALSE;
671    }
672  }
673  if (v!=NULL)                     /* u<>NULL, v<>NULL */
674  {
675    do
676    {
677      res->next = (leftv)omAlloc0Bin(sleftv_bin);
678      leftv tmp_u=u->next; u->next=NULL;
679      leftv tmp_v=v->next; v->next=NULL;
680      BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
681      u->next=tmp_u;
682      v->next=tmp_v;
683      if (b)
684        return TRUE;
685      u=tmp_u;
686      v=tmp_v;
687      res=res->next;
688    } while ((u!=NULL) && (v!=NULL));
689    return FALSE;
690  }
691  loop                             /* u<>NULL, v==NULL */
692  {
693    res->next = (leftv)omAlloc0Bin(sleftv_bin);
694    res=res->next;
695    res->data = u->CopyD();
696    res->rtyp = u->Typ();
697    u=u->next;
698    if (u==NULL) return FALSE;
699  }
700}
701static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
702{
703  switch(u->Typ())
704  {
705    case 0:
706    {
707      int name_err=0;
708      if(isupper(u->name[0]))
709      {
710        const char *c=u->name+1;
711        while((*c!='\0')&&(islower(*c)||(isdigit(*c))||(*c=='_'))) c++;
712        if (*c!='\0')
713          name_err=1;
714        else
715        {
716          Print("%s of type 'ANY'. Trying load.\n", u->name);
717          if(iiTryLoadLib(u, u->name))
718          {
719            Werror("'%s' no such package", u->name);
720            return TRUE;
721          }
722          syMake(u,u->name,NULL);
723        }
724      }
725      else name_err=1;
726      if(name_err)
727      { Werror("'%s' is an invalid package name",u->name);return TRUE;}
728      // and now, after the loading: use next case !!! no break !!!
729    }
730    case PACKAGE_CMD:
731      {
732        package pa=(package)u->Data();
733        if (u->rtyp==IDHDL) pa=IDPACKAGE((idhdl)u->data);
734        if((!pa->loaded)
735        && (pa->language > LANG_TOP))
736        {
737          Werror("'%s' not loaded", u->name);
738          return TRUE;
739        }
740        if(v->rtyp == IDHDL)
741        {
742          v->name = omStrDup(v->name);
743        }
744        else if (v->rtyp!=0)
745        {
746          WerrorS("reserved name with ::");
747          return TRUE;
748        }
749        v->req_packhdl=pa;
750        syMake(v, v->name, pa);
751        memcpy(res, v, sizeof(sleftv));
752        memset(v, 0, sizeof(sleftv));
753      }
754      break;
755    case DEF_CMD:
756      break;
757    default:
758      WerrorS("<package>::<id> expected");
759      return TRUE;
760  }
761  return FALSE;
762}
763static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
764{
765  unsigned int a=(unsigned int)(unsigned long)u->Data();
766  unsigned int b=(unsigned int)(unsigned long)v->Data();
767  unsigned int c=a+b;
768  res->data = (char *)((long)c);
769  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
770  {
771    WarnS("int overflow(+), result may be wrong");
772  }
773  return jjPLUSMINUS_Gen(res,u,v);
774}
775static BOOLEAN jjPLUS_BI(leftv res, leftv u, leftv v)
776{
777  res->data = (char *)(n_Add((number)u->Data(), (number)v->Data(),coeffs_BIGINT));
778  return jjPLUSMINUS_Gen(res,u,v);
779}
780static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
781{
782  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
783  return jjPLUSMINUS_Gen(res,u,v);
784}
785static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
786{
787  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
788  return jjPLUSMINUS_Gen(res,u,v);
789}
790static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
791{
792  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
793  if (res->data==NULL)
794  {
795     WerrorS("intmat size not compatible");
796     return TRUE;
797  }
798  return jjPLUSMINUS_Gen(res,u,v);
799}
800static BOOLEAN jjPLUS_BIM(leftv res, leftv u, leftv v)
801{
802  res->data = (char *)bimAdd((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
803  if (res->data==NULL)
804  {
805    WerrorS("bigintmat/cmatrix not compatible");
806    return TRUE;
807  }
808  return jjPLUSMINUS_Gen(res,u,v);
809}
810static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
811{
812  matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
813  res->data = (char *)(mp_Add(A , B, currRing));
814  if (res->data==NULL)
815  {
816     Werror("matrix size not compatible(%dx%d, %dx%d)",
817             MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
818     return TRUE;
819  }
820  return jjPLUSMINUS_Gen(res,u,v);
821}
822static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
823{
824  matrix m=(matrix)u->Data();
825  matrix p= mp_InitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)),currRing);
826  if (iiOp=='+')
827    res->data = (char *)mp_Add(m , p,currRing);
828  else
829    res->data = (char *)mp_Sub(m , p,currRing);
830  idDelete((ideal *)&p);
831  return jjPLUSMINUS_Gen(res,u,v);
832}
833static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
834{
835  return jjPLUS_MA_P(res,v,u);
836}
837static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
838{
839  char*    a = (char * )(u->Data());
840  char*    b = (char * )(v->Data());
841  char*    r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
842  strcpy(r,a);
843  strcat(r,b);
844  res->data=r;
845  return jjPLUSMINUS_Gen(res,u,v);
846}
847static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
848{
849  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
850  return jjPLUSMINUS_Gen(res,u,v);
851}
852static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
853{
854  void *ap=u->Data(); void *bp=v->Data();
855  int aa=(int)(long)ap;
856  int bb=(int)(long)bp;
857  int cc=aa-bb;
858  unsigned int a=(unsigned int)(unsigned long)ap;
859  unsigned int b=(unsigned int)(unsigned long)bp;
860  unsigned int c=a-b;
861  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
862  {
863    WarnS("int overflow(-), result may be wrong");
864  }
865  res->data = (char *)((long)cc);
866  return jjPLUSMINUS_Gen(res,u,v);
867}
868static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
869{
870  res->data = (char *)(n_Sub((number)u->Data(), (number)v->Data(),coeffs_BIGINT));
871  return jjPLUSMINUS_Gen(res,u,v);
872}
873static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
874{
875  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
876  return jjPLUSMINUS_Gen(res,u,v);
877}
878static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
879{
880  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
881  return jjPLUSMINUS_Gen(res,u,v);
882}
883static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
884{
885  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
886  if (res->data==NULL)
887  {
888     WerrorS("intmat size not compatible");
889     return TRUE;
890  }
891  return jjPLUSMINUS_Gen(res,u,v);
892}
893static BOOLEAN jjMINUS_BIM(leftv res, leftv u, leftv v)
894{
895  res->data = (char *)bimSub((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
896  if (res->data==NULL)
897  {
898    WerrorS("bigintmat/cmatrix not compatible");
899    return TRUE;
900  }
901  return jjPLUSMINUS_Gen(res,u,v);
902}
903static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
904{
905  matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
906  res->data = (char *)(mp_Sub(A , B, currRing));
907  if (res->data==NULL)
908  {
909     Werror("matrix size not compatible(%dx%d, %dx%d)",
910             MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
911     return TRUE;
912  }
913  return jjPLUSMINUS_Gen(res,u,v);
914  return FALSE;
915}
916static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
917{
918  int a=(int)(long)u->Data();
919  int b=(int)(long)v->Data();
920  int64 c=(int64)a * (int64)b;
921  if ((c>INT_MAX)||(c<INT_MIN))
922    WarnS("int overflow(*), result may be wrong");
923  res->data = (char *)((long)((int)c));
924  if ((u->Next()!=NULL) || (v->Next()!=NULL))
925    return jjOP_REST(res,u,v);
926  return FALSE;
927}
928static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
929{
930  res->data = (char *)(n_Mult( (number)u->Data(), (number)v->Data(),coeffs_BIGINT));
931  if ((v->next!=NULL) || (u->next!=NULL))
932    return jjOP_REST(res,u,v);
933  return FALSE;
934}
935static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
936{
937  res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
938  number n=(number)res->data;
939  nNormalize(n);
940  res->data=(char *)n;
941  if ((v->next!=NULL) || (u->next!=NULL))
942    return jjOP_REST(res,u,v);
943  return FALSE;
944}
945static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
946{
947  poly a;
948  poly b;
949  if (v->next==NULL)
950  {
951    a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
952    if (u->next==NULL)
953    {
954      b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
955      if ((a!=NULL) && (b!=NULL)
956      && ((long)pTotaldegree(a)>si_max((long)rVar(currRing),(long)currRing->bitmask/2)-(long)pTotaldegree(b)))
957      {
958        Warn("possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
959          pTotaldegree(a),pTotaldegree(b),currRing->bitmask/2);
960      }
961      res->data = (char *)(pMult( a, b));
962      pNormalize((poly)res->data);
963      return FALSE;
964    }
965    // u->next exists: copy v
966    b=pCopy((poly)v->Data());
967    if ((a!=NULL) && (b!=NULL)
968    && (pTotaldegree(a)+pTotaldegree(b)>si_max((long)rVar(currRing),(long)currRing->bitmask/2)))
969    {
970      Warn("possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
971          pTotaldegree(a),pTotaldegree(b),currRing->bitmask/2);
972    }
973    res->data = (char *)(pMult( a, b));
974    pNormalize((poly)res->data);
975    return jjOP_REST(res,u,v);
976  }
977  // v->next exists: copy u
978  a=pCopy((poly)u->Data());
979  b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
980  if ((a!=NULL) && (b!=NULL)
981  && ((unsigned long)(pTotaldegree(a)+pTotaldegree(b))>=currRing->bitmask/2))
982  {
983    pDelete(&a);
984    pDelete(&b);
985    WerrorS("OVERFLOW");
986    return TRUE;
987  }
988  res->data = (char *)(pMult( a, b));
989  pNormalize((poly)res->data);
990  return jjOP_REST(res,u,v);
991}
992static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
993{
994  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
995  id_Normalize((ideal)res->data,currRing);
996  if ((v->next!=NULL) || (u->next!=NULL))
997    return jjOP_REST(res,u,v);
998  return FALSE;
999}
1000static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
1001{
1002  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
1003  if (res->data==NULL)
1004  {
1005     WerrorS("intmat size not compatible");
1006     return TRUE;
1007  }
1008  if ((v->next!=NULL) || (u->next!=NULL))
1009    return jjOP_REST(res,u,v);
1010  return FALSE;
1011}
1012static BOOLEAN jjTIMES_BIM(leftv res, leftv u, leftv v)
1013{
1014  res->data = (char *)bimMult((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
1015  if (res->data==NULL)
1016  {
1017    WerrorS("bigintmat/cmatrix not compatible");
1018    return TRUE;
1019  }
1020  if ((v->next!=NULL) || (u->next!=NULL))
1021    return jjOP_REST(res,u,v);
1022  return FALSE;
1023}
1024static BOOLEAN jjTIMES_MA_BI1(leftv res, leftv u, leftv v)
1025{
1026  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
1027  if (nMap==NULL) return TRUE;
1028  number n=nMap((number)v->Data(),coeffs_BIGINT,currRing->cf);
1029  poly p=pNSet(n);
1030  ideal I= (ideal)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1031  res->data = (char *)I;
1032  return FALSE;
1033}
1034static BOOLEAN jjTIMES_MA_BI2(leftv res, leftv u, leftv v)
1035{
1036  return jjTIMES_MA_BI1(res,v,u);
1037}
1038static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
1039{
1040  poly p=(poly)v->CopyD(POLY_CMD);
1041  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
1042  ideal I= (ideal)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1043  if (r>0) I->rank=r;
1044  id_Normalize(I,currRing);
1045  res->data = (char *)I;
1046  return FALSE;
1047}
1048static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
1049{
1050  poly p=(poly)u->CopyD(POLY_CMD);
1051  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
1052  ideal I= (ideal)pMultMp(p,(matrix)v->CopyD(MATRIX_CMD),currRing);
1053  if (r>0) I->rank=r;
1054  id_Normalize(I,currRing);
1055  res->data = (char *)I;
1056  return FALSE;
1057}
1058static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
1059{
1060  number n=(number)v->CopyD(NUMBER_CMD);
1061  poly p=pNSet(n);
1062  res->data = (char *)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1063  id_Normalize((ideal)res->data,currRing);
1064  return FALSE;
1065}
1066static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
1067{
1068  return jjTIMES_MA_N1(res,v,u);
1069}
1070static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
1071{
1072  res->data = (char *)mp_MultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data(),currRing);
1073  id_Normalize((ideal)res->data,currRing);
1074  return FALSE;
1075}
1076static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1077{
1078  return jjTIMES_MA_I1(res,v,u);
1079}
1080static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1081{
1082  matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
1083  res->data = (char *)mp_Mult(A,B,currRing);
1084  if (res->data==NULL)
1085  {
1086     Werror("matrix size not compatible(%dx%d, %dx%d) in *",
1087             MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
1088     return TRUE;
1089  }
1090  id_Normalize((ideal)res->data,currRing);
1091  if ((v->next!=NULL) || (u->next!=NULL))
1092    return jjOP_REST(res,u,v);
1093  return FALSE;
1094}
1095static BOOLEAN jjGE_BI(leftv res, leftv u, leftv v)
1096{
1097  number h=n_Sub((number)u->Data(),(number)v->Data(),coeffs_BIGINT);
1098  res->data = (char *) (n_GreaterZero(h,coeffs_BIGINT)||(n_IsZero(h,coeffs_BIGINT)));
1099  n_Delete(&h,coeffs_BIGINT);
1100  return FALSE;
1101}
1102static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1103{
1104  res->data = (char *)(long)((int)((long)u->Data()) >= (int)((long)v->Data()));
1105  return FALSE;
1106}
1107static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1108{
1109  res->data = (char *)(long) (nGreater((number)u->Data(),(number)v->Data())
1110                       || nEqual((number)u->Data(),(number)v->Data()));
1111  return FALSE;
1112}
1113static BOOLEAN jjGT_BI(leftv res, leftv u, leftv v)
1114{
1115  number h=n_Sub((number)u->Data(),(number)v->Data(),coeffs_BIGINT);
1116  res->data = (char *)(long) (n_GreaterZero(h,coeffs_BIGINT)&&(!n_IsZero(h,coeffs_BIGINT)));
1117  n_Delete(&h,coeffs_BIGINT);
1118  return FALSE;
1119}
1120static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1121{
1122  res->data = (char *)(long)((int)((long)u->Data()) > (int)((long)v->Data()));
1123  return FALSE;
1124}
1125static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1126{
1127  res->data = (char *)(long)(nGreater((number)u->Data(),(number)v->Data()));
1128  return FALSE;
1129}
1130static BOOLEAN jjLE_BI(leftv res, leftv u, leftv v)
1131{
1132  return jjGE_BI(res,v,u);
1133}
1134static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1135{
1136  res->data = (char *)(long)((int)((long)u->Data()) <= (int)((long)v->Data()));
1137  return FALSE;
1138}
1139static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1140{
1141  return jjGE_N(res,v,u);
1142}
1143static BOOLEAN jjLT_BI(leftv res, leftv u, leftv v)
1144{
1145  return jjGT_BI(res,v,u);
1146}
1147static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1148{
1149  res->data = (char *)(long)((int)((long)u->Data()) < (int)((long)v->Data()));
1150  return FALSE;
1151}
1152static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1153{
1154  return jjGT_N(res,v,u);
1155}
1156static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1157{
1158  if (iiOp=='/') Warn("int division with `/`: use `div` instead in line >>%s<<",my_yylinebuf);
1159  int a= (int)(long)u->Data();
1160  int b= (int)(long)v->Data();
1161  if (b==0)
1162  {
1163    WerrorS(ii_div_by_0);
1164    return TRUE;
1165  }
1166  int c=a%b;
1167  int r=0;
1168  switch (iiOp)
1169  {
1170    case '%':
1171        r=c;            break;
1172    case '/':
1173    case INTDIV_CMD:
1174        r=((a-c) /b);   break;
1175  }
1176  res->data=(void *)((long)r);
1177  return FALSE;
1178}
1179static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
1180{
1181  number q=(number)v->Data();
1182  if (n_IsZero(q,coeffs_BIGINT))
1183  {
1184    WerrorS(ii_div_by_0);
1185    return TRUE;
1186  }
1187  q = n_Div((number)u->Data(),q,coeffs_BIGINT);
1188  n_Normalize(q,coeffs_BIGINT);
1189  res->data = (char *)q;
1190  return FALSE;
1191}
1192static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1193{
1194  number q=(number)v->Data();
1195  if (nIsZero(q))
1196  {
1197    WerrorS(ii_div_by_0);
1198    return TRUE;
1199  }
1200  q = nDiv((number)u->Data(),q);
1201  nNormalize(q);
1202  res->data = (char *)q;
1203  return FALSE;
1204}
1205static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1206{
1207  poly q=(poly)v->CopyD();
1208  poly p=(poly)(u->CopyD());
1209  res->data=(void*)(p_Divide(p /*(poly)(u->CopyD())*/ ,
1210                                         q /*(poly)(v->CopyD())*/ ,currRing));
1211  if (res->data!=NULL) pNormalize((poly)res->data);
1212  return errorreported; /*there may be errors in p_Divide: div. ny 0, etc.*/
1213}
1214static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1215{
1216  poly q=(poly)v->Data();
1217  if (q==NULL)
1218  {
1219    WerrorS(ii_div_by_0);
1220    return TRUE;
1221  }
1222  matrix m=(matrix)(u->Data());
1223  int r=m->rows();
1224  int c=m->cols();
1225  matrix mm=mpNew(r,c);
1226  unsigned i,j;
1227  for(i=r;i>0;i--)
1228  {
1229    for(j=c;j>0;j--)
1230    {
1231      if (pNext(q)!=NULL)
1232      {
1233        MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1234                                           q /*(poly)(v->Data())*/, currRing );
1235      }
1236      else
1237        MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1238    }
1239  }
1240  id_Normalize((ideal)mm,currRing);
1241  res->data=(char *)mm;
1242  return FALSE;
1243}
1244static BOOLEAN jjEQUAL_BI(leftv res, leftv u, leftv v)
1245{
1246  res->data = (char *)((long)n_Equal((number)u->Data(),(number)v->Data(),coeffs_BIGINT));
1247  jjEQUAL_REST(res,u,v);
1248  return FALSE;
1249}
1250static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1251{
1252  res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1253  jjEQUAL_REST(res,u,v);
1254  return FALSE;
1255}
1256static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1257{
1258  res->data = (char *)((long)mp_Equal((matrix)u->Data(),(matrix)v->Data(),currRing));
1259  jjEQUAL_REST(res,u,v);
1260  return FALSE;
1261}
1262static BOOLEAN jjEQUAL_R(leftv res, leftv u, leftv v)
1263{
1264  res->data = (char *)(long)(u->Data()==v->Data());
1265  jjEQUAL_REST(res,u,v);
1266  return FALSE;
1267}
1268static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1269{
1270  res->data = (char *)((long)nEqual((number)u->Data(),(number)v->Data()));
1271  jjEQUAL_REST(res,u,v);
1272  return FALSE;
1273}
1274static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1275{
1276  poly p=(poly)u->Data();
1277  poly q=(poly)v->Data();
1278  res->data = (char *) ((long)pEqualPolys(p,q));
1279  jjEQUAL_REST(res,u,v);
1280  return FALSE;
1281}
1282static void jjEQUAL_REST(leftv res,leftv u,leftv v)
1283{
1284  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1285  {
1286    int save_iiOp=iiOp;
1287    if (iiOp==NOTEQUAL)
1288      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
1289    else
1290      iiExprArith2(res,u->next,iiOp,v->next);
1291    iiOp=save_iiOp;
1292  }
1293  if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1294}
1295static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1296{
1297  res->data = (char *)((long)u->Data() && (long)v->Data());
1298  return FALSE;
1299}
1300static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1301{
1302  res->data = (char *)((long)u->Data() || (long)v->Data());
1303  return FALSE;
1304}
1305static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1306{
1307  res->rtyp=u->rtyp; u->rtyp=0;
1308  res->data=u->data; u->data=NULL;
1309  res->name=u->name; u->name=NULL;
1310  res->e=u->e;       u->e=NULL;
1311  if (res->e==NULL) res->e=jjMakeSub(v);
1312  else
1313  {
1314    Subexpr sh=res->e;
1315    while (sh->next != NULL) sh=sh->next;
1316    sh->next=jjMakeSub(v);
1317  }
1318  if (u->next!=NULL)
1319  {
1320    leftv rn=(leftv)omAlloc0Bin(sleftv_bin);
1321    BOOLEAN bo=iiExprArith2(rn,u->next,iiOp,v);
1322    res->next=rn;
1323    return bo;
1324  }
1325  return FALSE;
1326}
1327static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1328{
1329  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1330  {
1331    WerrorS("indexed object must have a name");
1332    return TRUE;
1333  }
1334  intvec * iv=(intvec *)v->Data();
1335  leftv p=NULL;
1336  int i;
1337  sleftv t;
1338  memset(&t,0,sizeof(t));
1339  t.rtyp=INT_CMD;
1340  for (i=0;i<iv->length(); i++)
1341  {
1342    t.data=(char *)((long)(*iv)[i]);
1343    if (p==NULL)
1344    {
1345      p=res;
1346    }
1347    else
1348    {
1349      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1350      p=p->next;
1351    }
1352    p->rtyp=IDHDL;
1353    p->data=u->data;
1354    p->name=u->name;
1355    p->flag=u->flag;
1356    p->e=jjMakeSub(&t);
1357  }
1358  u->rtyp=0;
1359  u->data=NULL;
1360  u->name=NULL;
1361  return FALSE;
1362}
1363static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1364{
1365  poly p=(poly)u->Data();
1366  int i=(int)(long)v->Data();
1367  int j=0;
1368  while (p!=NULL)
1369  {
1370    j++;
1371    if (j==i)
1372    {
1373      res->data=(char *)pHead(p);
1374      return FALSE;
1375    }
1376    pIter(p);
1377  }
1378  return FALSE;
1379}
1380static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1381{
1382  poly p=(poly)u->Data();
1383  poly r=NULL;
1384  intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1385  int i;
1386  int sum=0;
1387  for(i=iv->length()-1;i>=0;i--)
1388    sum+=(*iv)[i];
1389  int j=0;
1390  while ((p!=NULL) && (sum>0))
1391  {
1392    j++;
1393    for(i=iv->length()-1;i>=0;i--)
1394    {
1395      if (j==(*iv)[i])
1396      {
1397        r=pAdd(r,pHead(p));
1398        sum-=j;
1399        (*iv)[i]=0;
1400        break;
1401      }
1402    }
1403    pIter(p);
1404  }
1405  delete iv;
1406  res->data=(char *)r;
1407  return FALSE;
1408}
1409static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1410{
1411  poly p=(poly)u->CopyD(VECTOR_CMD);
1412  poly r=p; // pointer to the beginning of component i
1413  poly o=NULL;
1414  int i=(int)(long)v->Data();
1415  while (p!=NULL)
1416  {
1417    if (pGetComp(p)!=i)
1418    {
1419      if (r==p) r=pNext(p);
1420      if (o!=NULL)
1421      {
1422        if (pNext(o)!=NULL) pLmDelete(&pNext(o));
1423        p=pNext(o);
1424      }
1425      else
1426        pLmDelete(&p);
1427    }
1428    else
1429    {
1430      pSetComp(p, 0);
1431      p_SetmComp(p, currRing);
1432      o=p;
1433      p=pNext(o);
1434    }
1435  }
1436  res->data=(char *)r;
1437  return FALSE;
1438}
1439static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1440{
1441  poly p=(poly)u->CopyD(VECTOR_CMD);
1442  if (p!=NULL)
1443  {
1444    poly r=pOne();
1445    poly hp=r;
1446    intvec *iv=(intvec *)v->Data();
1447    int i;
1448    loop
1449    {
1450      for(i=0;i<iv->length();i++)
1451      {
1452        if (((int)pGetComp(p))==(*iv)[i])
1453        {
1454          poly h;
1455          pSplit(p,&h);
1456          pNext(hp)=p;
1457          p=h;
1458          pIter(hp);
1459          break;
1460        }
1461      }
1462      if (p==NULL) break;
1463      if (i==iv->length())
1464      {
1465        pLmDelete(&p);
1466        if (p==NULL) break;
1467      }
1468    }
1469    pLmDelete(&r);
1470    res->data=(char *)r;
1471  }
1472  return FALSE;
1473}
1474static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v);
1475static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1476{
1477  if(u->name==NULL) return TRUE;
1478  char * nn = (char *)omAlloc(strlen(u->name) + 14);
1479  sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1480  omFree((ADDRESS)u->name);
1481  u->name=NULL;
1482  char *n=omStrDup(nn);
1483  omFree((ADDRESS)nn);
1484  syMake(res,n);
1485  if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1486  return FALSE;
1487}
1488static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1489{
1490  intvec * iv=(intvec *)v->Data();
1491  leftv p=NULL;
1492  int i;
1493  long slen = strlen(u->name) + 14;
1494  char *n = (char*) omAlloc(slen);
1495
1496  for (i=0;i<iv->length(); i++)
1497  {
1498    if (p==NULL)
1499    {
1500      p=res;
1501    }
1502    else
1503    {
1504      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1505      p=p->next;
1506    }
1507    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1508    syMake(p,omStrDup(n));
1509  }
1510  omFree((ADDRESS)u->name);
1511  u->name = NULL;
1512  omFreeSize(n, slen);
1513  if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1514  return FALSE;
1515}
1516static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
1517{
1518  leftv tmp=(leftv)omAllocBin(sleftv_bin);
1519  memset(tmp,0,sizeof(sleftv));
1520  BOOLEAN b;
1521  if (v->Typ()==INTVEC_CMD)
1522    b=jjKLAMMER_IV(tmp,u,v);
1523  else
1524    b=jjKLAMMER(tmp,u,v);
1525  if (b)
1526  {
1527    omFreeBin(tmp,sleftv_bin);
1528    return TRUE;
1529  }
1530  leftv h=res;
1531  while (h->next!=NULL) h=h->next;
1532  h->next=tmp;
1533  return FALSE;
1534}
1535BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1536{
1537  void *d;
1538  Subexpr e;
1539  int typ;
1540  BOOLEAN t=FALSE;
1541  idhdl tmp_proc=NULL;
1542  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1543  {
1544    tmp_proc=(idhdl)omAlloc0(sizeof(idrec));
1545    tmp_proc->id="_auto";
1546    tmp_proc->typ=PROC_CMD;
1547    tmp_proc->data.pinf=(procinfo *)u->Data();
1548    tmp_proc->ref=1;
1549    d=u->data; u->data=(void *)tmp_proc;
1550    e=u->e; u->e=NULL;
1551    t=TRUE;
1552    typ=u->rtyp; u->rtyp=IDHDL;
1553  }
1554  BOOLEAN sl;
1555  if (u->req_packhdl==currPack)
1556    sl = iiMake_proc((idhdl)u->data,NULL,v);
1557  else
1558    sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1559  if (t)
1560  {
1561    u->rtyp=typ;
1562    u->data=d;
1563    u->e=e;
1564    omFreeSize(tmp_proc,sizeof(idrec));
1565  }
1566  if (sl) return TRUE;
1567  memcpy(res,&iiRETURNEXPR,sizeof(sleftv));
1568  iiRETURNEXPR.Init();
1569  return FALSE;
1570}
1571static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1572{
1573  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1574  leftv sl=NULL;
1575  if ((v->e==NULL)&&(v->name!=NULL))
1576  {
1577    map m=(map)u->Data();
1578    sl=iiMap(m,v->name);
1579  }
1580  else
1581  {
1582    Werror("%s(<name>) expected",u->Name());
1583  }
1584  if (sl==NULL) return TRUE;
1585  memcpy(res,sl,sizeof(sleftv));
1586  omFreeBin((ADDRESS)sl, sleftv_bin);
1587  return FALSE;
1588}
1589static BOOLEAN jjRING_1(leftv res, leftv u, leftv v)
1590{
1591  u->next=(leftv)omAlloc(sizeof(sleftv));
1592  memcpy(u->next,v,sizeof(sleftv));
1593  memset(v,0,sizeof(sleftv));
1594  BOOLEAN bo=iiExprArithM(res,u,'[');
1595  u->next=NULL;
1596  return bo;
1597}
1598static BOOLEAN jjCHINREM_BI(leftv res, leftv u, leftv v)
1599{
1600  intvec *c=(intvec*)u->Data();
1601  intvec* p=(intvec*)v->Data();
1602  int rl=p->length();
1603  number *x=(number *)omAlloc(rl*sizeof(number));
1604  number *q=(number *)omAlloc(rl*sizeof(number));
1605  int i;
1606  for(i=rl-1;i>=0;i--)
1607  {
1608    q[i]=n_Init((*p)[i], coeffs_BIGINT);
1609    x[i]=n_Init((*c)[i], coeffs_BIGINT);
1610  }
1611  CFArray iv(rl);
1612  number n=n_ChineseRemainderSym(x,q,rl,FALSE,iv,coeffs_BIGINT);
1613  for(i=rl-1;i>=0;i--)
1614  {
1615    n_Delete(&(q[i]),coeffs_BIGINT);
1616    n_Delete(&(x[i]),coeffs_BIGINT);
1617  }
1618  omFree(x); omFree(q);
1619  res->data=(char *)n;
1620  return FALSE;
1621}
1622#if 0
1623static BOOLEAN jjCHINREM_P(leftv res, leftv u, leftv v)
1624{
1625  lists c=(lists)u->CopyD(); // list of poly
1626  intvec* p=(intvec*)v->Data();
1627  int rl=p->length();
1628  poly r=NULL,h, result=NULL;
1629  number *x=(number *)omAlloc(rl*sizeof(number));
1630  number *q=(number *)omAlloc(rl*sizeof(number));
1631  int i;
1632  for(i=rl-1;i>=0;i--)
1633  {
1634    q[i]=nlInit((*p)[i]);
1635  }
1636  loop
1637  {
1638    for(i=rl-1;i>=0;i--)
1639    {
1640      if (c->m[i].Typ()!=POLY_CMD)
1641      {
1642        Werror("poly expected at pos %d",i+1);
1643        for(i=rl-1;i>=0;i--)
1644        {
1645          nlDelete(&(q[i]),currRing);
1646        }
1647        omFree(x); omFree(q); // delete c
1648        return TRUE;
1649      }
1650      h=((poly)c->m[i].Data());
1651      if (r==NULL) r=h;
1652      else if (pLmCmp(r,h)==-1) r=h;
1653    }
1654    if (r==NULL) break;
1655    for(i=rl-1;i>=0;i--)
1656    {
1657      h=((poly)c->m[i].Data());
1658      if (pLmCmp(r,h)==0)
1659      {
1660        x[i]=pGetCoeff(h);
1661        h=pLmFreeAndNext(h);
1662        c->m[i].data=(char*)h;
1663      }
1664      else
1665        x[i]=nlInit(0);
1666    }
1667    number n=n_ChineseRemainder(x,q,rl,currRing->cf);
1668    for(i=rl-1;i>=0;i--)
1669    {
1670      nlDelete(&(x[i]),currRing);
1671    }
1672    h=pHead(r);
1673    pSetCoeff(h,n);
1674    result=pAdd(result,h);
1675  }
1676  for(i=rl-1;i>=0;i--)
1677  {
1678    nlDelete(&(q[i]),currRing);
1679  }
1680  omFree(x); omFree(q);
1681  res->data=(char *)result;
1682  return FALSE;
1683}
1684#endif
1685static BOOLEAN jjALIGN_V(leftv res, leftv u, leftv v)
1686{
1687  poly p=(poly)u->CopyD();
1688  int s=(int)(long)v->Data();
1689  if (s+p_MinComp(p,currRing)<=0)
1690  { p_Delete(&p,currRing);return TRUE;}
1691  p_Shift(&p,s,currRing);
1692  res->data=p;
1693  return FALSE;
1694}
1695static BOOLEAN jjALIGN_M(leftv res, leftv u, leftv v)
1696{
1697  ideal M=(ideal)u->CopyD();
1698  int s=(int)(long)v->Data();
1699  for(int i=IDELEMS(M)-1; i>=0;i--)
1700  {
1701    if (s+p_MinComp(M->m[i],currRing)<=0)
1702    { id_Delete(&M,currRing);return TRUE;}
1703  }
1704  id_Shift(M,s,currRing);
1705  res->data=M;
1706  return FALSE;
1707}
1708static BOOLEAN jjCHINREM_ID(leftv res, leftv u, leftv v);
1709static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1710{
1711  poly p=(poly)v->Data();
1712  if ((p==NULL)||(pNext(p)!=NULL)) return TRUE;
1713  res->data=(char *)mp_CoeffProc((poly)u->Data(),p /*(poly)v->Data()*/,currRing);
1714  return FALSE;
1715}
1716static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1717{
1718  int i=pVar((poly)v->Data());
1719  if (i==0)
1720  {
1721    WerrorS("ringvar expected");
1722    return TRUE;
1723  }
1724  res->data=(char *)mp_Coeffs((ideal)u->CopyD(),i,currRing);
1725  return FALSE;
1726}
1727static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1728{
1729  poly p = pInit();
1730  int i;
1731  for (i=1; i<=currRing->N; i++)
1732  {
1733    pSetExp(p, i, 1);
1734  }
1735  pSetm(p);
1736  res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1737                                    (ideal)(v->Data()), p);
1738  pLmFree(&p);
1739  return FALSE;
1740}
1741static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1742{
1743  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1744  return FALSE;
1745}
1746static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1747{
1748  short *iv=iv2array((intvec *)v->Data(),currRing);
1749  ideal I=(ideal)u->Data();
1750  int d=-1;
1751  int i;
1752  for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)p_DegW(I->m[i],iv,currRing));
1753  omFreeSize( (ADDRESS)iv, (rVar(currRing)+1)*sizeof(short) );
1754  res->data = (char *)((long)d);
1755  return FALSE;
1756}
1757static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1758{
1759  poly p=(poly)u->Data();
1760  if (p!=NULL)
1761  {
1762    short *iv=iv2array((intvec *)v->Data(),currRing);
1763    const long d = p_DegW(p,iv,currRing);
1764    omFreeSize( (ADDRESS)iv, (rVar(currRing)+1)*sizeof(short) );
1765    res->data = (char *)(d);
1766  }
1767  else
1768    res->data=(char *)(long)(-1);
1769  return FALSE;
1770}
1771static BOOLEAN jjDelete_IV(leftv res, leftv u, leftv v)
1772{
1773  int pos=(int)(long)v->Data();
1774  intvec *iv=(intvec*)u->Data();
1775  res->data=(void*)iv->delete_pos(pos-1);
1776  return res->data==NULL;
1777}
1778static BOOLEAN jjDelete_ID(leftv res, leftv u, leftv v)
1779{
1780  int pos=(int)(long)v->Data();
1781  ideal I=(ideal)u->Data();
1782  res->data=(void*)id_Delete_Pos(I,pos-1,currRing);
1783  return res->data==NULL;
1784}
1785static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1786{
1787  int i=pVar((poly)v->Data());
1788  if (i==0)
1789  {
1790    WerrorS("ringvar expected");
1791    return TRUE;
1792  }
1793  res->data=(char *)pDiff((poly)(u->Data()),i);
1794  return FALSE;
1795}
1796static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1797{
1798  int i=pVar((poly)v->Data());
1799  if (i==0)
1800  {
1801    WerrorS("ringvar expected");
1802    return TRUE;
1803  }
1804  res->data=(char *)idDiff((matrix)(u->Data()),i);
1805  return FALSE;
1806}
1807static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1808{
1809  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1810  return FALSE;
1811}
1812static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1813{
1814  assumeStdFlag(v);
1815  if (rHasMixedOrdering(currRing))
1816  {
1817     Warn("dim(%s,...) may be wrong because the mixed monomial ordering",v->Name());
1818  }
1819#ifdef HAVE_RINGS
1820  if (rField_is_Ring(currRing))
1821  {
1822    ideal vid = (ideal)v->Data();
1823    int i = idPosConstant(vid);
1824    if ((i != -1) && (n_IsUnit(pGetCoeff(vid->m[i]),currRing->cf)))
1825    { /* ideal v contains unit; dim = -1 */
1826      res->data = (char *)-1;
1827      return FALSE;
1828    }
1829    ideal vv = id_Copy(vid, currRing);
1830    ideal ww = id_Copy((ideal)w->Data(), currRing);
1831    /* drop degree zero generator from vv (if any) */
1832    if (i != -1) pDelete(&vv->m[i]);
1833    long d = (long)scDimInt(vv, ww);
1834    if (rField_is_Ring_Z(currRing) && (i == -1)) d++;
1835    res->data = (char *)d;
1836    idDelete(&vv); idDelete(&ww);
1837    return FALSE;
1838  }
1839#endif
1840  if(currRing->qideal==NULL)
1841    res->data = (char *)((long)scDimInt((ideal)(v->Data()),(ideal)w->Data()));
1842  else
1843  {
1844    ideal q=idSimpleAdd(currRing->qideal,(ideal)w->Data());
1845    res->data = (char *)((long)scDimInt((ideal)(v->Data()),q));
1846    idDelete(&q);
1847  }
1848  return FALSE;
1849}
1850static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1851{
1852  ideal vi=(ideal)v->Data();
1853  int vl= IDELEMS(vi);
1854  ideal ui=(ideal)u->Data();
1855  unsigned ul= IDELEMS(ui);
1856  ideal R; matrix U;
1857  ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1858  if (m==NULL) return TRUE;
1859  // now make sure that all matrices have the corect size:
1860  matrix T = id_Module2formatedMatrix(m,vl,ul,currRing);
1861  int i;
1862  if (MATCOLS(U) != (int)ul)
1863  {
1864    unsigned mul=si_min(ul,MATCOLS(U));
1865    matrix UU=mpNew(ul,ul);
1866    unsigned j;
1867    for(i=mul;i>0;i--)
1868    {
1869      for(j=mul;j>0;j--)
1870      {
1871        MATELEM(UU,i,j)=MATELEM(U,i,j);
1872        MATELEM(U,i,j)=NULL;
1873      }
1874    }
1875    idDelete((ideal *)&U);
1876    U=UU;
1877  }
1878  // make sure that U is a diagonal matrix of units
1879  for(i=ul;i>0;i--)
1880  {
1881    if(MATELEM(U,i,i)==NULL) MATELEM(U,i,i)=pOne();
1882  }
1883  lists L=(lists)omAllocBin(slists_bin);
1884  L->Init(3);
1885  L->m[0].rtyp=MATRIX_CMD;   L->m[0].data=(void *)T;
1886  L->m[1].rtyp=u->Typ();     L->m[1].data=(void *)R;
1887  L->m[2].rtyp=MATRIX_CMD;   L->m[2].data=(void *)U;
1888  res->data=(char *)L;
1889  return FALSE;
1890}
1891static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1892{
1893  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1894  //setFlag(res,FLAG_STD);
1895  return v->next!=NULL; //do not allow next like in eliminate(I,a(1..4))
1896}
1897static BOOLEAN jjELIMIN_IV(leftv res, leftv u, leftv v)
1898{
1899  poly p=pOne();
1900  intvec *iv=(intvec*)v->Data();
1901  for(int i=iv->length()-1; i>=0; i--)
1902  {
1903    pSetExp(p,(*iv)[i],1);
1904  }
1905  pSetm(p);
1906  res->data=(char *)idElimination((ideal)u->Data(),p);
1907  pLmDelete(&p);
1908  //setFlag(res,FLAG_STD);
1909  return FALSE;
1910}
1911static BOOLEAN jjEXPORTTO(leftv, leftv u, leftv v)
1912{
1913  //Print("exportto %s -> %s\n",v->Name(),u->Name() );
1914  return iiExport(v,0,IDPACKAGE((idhdl)u->data));
1915}
1916static BOOLEAN jjERROR(leftv, leftv u)
1917{
1918  WerrorS((char *)u->Data());
1919  extern int inerror;
1920  inerror=3;
1921  return TRUE;
1922}
1923static BOOLEAN jjEXTGCD_BI(leftv res, leftv u, leftv v)
1924{
1925  number uu=(number)u->Data();number vv=(number)v->Data();
1926  lists L=(lists)omAllocBin(slists_bin);
1927  number a,b;
1928  number p0=n_ExtGcd(uu,vv,&a,&b,coeffs_BIGINT);
1929  L->Init(3);
1930  L->m[0].rtyp=BIGINT_CMD;   L->m[0].data=(void *)p0;
1931  L->m[1].rtyp=BIGINT_CMD;   L->m[1].data=(void *)a;
1932  L->m[2].rtyp=BIGINT_CMD;   L->m[2].data=(void *)b;
1933  res->rtyp=LIST_CMD;
1934  res->data=(char *)L;
1935  return FALSE;
1936}
1937static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1938{
1939  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1940  int p0=ABS(uu),p1=ABS(vv);
1941  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1942
1943  while ( p1!=0 )
1944  {
1945    q=p0 / p1;
1946    r=p0 % p1;
1947    p0 = p1; p1 = r;
1948    r = g0 - g1 * q;
1949    g0 = g1; g1 = r;
1950    r = f0 - f1 * q;
1951    f0 = f1; f1 = r;
1952  }
1953  int a = f0;
1954  int b = g0;
1955  if ( uu /*(int)(long)u->Data()*/ < 0 ) a=-a;
1956  if ( vv /*(int)(long)v->Data()*/ < 0 ) b=-b;
1957  lists L=(lists)omAllocBin(slists_bin);
1958  L->Init(3);
1959  L->m[0].rtyp=INT_CMD;   L->m[0].data=(void *)(long)p0;
1960  L->m[1].rtyp=INT_CMD;   L->m[1].data=(void *)(long)a;
1961  L->m[2].rtyp=INT_CMD;   L->m[2].data=(void *)(long)b;
1962  res->rtyp=LIST_CMD;
1963  res->data=(char *)L;
1964  return FALSE;
1965}
1966static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1967{
1968  poly r,pa,pb;
1969  BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb,currRing);
1970  if (ret) return TRUE;
1971  lists L=(lists)omAllocBin(slists_bin);
1972  L->Init(3);
1973  res->data=(char *)L;
1974  L->m[0].data=(void *)r;
1975  L->m[0].rtyp=POLY_CMD;
1976  L->m[1].data=(void *)pa;
1977  L->m[1].rtyp=POLY_CMD;
1978  L->m[2].data=(void *)pb;
1979  L->m[2].rtyp=POLY_CMD;
1980  return FALSE;
1981}
1982extern int singclap_factorize_retry;
1983static BOOLEAN jjFAC_P2(leftv res, leftv u,leftv dummy)
1984{
1985  intvec *v=NULL;
1986  int sw=(int)(long)dummy->Data();
1987  int fac_sw=sw;
1988  if ((sw<0)||(sw>2)) fac_sw=1;
1989  singclap_factorize_retry=0;
1990  ideal f=singclap_factorize((poly)(u->CopyD()), &v, fac_sw,currRing);
1991  if (f==NULL)
1992    return TRUE;
1993  switch(sw)
1994  {
1995    case 0:
1996    case 2:
1997    {
1998      lists l=(lists)omAllocBin(slists_bin);
1999      l->Init(2);
2000      l->m[0].rtyp=IDEAL_CMD;
2001      l->m[0].data=(void *)f;
2002      l->m[1].rtyp=INTVEC_CMD;
2003      l->m[1].data=(void *)v;
2004      res->data=(void *)l;
2005      res->rtyp=LIST_CMD;
2006      return FALSE;
2007    }
2008    case 1:
2009      res->data=(void *)f;
2010      return FALSE;
2011    case 3:
2012      {
2013        poly p=f->m[0];
2014        int i=IDELEMS(f);
2015        f->m[0]=NULL;
2016        while(i>1)
2017        {
2018          i--;
2019          p=pMult(p,f->m[i]);
2020          f->m[i]=NULL;
2021        }
2022        res->data=(void *)p;
2023        res->rtyp=POLY_CMD;
2024      }
2025      return FALSE;
2026  }
2027  WerrorS("invalid switch");
2028  return TRUE;
2029}
2030static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
2031{
2032  ideal_list p,h;
2033  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
2034  p=h;
2035  int l=0;
2036  while (p!=NULL) { p=p->next;l++; }
2037  lists L=(lists)omAllocBin(slists_bin);
2038  L->Init(l);
2039  l=0;
2040  while(h!=NULL)
2041  {
2042    L->m[l].data=(char *)h->d;
2043    L->m[l].rtyp=IDEAL_CMD;
2044    p=h->next;
2045    omFreeSize(h,sizeof(*h));
2046    h=p;
2047    l++;
2048  }
2049  res->data=(void *)L;
2050  return FALSE;
2051}
2052static BOOLEAN jjFAREY_BI(leftv res, leftv u, leftv v)
2053{
2054  if (rField_is_Q(currRing))
2055  {
2056    number uu=(number)u->Data();
2057    number vv=(number)v->Data();
2058    res->data=(char *)n_Farey(uu,vv,currRing->cf);
2059    return FALSE;
2060  }
2061  else return TRUE;
2062}
2063static BOOLEAN jjFAREY_ID(leftv res, leftv u, leftv v)
2064{
2065  ideal uu=(ideal)u->Data();
2066  number vv=(number)v->Data();
2067  //timespec buf1,buf2;
2068  //clock_gettime(CLOCK_THREAD_CPUTIME_ID,&buf1);
2069  res->data=(void*)id_Farey(uu,vv,currRing);
2070  //clock_gettime(CLOCK_THREAD_CPUTIME_ID,&buf2);
2071  //const unsigned long SEC = 1000L*1000L*1000L;
2072  //all_farey+=((buf2.tv_sec-buf1.tv_sec)*SEC+
2073  //                              buf2.tv_nsec-buf1.tv_nsec);
2074  //farey_cnt++;
2075  return FALSE;
2076}
2077static BOOLEAN jjFAREY_LI(leftv res, leftv u, leftv v);
2078static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
2079{
2080  ring r=(ring)u->Data();
2081  idhdl w;
2082  int op=iiOp;
2083  nMapFunc nMap;
2084
2085  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
2086  {
2087    int *perm=NULL;
2088    int *par_perm=NULL;
2089    int par_perm_size=0;
2090    BOOLEAN bo;
2091    if ((nMap=n_SetMap(r->cf,currRing->cf))==NULL)
2092    {
2093      // Allow imap/fetch to be make an exception only for:
2094      if ( (rField_is_Q_a(r) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
2095            (rField_is_Q(currRing) || rField_is_Q_a(currRing) ||
2096             (rField_is_Zp(currRing) || rField_is_Zp_a(currRing))))
2097           ||
2098           (rField_is_Zp_a(r) &&  // Zp(a..) -> Zp(a..) || Zp
2099            (rField_is_Zp(currRing, r->cf->ch) ||
2100             rField_is_Zp_a(currRing, r->cf->ch))) )
2101      {
2102        par_perm_size=rPar(r);
2103      }
2104      else
2105      {
2106        goto err_fetch;
2107      }
2108    }
2109    if ((iiOp!=FETCH_CMD) || (r->N!=currRing->N) || (rPar(r)!=rPar(currRing)))
2110    {
2111      perm=(int *)omAlloc0((r->N+1)*sizeof(int));
2112      if (par_perm_size!=0)
2113        par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
2114      op=IMAP_CMD;
2115      if (iiOp==IMAP_CMD)
2116      {
2117        int r_par=0;
2118        char ** r_par_names=NULL;
2119        if (r->cf->extRing!=NULL)
2120        {
2121          r_par=r->cf->extRing->N;
2122          r_par_names=r->cf->extRing->names;
2123        }
2124        int c_par=0;
2125        char ** c_par_names=NULL;
2126        if (currRing->cf->extRing!=NULL)
2127        {
2128          c_par=currRing->cf->extRing->N;
2129          c_par_names=currRing->cf->extRing->names;
2130        }
2131        maFindPerm(r->names,       r->N,       r_par_names, r_par,
2132                   currRing->names,currRing->N,c_par_names, c_par,
2133                   perm,par_perm, currRing->cf->type);
2134      }
2135      else
2136      {
2137        unsigned i;
2138        if (par_perm_size!=0)
2139          for(i=si_min(rPar(r),rPar(currRing));i>0;i--) par_perm[i-1]=-i;
2140        for(i=si_min(r->N,currRing->N);i>0;i--) perm[i]=i;
2141      }
2142    }
2143    if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
2144    {
2145      unsigned i;
2146      for(i=0;i<(unsigned)si_min(r->N,currRing->N);i++)
2147      {
2148        Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
2149      }
2150      for(i=0;i<(unsigned)si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
2151      {
2152        Print("// par nr %d: %s -> %s\n",
2153              i,rParameter(r)[i],rParameter(currRing)[i]);
2154      }
2155    }
2156    if (IDTYP(w)==ALIAS_CMD) w=(idhdl)IDDATA(w);
2157    sleftv tmpW;
2158    memset(&tmpW,0,sizeof(sleftv));
2159    tmpW.rtyp=IDTYP(w);
2160    tmpW.data=IDDATA(w);
2161    if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
2162                         perm,par_perm,par_perm_size,nMap)))
2163    {
2164      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
2165    }
2166    if (perm!=NULL)
2167      omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
2168    if (par_perm!=NULL)
2169      omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
2170    return bo;
2171  }
2172  else
2173  {
2174    Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
2175  }
2176  return TRUE;
2177err_fetch:
2178  char *s1=nCoeffString(r->cf);
2179  char *s2=nCoeffString(currRing->cf);
2180  Werror("no identity map from %s (%s -> %s)",u->Fullname(),s1,s2);
2181  omFree(s2); omFree(s1);
2182  return TRUE;
2183}
2184static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
2185{
2186  /*4
2187  * look for the substring what in the string where
2188  * return the position of the first char of what in where
2189  * or 0
2190  */
2191  char *where=(char *)u->Data();
2192  char *what=(char *)v->Data();
2193  char *found = strstr(where,what);
2194  if (found != NULL)
2195  {
2196    res->data=(char *)((found-where)+1);
2197  }
2198  /*else res->data=NULL;*/
2199  return FALSE;
2200}
2201
2202static BOOLEAN jjFRES3(leftv res, leftv u, leftv v, leftv w)
2203{
2204    assumeStdFlag(u);
2205    ideal id = (ideal)u->Data();
2206    int maxl = (int)(long)v->Data();
2207    if (maxl < 0) {
2208        WerrorS("length for fres must not be negative");
2209        return TRUE;
2210    }
2211    if (maxl == 0) {
2212        maxl = currRing->N+1;
2213        if (currRing->qideal != NULL) {
2214            Warn("full resolution in a qring may be infinite, "
2215                "setting max length to %d", maxl);
2216        }
2217    }
2218    char* method = (char *)w->Data();
2219    if (strcmp(method, "complete") != 0
2220            && strcmp(method, "frame") != 0
2221            && strcmp(method, "extended frame") != 0
2222            && strcmp(method, "linear strand") != 0) {
2223        WerrorS("wrong optional argument for fres");
2224    }
2225    syStrategy r;
2226    r = syFrank(id, maxl, method);
2227    r->list_length = maxl;
2228    if (r == NULL) return TRUE;
2229    assume( (r->minres != NULL) || (r->fullres != NULL) );
2230    res->data = (void *)r;
2231    return FALSE;
2232}
2233
2234static BOOLEAN jjFRES(leftv res, leftv u, leftv v)
2235{
2236    leftv w = (leftv)omalloc0(sizeof(sleftv));
2237    w->rtyp = STRING_CMD;
2238    w->data = (char *)"complete";   // default
2239    BOOLEAN RES = jjFRES3(res, u, v, w);
2240    omFree(w);
2241    return RES;
2242}
2243
2244static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
2245{
2246  res->data=(char *)fractalWalkProc(u,v);
2247  setFlag( res, FLAG_STD );
2248  return FALSE;
2249}
2250static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
2251{
2252  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
2253  int p0=ABS(uu),p1=ABS(vv);
2254  int r;
2255  while ( p1!=0 )
2256  {
2257    r=p0 % p1;
2258    p0 = p1; p1 = r;
2259  }
2260  res->rtyp=INT_CMD;
2261  res->data=(char *)(long)p0;
2262  return FALSE;
2263}
2264static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
2265{
2266  number n1 = (number) u->Data();
2267  number n2 = (number) v->Data();
2268  res->data = n_Gcd(n1,n2,coeffs_BIGINT);
2269  return FALSE;
2270}
2271static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
2272{
2273  number a=(number) u->Data();
2274  number b=(number) v->Data();
2275  if (nIsZero(a))
2276  {
2277    if (nIsZero(b)) res->data=(char *)nInit(1);
2278    else            res->data=(char *)nCopy(b);
2279  }
2280  else
2281  {
2282    if (nIsZero(b))  res->data=(char *)nCopy(a);
2283    //else res->data=(char *)n_Gcd(a, b, currRing->cf);
2284    else res->data=(char *)n_SubringGcd(a, b, currRing->cf);
2285  }
2286  return FALSE;
2287}
2288static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
2289{
2290  res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
2291                                 (poly)(v->CopyD(POLY_CMD)),currRing);
2292  return FALSE;
2293}
2294static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
2295{
2296#ifdef HAVE_RINGS
2297  if (rField_is_Ring_Z(currRing))
2298  {
2299    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
2300    PrintS("//       performed for generic fibre, that is, over Q\n");
2301  }
2302#endif
2303  assumeStdFlag(u);
2304  intvec *module_w=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2305  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal);
2306  switch((int)(long)v->Data())
2307  {
2308    case 1:
2309      res->data=(void *)iv;
2310      return FALSE;
2311    case 2:
2312      res->data=(void *)hSecondSeries(iv);
2313      delete iv;
2314      return FALSE;
2315  }
2316  delete iv;
2317  WerrorS(feNotImplemented);
2318  return TRUE;
2319}
2320static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
2321{
2322  int i=pVar((poly)v->Data());
2323  if (i==0)
2324  {
2325    WerrorS("ringvar expected");
2326    return TRUE;
2327  }
2328  poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2329  int d=pWTotaldegree(p);
2330  pLmDelete(p);
2331  if (d==1)
2332    res->data = (char *)p_Homogen((poly)u->Data(), i, currRing);
2333  else
2334    WerrorS("variable must have weight 1");
2335  return (d!=1);
2336}
2337static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
2338{
2339  int i=pVar((poly)v->Data());
2340  if (i==0)
2341  {
2342    WerrorS("ringvar expected");
2343    return TRUE;
2344  }
2345  pFDegProc deg;
2346  if (currRing->pLexOrder && (currRing->order[0]==ringorder_lp))
2347    deg=p_Totaldegree;
2348   else
2349    deg=currRing->pFDeg;
2350  poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2351  int d=deg(p,currRing);
2352  pLmDelete(p);
2353  if (d==1)
2354    res->data = (char *)id_Homogen((ideal)u->Data(), i, currRing);
2355  else
2356    WerrorS("variable must have weight 1");
2357  return (d!=1);
2358}
2359static BOOLEAN jjHOMOG1_W(leftv res, leftv v, leftv u)
2360{
2361  intvec *w=new intvec(rVar(currRing));
2362  intvec *vw=(intvec*)u->Data();
2363  ideal v_id=(ideal)v->Data();
2364  pFDegProc save_FDeg=currRing->pFDeg;
2365  pLDegProc save_LDeg=currRing->pLDeg;
2366  BOOLEAN save_pLexOrder=currRing->pLexOrder;
2367  currRing->pLexOrder=FALSE;
2368  kHomW=vw;
2369  kModW=w;
2370  pSetDegProcs(currRing,kHomModDeg);
2371  res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
2372  currRing->pLexOrder=save_pLexOrder;
2373  kHomW=NULL;
2374  kModW=NULL;
2375  pRestoreDegProcs(currRing,save_FDeg,save_LDeg);
2376  if (w!=NULL) delete w;
2377  return FALSE;
2378}
2379static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
2380{
2381  assumeStdFlag(u);
2382  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2383                    currRing->qideal);
2384  return FALSE;
2385}
2386static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
2387{
2388  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2389  if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
2390  return FALSE;
2391}
2392static BOOLEAN jjINTERPOLATION (leftv res, leftv l, leftv v)
2393{
2394  const lists L = (lists)l->Data();
2395  const int n = L->nr; assume (n >= 0);
2396  std::vector<ideal> V(n + 1);
2397
2398  for(int i = n; i >= 0; i--) V[i] = (ideal)(L->m[i].Data());
2399
2400  res->data=interpolation(V, (intvec*)v->Data());
2401  setFlag(res,FLAG_STD);
2402  return errorreported;
2403}
2404static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2405{
2406  extern BOOLEAN jjStdJanetBasis(leftv res, leftv v,int flag);
2407  return jjStdJanetBasis(res,u,(int)(long)v->Data());
2408}
2409
2410static BOOLEAN jjJanetBasis(leftv res, leftv v)
2411{
2412  extern BOOLEAN jjStdJanetBasis(leftv res, leftv v,int flag);
2413  return jjStdJanetBasis(res,v,0);
2414}
2415static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2416{
2417  res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2418  return FALSE;
2419}
2420static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2421{
2422  res->data = (char *)id_Jet((ideal)u->Data(),(int)(long)v->Data(),currRing);
2423  return FALSE;
2424}
2425static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2426{
2427  assumeStdFlag(u);
2428  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2429  res->data = (char *)scKBase((int)(long)v->Data(),
2430                              (ideal)(u->Data()),currRing->qideal, w_u);
2431  if (w_u!=NULL)
2432  {
2433    atSet(res,omStrDup("isHomog"),ivCopy(w_u),INTVEC_CMD);
2434  }
2435  return FALSE;
2436}
2437static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w);
2438static BOOLEAN jjKERNEL(leftv res, leftv u, leftv v)
2439{
2440  return jjPREIMAGE(res,u,v,NULL);
2441}
2442static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2443{
2444  return mpKoszul(res, u,v,NULL);
2445}
2446static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2447{
2448  sleftv h;
2449  memset(&h,0,sizeof(sleftv));
2450  h.rtyp=INT_CMD;
2451  h.data=(void *)(long)IDELEMS((ideal)v->Data());
2452  return mpKoszul(res, u, &h, v);
2453}
2454static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2455{
2456  int ul= IDELEMS((ideal)u->Data());
2457  int vl= IDELEMS((ideal)v->Data());
2458  ideal m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,
2459                   hasFlag(u,FLAG_STD));
2460  if (m==NULL) return TRUE;
2461  res->data = (char *)id_Module2formatedMatrix(m,ul,vl,currRing);
2462  return FALSE;
2463}
2464static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2465{
2466  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
2467  idhdl h=(idhdl)v->data;
2468  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2469  res->data = (char *)idLiftStd((ideal)u->Data(),
2470                                &(h->data.umatrix),testHomog);
2471  setFlag(res,FLAG_STD); v->flag=0;
2472  return FALSE;
2473}
2474static BOOLEAN jjLOAD2(leftv /*res*/, leftv/* LIB */ , leftv v)
2475{
2476  return jjLOAD((char*)v->Data(),TRUE);
2477}
2478static BOOLEAN jjLOAD_E(leftv /*res*/, leftv v, leftv u)
2479{
2480  char * s=(char *)u->Data();
2481  if(strcmp(s, "with")==0)
2482    return jjLOAD((char*)v->Data(), TRUE);
2483  if (strcmp(s,"try")==0)
2484    return jjLOAD_TRY((char*)v->Data());
2485  WerrorS("invalid second argument");
2486  WerrorS("load(\"libname\" [,option]);");
2487  return TRUE;
2488}
2489static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2490{
2491  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2492  tHomog hom=testHomog;
2493  if (w_u!=NULL)
2494  {
2495    w_u=ivCopy(w_u);
2496    hom=isHomog;
2497  }
2498  intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2499  if (w_v!=NULL)
2500  {
2501    w_v=ivCopy(w_v);
2502    hom=isHomog;
2503  }
2504  if ((w_u!=NULL) && (w_v==NULL))
2505    w_v=ivCopy(w_u);
2506  if ((w_v!=NULL) && (w_u==NULL))
2507    w_u=ivCopy(w_v);
2508  ideal u_id=(ideal)u->Data();
2509  ideal v_id=(ideal)v->Data();
2510  if (w_u!=NULL)
2511  {
2512     if ((*w_u).compare((w_v))!=0)
2513     {
2514       WarnS("incompatible weights");
2515       delete w_u; w_u=NULL;
2516       hom=testHomog;
2517     }
2518     else
2519     {
2520       if ((!idTestHomModule(u_id,currRing->qideal,w_v))
2521       || (!idTestHomModule(v_id,currRing->qideal,w_v)))
2522       {
2523         WarnS("wrong weights");
2524         delete w_u; w_u=NULL;
2525         hom=testHomog;
2526       }
2527     }
2528  }
2529  res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2530  if (w_u!=NULL)
2531  {
2532    atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2533  }
2534  delete w_v;
2535  //if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
2536  return FALSE;
2537}
2538static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2539{
2540  number q=(number)v->Data();
2541  if (n_IsZero(q,coeffs_BIGINT))
2542  {
2543    WerrorS(ii_div_by_0);
2544    return TRUE;
2545  }
2546  res->data =(char *) n_IntMod((number)u->Data(),q,coeffs_BIGINT);
2547  return FALSE;
2548}
2549static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2550{
2551  number q=(number)v->Data();
2552  if (nIsZero(q))
2553  {
2554    WerrorS(ii_div_by_0);
2555    return TRUE;
2556  }
2557  res->data =(char *) n_IntMod((number)u->Data(),q,currRing->cf);
2558  return FALSE;
2559}
2560static BOOLEAN jjMOD_P(leftv res, leftv u, leftv v)
2561{
2562  poly q=(poly)v->Data();
2563  if (q==NULL)
2564  {
2565    WerrorS(ii_div_by_0);
2566    return TRUE;
2567  }
2568  poly p=(poly)(u->Data());
2569  if (p==NULL)
2570  {
2571    res->data=NULL;
2572    return FALSE;
2573  }
2574  res->data=(void*)(singclap_pmod(p /*(poly)(u->Data())*/ ,
2575                                  q /*(poly)(v->Data())*/ ,currRing));
2576  return FALSE;
2577}
2578static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v);
2579static BOOLEAN jjMONITOR1(leftv res, leftv v)
2580{
2581  return jjMONITOR2(res,v,NULL);
2582}
2583static BOOLEAN jjMONITOR2(leftv, leftv u,leftv v)
2584{
2585#if 0
2586  char *opt=(char *)v->Data();
2587  int mode=0;
2588  while(*opt!='\0')
2589  {
2590    if (*opt=='i') mode |= SI_PROT_I;
2591    else if (*opt=='o') mode |= SI_PROT_O;
2592    opt++;
2593  }
2594  monitor((char *)(u->Data()),mode);
2595#else
2596  si_link l=(si_link)u->Data();
2597  if (slOpen(l,SI_LINK_WRITE,u)) return TRUE;
2598  if(strcmp(l->m->type,"ASCII")!=0)
2599  {
2600    Werror("ASCII link required, not `%s`",l->m->type);
2601    slClose(l);
2602    return TRUE;
2603  }
2604  SI_LINK_SET_CLOSE_P(l); // febase handles the FILE*
2605  if ( l->name[0]!='\0') // "" is the stop condition
2606  {
2607    const char *opt;
2608    int mode=0;
2609    if (v==NULL) opt=(const char*)"i";
2610    else         opt=(const char *)v->Data();
2611    while(*opt!='\0')
2612    {
2613      if (*opt=='i') mode |= SI_PROT_I;
2614      else if (*opt=='o') mode |= SI_PROT_O;
2615      opt++;
2616    }
2617    monitor((FILE *)l->data,mode);
2618  }
2619  else
2620    monitor(NULL,0);
2621  return FALSE;
2622#endif
2623}
2624static BOOLEAN jjMONOM(leftv res, leftv v)
2625{
2626  intvec *iv=(intvec *)v->Data();
2627  poly p=pOne();
2628  int e;
2629  BOOLEAN err=FALSE;
2630  for(unsigned i=si_min(currRing->N,iv->length()); i>0; i--)
2631  {
2632    e=(*iv)[i-1];
2633    if (e>=0) pSetExp(p,i,e);
2634    else err=TRUE;
2635  }
2636  if (iv->length()==(currRing->N+1))
2637  {
2638    res->rtyp=VECTOR_CMD;
2639    e=(*iv)[currRing->N];
2640    if (e>=0) pSetComp(p,e);
2641    else err=TRUE;
2642  }
2643  pSetm(p);
2644  res->data=(char*)p;
2645  if(err) { pDelete(&p); WerrorS("no negative exponent allowed"); }
2646  return err;
2647}
2648static BOOLEAN jjNEWSTRUCT2(leftv, leftv u, leftv v)
2649{
2650  // u: the name of the new type
2651  // v: the elements
2652  const char *s=(const char *)u->Data();
2653  newstruct_desc d=NULL;
2654  if (strlen(s)>=2)
2655  {
2656    d=newstructFromString((const char *)v->Data());
2657    if (d!=NULL) newstruct_setup(s,d);
2658  }
2659  else WerrorS("name of newstruct must be longer than 1 character");
2660  return d==NULL;
2661}
2662static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2663{
2664  idhdl h=(idhdl)u->data;
2665  int i=(int)(long)v->Data();
2666  int p=0;
2667  if ((0<i)
2668  && (rParameter(IDRING(h))!=NULL)
2669  && (i<=(p=rPar(IDRING(h)))))
2670    res->data=omStrDup(rParameter(IDRING(h))[i-1]);
2671  else
2672  {
2673    Werror("par number %d out of range 1..%d",i,p);
2674    return TRUE;
2675  }
2676  return FALSE;
2677}
2678#ifdef HAVE_PLURAL
2679static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2680{
2681  if( currRing->qideal != NULL )
2682  {
2683    WerrorS("basering must NOT be a qring!");
2684    return TRUE;
2685  }
2686
2687  if (iiOp==NCALGEBRA_CMD)
2688  {
2689    return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing,false,true,false,currRing);
2690  }
2691  else
2692  {
2693    ring r=rCopy(currRing);
2694    BOOLEAN result=nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),r,false,true,false,currRing);
2695    res->data=r;
2696    return result;
2697  }
2698}
2699static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2700{
2701  if( currRing->qideal != NULL )
2702  {
2703    WerrorS("basering must NOT be a qring!");
2704    return TRUE;
2705  }
2706
2707  if (iiOp==NCALGEBRA_CMD)
2708  {
2709    return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing,false,true,false,currRing);
2710  }
2711  else
2712  {
2713    ring r=rCopy(currRing);
2714    BOOLEAN result=nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,r,false,true,false,currRing);
2715    res->data=r;
2716    return result;
2717  }
2718}
2719static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2720{
2721  if( currRing->qideal != NULL )
2722  {
2723    WerrorS("basering must NOT be a qring!");
2724    return TRUE;
2725  }
2726
2727  if (iiOp==NCALGEBRA_CMD)
2728  {
2729    return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing,false,true,false,currRing);
2730  }
2731  else
2732  {
2733    ring r=rCopy(currRing);
2734    BOOLEAN result=nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),r,false,true,false,currRing);
2735    res->data=r;
2736    return result;
2737  }
2738}
2739static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2740{
2741  if( currRing->qideal != NULL )
2742  {
2743    WerrorS("basering must NOT be a qring!");
2744    return TRUE;
2745  }
2746
2747  if (iiOp==NCALGEBRA_CMD)
2748  {
2749    return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing,false,true,false,currRing);
2750  }
2751  else
2752  {
2753    ring r=rCopy(currRing);
2754    BOOLEAN result=nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,r,false,true,false,currRing);
2755    res->data=r;
2756    return result;
2757  }
2758}
2759static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2760{
2761  res->data=NULL;
2762
2763  if (rIsPluralRing(currRing))
2764  {
2765    const poly q = (poly)b->Data();
2766
2767    if( q != NULL )
2768    {
2769      if( (poly)a->Data() != NULL )
2770      {
2771        poly p = (poly)a->CopyD(POLY_CMD); // p = copy!
2772        res->data = nc_p_Bracket_qq(p,q, currRing); // p will be destroyed!
2773      }
2774    }
2775  }
2776  return FALSE;
2777}
2778static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2779{
2780  /* number, poly, vector, ideal, module, matrix */
2781  ring  r = (ring)a->Data();
2782  if (r == currRing)
2783  {
2784    res->data = b->Data();
2785    res->rtyp = b->rtyp;
2786    return FALSE;
2787  }
2788  if (!rIsLikeOpposite(currRing, r))
2789  {
2790    Werror("%s is not an opposite ring to current ring",a->Fullname());
2791    return TRUE;
2792  }
2793  idhdl w;
2794  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2795  {
2796    int argtype = IDTYP(w);
2797    switch (argtype)
2798    {
2799    case NUMBER_CMD:
2800      {
2801        /* since basefields are equal, we can apply nCopy */
2802        res->data = nCopy((number)IDDATA(w));
2803        res->rtyp = argtype;
2804        break;
2805      }
2806    case POLY_CMD:
2807    case VECTOR_CMD:
2808      {
2809        poly    q = (poly)IDDATA(w);
2810        res->data = pOppose(r,q,currRing);
2811        res->rtyp = argtype;
2812        break;
2813      }
2814    case IDEAL_CMD:
2815    case MODUL_CMD:
2816      {
2817        ideal   Q = (ideal)IDDATA(w);
2818        res->data = idOppose(r,Q,currRing);
2819        res->rtyp = argtype;
2820        break;
2821      }
2822    case MATRIX_CMD:
2823      {
2824        ring save = currRing;
2825        rChangeCurrRing(r);
2826        matrix  m = (matrix)IDDATA(w);
2827        ideal   Q = id_Matrix2Module(mp_Copy(m, currRing),currRing);
2828        rChangeCurrRing(save);
2829        ideal   S = idOppose(r,Q,currRing);
2830        id_Delete(&Q, r);
2831        res->data = id_Module2Matrix(S,currRing);
2832        res->rtyp = argtype;
2833        break;
2834      }
2835    default:
2836      {
2837        WerrorS("unsupported type in oppose");
2838        return TRUE;
2839      }
2840    }
2841  }
2842  else
2843  {
2844    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2845    return TRUE;
2846  }
2847  return FALSE;
2848}
2849#endif /* HAVE_PLURAL */
2850
2851static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2852{
2853  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2854    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2855  id_DelMultiples((ideal)(res->data),currRing);
2856  if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
2857  return FALSE;
2858}
2859static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2860{
2861  int i=(int)(long)u->Data();
2862  int j=(int)(long)v->Data();
2863  if (j-i <0) {WerrorS("invalid range for random"); return TRUE;}
2864  res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
2865  return FALSE;
2866}
2867static BOOLEAN jjRANK2(leftv res, leftv u, leftv v)
2868{
2869  matrix m =(matrix)u->Data();
2870  int isRowEchelon = (int)(long)v->Data();
2871  if (isRowEchelon != 1) isRowEchelon = 0;
2872  int rank = luRank(m, isRowEchelon);
2873  res->data =(char *)(long)rank;
2874  return FALSE;
2875}
2876static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2877{
2878  si_link l=(si_link)u->Data();
2879  leftv r=slRead(l,v);
2880  if (r==NULL)
2881  {
2882    const char *s;
2883    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2884    else                            s=sNoName_fe;
2885    Werror("cannot read from `%s`",s);
2886    return TRUE;
2887  }
2888  memcpy(res,r,sizeof(sleftv));
2889  omFreeBin((ADDRESS)r, sleftv_bin);
2890  return FALSE;
2891}
2892static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2893{
2894  ideal vi=(ideal)v->Data();
2895  if (currRing->qideal!=NULL || vi->ncols>1 || rIsPluralRing(currRing))
2896    assumeStdFlag(v);
2897  res->data = (char *)kNF(vi,currRing->qideal,(poly)u->Data());
2898  return FALSE;
2899}
2900static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2901{
2902  ideal ui=(ideal)u->Data();
2903  ideal vi=(ideal)v->Data();
2904  if (currRing->qideal!=NULL || vi->ncols>1 || rIsPluralRing(currRing))
2905    assumeStdFlag(v);
2906  res->data = (char *)kNF(vi,currRing->qideal,ui);
2907  return FALSE;
2908}
2909static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2910{
2911  int maxl=(int)(long)v->Data();
2912  if (maxl<0)
2913  {
2914    WerrorS("length for res must not be negative");
2915    return TRUE;
2916  }
2917  syStrategy r;
2918  intvec *weights=NULL;
2919  int wmaxl=maxl;
2920  ideal u_id=(ideal)u->Data();
2921
2922  maxl--;
2923  if (/*(*/ maxl==-1 /*)*/) /*&& (iiOp!=MRES_CMD)*/
2924  {
2925    maxl = currRing->N-1+2*(iiOp==MRES_CMD);
2926    if (currRing->qideal!=NULL)
2927    {
2928      Warn(
2929      "full resolution in a qring may be infinite, setting max length to %d",
2930      maxl+1);
2931    }
2932  }
2933  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2934  if (weights!=NULL)
2935  {
2936    if (!idTestHomModule(u_id,currRing->qideal,weights))
2937    {
2938      WarnS("wrong weights given:");weights->show();PrintLn();
2939      weights=NULL;
2940    }
2941  }
2942  intvec *ww=NULL;
2943  int add_row_shift=0;
2944  if (weights!=NULL)
2945  {
2946     ww=ivCopy(weights);
2947     add_row_shift = ww->min_in();
2948     (*ww) -= add_row_shift;
2949  }
2950  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2951  {
2952    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2953  }
2954  else if (iiOp==SRES_CMD)
2955  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2956    r=sySchreyer(u_id,maxl+1);
2957  else if (iiOp == LRES_CMD)
2958  {
2959    int dummy;
2960    if((currRing->qideal!=NULL)||
2961    (!idHomIdeal (u_id,NULL)))
2962    {
2963       WerrorS
2964       ("`lres` not implemented for inhomogeneous input or qring");
2965       return TRUE;
2966    }
2967    if(currRing->N == 1)
2968      WarnS("the current implementation of `lres` may not work in the case of a single variable");
2969    r=syLaScala3(u_id,&dummy);
2970  }
2971  else if (iiOp == KRES_CMD)
2972  {
2973    int dummy;
2974    if((currRing->qideal!=NULL)||
2975    (!idHomIdeal (u_id,NULL)))
2976    {
2977       WerrorS
2978       ("`kres` not implemented for inhomogeneous input or qring");
2979       return TRUE;
2980    }
2981    r=syKosz(u_id,&dummy);
2982  }
2983  else
2984  {
2985    int dummy;
2986    if((currRing->qideal!=NULL)||
2987    (!idHomIdeal (u_id,NULL)))
2988    {
2989       WerrorS
2990       ("`hres` not implemented for inhomogeneous input or qring");
2991       return TRUE;
2992    }
2993    ideal u_id_copy=idCopy(u_id);
2994    idSkipZeroes(u_id_copy);
2995    r=syHilb(u_id_copy,&dummy);
2996    idDelete(&u_id_copy);
2997  }
2998  if (r==NULL) return TRUE;
2999  if (r->list_length>wmaxl)
3000  {
3001    for(int i=wmaxl-1;i>=r->list_length;i--)
3002    {
3003      if (r->fullres[i]!=NULL) id_Delete(&r->fullres[i],currRing);
3004      if (r->minres[i]!=NULL) id_Delete(&r->minres[i],currRing);
3005    }
3006  }
3007  r->list_length=wmaxl;
3008  res->data=(void *)r;
3009  if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
3010  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
3011  {
3012    ww=ivCopy(r->weights[0]);
3013    if (weights!=NULL) (*ww) += add_row_shift;
3014    atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
3015  }
3016  else
3017  {
3018    if (weights!=NULL)
3019    {
3020      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3021    }
3022  }
3023
3024  // test the La Scala case' output
3025  assume( ((iiOp == LRES_CMD) || (iiOp == HRES_CMD)) == (r->syRing != NULL) );
3026  assume( (r->syRing != NULL) == (r->resPairs != NULL) );
3027
3028  if(iiOp != HRES_CMD)
3029    assume( (r->minres != NULL) || (r->fullres != NULL) ); // is wrong for HRES_CMD...
3030  else
3031    assume( (r->orderedRes != NULL) || (r->res != NULL) ); // analog for hres...
3032
3033  return FALSE;
3034}
3035static BOOLEAN jjPFAC2(leftv res, leftv u, leftv v)
3036{
3037  number n1; int i;
3038
3039  if ((u->Typ() == BIGINT_CMD) ||
3040     ((u->Typ() == NUMBER_CMD) && rField_is_Q(currRing)))
3041  {
3042    n1 = (number)u->CopyD();
3043  }
3044  else if (u->Typ() == INT_CMD)
3045  {
3046    i = (int)(long)u->Data();
3047    n1 = n_Init(i, coeffs_BIGINT);
3048  }
3049  else
3050  {
3051    return TRUE;
3052  }
3053
3054  i = (int)(long)v->Data();
3055
3056  lists l = primeFactorisation(n1, i);
3057  n_Delete(&n1, coeffs_BIGINT);
3058  res->data = (char*)l;
3059  return FALSE;
3060}
3061static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
3062{
3063  ring r;
3064  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
3065  res->data = (char *)r;
3066  return (i==-1);
3067}
3068#define SIMPL_LMDIV 32
3069#define SIMPL_LMEQ  16
3070#define SIMPL_MULT 8
3071#define SIMPL_EQU  4
3072#define SIMPL_NULL 2
3073#define SIMPL_NORM 1
3074static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
3075{
3076  int sw = (int)(long)v->Data();
3077  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
3078  ideal id = (ideal)u->CopyD(IDEAL_CMD);
3079  if (sw & SIMPL_LMDIV)
3080  {
3081    id_DelDiv(id,currRing);
3082  }
3083  if (sw & SIMPL_LMEQ)
3084  {
3085    id_DelLmEquals(id,currRing);
3086  }
3087  if (sw & SIMPL_MULT)
3088  {
3089    id_DelMultiples(id,currRing);
3090  }
3091  else if(sw & SIMPL_EQU)
3092  {
3093    id_DelEquals(id,currRing);
3094  }
3095  if (sw & SIMPL_NULL)
3096  {
3097    idSkipZeroes(id);
3098  }
3099  if (sw & SIMPL_NORM)
3100  {
3101    id_Norm(id,currRing);
3102  }
3103  res->data = (char * )id;
3104  return FALSE;
3105}
3106extern int singclap_factorize_retry;
3107static BOOLEAN jjSQR_FREE2(leftv res, leftv u, leftv dummy)
3108{
3109  intvec *v=NULL;
3110  int sw=(int)(long)dummy->Data();
3111  int fac_sw=sw;
3112  if (sw<0) fac_sw=1;
3113  singclap_factorize_retry=0;
3114  ideal f=singclap_sqrfree((poly)(u->CopyD()), &v, fac_sw, currRing);
3115  if (f==NULL)
3116    return TRUE;
3117  switch(sw)
3118  {
3119    case 0:
3120    case 2:
3121    {
3122      lists l=(lists)omAllocBin(slists_bin);
3123      l->Init(2);
3124      l->m[0].rtyp=IDEAL_CMD;
3125      l->m[0].data=(void *)f;
3126      l->m[1].rtyp=INTVEC_CMD;
3127      l->m[1].data=(void *)v;
3128      res->data=(void *)l;
3129      res->rtyp=LIST_CMD;
3130      return FALSE;
3131    }
3132    case 1:
3133      res->data=(void *)f;
3134      return FALSE;
3135    case 3:
3136      {
3137        poly p=f->m[0];
3138        int i=IDELEMS(f);
3139        f->m[0]=NULL;
3140        while(i>1)
3141        {
3142          i--;
3143          p=pMult(p,f->m[i]);
3144          f->m[i]=NULL;
3145        }
3146        res->data=(void *)p;
3147        res->rtyp=POLY_CMD;
3148      }
3149      return FALSE;
3150  }
3151  WerrorS("invalid switch");
3152  return FALSE;
3153}
3154static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
3155{
3156  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
3157  return FALSE;
3158}
3159static BOOLEAN jjSTATUS2L(leftv res, leftv u, leftv v)
3160{
3161  res->data = (void *)(long)slStatusSsiL((lists) u->Data(), (int)(long) v->Data());
3162  //return (res->data== (void*)(long)-2);
3163  return FALSE;
3164}
3165static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
3166{
3167  int sw = (int)(long)v->Data();
3168  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3169  poly p = (poly)u->CopyD(POLY_CMD);
3170  if (sw & SIMPL_NORM)
3171  {
3172    pNorm(p);
3173  }
3174  res->data = (char * )p;
3175  return FALSE;
3176}
3177static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
3178{
3179  ideal result;
3180  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3181  tHomog hom=testHomog;
3182  ideal u_id=(ideal)(u->Data());
3183  if (w!=NULL)
3184  {
3185    if (!idTestHomModule(u_id,currRing->qideal,w))
3186    {
3187      WarnS("wrong weights:");w->show();PrintLn();
3188      w=NULL;
3189    }
3190    else
3191    {
3192      w=ivCopy(w);
3193      hom=isHomog;
3194    }
3195  }
3196  result=kStd(u_id,currRing->qideal,hom,&w,(intvec *)v->Data());
3197  idSkipZeroes(result);
3198  res->data = (char *)result;
3199  setFlag(res,FLAG_STD);
3200  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3201  return FALSE;
3202}
3203static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
3204{
3205  ideal result;
3206  assumeStdFlag(u);
3207  ideal i1=(ideal)(u->Data());
3208  ideal i0;
3209  int r=v->Typ();
3210  if ((/*v->Typ()*/r==POLY_CMD) ||(r==VECTOR_CMD))
3211  {
3212    i0=idInit(1,i1->rank); // TODO: rank is wrong (if v is a vector!)
3213    i0->m[0]=(poly)v->Data();
3214    int ii0=idElem(i0); /* size of i0 */
3215    i1=idSimpleAdd(i1,i0); //
3216    memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3217    idDelete(&i0);
3218    intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3219    tHomog hom=testHomog;
3220
3221    if (w!=NULL)
3222    {
3223      if (!idTestHomModule(i1,currRing->qideal,w))
3224      {
3225        // no warnung: this is legal, if i in std(i,p)
3226        // is homogeneous, but p not
3227        w=NULL;
3228      }
3229      else
3230      {
3231        w=ivCopy(w);
3232        hom=isHomog;
3233      }
3234    }
3235    BITSET save1;
3236    SI_SAVE_OPT1(save1);
3237    si_opt_1|=Sy_bit(OPT_SB_1);
3238    /* ii0 appears to be the position of the first element of il that
3239       does not belong to the old SB ideal */
3240    result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii0);
3241    SI_RESTORE_OPT1(save1);
3242    idDelete(&i1);
3243    idSkipZeroes(result);
3244    if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3245    res->data = (char *)result;
3246  }
3247  else /*IDEAL/MODULE*/
3248  {
3249    i0=(ideal)v->CopyD();
3250    int ii0=idElem(i0); /* size of i0 */
3251    i1=idSimpleAdd(i1,i0); //
3252    memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3253    idDelete(&i0);
3254    intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3255    tHomog hom=testHomog;
3256
3257    if (w!=NULL)
3258    {
3259      if (!idTestHomModule(i1,currRing->qideal,w))
3260      {
3261        // no warnung: this is legal, if i in std(i,p)
3262        // is homogeneous, but p not
3263        w=NULL;
3264      }
3265      else
3266      {
3267        w=ivCopy(w);
3268        hom=isHomog;
3269      }
3270    }
3271    if (ii0*4 >= 3*IDELEMS(i1)) // MAGIC: add few poly to large SB: 3/4
3272    {
3273      BITSET save1;
3274      SI_SAVE_OPT1(save1);
3275      si_opt_1|=Sy_bit(OPT_SB_1);
3276      /* ii0 appears to be the position of the first element of il that
3277       does not belong to the old SB ideal */
3278      result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii0);
3279      SI_RESTORE_OPT1(save1);
3280    }
3281    else
3282    {
3283      result=kStd(i1,currRing->qideal,hom,&w);
3284    }
3285    idDelete(&i1);
3286    idSkipZeroes(result);
3287    if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3288    res->data = (char *)result;
3289  }
3290  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
3291  return FALSE;
3292}
3293static BOOLEAN jjSYZ_2(leftv res, leftv u, leftv v)
3294{
3295  // see jjSYZYGY
3296  intvec *w=NULL;
3297  ideal I=(ideal)u->Data();
3298  GbVariant alg=syGetAlgorithm((char*)v->Data(),currRing,I);
3299  res->data = (char *)idSyzygies(I,testHomog,&w,TRUE,FALSE,NULL,alg);
3300  if (w!=NULL) delete w;
3301  if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
3302  return FALSE;
3303
3304}
3305static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
3306{
3307  idhdl h=(idhdl)u->data;
3308  int i=(int)(long)v->Data();
3309  if ((0<i) && (i<=IDRING(h)->N))
3310    res->data=omStrDup(IDRING(h)->names[i-1]);
3311  else
3312  {
3313    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
3314    return TRUE;
3315  }
3316  return FALSE;
3317}
3318static BOOLEAN jjWAIT1ST2(leftv res, leftv u, leftv v)
3319{
3320// input: u: a list with links of type
3321//           ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
3322//        v: timeout for select in milliseconds
3323//           or 0 for polling
3324// returns: ERROR (via Werror): timeout negative
3325//           -1: the read state of all links is eof
3326//            0: timeout (or polling): none ready
3327//           i>0: (at least) L[i] is ready
3328  lists Lforks = (lists)u->Data();
3329  int t = (int)(long)v->Data();
3330  if(t < 0)
3331  {
3332    WerrorS("negative timeout"); return TRUE;
3333  }
3334  int i = slStatusSsiL(Lforks, t*1000);
3335  if(i == -2) /* error */
3336  {
3337    return TRUE;
3338  }
3339  res->data = (void*)(long)i;
3340  return FALSE;
3341}
3342static BOOLEAN jjWAITALL2(leftv res, leftv u, leftv v)
3343{
3344// input: u: a list with links of type
3345//           ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
3346//        v: timeout for select in milliseconds
3347//           or 0 for polling
3348// returns: ERROR (via Werror): timeout negative
3349//           -1: the read state of all links is eof
3350//           0: timeout (or polling): none ready
3351//           1: all links are ready
3352//              (caution: at least one is ready, but some maybe dead)
3353  lists Lforks = (lists)u->CopyD();
3354  int timeout = 1000*(int)(long)v->Data();
3355  if(timeout < 0)
3356  {
3357    WerrorS("negative timeout"); return TRUE;
3358  }
3359  int t = getRTimer()/TIMER_RESOLUTION;  // in seconds
3360  int i;
3361  int ret = -1;
3362  for(unsigned nfinished = 0; nfinished < ((unsigned)Lforks->nr)+1; nfinished++)
3363  {
3364    i = slStatusSsiL(Lforks, timeout);
3365    if(i > 0) /* Lforks[i] is ready */
3366    {
3367      ret = 1;
3368      Lforks->m[i-1].CleanUp();
3369      Lforks->m[i-1].rtyp=DEF_CMD;
3370      Lforks->m[i-1].data=NULL;
3371      timeout = si_max(0,timeout - 1000*(getRTimer()/TIMER_RESOLUTION - t));
3372    }
3373    else /* terminate the for loop */
3374    {
3375      if(i == -2) /* error */
3376      {
3377        return TRUE;
3378      }
3379      if(i == 0) /* timeout */
3380      {
3381        ret = 0;
3382      }
3383      break;
3384    }
3385  }
3386  Lforks->Clean();
3387  res->data = (void*)(long)ret;
3388  return FALSE;
3389}
3390static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
3391{
3392  res->data = (char *)mp_Wedge((matrix)u->Data(),(int)(long)v->Data(),currRing);
3393  return FALSE;
3394}
3395#define jjWRONG2 (proc2)jjWRONG
3396#define jjWRONG3 (proc3)jjWRONG
3397static BOOLEAN jjWRONG(leftv, leftv)
3398{
3399  return TRUE;
3400}
3401
3402/*=================== operations with 1 arg.: static proc =================*/
3403/* must be ordered: first operations for chars (infix ops),
3404 * then alphabetically */
3405
3406static BOOLEAN jjDUMMY(leftv res, leftv u)
3407{
3408  res->data = (char *)u->CopyD();
3409  return FALSE;
3410}
3411static BOOLEAN jjNULL(leftv, leftv)
3412{
3413  return FALSE;
3414}
3415//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3416//{
3417//  res->data = (char *)((int)(long)u->Data()+1);
3418//  return FALSE;
3419//}
3420//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3421//{
3422//  res->data = (char *)((int)(long)u->Data()-1);
3423//  return FALSE;
3424//}
3425static BOOLEAN jjPLUSPLUS(leftv, leftv u)
3426{
3427  if (IDTYP((idhdl)u->data)==INT_CMD)
3428  {
3429    int i=IDINT((idhdl)u->data);
3430    if (iiOp==PLUSPLUS) i++;
3431    else                i--;
3432    IDDATA((idhdl)u->data)=(char *)(long)i;
3433    return FALSE;
3434  }
3435  return TRUE;
3436}
3437static BOOLEAN jjUMINUS_BI(leftv res, leftv u)
3438{
3439  number n=(number)u->CopyD(BIGINT_CMD);
3440  n=n_InpNeg(n,coeffs_BIGINT);
3441  res->data = (char *)n;
3442  return FALSE;
3443}
3444static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3445{
3446  res->data = (char *)(-(long)u->Data());
3447  return FALSE;
3448}
3449static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3450{
3451  number n=(number)u->CopyD(NUMBER_CMD);
3452  n=nInpNeg(n);
3453  res->data = (char *)n;
3454  return FALSE;
3455}
3456static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3457{
3458  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3459  return FALSE;
3460}
3461static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3462{
3463  poly m1=pISet(-1);
3464  res->data = (char *)mp_MultP((matrix)u->CopyD(MATRIX_CMD),m1,currRing);
3465  return FALSE;
3466}
3467static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3468{
3469  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3470  (*iv)*=(-1);
3471  res->data = (char *)iv;
3472  return FALSE;
3473}
3474static BOOLEAN jjUMINUS_BIM(leftv res, leftv u)
3475{
3476  bigintmat *bim=(bigintmat *)u->CopyD(BIGINTMAT_CMD);
3477  (*bim)*=(-1);
3478  res->data = (char *)bim;
3479  return FALSE;
3480}
3481// dummy for python_module.so and similiar
3482static BOOLEAN jjSetRing(leftv, leftv u)
3483{
3484  if (u->rtyp==IDHDL) rSetHdl((idhdl)u->data);
3485  else
3486  {
3487    ring r=(ring)u->Data();
3488    idhdl h=rFindHdl(r,NULL);
3489    if (h==NULL)
3490    {
3491      char name_buffer[100];
3492      static int ending=1000000;
3493      ending++;
3494      sprintf(name_buffer, "PYTHON_RING_VAR%d",ending);
3495      h=enterid(name_buffer,0,RING_CMD,&IDROOT);
3496      IDRING(h)=r;
3497      r->ref++;
3498    }
3499    rSetHdl(h);
3500  }
3501  return FALSE;
3502}
3503static BOOLEAN jjPROC1(leftv res, leftv u)
3504{
3505  return jjPROC(res,u,NULL);
3506}
3507static BOOLEAN jjBAREISS(leftv res, leftv v)
3508{
3509  //matrix m=(matrix)v->Data();
3510  //lists l=mpBareiss(m,FALSE);
3511  intvec *iv;
3512  ideal m;
3513  sm_CallBareiss((ideal)v->Data(),0,0,m,&iv, currRing);
3514  lists l=(lists)omAllocBin(slists_bin);
3515  l->Init(2);
3516  l->m[0].rtyp=MODUL_CMD;
3517  l->m[1].rtyp=INTVEC_CMD;
3518  l->m[0].data=(void *)m;
3519  l->m[1].data=(void *)iv;
3520  res->data = (char *)l;
3521  return FALSE;
3522}
3523//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3524//{
3525//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3526//  ivTriangMat(m);
3527//  res->data = (char *)m;
3528//  return FALSE;
3529//}
3530static BOOLEAN jjBAREISS_BIM(leftv res, leftv v)
3531{
3532  bigintmat *b=(bigintmat*)v->CopyD(BIGINTMAT_CMD);
3533  b->hnf();
3534  res->data=(char*)b;
3535  return FALSE;
3536}
3537static BOOLEAN jjBI2N(leftv res, leftv u)
3538{
3539  BOOLEAN bo=FALSE;
3540  number n=(number)u->CopyD();
3541  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
3542  if (nMap!=NULL)
3543    res->data=nMap(n,coeffs_BIGINT,currRing->cf);
3544  else
3545  {
3546    Werror("cannot convert bigint to cring %s", nCoeffName(currRing->cf));
3547    bo=TRUE;
3548  }
3549  n_Delete(&n,coeffs_BIGINT);
3550  return bo;
3551}
3552static BOOLEAN jjBI2IM(leftv res, leftv u)
3553{
3554  bigintmat *b=(bigintmat*)u->Data();
3555  res->data=(void *)bim2iv(b);
3556  return FALSE;
3557}
3558static BOOLEAN jjBI2P(leftv res, leftv u)
3559{
3560  sleftv tmp;
3561  BOOLEAN bo=jjBI2N(&tmp,u);
3562  if (!bo)
3563  {
3564    number n=(number) tmp.data;
3565    if (nIsZero(n)) { res->data=NULL;nDelete(&n); }
3566    else
3567    {
3568      res->data=(void *)pNSet(n);
3569    }
3570  }
3571  return bo;
3572}
3573static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3574{
3575  return iiExprArithM(res,u,iiOp);
3576}
3577static BOOLEAN jjCHAR(leftv res, leftv v)
3578{
3579  res->data = (char *)(long)rChar((ring)v->Data());
3580  return FALSE;
3581}
3582static BOOLEAN jjCOLS(leftv res, leftv v)
3583{
3584  res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3585  return FALSE;
3586}
3587static BOOLEAN jjCOLS_BIM(leftv res, leftv v)
3588{
3589  res->data = (char *)(long)((bigintmat*)(v->Data()))->cols();
3590  return FALSE;
3591}
3592static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3593{
3594  res->data = (char *)(long)((intvec*)(v->Data()))->cols();
3595  return FALSE;
3596}
3597static BOOLEAN jjCONTENT(leftv res, leftv v)
3598{
3599  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3600  poly p=(poly)v->CopyD(POLY_CMD);
3601  if (p!=NULL) p_Cleardenom(p, currRing);
3602  res->data = (char *)p;
3603  return FALSE;
3604}
3605static BOOLEAN jjCOUNT_BI(leftv res, leftv v)
3606{
3607  res->data = (char *)(long)n_Size((number)v->Data(),coeffs_BIGINT);
3608  return FALSE;
3609}
3610static BOOLEAN jjCOUNT_BIM(leftv res, leftv v)
3611{
3612  bigintmat* aa= (bigintmat *)v->Data();
3613  res->data = (char *)(long)(aa->rows()*aa->cols());
3614  return FALSE;
3615}
3616static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3617{
3618  res->data = (char *)(long)nSize((number)v->Data());
3619  return FALSE;
3620}
3621static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3622{
3623  lists l=(lists)v->Data();
3624  res->data = (char *)(long)(lSize(l)+1);
3625  return FALSE;
3626}
3627static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3628{
3629  matrix m=(matrix)v->Data();
3630  res->data = (char *)(long)(MATROWS(m)*MATCOLS(m));
3631  return FALSE;
3632}
3633static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3634{
3635  res->data = (char *)(long)((intvec*)(v->Data()))->length();
3636  return FALSE;
3637}
3638static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3639{
3640  ring r=(ring)v->Data();
3641  int elems=-1;
3642  if (rField_is_Zp(r))      elems=r->cf->ch;
3643  else if (rField_is_GF(r)) elems=r->cf->m_nfCharQ;
3644  else if (rField_is_Zp_a(r) && (r->cf->type==n_algExt))
3645  {
3646    extern int ipower ( int b, int n ); /* factory/cf_util */
3647    elems=ipower(r->cf->ch,r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
3648  }
3649  res->data = (char *)(long)elems;
3650  return FALSE;
3651}
3652static BOOLEAN jjDEG(leftv res, leftv v)
3653{
3654  int dummy;
3655  poly p=(poly)v->Data();
3656  if (p!=NULL) res->data = (char *)currRing->pLDeg(p,&dummy,currRing);
3657  else res->data=(char *)-1;
3658  return FALSE;
3659}
3660static BOOLEAN jjDEG_M(leftv res, leftv u)
3661{
3662  ideal I=(ideal)u->Data();
3663  int d=-1;
3664  int dummy;
3665  int i;
3666  for(i=IDELEMS(I)-1;i>=0;i--)
3667    if (I->m[i]!=NULL) d=si_max(d,(int)currRing->pLDeg(I->m[i],&dummy,currRing));
3668  res->data = (char *)(long)d;
3669  return FALSE;
3670}
3671static BOOLEAN jjDEGREE(leftv res, leftv v)
3672{
3673  SPrintStart();
3674#ifdef HAVE_RINGS
3675  if (rField_is_Ring_Z(currRing))
3676  {
3677    PrintS("// NOTE: computation of degree is being performed for\n");
3678    PrintS("//       generic fibre, that is, over Q\n");
3679  }
3680#endif
3681  assumeStdFlag(v);
3682  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3683  scDegree((ideal)v->Data(),module_w,currRing->qideal);
3684  char *s=SPrintEnd();
3685  int l=strlen(s)-1;
3686  s[l]='\0';
3687  res->data=(void*)s;
3688  return FALSE;
3689}
3690static BOOLEAN jjDEFINED(leftv res, leftv v)
3691{
3692  if ((v->rtyp==IDHDL)
3693  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3694  {
3695    res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3696  }
3697  else if (v->rtyp!=0) res->data=(void *)(-1);
3698  return FALSE;
3699}
3700
3701/// Return the denominator of the input number
3702/// NOTE: the input number is normalized as a side effect
3703static BOOLEAN jjDENOMINATOR(leftv res, leftv v)
3704{
3705  number n = reinterpret_cast<number>(v->Data());
3706  res->data = reinterpret_cast<void*>(n_GetDenom(n, currRing->cf));
3707  return FALSE;
3708}
3709
3710/// Return the numerator of the input number
3711/// NOTE: the input number is normalized as a side effect
3712static BOOLEAN jjNUMERATOR(leftv res, leftv v)
3713{
3714  number n = reinterpret_cast<number>(v->Data());
3715  res->data = reinterpret_cast<void*>(n_GetNumerator(n, currRing->cf));
3716  return FALSE;
3717}
3718
3719static BOOLEAN jjDET(leftv res, leftv v)
3720{
3721  matrix m=(matrix)v->Data();
3722  poly p;
3723  if (sm_CheckDet((ideal)m,m->cols(),TRUE, currRing))
3724  {
3725    ideal I=id_Matrix2Module(mp_Copy(m, currRing),currRing);
3726    p=sm_CallDet(I, currRing);
3727    idDelete(&I);
3728  }
3729  else
3730    p=singclap_det(m,currRing);
3731  res ->data = (char *)p;
3732  return FALSE;
3733}
3734static BOOLEAN jjDET_BI(leftv res, leftv v)
3735{
3736  bigintmat * m=(bigintmat*)v->Data();
3737  int i,j;
3738  i=m->rows();j=m->cols();
3739  if(i==j)
3740    res->data = (char *)(long)singclap_det_bi(m,coeffs_BIGINT);
3741  else
3742  {
3743    Werror("det of %d x %d bigintmat",i,j);
3744    return TRUE;
3745  }
3746  return FALSE;
3747}
3748#ifdef SINGULAR_4_2
3749static BOOLEAN jjDET_N2(leftv res, leftv v)
3750{
3751  bigintmat * m=(bigintmat*)v->Data();
3752  number2 r=(number2)omAlloc0(sizeof(*r));
3753  int i,j;
3754  i=m->rows();j=m->cols();
3755  if(i==j)
3756  {
3757    r->n=m->det();
3758    r->cf=m->basecoeffs();
3759  }
3760  else
3761  {
3762    omFreeSize(r,sizeof(*r));
3763    Werror("det of %d x %d cmatrix",i,j);
3764    return TRUE;
3765  }
3766  res->data=(void*)r;
3767  return FALSE;
3768}
3769#endif
3770static BOOLEAN jjDET_I(leftv res, leftv v)
3771{
3772  intvec * m=(intvec*)v->Data();
3773  int i,j;
3774  i=m->rows();j=m->cols();
3775  if(i==j)
3776    res->data = (char *)(long)singclap_det_i(m,currRing);
3777  else
3778  {
3779    Werror("det of %d x %d intmat",i,j);
3780    return TRUE;
3781  }
3782  return FALSE;
3783}
3784static BOOLEAN jjDET_S(leftv res, leftv v)
3785{
3786  ideal I=(ideal)v->Data();
3787  poly p;
3788  if (IDELEMS(I)<1) return TRUE;
3789  if (sm_CheckDet(I,IDELEMS(I),FALSE, currRing))
3790  {
3791    matrix m=id_Module2Matrix(id_Copy(I,currRing),currRing);
3792    p=singclap_det(m,currRing);
3793    idDelete((ideal *)&m);
3794  }
3795  else
3796    p=sm_CallDet(I, currRing);
3797  res->data = (char *)p;
3798  return FALSE;
3799}
3800static BOOLEAN jjDIM(leftv res, leftv v)
3801{
3802  assumeStdFlag(v);
3803  if (rHasMixedOrdering(currRing))
3804  {
3805     Warn("dim(%s) may be wrong because the mixed monomial ordering",v->Name());
3806  }
3807#ifdef HAVE_RINGS
3808  if (rField_is_Ring(currRing))
3809  {
3810    ideal vid = (ideal)v->Data();
3811    int i = idPosConstant(vid);
3812    if ((i != -1) && (n_IsUnit(pGetCoeff(vid->m[i]),currRing->cf)))
3813    { /* ideal v contains unit; dim = -1 */
3814      res->data = (char *)-1L;
3815      return FALSE;
3816    }
3817    ideal vv = id_Head(vid,currRing);
3818    idSkipZeroes(vv);
3819    int j = idPosConstant(vv);
3820    long d;
3821    if(j == -1)
3822    {
3823      d = (long)scDimInt(vv, currRing->qideal);
3824      if(rField_is_Ring_Z(currRing))
3825        d++;
3826    }
3827    else
3828    {
3829      if(n_IsUnit(pGetCoeff(vv->m[j]),currRing->cf))
3830        d = -1;
3831      else
3832        d = (long)scDimInt(vv, currRing->qideal);
3833    }
3834    //Anne's Idea for std(4,2x) = 0 bug
3835    long dcurr = d;
3836    for(unsigned ii=0;ii<(unsigned)IDELEMS(vv);ii++)
3837    {
3838      if(vv->m[ii] != NULL && !n_IsUnit(pGetCoeff(vv->m[ii]),currRing->cf))
3839      {
3840        ideal vc = idCopy(vv);
3841        poly c = pInit();
3842        pSetCoeff0(c,nCopy(pGetCoeff(vv->m[ii])));
3843        idInsertPoly(vc,c);
3844        idSkipZeroes(vc);
3845        for(unsigned jj = 0;jj<(unsigned)IDELEMS(vc)-1;jj++)
3846        {
3847          if((vc->m[jj]!=NULL)
3848          && (n_DivBy(pGetCoeff(vc->m[jj]),pGetCoeff(c),currRing->cf)))
3849          {
3850            pDelete(&vc->m[jj]);
3851          }
3852        }
3853        idSkipZeroes(vc);
3854        j = idPosConstant(vc);
3855        if (j != -1) pDelete(&vc->m[j]);
3856        dcurr = (long)scDimInt(vc, currRing->qideal);
3857        // the following assumes the ground rings to be either zero- or one-dimensional
3858        if((j==-1) && rField_is_Ring_Z(currRing))
3859        {
3860          // should also be activated for other euclidean domains as groundfield
3861          dcurr++;
3862        }
3863        idDelete(&vc);
3864      }
3865      if(dcurr > d)
3866          d = dcurr;
3867    }
3868    res->data = (char *)d;
3869    idDelete(&vv);
3870    return FALSE;
3871  }
3872#endif
3873  res->data = (char *)(long)scDimInt((ideal)(v->Data()),currRing->qideal);
3874  return FALSE;
3875}
3876static BOOLEAN jjDUMP(leftv, leftv v)
3877{
3878  si_link l = (si_link)v->Data();
3879  if (slDump(l))
3880  {
3881    const char *s;
3882    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3883    else                            s=sNoName_fe;
3884    Werror("cannot dump to `%s`",s);
3885    return TRUE;
3886  }
3887  else
3888    return FALSE;
3889}
3890static BOOLEAN jjE(leftv res, leftv v)
3891{
3892  res->data = (char *)pOne();
3893  int co=(int)(long)v->Data();
3894  if (co>0)
3895  {
3896    pSetComp((poly)res->data,co);
3897    pSetm((poly)res->data);
3898  }
3899  else WerrorS("argument of gen must be positive");
3900  return (co<=0);
3901}
3902static BOOLEAN jjEXECUTE(leftv, leftv v)
3903{
3904  char * d = (char *)v->Data();
3905  char * s = (char *)omAlloc(strlen(d) + 13);
3906  strcpy( s, (char *)d);
3907  strcat( s, "\n;RETURN();\n");
3908  newBuffer(s,BT_execute);
3909  return yyparse();
3910}
3911static BOOLEAN jjFACSTD(leftv res, leftv v)
3912{
3913  lists L=(lists)omAllocBin(slists_bin);
3914  if (currRing->cf->convSingNFactoryN!=NULL) /* conversion to factory*/
3915  {
3916    ideal_list p,h;
3917    h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3918    if (h==NULL)
3919    {
3920      L->Init(1);
3921      L->m[0].data=(char *)idInit(1);
3922      L->m[0].rtyp=IDEAL_CMD;
3923    }
3924    else
3925    {
3926      p=h;
3927      int l=0;
3928      while (p!=NULL) { p=p->next;l++; }
3929      L->Init(l);
3930      l=0;
3931      while(h!=NULL)
3932      {
3933        L->m[l].data=(char *)h->d;
3934        L->m[l].rtyp=IDEAL_CMD;
3935        p=h->next;
3936        omFreeSize(h,sizeof(*h));
3937        h=p;
3938        l++;
3939      }
3940    }
3941  }
3942  else
3943  {
3944    WarnS("no factorization implemented");
3945    L->Init(1);
3946    iiExprArith1(&(L->m[0]),v,STD_CMD);
3947  }
3948  res->data=(void *)L;
3949  return FALSE;
3950}
3951static BOOLEAN jjFAC_P(leftv res, leftv u)
3952{
3953  intvec *v=NULL;
3954  singclap_factorize_retry=0;
3955  ideal f=singclap_factorize((poly)(u->CopyD()), &v, 0,currRing);
3956  if (f==NULL) return TRUE;
3957  ivTest(v);
3958  lists l=(lists)omAllocBin(slists_bin);
3959  l->Init(2);
3960  l->m[0].rtyp=IDEAL_CMD;
3961  l->m[0].data=(void *)f;
3962  l->m[1].rtyp=INTVEC_CMD;
3963  l->m[1].data=(void *)v;
3964  res->data=(void *)l;
3965  return FALSE;
3966}
3967static BOOLEAN jjGETDUMP(leftv, leftv v)
3968{
3969  si_link l = (si_link)v->Data();
3970  if (slGetDump(l))
3971  {
3972    const char *s;
3973    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3974    else                            s=sNoName_fe;
3975    Werror("cannot get dump from `%s`",s);
3976    return TRUE;
3977  }
3978  else
3979    return FALSE;
3980}
3981static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3982{
3983  assumeStdFlag(v);
3984  ideal I=(ideal)v->Data();
3985  res->data=(void *)iiHighCorner(I,0);
3986  return FALSE;
3987}
3988static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3989{
3990  assumeStdFlag(v);
3991  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3992  BOOLEAN delete_w=FALSE;
3993  ideal I=(ideal)v->Data();
3994  int i;
3995  poly p=NULL,po=NULL;
3996  int rk=id_RankFreeModule(I,currRing);
3997  if (w==NULL)
3998  {
3999    w = new intvec(rk);
4000    delete_w=TRUE;
4001  }
4002  for(i=rk;i>0;i--)
4003  {
4004    p=iiHighCorner(I,i);
4005    if (p==NULL)
4006    {
4007      WerrorS("module must be zero-dimensional");
4008      if (delete_w) delete w;
4009      return TRUE;
4010    }
4011    if (po==NULL)
4012    {
4013      po=p;
4014    }
4015    else
4016    {
4017      // now po!=NULL, p!=NULL
4018      int d=(currRing->pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - currRing->pFDeg(p,currRing)+(*w)[i-1]);
4019      if (d==0)
4020        d=pLmCmp(po,p);
4021      if (d > 0)
4022      {
4023        pDelete(&p);
4024      }
4025      else // (d < 0)
4026      {
4027        pDelete(&po); po=p;
4028      }
4029    }
4030  }
4031  if (delete_w) delete w;
4032  res->data=(void *)po;
4033  return FALSE;
4034}
4035static BOOLEAN jjHILBERT(leftv, leftv v)
4036{
4037#ifdef HAVE_RINGS
4038  if (rField_is_Ring_Z(currRing))
4039  {
4040    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
4041    PrintS("//       performed for generic fibre, that is, over Q\n");
4042  }
4043#endif
4044  assumeStdFlag(v);
4045  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4046  //scHilbertPoly((ideal)v->Data(),currRing->qideal);
4047  hLookSeries((ideal)v->Data(),module_w,currRing->qideal);
4048  return FALSE;
4049}
4050static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
4051{
4052#ifdef HAVE_RINGS
4053  if (rField_is_Ring_Z(currRing))
4054  {
4055    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
4056    PrintS("//       performed for generic fibre, that is, over Q\n");
4057  }
4058#endif
4059  res->data=(void *)hSecondSeries((intvec *)v->Data());
4060  return FALSE;
4061}
4062static BOOLEAN jjHOMOG1(leftv res, leftv v)
4063{
4064  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4065  ideal v_id=(ideal)v->Data();
4066  if (w==NULL)
4067  {
4068    res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
4069    if (res->data!=NULL)
4070    {
4071      if (v->rtyp==IDHDL)
4072      {
4073        char *s_isHomog=omStrDup("isHomog");
4074        if (v->e==NULL)
4075          atSet((idhdl)(v->data),s_isHomog,w,INTVEC_CMD);
4076        else
4077          atSet((idhdl)(v->LData()),s_isHomog,w,INTVEC_CMD);
4078      }
4079      else if (w!=NULL) delete w;
4080    } // if res->data==NULL then w==NULL
4081  }
4082  else
4083  {
4084    res->data=(void *)(long)idTestHomModule(v_id,currRing->qideal,w);
4085    if((res->data==NULL) && (v->rtyp==IDHDL))
4086    {
4087      if (v->e==NULL)
4088        atKill((idhdl)(v->data),"isHomog");
4089      else
4090        atKill((idhdl)(v->LData()),"isHomog");
4091    }
4092  }
4093  return FALSE;
4094}
4095static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4096{
4097  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4098  setFlag(res,FLAG_STD);
4099  return FALSE;
4100}
4101static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
4102{
4103  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
4104  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
4105  if (IDELEMS((ideal)mat)==0)
4106  {
4107    idDelete((ideal *)&mat);
4108    mat=(matrix)idInit(1,1);
4109  }
4110  else
4111  {
4112    MATROWS(mat)=1;
4113    mat->rank=1;
4114    idTest((ideal)mat);
4115  }
4116  res->data=(char *)mat;
4117  return FALSE;
4118}
4119static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
4120{
4121  map m=(map)v->CopyD(MAP_CMD);
4122  omFree((ADDRESS)m->preimage);
4123  m->preimage=NULL;
4124  ideal I=(ideal)m;
4125  I->rank=1;
4126  res->data=(char *)I;
4127  return FALSE;
4128}
4129static BOOLEAN jjIDEAL_R(leftv res, leftv v)
4130{
4131  if (currRing!=NULL)
4132  {
4133    ring q=(ring)v->Data();
4134    if (rSamePolyRep(currRing, q))
4135    {
4136      if (q->qideal==NULL)
4137        res->data=(char *)idInit(1,1);
4138      else
4139        res->data=(char *)idCopy(q->qideal);
4140      return FALSE;
4141    }
4142  }
4143  WerrorS("can only get ideal from identical qring");
4144  return TRUE;
4145}
4146static BOOLEAN jjIm2Iv(leftv res, leftv v)
4147{
4148  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
4149  iv->makeVector();
4150  res->data = iv;
4151  return FALSE;
4152}
4153static BOOLEAN jjIMPART(leftv res, leftv v)
4154{
4155  res->data = (char *)n_ImPart((number)v->Data(),currRing->cf);
4156  return FALSE;
4157}
4158static BOOLEAN jjINDEPSET(leftv res, leftv v)
4159{
4160  assumeStdFlag(v);
4161  res->data=(void *)scIndIntvec((ideal)(v->Data()),currRing->qideal);
4162  return FALSE;
4163}
4164static BOOLEAN jjINTERRED(leftv res, leftv v)
4165{
4166  ideal result=kInterRed((ideal)(v->Data()), currRing->qideal);
4167#ifdef HAVE_RINGS
4168  if(rField_is_Ring(currRing))
4169    WarnS("interred: this command is experimental over the integers");
4170#endif
4171  if (TEST_OPT_PROT) { PrintLn(); mflush(); }
4172  res->data = result;
4173  return FALSE;
4174}
4175static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
4176{
4177  res->data = (char *)(long)pVar((poly)v->Data());
4178  return FALSE;
4179}
4180static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
4181{
4182  res->data = (char *)(long)(r_IsRingVar((char *)v->Data(), currRing->names,
4183                                                            currRing->N)+1);
4184  return FALSE;
4185}
4186static BOOLEAN jjIS_RINGVAR0(leftv res, leftv)
4187{
4188  res->data = (char *)0;
4189  return FALSE;
4190}
4191static BOOLEAN jjJACOB_P(leftv res, leftv v)
4192{
4193  ideal i=idInit(currRing->N,1);
4194  int k;
4195  poly p=(poly)(v->Data());
4196  for (k=currRing->N;k>0;k--)
4197  {
4198    i->m[k-1]=pDiff(p,k);
4199  }
4200  res->data = (char *)i;
4201  return FALSE;
4202}
4203static BOOLEAN jjDIFF_COEF(leftv res, leftv u, leftv v)
4204{
4205  if (!nCoeff_is_transExt(currRing->cf))
4206  {
4207    WerrorS("differentiation not defined in the coefficient ring");
4208    return TRUE;
4209  }
4210  number n = (number) u->Data();
4211  number k = (number) v->Data();
4212  res->data = ntDiff(n,k,currRing->cf);
4213  return FALSE;
4214}
4215/*2
4216 * compute Jacobi matrix of a module/matrix
4217 * Jacobi(M) := ( diff(Mt,var(1))|, ... ,| diff(Mt,var(currRing->N))  ),
4218 * where Mt := transpose(M)
4219 * Note that this is consistent with the current conventions for jacob in Singular,
4220 * whereas M2 computes its transposed.
4221 */
4222static BOOLEAN jjJACOB_M(leftv res, leftv a)
4223{
4224  ideal id = (ideal)a->Data();
4225  id = id_Transp(id,currRing);
4226  int W = IDELEMS(id);
4227
4228  ideal result = idInit(W * currRing->N, id->rank);
4229  poly *p = result->m;
4230
4231  for( int v = 1; v <= currRing->N; v++ )
4232  {
4233    poly* q = id->m;
4234    for( int i = 0; i < W; i++, p++, q++ )
4235      *p = pDiff( *q, v );
4236  }
4237  idDelete(&id);
4238
4239  res->data = (char *)result;
4240  return FALSE;
4241}
4242
4243
4244static BOOLEAN jjKBASE(leftv res, leftv v)
4245{
4246  assumeStdFlag(v);
4247  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currRing->qideal);
4248  return FALSE;
4249}
4250static BOOLEAN jjL2R(leftv res, leftv v)
4251{
4252  res->data=(char *)syConvList((lists)v->Data());
4253  if (res->data != NULL)
4254    return FALSE;
4255  else
4256    return TRUE;
4257}
4258static BOOLEAN jjLEADCOEF(leftv res, leftv v)
4259{
4260  poly p=(poly)v->Data();
4261  if (p==NULL)
4262  {
4263    res->data=(char *)nInit(0);
4264  }
4265  else
4266  {
4267    res->data=(char *)nCopy(pGetCoeff(p));
4268  }
4269  return FALSE;
4270}
4271static BOOLEAN jjLEADEXP(leftv res, leftv v)
4272{
4273  poly p=(poly)v->Data();
4274  int s=currRing->N;
4275  if (v->Typ()==VECTOR_CMD) s++;
4276  intvec *iv=new intvec(s);
4277  if (p!=NULL)
4278  {
4279    for(int i = currRing->N;i;i--)
4280    {
4281      (*iv)[i-1]=pGetExp(p,i);
4282    }
4283    if (s!=currRing->N)
4284      (*iv)[currRing->N]=pGetComp(p);
4285  }
4286  res->data=(char *)iv;
4287  return FALSE;
4288}
4289static BOOLEAN jjLEADMONOM(leftv res, leftv v)
4290{
4291  poly p=(poly)v->Data();
4292  if (p == NULL)
4293  {
4294    res->data = (char*) NULL;
4295  }
4296  else
4297  {
4298    poly lm = pLmInit(p);
4299    pSetCoeff0(lm, nInit(1));
4300    res->data = (char*) lm;
4301  }
4302  return FALSE;
4303}
4304static BOOLEAN jjLOAD1(leftv /*res*/, leftv v)
4305{
4306  return jjLOAD((char*)v->Data(),FALSE);
4307}
4308static BOOLEAN jjLISTRING(leftv res, leftv v)
4309{
4310  lists l=(lists)v->Data();
4311  long mm=(long)atGet(v,"maxExp",INT_CMD);
4312  if (mm==0) mm=0x7fff;
4313  ring r=rCompose((lists)v->Data(),TRUE,mm);
4314  res->data=(char *)r;
4315  return (r==NULL);
4316}
4317static BOOLEAN jjPFAC1(leftv res, leftv v)
4318{
4319  /* call method jjPFAC2 with second argument = 0 (meaning that no
4320     valid bound for the prime factors has been given) */
4321  sleftv tmp;
4322  memset(&tmp, 0, sizeof(tmp));
4323  tmp.rtyp = INT_CMD;
4324  return jjPFAC2(res, v, &tmp);
4325}
4326static BOOLEAN jjLU_DECOMP(leftv res, leftv v)
4327{
4328  /* computes the LU-decomposition of a matrix M;
4329     i.e., M = P * L * U, where
4330        - P is a row permutation matrix,
4331        - L is in lower triangular form,
4332        - U is in upper row echelon form
4333     Then, we also have P * M = L * U.
4334     A list [P, L, U] is returned. */
4335  matrix mat = (const matrix)v->Data();
4336  if (!idIsConstant((ideal)mat))
4337  {
4338    WerrorS("matrix must be constant");
4339    return TRUE;
4340  }
4341  matrix pMat;
4342  matrix lMat;
4343  matrix uMat;
4344
4345  luDecomp(mat, pMat, lMat, uMat);
4346
4347  lists ll = (lists)omAllocBin(slists_bin);
4348  ll->Init(3);
4349  ll->m[0].rtyp=MATRIX_CMD; ll->m[0].data=(void *)pMat;
4350  ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)lMat;
4351  ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)uMat;
4352  res->data=(char*)ll;
4353
4354  return FALSE;
4355}
4356static BOOLEAN jjMEMORY(leftv res, leftv v)
4357{
4358  // clean out "_":
4359  sLastPrinted.CleanUp();
4360  memset(&sLastPrinted,0,sizeof(sleftv));
4361  // collect all info:
4362  omUpdateInfo();
4363  switch(((int)(long)v->Data()))
4364  {
4365  case 0:
4366    res->data=(char *)n_Init(om_Info.UsedBytes,coeffs_BIGINT);
4367    break;
4368  case 1:
4369    res->data = (char *)n_Init(om_Info.CurrentBytesSystem,coeffs_BIGINT);
4370    break;
4371  case 2:
4372    res->data = (char *)n_Init(om_Info.MaxBytesSystem,coeffs_BIGINT);
4373    break;
4374  default:
4375    omPrintStats(stdout);
4376    omPrintInfo(stdout);
4377    omPrintBinStats(stdout);
4378    res->data = (char *)0;
4379    res->rtyp = NONE;
4380  }
4381  return FALSE;
4382  res->data = (char *)0;
4383  return FALSE;
4384}
4385//static BOOLEAN jjMONITOR1(leftv res, leftv v)
4386//{
4387//  return jjMONITOR2(res,v,NULL);
4388//}
4389static BOOLEAN jjMSTD(leftv res, leftv v)
4390{
4391  int t=v->Typ();
4392  ideal r,m;
4393  r=kMin_std((ideal)v->Data(),currRing->qideal,testHomog,NULL,m);
4394  lists l=(lists)omAllocBin(slists_bin);
4395  l->Init(2);
4396  l->m[0].rtyp=t;
4397  l->m[0].data=(char *)r;
4398  setFlag(&(l->m[0]),FLAG_STD);
4399  l->m[1].rtyp=t;
4400  l->m[1].data=(char *)m;
4401  res->data=(char *)l;
4402  return FALSE;
4403}
4404static BOOLEAN jjMULT(leftv res, leftv v)
4405{
4406  assumeStdFlag(v);
4407  res->data = (char *)(long)scMultInt((ideal)(v->Data()),currRing->qideal);
4408  return FALSE;
4409}
4410static BOOLEAN jjMINRES_R(leftv res, leftv v)
4411{
4412  intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4413
4414  syStrategy tmp=(syStrategy)v->Data();
4415  tmp = syMinimize(tmp); // enrich itself!
4416
4417  res->data=(char *)tmp;
4418
4419  if (weights!=NULL)
4420    atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
4421
4422  return FALSE;
4423}
4424static BOOLEAN jjN2BI(leftv res, leftv v)
4425{
4426  number n,i; i=(number)v->Data();
4427  nMapFunc nMap=n_SetMap(currRing->cf,coeffs_BIGINT);
4428  if (nMap!=NULL)
4429    n=nMap(i,currRing->cf,coeffs_BIGINT);
4430  else goto err;
4431  res->data=(void *)n;
4432  return FALSE;
4433err:
4434  WerrorS("cannot convert to bigint"); return TRUE;
4435}
4436static BOOLEAN jjNAMEOF(leftv res, leftv v)
4437{
4438  if ((v->rtyp==IDHDL)||(v->rtyp==ALIAS_CMD))
4439    res->data=omStrDup(v->name);
4440  else if (v->name==NULL)
4441    res->data=omStrDup("");
4442  else
4443  {
4444    res->data = (char *)v->name;
4445    v->name=NULL;
4446  }
4447  return FALSE;
4448}
4449static BOOLEAN jjNAMES(leftv res, leftv v)
4450{
4451  res->data=ipNameList(((ring)v->Data())->idroot);
4452  return FALSE;
4453}
4454static BOOLEAN jjNAMES_I(leftv res, leftv v)
4455{
4456  res->data=ipNameListLev((IDROOT),(int)(long)v->Data());
4457  return FALSE;
4458}
4459static BOOLEAN jjNOT(leftv res, leftv v)
4460{
4461  res->data=(char*)(long)((long)v->Data()==0 ? 1 : 0);
4462  return FALSE;
4463}
4464static BOOLEAN jjNVARS(leftv res, leftv v)
4465{
4466  res->data = (char *)(long)(((ring)(v->Data()))->N);
4467  return FALSE;
4468}
4469static BOOLEAN jjOpenClose(leftv, leftv v)
4470{
4471  si_link l=(si_link)v->Data();
4472  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN,v);
4473  else { slPrepClose(l); return slClose(l);}
4474}
4475static BOOLEAN jjORD(leftv res, leftv v)
4476{
4477  poly p=(poly)v->Data();
4478  res->data=(char *)( p==NULL ? -1 : currRing->pFDeg(p,currRing) );
4479  return FALSE;
4480}
4481static BOOLEAN jjPAR1(leftv res, leftv v)
4482{
4483  int i=(int)(long)v->Data();
4484  int p=0;
4485  p=rPar(currRing);
4486  if ((0<i) && (i<=p))
4487  {
4488    res->data=(char *)n_Param(i,currRing);
4489  }
4490  else
4491  {
4492    Werror("par number %d out of range 1..%d",i,p);
4493    return TRUE;
4494  }
4495  return FALSE;
4496}
4497static BOOLEAN jjPARDEG(leftv res, leftv v)
4498{
4499  number nn=(number)v->Data();
4500  res->data = (char *)(long)n_ParDeg(nn, currRing->cf);
4501  return FALSE;
4502}
4503static BOOLEAN jjPARSTR1(leftv res, leftv v)
4504{
4505  if (currRing==NULL)
4506  {
4507    WerrorS("no ring active");
4508    return TRUE;
4509  }
4510  int i=(int)(long)v->Data();
4511  int p=0;
4512  if ((0<i) && (rParameter(currRing)!=NULL) && (i<=(p=rPar(currRing))))
4513    res->data=omStrDup(rParameter(currRing)[i-1]);
4514  else
4515  {
4516    Werror("par number %d out of range 1..%d",i,p);
4517    return TRUE;
4518  }
4519  return FALSE;
4520}
4521static BOOLEAN jjP2BI(leftv res, leftv v)
4522{
4523  poly p=(poly)v->Data();
4524  if (p==NULL) { res->data=(char *)n_Init(0,coeffs_BIGINT); return FALSE; }
4525  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
4526  {
4527    WerrorS("poly must be constant");
4528    return TRUE;
4529  }
4530  number i=pGetCoeff(p);
4531  number n;
4532  nMapFunc nMap=n_SetMap(currRing->cf,coeffs_BIGINT);
4533  if (nMap!=NULL)
4534    n=nMap(i,currRing->cf,coeffs_BIGINT);
4535  else goto err;
4536  res->data=(void *)n;
4537  return FALSE;
4538err:
4539  WerrorS("cannot convert to bigint"); return TRUE;
4540}
4541static BOOLEAN jjP2I(leftv res, leftv v)
4542{
4543  poly p=(poly)v->Data();
4544  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
4545  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
4546  {
4547    WerrorS("poly must be constant");
4548    return TRUE;
4549  }
4550  res->data = (char *)(long)iin_Int(pGetCoeff(p),currRing->cf);
4551  return FALSE;
4552}
4553static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
4554{
4555  map mapping=(map)v->Data();
4556  syMake(res,omStrDup(mapping->preimage));
4557  return FALSE;
4558}
4559static BOOLEAN jjPRIME(leftv res, leftv v)
4560{
4561  int i = IsPrime((int)(long)(v->Data()));
4562  res->data = (char *)(long)(i > 1 ? i : 2);
4563  return FALSE;
4564}
4565static BOOLEAN jjPRUNE(leftv res, leftv v)
4566{
4567  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4568  ideal v_id=(ideal)v->Data();
4569  if (w!=NULL)
4570  {
4571    if (!idTestHomModule(v_id,currRing->qideal,w))
4572    {
4573      WarnS("wrong weights");
4574      w=NULL;
4575      // and continue at the non-homog case below
4576    }
4577    else
4578    {
4579      w=ivCopy(w);
4580      intvec **ww=&w;
4581      res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
4582      atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
4583      return FALSE;
4584    }
4585  }
4586  res->data = (char *)idMinEmbedding(v_id);
4587  return FALSE;
4588}
4589static BOOLEAN jjP2N(leftv res, leftv v)
4590{
4591  number n;
4592  poly p;
4593  if (((p=(poly)v->Data())!=NULL)
4594  && (pIsConstant(p)))
4595  {
4596    n=nCopy(pGetCoeff(p));
4597  }
4598  else
4599  {
4600    n=nInit(0);
4601  }
4602  res->data = (char *)n;
4603  return FALSE;
4604}
4605static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
4606{
4607  char *s= (char *)v->Data();
4608  // try system keywords
4609  for(unsigned i=0; i<sArithBase.nCmdUsed; i++)
4610  {
4611    //Print("test %d, >>%s<<, tab:>>%s<<\n",i,s,sArithBase.sCmds[i].name);
4612    if (strcmp(s, sArithBase.sCmds[i].name) == 0)
4613    {
4614      res->data = (char *)1;
4615      return FALSE;
4616    }
4617  }
4618  // try blackbox names
4619  int id;
4620  blackboxIsCmd(s,id);
4621  if (id>0)
4622  {
4623    res->data = (char *)1;
4624  }
4625  return FALSE;
4626}
4627static BOOLEAN jjRANK1(leftv res, leftv v)
4628{
4629  matrix m =(matrix)v->Data();
4630  int rank = luRank(m, 0);
4631  res->data =(char *)(long)rank;
4632  return FALSE;
4633}
4634static BOOLEAN jjREAD(leftv res, leftv v)
4635{
4636  return jjREAD2(res,v,NULL);
4637}
4638static BOOLEAN jjREGULARITY(leftv res, leftv v)
4639{
4640  res->data = (char *)(long)iiRegularity((lists)v->Data());
4641  return FALSE;
4642}
4643static BOOLEAN jjREPART(leftv res, leftv v)
4644{
4645  res->data = (char *)n_RePart((number)v->Data(),currRing->cf);
4646  return FALSE;
4647}
4648static BOOLEAN jjRINGLIST(leftv res, leftv v)
4649{
4650  ring r=(ring)v->Data();
4651  if (r!=NULL)
4652  {
4653    res->data = (char *)rDecompose((ring)v->Data());
4654    if (res->data!=NULL)
4655    {
4656      long mm=r->bitmask/2;
4657      if (mm>MAX_INT_VAL) mm=MAX_INT_VAL;
4658      atSet(res,omStrDup("maxExp"),(void*)mm,INT_CMD);
4659      return FALSE;
4660    }
4661  }
4662  return TRUE;
4663}
4664static BOOLEAN jjRINGLIST_C(leftv res, leftv v)
4665{
4666  coeffs r=(coeffs)v->Data();
4667  if (r!=NULL)
4668    return rDecompose_CF(res,r);
4669  return TRUE;
4670}
4671static BOOLEAN jjRING_LIST(leftv res, leftv v)
4672{
4673  ring r=(ring)v->Data();
4674  if (r!=NULL)
4675    res->data = (char *)rDecompose_list_cf((ring)v->Data());
4676  return (r==NULL)||(res->data==NULL);
4677}
4678static BOOLEAN jjROWS(leftv res, leftv v)
4679{
4680  ideal i = (ideal)v->Data();
4681  res->data = (char *)i->rank;
4682  return FALSE;
4683}
4684static BOOLEAN jjROWS_BIM(leftv res, leftv v)
4685{
4686  res->data = (char *)(long)((bigintmat*)(v->Data()))->rows();
4687  return FALSE;
4688}
4689static BOOLEAN jjROWS_IV(leftv res, leftv v)
4690{
4691  res->data = (char *)(long)((intvec*)(v->Data()))->rows();
4692  return FALSE;
4693}
4694static BOOLEAN jjRPAR(leftv res, leftv v)
4695{
4696  res->data = (char *)(long)rPar(((ring)v->Data()));
4697  return FALSE;
4698}
4699static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4700{
4701  const bool bIsSCA = rIsSCA(currRing);
4702
4703  if ((currRing->qideal!=NULL) && !bIsSCA)
4704  {
4705    WerrorS("qring not supported by slimgb at the moment");
4706    return TRUE;
4707  }
4708  if (rHasLocalOrMixedOrdering(currRing))
4709  {
4710    WerrorS("ordering must be global for slimgb");
4711    return TRUE;
4712  }
4713  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4714  // tHomog hom=testHomog;
4715  ideal u_id=(ideal)u->Data();
4716  if (w!=NULL)
4717  {
4718    if (!idTestHomModule(u_id,currRing->qideal,w))
4719    {
4720      WarnS("wrong weights");
4721      w=NULL;
4722    }
4723    else
4724    {
4725      w=ivCopy(w);
4726      // hom=isHomog;
4727    }
4728  }
4729
4730  assume(u_id->rank>=id_RankFreeModule(u_id, currRing));
4731  res->data=(char *)t_rep_gb(currRing,
4732    u_id,u_id->rank);
4733  //res->data=(char *)t_rep_gb(currRing, u_id);
4734
4735  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4736  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4737  return FALSE;
4738}
4739static BOOLEAN jjSBA(leftv res, leftv v)
4740{
4741  ideal result;
4742  ideal v_id=(ideal)v->Data();
4743  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4744  tHomog hom=testHomog;
4745  if (w!=NULL)
4746  {
4747    if (!idTestHomModule(v_id,currRing->qideal,w))
4748    {
4749      WarnS("wrong weights");
4750      w=NULL;
4751    }
4752    else
4753    {
4754      hom=isHomog;
4755      w=ivCopy(w);
4756    }
4757  }
4758  result=kSba(v_id,currRing->qideal,hom,&w,1,0);
4759  idSkipZeroes(result);
4760  res->data = (char *)result;
4761  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4762  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4763  return FALSE;
4764}
4765static BOOLEAN jjSBA_1(leftv res, leftv v, leftv u)
4766{
4767  ideal result;
4768  ideal v_id=(ideal)v->Data();
4769  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4770  tHomog hom=testHomog;
4771  if (w!=NULL)
4772  {
4773    if (!idTestHomModule(v_id,currRing->qideal,w))
4774    {
4775      WarnS("wrong weights");
4776      w=NULL;
4777    }
4778    else
4779    {
4780      hom=isHomog;
4781      w=ivCopy(w);
4782    }
4783  }
4784  result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),0);
4785  idSkipZeroes(result);
4786  res->data = (char *)result;
4787  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4788  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4789  return FALSE;
4790}
4791static BOOLEAN jjSBA_2(leftv res, leftv v, leftv u, leftv t)
4792{
4793  ideal result;
4794  ideal v_id=(ideal)v->Data();
4795  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4796  tHomog hom=testHomog;
4797  if (w!=NULL)
4798  {
4799    if (!idTestHomModule(v_id,currRing->qideal,w))
4800    {
4801      WarnS("wrong weights");
4802      w=NULL;
4803    }
4804    else
4805    {
4806      hom=isHomog;
4807      w=ivCopy(w);
4808    }
4809  }
4810  result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),(int)(long)t->Data());
4811  idSkipZeroes(result);
4812  res->data = (char *)result;
4813  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4814  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4815  return FALSE;
4816}
4817static BOOLEAN jjSTD(leftv res, leftv v)
4818{
4819  ideal result;
4820  ideal v_id=(ideal)v->Data();
4821  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4822  tHomog hom=testHomog;
4823  if (w!=NULL)
4824  {
4825    if (!idTestHomModule(v_id,currRing->qideal,w))
4826    {
4827      WarnS("wrong weights");
4828      w=NULL;
4829    }
4830    else
4831    {
4832      hom=isHomog;
4833      w=ivCopy(w);
4834    }
4835  }
4836  result=kStd(v_id,currRing->qideal,hom,&w);
4837  idSkipZeroes(result);
4838  res->data = (char *)result;
4839  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4840  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4841  return FALSE;
4842}
4843static BOOLEAN jjSort_Id(leftv res, leftv v)
4844{
4845  res->data = (char *)idSort((ideal)v->Data());
4846  return FALSE;
4847}
4848static BOOLEAN jjSQR_FREE(leftv res, leftv u)
4849{
4850  singclap_factorize_retry=0;
4851  intvec *v=NULL;
4852  ideal f=singclap_sqrfree((poly)(u->CopyD()), &v, 0, currRing);
4853  if (f==NULL) return TRUE;
4854  ivTest(v);
4855  lists l=(lists)omAllocBin(slists_bin);
4856  l->Init(2);
4857  l->m[0].rtyp=IDEAL_CMD;
4858  l->m[0].data=(void *)f;
4859  l->m[1].rtyp=INTVEC_CMD;
4860  l->m[1].data=(void *)v;
4861  res->data=(void *)l;
4862  return FALSE;
4863}
4864#if 1
4865static BOOLEAN jjSYZYGY(leftv res, leftv v)
4866{
4867  intvec *w=NULL;
4868  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4869  if (w!=NULL) delete w;
4870  if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
4871  return FALSE;
4872}
4873#else
4874// activate, if idSyz handle module weights correctly !
4875static BOOLEAN jjSYZYGY(leftv res, leftv v)
4876{
4877  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4878  ideal v_id=(ideal)v->Data();
4879  tHomog hom=testHomog;
4880  int add_row_shift=0;
4881  if (w!=NULL)
4882  {
4883    w=ivCopy(w);
4884    add_row_shift=w->min_in();
4885    (*w)-=add_row_shift;
4886    if (idTestHomModule(v_id,currRing->qideal,w))
4887      hom=isHomog;
4888    else
4889    {
4890      //WarnS("wrong weights");
4891      delete w; w=NULL;
4892      hom=testHomog;
4893    }
4894  }
4895  res->data = (char *)idSyzygies(v_id,hom,&w);
4896  if (w!=NULL)
4897  {
4898    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4899  }
4900  return FALSE;
4901}
4902#endif
4903static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4904{
4905  res->data = (char *)(long)ivTrace((intvec*)(v->Data()));
4906  return FALSE;
4907}
4908static BOOLEAN jjTRANSP_BIM(leftv res, leftv v)
4909{
4910  res->data = (char *)(((bigintmat*)(v->Data()))->transpose());
4911  return FALSE;
4912}
4913static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4914{
4915  res->data = (char *)ivTranp((intvec*)(v->Data()));
4916  return FALSE;
4917}
4918#ifdef HAVE_PLURAL
4919static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4920{
4921  ring    r = (ring)a->Data();
4922  //if (rIsPluralRing(r))
4923  if (r->OrdSgn==1)
4924  {
4925    res->data = rOpposite(r);
4926  }
4927  else
4928  {
4929    WarnS("opposite only for global orderings");
4930    res->data = rCopy(r);
4931  }
4932  return FALSE;
4933}
4934static BOOLEAN jjENVELOPE(leftv res, leftv a)
4935{
4936  ring    r = (ring)a->Data();
4937  if (rIsPluralRing(r))
4938  {
4939    ring s = rEnvelope(r);
4940    res->data = s;
4941  }
4942  else  res->data = rCopy(r);
4943  return FALSE;
4944}
4945static BOOLEAN jjTWOSTD(leftv res, leftv a)
4946{
4947  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
4948  else  res->data=(ideal)a->CopyD();
4949  setFlag(res,FLAG_STD);
4950  setFlag(res,FLAG_TWOSTD);
4951  return FALSE;
4952}
4953#endif
4954
4955static BOOLEAN jjTYPEOF(leftv res, leftv v)
4956{
4957  int t=(int)(long)v->data;
4958  switch (t)
4959  {
4960    case CRING_CMD:
4961    case INT_CMD:
4962    case POLY_CMD:
4963    case VECTOR_CMD:
4964    case STRING_CMD:
4965    case INTVEC_CMD:
4966    case IDEAL_CMD:
4967    case MATRIX_CMD:
4968    case MODUL_CMD:
4969    case MAP_CMD:
4970    case PROC_CMD:
4971    case RING_CMD:
4972    //case QRING_CMD:
4973    case INTMAT_CMD:
4974    case BIGINTMAT_CMD:
4975    case NUMBER_CMD:
4976    #ifdef SINGULAR_4_2
4977    case CNUMBER_CMD:
4978    #endif
4979    case BIGINT_CMD:
4980    case LIST_CMD:
4981    case PACKAGE_CMD:
4982    case LINK_CMD:
4983    case RESOLUTION_CMD:
4984         res->data=omStrDup(Tok2Cmdname(t)); break;
4985    case DEF_CMD:
4986    case NONE:           res->data=omStrDup("none"); break;
4987    default:
4988    {
4989      if (t>MAX_TOK)
4990        res->data=omStrDup(getBlackboxName(t));
4991      else
4992        res->data=omStrDup("?unknown type?");
4993      break;
4994    }
4995  }
4996  return FALSE;
4997}
4998static BOOLEAN jjUNIVARIATE(leftv res, leftv v)
4999{
5000  res->data=(char *)(long)pIsUnivariate((poly)v->Data());
5001  return FALSE;
5002}
5003static BOOLEAN jjVAR1(leftv res, leftv v)
5004{
5005  int i=(int)(long)v->Data();
5006  if ((0<i) && (i<=currRing->N))
5007  {
5008    poly p=pOne();
5009    pSetExp(p,i,1);
5010    pSetm(p);
5011    res->data=(char *)p;
5012  }
5013  else
5014  {
5015    Werror("var number %d out of range 1..%d",i,currRing->N);
5016    return TRUE;
5017  }
5018  return FALSE;
5019}
5020static BOOLEAN jjVARSTR1(leftv res, leftv v)
5021{
5022  if (currRing==NULL)
5023  {
5024    WerrorS("no ring active");
5025    return TRUE;
5026  }
5027  int i=(int)(long)v->Data();
5028  if ((0<i) && (i<=currRing->N))
5029    res->data=omStrDup(currRing->names[i-1]);
5030  else
5031  {
5032    Werror("var number %d out of range 1..%d",i,currRing->N);
5033    return TRUE;
5034  }
5035  return FALSE;
5036}
5037static BOOLEAN jjVDIM(leftv res, leftv v)
5038{
5039  assumeStdFlag(v);
5040  res->data = (char *)(long)scMult0Int((ideal)v->Data(),currRing->qideal);
5041  return FALSE;
5042}
5043BOOLEAN jjWAIT1ST1(leftv res, leftv u)
5044{
5045// input: u: a list with links of type
5046//           ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
5047// returns: -1:  the read state of all links is eof
5048//          i>0: (at least) u[i] is ready
5049  lists Lforks = (lists)u->Data();
5050  int i = slStatusSsiL(Lforks, -1);
5051  if(i == -2) /* error */
5052  {
5053    return TRUE;
5054  }
5055  res->data = (void*)(long)i;
5056  return FALSE;
5057}
5058BOOLEAN jjWAITALL1(leftv res, leftv u)
5059{
5060// input: u: a list with links of type
5061//           ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
5062// returns: -1: the read state of all links is eof
5063//           1: all links are ready
5064//              (caution: at least one is ready, but some maybe dead)
5065  lists Lforks = (lists)u->CopyD();
5066  int i;
5067  int j = -1;
5068  for(int nfinished = 0; nfinished < Lforks->nr+1; nfinished++)
5069  {
5070    i = slStatusSsiL(Lforks, -1);
5071    if(i == -2) /* error */
5072    {
5073      return TRUE;
5074    }
5075    if(i == -1)
5076    {
5077      break;
5078    }
5079    j = 1;
5080    Lforks->m[i-1].CleanUp();
5081    Lforks->m[i-1].rtyp=DEF_CMD;
5082    Lforks->m[i-1].data=NULL;
5083  }
5084  res->data = (void*)(long)j;
5085  Lforks->Clean();
5086  return FALSE;
5087}
5088
5089BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
5090{
5091  char libnamebuf[1024];
5092  lib_types LT = type_of_LIB(s, libnamebuf);
5093
5094#ifdef HAVE_DYNAMIC_LOADING
5095  extern BOOLEAN load_modules(const char *newlib, char *fullpath, BOOLEAN autoexport);
5096#endif /* HAVE_DYNAMIC_LOADING */
5097  switch(LT)
5098  {
5099      default:
5100      case LT_NONE:
5101        Werror("%s: unknown type", s);
5102        break;
5103      case LT_NOTFOUND:
5104        Werror("cannot open %s", s);
5105        break;
5106
5107      case LT_SINGULAR:
5108      {
5109        char *plib = iiConvName(s);
5110        idhdl pl = IDROOT->get(plib,0);
5111        if (pl==NULL)
5112        {
5113          pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
5114          IDPACKAGE(pl)->language = LANG_SINGULAR;
5115          IDPACKAGE(pl)->libname=omStrDup(s);
5116        }
5117        else if (IDTYP(pl)!=PACKAGE_CMD)
5118        {
5119          Werror("can not create package `%s`",plib);
5120          omFree(plib);
5121          return TRUE;
5122        }
5123        else /* package */
5124        {
5125          package pa=IDPACKAGE(pl);
5126          if ((pa->language==LANG_C)
5127          || (pa->language==LANG_MIX))
5128          {
5129            Werror("can not create package `%s` - binaries  exists",plib);
5130            omfree(plib);
5131            return TRUE;
5132          }
5133        }
5134        omFree(plib);
5135        package savepack=currPack;
5136        currPack=IDPACKAGE(pl);
5137        IDPACKAGE(pl)->loaded=TRUE;
5138        char libnamebuf[1024];
5139        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
5140        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
5141        currPack=savepack;
5142        IDPACKAGE(pl)->loaded=(!bo);
5143        return bo;
5144      }
5145      case LT_BUILTIN:
5146        SModulFunc_t iiGetBuiltinModInit(const char*);
5147        return load_builtin(s,autoexport, iiGetBuiltinModInit(s));
5148      case LT_MACH_O:
5149      case LT_ELF:
5150      case LT_HPUX:
5151#ifdef HAVE_DYNAMIC_LOADING
5152        return load_modules(s, libnamebuf, autoexport);
5153#else /* HAVE_DYNAMIC_LOADING */
5154        WerrorS("Dynamic modules are not supported by this version of Singular");
5155        break;
5156#endif /* HAVE_DYNAMIC_LOADING */
5157  }
5158  return TRUE;
5159}
5160static int WerrorS_dummy_cnt=0;
5161static void WerrorS_dummy(const char *)
5162{
5163  WerrorS_dummy_cnt++;
5164}
5165BOOLEAN jjLOAD_TRY(const char *s)
5166{
5167  void (*WerrorS_save)(const char *s) = WerrorS_callback;
5168  WerrorS_callback=WerrorS_dummy;
5169  WerrorS_dummy_cnt=0;
5170  BOOLEAN bo=jjLOAD(s,TRUE);
5171  if (TEST_OPT_PROT && (bo || (WerrorS_dummy_cnt>0)))
5172    Print("loading of >%s< failed\n",s);
5173  WerrorS_callback=WerrorS_save;
5174  errorreported=0;
5175  return FALSE;
5176}
5177
5178static BOOLEAN jjstrlen(leftv res, leftv v)
5179{
5180  res->data = (char *)strlen((char *)v->Data());
5181  return FALSE;
5182}
5183static BOOLEAN jjpLength(leftv res, leftv v)
5184{
5185  res->data = (char *)(long)pLength((poly)v->Data());
5186  return FALSE;
5187}
5188static BOOLEAN jjidElem(leftv res, leftv v)
5189{
5190  res->data = (char *)(long)idElem((ideal)v->Data());
5191  return FALSE;
5192}
5193static BOOLEAN jjidFreeModule(leftv res, leftv v)
5194{
5195  res->data = (char *)id_FreeModule((int)(long)v->Data(), currRing);
5196  return FALSE;
5197}
5198static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
5199{
5200  res->data = (char *)id_Vec2Ideal((poly)v->Data(), currRing);
5201  return FALSE;
5202}
5203static BOOLEAN jjrCharStr(leftv res, leftv v)
5204{
5205  res->data = rCharStr((ring)v->Data());
5206  return FALSE;
5207}
5208static BOOLEAN jjpHead(leftv res, leftv v)
5209{
5210  res->data = (char *)pHead((poly)v->Data());
5211  return FALSE;
5212}
5213static BOOLEAN jjidHead(leftv res, leftv v)
5214{
5215  res->data = (char *)id_Head((ideal)v->Data(),currRing);
5216  setFlag(res,FLAG_STD);
5217  return FALSE;
5218}
5219static BOOLEAN jjidMinBase(leftv res, leftv v)
5220{
5221  res->data = (char *)idMinBase((ideal)v->Data());
5222  return FALSE;
5223}
5224#if 0 // unused
5225static BOOLEAN jjsyMinBase(leftv res, leftv v)
5226{
5227  res->data = (char *)syMinBase((ideal)v->Data());
5228  return FALSE;
5229}
5230#endif
5231static BOOLEAN jjpMaxComp(leftv res, leftv v)
5232{
5233  res->data = (char *)pMaxComp((poly)v->Data());
5234  return FALSE;
5235}
5236static BOOLEAN jjmpTrace(leftv res, leftv v)
5237{
5238  res->data = (char *)mp_Trace((matrix)v->Data(),currRing);
5239  return FALSE;
5240}
5241static BOOLEAN jjmpTransp(leftv res, leftv v)
5242{
5243  res->data = (char *)mp_Transp((matrix)v->Data(),currRing);
5244  return FALSE;
5245}
5246static BOOLEAN jjrOrdStr(leftv res, leftv v)
5247{
5248  res->data = rOrdStr((ring)v->Data());
5249  return FALSE;
5250}
5251static BOOLEAN jjrVarStr(leftv res, leftv v)
5252{
5253  res->data = rVarStr((ring)v->Data());
5254  return FALSE;
5255}
5256static BOOLEAN jjrParStr(leftv res, leftv v)
5257{
5258  res->data = rParStr((ring)v->Data());
5259  return FALSE;
5260}
5261static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
5262{
5263  res->data=(char *)(long)sySize((syStrategy)v->Data());
5264  return FALSE;
5265}
5266static BOOLEAN jjDIM_R(leftv res, leftv v)
5267{
5268  res->data = (char *)(long)syDim((syStrategy)v->Data());
5269  return FALSE;
5270}
5271static BOOLEAN jjidTransp(leftv res, leftv v)
5272{
5273  res->data = (char *)id_Transp((ideal)v->Data(),currRing);
5274  return FALSE;
5275}
5276static BOOLEAN jjnInt(leftv res, leftv u)
5277{
5278  number n=(number)u->CopyD(); // n_Int may call n_Normalize
5279  res->data=(char *)(long)iin_Int(n,currRing->cf);
5280  n_Delete(&n,currRing->cf);
5281  return FALSE;
5282}
5283static BOOLEAN jjnlInt(leftv res, leftv u)
5284{
5285  number n=(number)u->Data();
5286  res->data=(char *)(long)iin_Int(n,coeffs_BIGINT );
5287  return FALSE;
5288}
5289/*=================== operations with 3 args.: static proc =================*/
5290/* must be ordered: first operations for chars (infix ops),
5291 * then alphabetically */
5292static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
5293{
5294  char *s= (char *)u->Data();
5295  int   r = (int)(long)v->Data();
5296  int   c = (int)(long)w->Data();
5297  int l = strlen(s);
5298
5299  if ( (r<1) || (r>l) || (c<0) )
5300  {
5301    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
5302    return TRUE;
5303  }
5304  res->data = (char *)omAlloc((long)(c+1));
5305  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
5306  return FALSE;
5307}
5308static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
5309{
5310  intvec *iv = (intvec *)u->Data();
5311  int   r = (int)(long)v->Data();
5312  int   c = (int)(long)w->Data();
5313  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
5314  {
5315    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
5316           r,c,u->Fullname(),iv->rows(),iv->cols());
5317    return TRUE;
5318  }
5319  res->data=u->data; u->data=NULL;
5320  res->rtyp=u->rtyp; u->rtyp=0;
5321  res->name=u->name; u->name=NULL;
5322  Subexpr e=jjMakeSub(v);
5323          e->next=jjMakeSub(w);
5324  if (u->e==NULL) res->e=e;
5325  else
5326  {
5327    Subexpr h=u->e;
5328    while (h->next!=NULL) h=h->next;
5329    h->next=e;
5330    res->e=u->e;
5331    u->e=NULL;
5332  }
5333  return FALSE;
5334}
5335static BOOLEAN jjBRACK_Bim(leftv res, leftv u, leftv v, leftv w)
5336{
5337  bigintmat *bim = (bigintmat *)u->Data();
5338  int   r = (int)(long)v->Data();
5339  int   c = (int)(long)w->Data();
5340  if ((r<1)||(r>bim->rows())||(c<1)||(c>bim->cols()))
5341  {
5342    Werror("wrong range[%d,%d] in bigintmat %s(%d x %d)",
5343           r,c,u->Fullname(),bim->rows(),bim->cols());
5344    return TRUE;
5345  }
5346  res->data=u->data; u->data=NULL;
5347  res->rtyp=u->rtyp; u->rtyp=0;
5348  res->name=u->name; u->name=NULL;
5349  Subexpr e=jjMakeSub(v);
5350          e->next=jjMakeSub(w);
5351  if (u->e==NULL)
5352    res->e=e;
5353  else
5354  {
5355    Subexpr h=u->e;
5356    while (h->next!=NULL) h=h->next;
5357    h->next=e;
5358    res->e=u->e;
5359    u->e=NULL;
5360  }
5361  return FALSE;
5362}
5363static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
5364{
5365  matrix m= (matrix)u->Data();
5366  int   r = (int)(long)v->Data();
5367  int   c = (int)(long)w->Data();
5368  //Print("gen. elem %d, %d\n",r,c);
5369  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
5370  {
5371    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
5372      MATROWS(m),MATCOLS(m));
5373    return TRUE;
5374  }
5375  res->data=u->data; u->data=NULL;
5376  res->rtyp=u->rtyp; u->rtyp=0;
5377  res->name=u->name; u->name=NULL;
5378  Subexpr e=jjMakeSub(v);
5379          e->next=jjMakeSub(w);
5380  if (u->e==NULL)
5381    res->e=e;
5382  else
5383  {
5384    Subexpr h=u->e;
5385    while (h->next!=NULL) h=h->next;
5386    h->next=e;
5387    res->e=u->e;
5388    u->e=NULL;
5389  }
5390  return FALSE;
5391}
5392static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
5393{
5394  sleftv t;
5395  sleftv ut;
5396  leftv p=NULL;
5397  intvec *iv=(intvec *)w->Data();
5398  int l;
5399  BOOLEAN nok;
5400
5401  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5402  {
5403    WerrorS("cannot build expression lists from unnamed objects");
5404    return TRUE;
5405  }
5406  memcpy(&ut,u,sizeof(ut));
5407  memset(&t,0,sizeof(t));
5408  t.rtyp=INT_CMD;
5409  for (l=0;l< iv->length(); l++)
5410  {
5411    t.data=(char *)(long)((*iv)[l]);
5412    if (p==NULL)
5413    {
5414      p=res;
5415    }
5416    else
5417    {
5418      p->next=(leftv)omAlloc0Bin(sleftv_bin);
5419      p=p->next;
5420    }
5421    memcpy(u,&ut,sizeof(ut));
5422    if (u->Typ() == MATRIX_CMD)
5423      nok=jjBRACK_Ma(p,u,v,&t);
5424    else if (u->Typ() == BIGINTMAT_CMD)
5425      nok=jjBRACK_Bim(p,u,v,&t);
5426    else /* INTMAT_CMD */
5427      nok=jjBRACK_Im(p,u,v,&t);
5428    if (nok)
5429    {
5430      while (res->next!=NULL)
5431      {
5432        p=res->next->next;
5433        omFreeBin((ADDRESS)res->next, sleftv_bin);
5434        // res->e aufraeumen !!!!
5435        res->next=p;
5436      }
5437      return TRUE;
5438    }
5439  }
5440  return FALSE;
5441}
5442static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
5443{
5444  sleftv t;
5445  sleftv ut;
5446  leftv p=NULL;
5447  intvec *iv=(intvec *)v->Data();
5448  int l;
5449  BOOLEAN nok;
5450
5451  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5452  {
5453    WerrorS("cannot build expression lists from unnamed objects");
5454    return TRUE;
5455  }
5456  memcpy(&ut,u,sizeof(ut));
5457  memset(&t,0,sizeof(t));
5458  t.rtyp=INT_CMD;
5459  for (l=0;l< iv->length(); l++)
5460  {
5461    t.data=(char *)(long)((*iv)[l]);
5462    if (p==NULL)
5463    {
5464      p=res;
5465    }
5466    else
5467    {
5468      p->next=(leftv)omAlloc0Bin(sleftv_bin);
5469      p=p->next;
5470    }
5471    memcpy(u,&ut,sizeof(ut));
5472    if (u->Typ() == MATRIX_CMD)
5473      nok=jjBRACK_Ma(p,u,&t,w);
5474    else if (u->Typ() == BIGINTMAT_CMD)
5475      nok=jjBRACK_Bim(p,u,&t,w);
5476    else /* INTMAT_CMD */
5477      nok=jjBRACK_Im(p,u,&t,w);
5478    if (nok)
5479    {
5480      while (res->next!=NULL)
5481      {
5482        p=res->next->next;
5483        omFreeBin((ADDRESS)res->next, sleftv_bin);
5484        // res->e aufraeumen !!
5485        res->next=p;
5486      }
5487      return TRUE;
5488    }
5489  }
5490  return FALSE;
5491}
5492static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
5493{
5494  sleftv t1,t2,ut;
5495  leftv p=NULL;
5496  intvec *vv=(intvec *)v->Data();
5497  intvec *wv=(intvec *)w->Data();
5498  int vl;
5499  int wl;
5500  BOOLEAN nok;
5501
5502  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5503  {
5504    WerrorS("cannot build expression lists from unnamed objects");
5505    return TRUE;
5506  }
5507  memcpy(&ut,u,sizeof(ut));
5508  memset(&t1,0,sizeof(sleftv));
5509  memset(&t2,0,sizeof(sleftv));
5510  t1.rtyp=INT_CMD;
5511  t2.rtyp=INT_CMD;
5512  for (vl=0;vl< vv->length(); vl++)
5513  {
5514    t1.data=(char *)(long)((*vv)[vl]);
5515    for (wl=0;wl< wv->length(); wl++)
5516    {
5517      t2.data=(char *)(long)((*wv)[wl]);
5518      if (p==NULL)
5519      {
5520        p=res;
5521      }
5522      else
5523      {
5524        p->next=(leftv)omAlloc0Bin(sleftv_bin);
5525        p=p->next;
5526      }
5527      memcpy(u,&ut,sizeof(ut));
5528      if (u->Typ() == MATRIX_CMD)
5529        nok=jjBRACK_Ma(p,u,&t1,&t2);
5530      else if (u->Typ() == BIGINTMAT_CMD)
5531        nok=jjBRACK_Bim(p,u,&t1,&t2);
5532      else /* INTMAT_CMD */
5533        nok=jjBRACK_Im(p,u,&t1,&t2);
5534      if (nok)
5535      {
5536        res->CleanUp();
5537        return TRUE;
5538      }
5539    }
5540  }
5541  return FALSE;
5542}
5543static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
5544{
5545  v->next=(leftv)omAllocBin(sleftv_bin);
5546  memcpy(v->next,w,sizeof(sleftv));
5547  memset(w,0,sizeof(sleftv));
5548  return jjPROC(res,u,v);
5549}
5550static BOOLEAN jjRING_2(leftv res, leftv u, leftv v, leftv w)
5551{
5552  u->next=(leftv)omAlloc(sizeof(sleftv));
5553  memcpy(u->next,v,sizeof(sleftv));
5554  memset(v,0,sizeof(sleftv));
5555  u->next->next=(leftv)omAlloc(sizeof(sleftv));
5556  memcpy(u->next->next,w,sizeof(sleftv));
5557  memset(w,0,sizeof(sleftv));
5558  BOOLEAN bo=iiExprArithM(res,u,'[');
5559  u->next=NULL;
5560  return bo;
5561}
5562static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5563{
5564  intvec *iv;
5565  ideal m;
5566  lists l=(lists)omAllocBin(slists_bin);
5567  int k=(int)(long)w->Data();
5568  if (k>=0)
5569  {
5570    sm_CallBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv, currRing);
5571    l->Init(2);
5572    l->m[0].rtyp=MODUL_CMD;
5573    l->m[1].rtyp=INTVEC_CMD;
5574    l->m[0].data=(void *)m;
5575    l->m[1].data=(void *)iv;
5576  }
5577  else
5578  {
5579    m=sm_CallSolv((ideal)u->Data(), currRing);
5580    l->Init(1);
5581    l->m[0].rtyp=IDEAL_CMD;
5582    l->m[0].data=(void *)m;
5583  }
5584  res->data = (char *)l;
5585  return FALSE;
5586}
5587static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5588{
5589  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
5590  {
5591    WerrorS("3rd argument must be a name of a matrix");
5592    return TRUE;
5593  }
5594  ideal i=(ideal)u->Data();
5595  int rank=(int)i->rank;
5596  BOOLEAN r=jjCOEFFS_Id(res,u,v);
5597  if (r) return TRUE;
5598  mp_Monomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data(),currRing);
5599  return FALSE;
5600}
5601static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5602{
5603  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5604           (ideal)(v->Data()),(poly)(w->Data()));
5605  return FALSE;
5606}
5607static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5608{
5609  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
5610  {
5611    WerrorS("3rd argument must be a name of a matrix");
5612    return TRUE;
5613  }
5614  // CopyD for POLY_CMD and VECTOR_CMD are identical:
5615  poly p=(poly)u->CopyD(POLY_CMD);
5616  ideal i=idInit(1,1);
5617  i->m[0]=p;
5618  sleftv t;
5619  memset(&t,0,sizeof(t));
5620  t.data=(char *)i;
5621  t.rtyp=IDEAL_CMD;
5622  int rank=1;
5623  if (u->Typ()==VECTOR_CMD)
5624  {
5625    i->rank=rank=pMaxComp(p);
5626    t.rtyp=MODUL_CMD;
5627  }
5628  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5629  t.CleanUp();
5630  if (r) return TRUE;
5631  mp_Monomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data(),currRing);
5632  return FALSE;
5633}
5634static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5635{
5636  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5637    (intvec *)w->Data());
5638  //setFlag(res,FLAG_STD);
5639  return FALSE;
5640}
5641static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5642{
5643  /*4
5644  * look for the substring what in the string where
5645  * starting at position n
5646  * return the position of the first char of what in where
5647  * or 0
5648  */
5649  int n=(int)(long)w->Data();
5650  char *where=(char *)u->Data();
5651  char *what=(char *)v->Data();
5652  char *found;
5653  if ((1>n)||(n>(int)strlen(where)))
5654  {
5655    Werror("start position %d out of range",n);
5656    return TRUE;
5657  }
5658  found = strchr(where+n-1,*what);
5659  if (*(what+1)!='\0')
5660  {
5661    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5662    {
5663      found=strchr(found+1,*what);
5664    }
5665  }
5666  if (found != NULL)
5667  {
5668    res->data=(char *)((found-where)+1);
5669  }
5670  return FALSE;
5671}
5672static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5673{
5674  if ((int)(long)w->Data()==0)
5675    res->data=(char *)walkProc(u,v);
5676  else
5677    res->data=(char *)fractalWalkProc(u,v);
5678  setFlag( res, FLAG_STD );
5679  return FALSE;
5680}
5681static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5682{
5683  intvec *wdegree=(intvec*)w->Data();
5684  if (wdegree->length()!=currRing->N)
5685  {
5686    Werror("weight vector must have size %d, not %d",
5687           currRing->N,wdegree->length());
5688    return TRUE;
5689  }
5690#ifdef HAVE_RINGS
5691  if (rField_is_Ring_Z(currRing))
5692  {
5693    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
5694    PrintS("//       performed for generic fibre, that is, over Q\n");
5695  }
5696#endif
5697  assumeStdFlag(u);
5698  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5699  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal,wdegree);
5700  switch((int)(long)v->Data())
5701  {
5702    case 1:
5703      res->data=(void *)iv;
5704      return FALSE;
5705    case 2:
5706      res->data=(void *)hSecondSeries