source: git/Singular/iparith.cc @ 69d99e

spielwiese
Last change on this file since 69d99e was 69d99e, checked in by Hans Schönemann <hannes@…>, 26 years ago
* hannes: lres only for qring=NULL and homogeneous input git-svn-id: file:///usr/local/Singular/svn/trunk@1949 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 152.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT: table driven kernel interface, used by interpreter
6*/
7
8#include <stdlib.h>
9#include <string.h>
10#include <ctype.h>
11
12#include <stdio.h>
13#include <time.h>
14
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "mmemory.h"
22#include "febase.h"
23#include "longalg.h"
24#include "polys.h"
25#include "ideals.h"
26#include "matpol.h"
27#include "kstd1.h"
28#include "timer.h"
29#include "ring.h"
30#include "subexpr.h"
31#include "lists.h"
32#include "numbers.h"
33#include "stairc.h"
34#include "maps.h"
35#include "syz.h"
36#include "weight.h"
37#include "ipconv.h"
38#include "ipprint.h"
39#include "sing_dld.h"
40#include "attrib.h"
41#include "silink.h"
42#ifdef HAVE_FACTORY
43#include "clapsing.h"
44#include "kstdfac.h"
45#endif
46#ifdef HAVE_FGLM
47#include "fglm.h"
48#endif
49#include "ipshell.h"
50
51/*=============== types =====================*/
52struct sValCmdTab
53{
54  short cmd;
55  short start;
56};
57
58typedef sValCmdTab jjValCmdTab[];
59
60/* ifdef GENTABLE: definitions are in ipshell.h */
61#ifndef GENTABLE
62typedef char * (*Proc1)(char *);
63struct sValCmd1
64{
65  proc1 p;
66  short cmd;
67  short res;
68  short arg;
69};
70
71typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
72struct sValCmd2
73{
74  proc2 p;
75  short cmd;
76  short res;
77  short arg1;
78  short arg2;
79};
80
81typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
82struct sValCmd3
83{
84  proc3 p;
85  short cmd;
86  short res;
87  short arg1;
88  short arg2;
89  short arg3;
90};
91struct sValCmdM
92{
93  proc1 p;
94  short cmd;
95  short res;
96  short number_of_args; /* -1: any, -2: any >0, .. */
97};
98#endif
99
100
101/*============= proc =======================*/
102static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
103#ifdef MDEBUG
104#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
105static Subexpr jjDBMakeSub(leftv e,char *f, int l);
106#else
107static Subexpr jjMakeSub(leftv e);
108#endif
109
110
111/*============= vars ======================*/
112extern int cmdtok;
113extern BOOLEAN expected_parms;
114
115int iiOp; /* the current operation*/
116
117#ifdef GENTABLE
118cmdnames cmds[] =
119{  // name-string alias tokval          toktype
120  { "$INVALID$",   0, -1,                 0},
121  { "and",         0, '&' ,               '&'},
122  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
123  { "bareiss",     0, BAREISS_CMD ,       CMD_1},
124  { "betti",       0, BETTI_CMD ,         CMD_1},
125  { "break",       0, BREAK_CMD ,         BREAK_CMD},
126  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
127  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
128  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
129  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
130  { "close",       0, CLOSE_CMD ,         CMD_1},
131  { "coef",        0, COEF_CMD ,          CMD_M},
132  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
133  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
134  { "contract",    0, CONTRACT_CMD ,      CMD_2},
135  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
136  { "def",         0, DEF_CMD ,           ROOT_DECL},
137  { "defined",     0, DEFINED_CMD ,       CMD_1},
138  { "deg",         0, DEG_CMD ,           CMD_12},
139  { "degree",      0, DEGREE_CMD ,        CMD_1},
140  { "delete",      0, DELETE_CMD ,        CMD_2},
141  { "det",         0, DET_CMD ,           CMD_1},
142  { "diff",        0, DIFF_CMD ,          CMD_2},
143  { "dim",         0, DIM_CMD ,           CMD_1},
144  { "div",         0, INTDIV ,            INTDIV},
145//#ifdef DRING
146  { "dring",       0, DRING_CMD ,         DRING_CMD},
147//#endif
148  { "dump",        0, DUMP_CMD,           CMD_1},
149  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
150  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
151  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
152  { "else",        0, ELSE_CMD ,          ELSE_CMD},
153  { "eval",        0, EVAL ,              EVAL},
154  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
155  { "execute",     0, EXECUTE_CMD ,       EXECUTE_CMD},
156  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
157  { "factorize",   0, FAC_CMD ,           CMD_12},
158  { "fetch",       0, FETCH_CMD ,         CMD_2},
159  { "fglm",        0, FGLM_CMD ,          CMD_2},
160  { "find",        0, FIND_CMD ,          CMD_23},
161  { "finduni",     0, FINDUNI_CMD,        CMD_1},
162  { "forif",       0, IF_CMD ,            IF_CMD},
163  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
164  { "facstd",      0, FACSTD_CMD ,        CMD_12},
165  { "gen",         0, E_CMD ,             CMD_1},
166  { "getdump",     0, GETDUMP_CMD,        CMD_1},
167  { "gcd",         0, GCD_CMD ,           CMD_2},
168  { "GCD",         2, GCD_CMD ,           CMD_2},
169  { "hilb",        0, HILBERT_CMD ,       CMD_12},
170  { "homog",       0, HOMOG_CMD ,         CMD_12},
171  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
172  { "if",          0, IF_CMD ,            IF_CMD},
173  { "imap",        0, IMAP_CMD ,          CMD_2},
174  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
175  { "insert",      0, INSERT_CMD ,        CMD_23},
176  { "int",         0, INT_CMD ,           ROOT_DECL},
177  { "interred",    0, INTERRED_CMD ,      CMD_1},
178  { "intersect",   0, INTERSECT_CMD ,     CMD_M},
179  { "intmat",      0, INTMAT_CMD ,        INTMAT_CMD},
180  { "intvec",      0, INTVEC_CMD ,        ROOT_DECL_LIST},
181  { "jacob",       0, JACOB_CMD ,         CMD_1},
182  { "jet",         0, JET_CMD ,           CMD_23},
183  { "kbase",       0, KBASE_CMD ,         CMD_12},
184  { "keepring",    0, KEEPRING_CMD ,      KEEPRING_CMD},
185  { "kill",        0, KILL_CMD ,          KILL_CMD},
186  { "killattrib",  0, KILLATTR_CMD ,      CMD_12},
187  { "koszul",      0, KOSZUL_CMD ,        CMD_23},
188  { "lead",        0, LEAD_CMD ,          CMD_1},
189  { "leadcoef",    0, LEADCOEF_CMD ,      CMD_1},
190  { "leadexp",     0, LEADEXP_CMD ,       CMD_1},
191  { "LIB",         0, LIB_CMD ,           SYSVAR},
192  { "lift",        0, LIFT_CMD ,          CMD_2},
193  { "liftstd",     0, LIFTSTD_CMD ,       CMD_2},
194  { "link",        0, LINK_CMD ,          ROOT_DECL},
195  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
196  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
197  { "lres",        0, LRES_CMD ,          CMD_2},
198  { "map",         0, MAP_CMD ,           RING_DECL},
199  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
200  { "maxideal",    0, MAXID_CMD ,         CMD_1},
201  { "memory",      0, MEMORY_CMD ,        CMD_1},
202  { "minbase",     0, MINBASE_CMD ,       CMD_1},
203  { "minor",       0, MINOR_CMD ,         CMD_2},
204  { "minres",      0, MINRES_CMD ,        CMD_1},
205  { "mod",         0, '%',                '%'},
206  { "module",      0, MODUL_CMD ,         MODUL_CMD},
207  { "modulo",      0, MODULO_CMD ,        CMD_2},
208  { "monitor",     0, MONITOR_CMD ,       CMD_12},
209  { "mult",        0, MULTIPLICITY_CMD ,  CMD_1},
210  #ifdef OLD_RES
211  { "mres",        0, MRES_CMD ,          CMD_23},
212  #else
213  { "mres",        0, MRES_CMD ,          CMD_2},
214  #endif
215  { "mstd",        0, MSTD_CMD ,          CMD_1},
216  { "nameof",      0, NAMEOF_CMD ,        CMD_1},
217  { "names",       0, NAMES_CMD ,         CMD_M},
218  { "ncols",       0, COLS_CMD ,          CMD_1},
219  { "not",         0, NOT ,               NOT},
220  { "npars",       0, NPARS_CMD ,         CMD_1},
221  { "nrows",       0, ROWS_CMD ,          CMD_1},
222  { "number",      0, NUMBER_CMD ,        RING_DECL},
223  { "nvars",       0, NVARS_CMD ,         CMD_1},
224  { "open",        0, OPEN_CMD ,          CMD_1},
225  { "option",      0, OPTION_CMD ,        CMD_M},
226  { "or",          0, '|' ,               '|'},
227  { "ord",         0, ORD_CMD ,           CMD_1},
228  { "ordstr",      0, ORDSTR_CMD ,        CMD_1},
229  { "package",     0, PACKAGE_CMD ,       ROOT_DECL},
230  { "par",         0, PAR_CMD ,           CMD_1},
231  { "parameter",   0, PARAMETER ,         PARAMETER},
232  { "pardeg",      0, PARDEG_CMD ,        CMD_1},
233  { "parstr",      0, PARSTR_CMD ,        CMD_12},
234  { "poly",        0, POLY_CMD ,          RING_DECL},
235  { "preimage",    0, PREIMAGE_CMD ,      CMD_3},
236  { "prime",       0, PRIME_CMD ,         CMD_1},
237  { "print",       0, PRINT_CMD ,         CMD_12},
238  { "prune",       0, PRUNE_CMD ,         CMD_1},
239  { "proc",        0, PROC_CMD ,          PROC_CMD},
240  { "qring",       0, QRING_CMD ,         ROOT_DECL},
241  { "quotient",    0, QUOTIENT_CMD ,      CMD_2},
242  { "quote",       0, QUOTE ,             QUOTE},
243  { "qhweight",    0, QHWEIGHT_CMD ,      CMD_1},
244  { "random",      0, RANDOM_CMD ,        CMD_23},
245  { "read",        0, READ_CMD ,          CMD_12},
246  { "reduce",      0, REDUCE_CMD ,        CMD_23},
247  { "regularity",  0, REGULARITY_CMD ,    CMD_1},
248  #ifdef OLD_RES
249  { "res",         0, RES_CMD ,           CMD_23},
250  #else
251  { "res",         0, RES_CMD ,           CMD_2},
252  #endif
253  { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
254  { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},
255  { "resultant",   0, RESULTANT_CMD,      CMD_3},
256  { "return",      0, RETURN ,            RETURN},
257  { "RETURN",      0, END_GRAMMAR ,       RETURN},
258  { "ring",        0, RING_CMD ,          RING_CMD},
259  { "rvar",        0, IS_RINGVAR ,        CMD_1},
260  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
261  { "simplify",    0, SIMPLIFY_CMD ,      CMD_2},
262  { "size",        0, COUNT_CMD ,         CMD_1},
263  { "sortvec",     0, SORTVEC_CMD ,       CMD_1},
264  #ifdef OLD_RES
265  { "sres",        0, SRES_CMD ,          CMD_23},
266  #else
267  { "sres",        0, SRES_CMD ,          CMD_2},
268  #endif
269  { "status",      0, STATUS_CMD,         CMD_23},
270  { "std",         0, STD_CMD ,           CMD_12},
271  { "string",      0, STRING_CMD ,        ROOT_DECL_LIST},
272  { "subst",       0, SUBST_CMD ,         CMD_3},
273  { "system",      0, SYSTEM_CMD,         CMD_M},
274  { "syz",         0, SYZYGY_CMD ,        CMD_1},
275  { "test",        0, TEST_CMD ,          CMD_M},
276  { "trace",       0, TRACE_CMD ,         CMD_1},
277  { "transpose",   0, TRANSPOSE_CMD ,     CMD_1},
278  { "type",        0, TYPE_CMD ,          TYPE_CMD},
279  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
280  { "var",         0, VAR_CMD ,           CMD_1},
281  { "varstr",      0, VARSTR_CMD ,        CMD_12},
282  { "vdim",        0, VDIM_CMD ,          CMD_1},
283  { "vector",      0, VECTOR_CMD ,        RING_DECL},
284  { "wedge",       0, WEDGE_CMD ,         CMD_2},
285  { "weight",      0, WEIGHT_CMD ,        CMD_1},
286  { "whileif",     0, IF_CMD ,            IF_CMD},
287  { "write",       0, WRITE_CMD ,         CMD_M},
288/* delete for next version:*/
289  { "IN",          1, LEAD_CMD ,          CMD_1},
290  { "NF",          1, REDUCE_CMD ,        CMD_23},
291  { "multiplicity",1, MULTIPLICITY_CMD ,  CMD_1},
292  { "verbose",     2, OPTION_CMD ,        CMD_M},
293//  { "rank",        1, ROWS_CMD ,          CMD_1},
294
295/* set sys vars*/
296//#ifdef SRING
297  { "alternating", 0, VALTVARS ,          SYSVAR},
298//#endif
299  { "degBound",    0, VMAXDEG ,           SYSVAR},
300  { "echo",        0, VECHO ,             SYSVAR},
301  { "minpoly",     0, VMINPOLY ,          SYSVAR},
302  { "multBound",   0, VMAXMULT ,          SYSVAR},
303  { "noether",     0, VNOETHER ,          SYSVAR},
304  { "pagelength",  0, VPAGELENGTH ,       SYSVAR},
305  { "pagewidth",   0, VCOLMAX ,           SYSVAR},
306  { "printlevel",  0, VPRINTLEVEL ,       SYSVAR},
307  { "short",       0, VSHORTOUT ,         SYSVAR},
308  { "timer",       0, VTIMER ,            SYSVAR},
309  { "rtimer",      0, VRTIMER,            SYSVAR},
310  { "TRACE",       0, TRACE ,             SYSVAR},
311  { "voice",       0, VOICE ,             SYSVAR},
312
313
314/* other reserved words:scanner.l */
315  { "pause",       2, -1 ,             0},
316  { "while",       0, -1 ,             0},
317  { "for",         0, -1 ,             0},
318  { "help",        0, -1 ,             0},
319  { "newline",     0, -1 ,             0},
320  { "exit",        0, -1 ,             0},
321  { "quit",        0, -1 ,             0},
322/* end of list marker */
323  { NULL, 0, 0, 0}
324};
325#endif
326
327/*=================== operations with 2 args.: static proc =================*/
328static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
329{
330  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
331  int bb = (int)(v->Data());
332  if (errorreported) return TRUE;
333  switch (iiOp)
334  {
335    case '+': (*aa) += bb; break;
336    case '-': (*aa) -= bb; break;
337    case '*': (*aa) *= bb; break;
338    case '/':
339    case INTDIV: (*aa) /= bb; break;
340    case '%': (*aa) %= bb; break;
341  }
342  res->data=(char *)aa;
343  return FALSE;
344}
345static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
346{
347  return jjOP_IV_I(res,v,u);
348}
349static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
350{
351  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
352  int bb = (int)(v->Data());
353  int i=min(aa->rows(),aa->cols());
354  switch (iiOp)
355  {
356    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
357              break;
358    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
359              break;
360  }
361  res->data=(char *)aa;
362  return FALSE;
363}
364static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
365{
366  return jjOP_IM_I(res,v,u);
367}
368static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
369{
370  res->data=(char *)new intvec((int)u->Data(),(int)v->Data());
371  return FALSE;
372}
373static void jjEQUAL_REST(leftv res,leftv u,leftv v)
374{
375  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
376  {
377    int save_iiOp=iiOp;
378    if (iiOp==NOTEQUAL)
379      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
380    else
381      iiExprArith2(res,u->next,iiOp,v->next);
382    iiOp=save_iiOp;
383  }
384  if (iiOp==NOTEQUAL) res->data=(char *)(!(int)res->data);
385}
386static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
387{
388  intvec*    a = (intvec * )(u->Data());
389  intvec*    b = (intvec * )(v->Data());
390  int r=a->compare(b);
391  switch  (iiOp)
392  {
393    case '<':
394      res->data  = (char *) (r<0);
395      break;
396    case '>':
397      res->data  = (char *) (r>0);
398      break;
399    case LE:
400      res->data  = (char *) (r<=0);
401      break;
402    case GE:
403      res->data  = (char *) (r>=0);
404      break;
405    case EQUAL_EQUAL:
406    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
407      res->data  = (char *) (r==0);
408      break;
409  }
410  jjEQUAL_REST(res,u,v);
411  return r==-2;
412}
413static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
414{
415  intvec* a = (intvec * )(u->Data());
416  int     b = (int )     (v->Data());
417  int r=a->compare(b);
418  switch  (iiOp)
419  {
420    case '<':
421      res->data  = (char *) (r<0);
422      break;
423    case '>':
424      res->data  = (char *) (r>0);
425      break;
426    case LE:
427      res->data  = (char *) (r<=0);
428      break;
429    case GE:
430      res->data  = (char *) (r>=0);
431      break;
432    case EQUAL_EQUAL:
433    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
434      res->data  = (char *) (r==0);
435      break;
436  }
437  jjEQUAL_REST(res,u,v);
438  return FALSE;
439}
440static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
441{
442  poly p=(poly)u->Data();
443  poly q=(poly)v->Data();
444  int r=pComp(p,q);
445  if (r==0)
446  {
447    /* compare lead coeffs */
448    number h=nSub(pGetCoeff(p),pGetCoeff(q));
449    r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
450    nDelete(&h);
451  }
452  else if (p==NULL)
453  {
454    if (q==NULL)
455    {
456      /* compare 0, 0 */
457      r=0;
458    }
459    else if(pIsConstant(q))
460    {
461      /* compare 0, const */
462      r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
463    }
464  }
465  else if (q==NULL)
466  {
467    if (pIsConstant(p))
468    {
469      /* compare const, 0 */
470      r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
471    }
472  }
473  switch  (iiOp)
474  {
475    case '<':
476      res->data  = (char *) (r < 0);
477      break;
478    case '>':
479      res->data  = (char *) (r > 0);
480      break;
481    case LE:
482      res->data  = (char *) (r <= 0);
483      break;
484    case GE:
485      res->data  = (char *) (r >= 0);
486      break;
487    //case EQUAL_EQUAL:
488    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
489    //  res->data  = (char *) (r == 0);
490    //  break;
491  }
492  jjEQUAL_REST(res,u,v);
493  return FALSE;
494}
495static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
496{
497  char*    a = (char * )(u->Data());
498  char*    b = (char * )(v->Data());
499  int result = strcmp(a,b);
500  switch  (iiOp)
501  {
502    case '<':
503      res->data  = (char *) (result  < 0);
504      break;
505    case '>':
506      res->data  = (char *) (result  > 0);
507      break;
508    case LE:
509      res->data  = (char *) (result  <= 0);
510      break;
511    case GE:
512      res->data  = (char *) (result  >= 0);
513      break;
514    case EQUAL_EQUAL:
515    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
516      res->data  = (char *) (result  == 0);
517      break;
518  }
519  jjEQUAL_REST(res,u,v);
520  return FALSE;
521}
522static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
523{
524  int b=(int)u->Data();
525  int e=(int)v->Data();
526  int rc = 1;
527  BOOLEAN overflow=FALSE;
528  if ((e >= 0)&&(b!=0))
529  {
530    int oldrc;
531    while ((e--)!=0)
532    {
533      oldrc=rc;
534      rc *= b;
535      if (!overflow)
536      {
537        if(rc/b!=oldrc) overflow=TRUE;
538      }
539    }
540  }
541  if (overflow)
542    Warn("int overflow(^), result may be wrong");
543  res->data = (char *)rc;
544  return FALSE;
545}
546static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
547{
548  int e=(int)v->Data();
549  number n=(number)u->CopyD();
550  if (e<0)
551  {
552    number m=nInvers(n);
553    nDelete(&n);
554    n=m;
555    e=-e;
556  }
557  nPower(n,e,(number*)&res->data);
558  nDelete(&n);
559  return FALSE;
560}
561static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
562{
563  res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)v->Data());
564  return FALSE;
565}
566static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
567{
568  res->data = (char *)idPower((ideal)(u->Data()),(int)(v->Data()));
569  return FALSE;
570}
571static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
572{
573  u=u->next;
574  v=v->next;
575  if (u==NULL)
576  {
577    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
578    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
579      return iiExprArith1(res->next,v,'-');
580    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
581    {
582      res->next = (leftv)Alloc0(sizeof(sleftv));
583      res=res->next;
584      res->data = v->CopyD();
585      res->rtyp = v->Typ();
586      v=v->next;
587      if (v==NULL) return FALSE;
588    }
589  }
590  if (v!=NULL)                     /* u<>NULL, v<>NULL */
591  {
592    res->next = (leftv)Alloc(sizeof(sleftv));
593    return iiExprArith2(res->next,u,iiOp,v);
594  }
595  loop                             /* u<>NULL, v==NULL */
596  {
597    res->next = (leftv)Alloc0(sizeof(sleftv));
598    res=res->next;
599    res->data = u->CopyD();
600    res->rtyp = u->Typ();
601    u=u->next;
602    if (u==NULL) return FALSE;
603  }
604}
605static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
606{
607  unsigned int a=(unsigned int)u->Data();
608  unsigned int b=(unsigned int)v->Data();
609  unsigned int c=a+b;
610  res->data = (char *)c;
611  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
612  {
613    Warn("int overflow(+), result may be wrong");
614  }
615  return jjPLUSMINUS_Gen(res,u,v);
616}
617static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
618{
619  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
620  return jjPLUSMINUS_Gen(res,u,v);
621}
622static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
623{
624  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
625  return jjPLUSMINUS_Gen(res,u,v);
626}
627static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
628{
629  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
630  if (res->data==NULL)
631  {
632     WerrorS("intmat size not compatible");
633     return TRUE;
634  }
635  return jjPLUSMINUS_Gen(res,u,v);
636}
637static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
638{
639  res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
640  if (res->data==NULL)
641  {
642     WerrorS("matrix size not compatible");
643     return TRUE;
644  }
645  return jjPLUSMINUS_Gen(res,u,v);
646}
647static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
648{
649  matrix m=(matrix)u->Data();
650  matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD()));
651  if (iiOp=='+')
652    res->data = (char *)mpAdd(m , p);
653  else
654    res->data = (char *)mpSub(m , p);
655  idDelete((ideal *)&p);
656  return jjPLUSMINUS_Gen(res,u,v);
657}
658static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
659{
660  return jjPLUS_MA_P(res,v,u);
661}
662static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
663{
664  char*    a = (char * )(u->Data());
665  char*    b = (char * )(v->Data());
666  char*    r = (char * )AllocL(strlen(a) + strlen(b) + 1);
667  strcpy(r,a);
668  strcat(r,b);
669  res->data=r;
670  return jjPLUSMINUS_Gen(res,u,v);
671}
672static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
673{
674  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
675  return jjPLUSMINUS_Gen(res,u,v);
676}
677static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
678{
679  unsigned int a=(unsigned int)u->Data();
680  unsigned int b=(unsigned int)v->Data();
681  unsigned int c=a-b;
682  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
683  {
684    Warn("int overflow(-), result may be wrong");
685  }
686  res->data = (char *)c;
687  return jjPLUSMINUS_Gen(res,u,v);
688}
689static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
690{
691  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
692  return jjPLUSMINUS_Gen(res,u,v);
693}
694static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
695{
696  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
697  return jjPLUSMINUS_Gen(res,u,v);
698}
699static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
700{
701  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
702  if (res->data==NULL)
703  {
704     WerrorS("intmat size not compatible");
705     return TRUE;
706  }
707  return jjPLUSMINUS_Gen(res,u,v);
708}
709static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
710{
711  res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
712  if (res->data==NULL)
713  {
714     WerrorS("matrix size not compatible");
715     return TRUE;
716  }
717  return jjPLUSMINUS_Gen(res,u,v);
718}
719static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
720{
721  int a=(int)u->Data();
722  int b=(int)v->Data();
723  int c=a * b;
724  if ((b!=0) && (c/b !=a))
725    Warn("int overflow(*), result may be wrong");
726  res->data = (char *)c;
727  if (u->Next()!=NULL)
728  {
729    u=u->next;
730    res->next = (leftv)Alloc(sizeof(sleftv));
731    return iiExprArith2(res->next,u,iiOp,v);
732  }
733  else if (v->Next()!=NULL)
734  {
735    v=v->next;
736    res->next = (leftv)Alloc(sizeof(sleftv));
737    return iiExprArith2(res->next,u,iiOp,v);
738  }
739  return FALSE;
740}
741static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
742{
743  number a;
744  number b;
745
746  if (v->next==NULL)
747  {
748    a=(number)u->Data();
749    if (u->next==NULL)
750    {
751      res->data = (char *)(nMult( a, (number)v->Data()));
752      return FALSE;
753    }
754    // u->next exists: copy v
755    b=(number)v->Data();
756    res->data = (char *)(nMult( a, b));
757    res->next = (leftv)Alloc(sizeof(sleftv));
758    res=res->next;
759    return iiExprArith2(res,u->next,iiOp,v);
760  }
761  // v->next exists: copy u
762  a=nCopy((number)u->Data());
763  b=(number)v->CopyD();
764  res->data = (char *)(nMult( a, b));
765  res->next = (leftv)Alloc(sizeof(sleftv));
766  return iiExprArith2(res->next,u,iiOp,v->next);
767}
768static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
769{
770  poly a;
771  poly b;
772
773  if (v->next==NULL)
774  {
775    a=(poly)u->CopyD();
776    if (u->next==NULL)
777    {
778      b=(poly)v->CopyD();
779      res->data = (char *)(pMult( a, b));
780      return FALSE;
781    }
782    // u->next exists: copy v
783    b=pCopy((poly)v->Data());
784    res->data = (char *)(pMult( a, b));
785    res->next = (leftv)Alloc(sizeof(sleftv));
786    res=res->next;
787    return iiExprArith2(res,u->next,iiOp,v);
788  }
789  // v->next exists: copy u
790  a=pCopy((poly)u->Data());
791  b=(poly)v->CopyD();
792  res->data = (char *)(pMult( a, b));
793  res->next = (leftv)Alloc(sizeof(sleftv));
794  return iiExprArith2(res->next,u,iiOp,v->next);
795}
796static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
797{
798  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
799  return FALSE;
800}
801static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
802{
803  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
804  if (res->data==NULL)
805  {
806     WerrorS("intmat size not compatible");
807     return TRUE;
808  }
809  return FALSE;
810}
811static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
812{
813  poly p=(poly)v->CopyD(POLY_CMD);
814  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
815  ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
816  if (r>0) I->rank=r;
817  res->data = (char *)I;
818  return FALSE;
819}
820static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
821{
822  return jjTIMES_MA_P1(res,v,u);
823}
824static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
825{
826  number n=(number)v->CopyD(NUMBER_CMD);
827  poly p=pOne();
828  pSetCoeff(p,n);
829  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
830  return FALSE;
831}
832static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
833{
834  return jjTIMES_MA_N1(res,v,u);
835}
836static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
837{
838  res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)v->Data());
839  return FALSE;
840}
841static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
842{
843  return jjTIMES_MA_I1(res,v,u);
844}
845static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
846{
847  res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
848  if (res->data==NULL)
849  {
850     WerrorS("matrix size not compatible");
851     return TRUE;
852  }
853  return FALSE;
854}
855static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
856{
857  res->data = (char *)((int)u->Data() >= (int)v->Data());
858  return FALSE;
859}
860static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
861{
862  number h=nSub((number)u->Data(),(number)v->Data());
863  res->data = (char *) (nGreaterZero(h)||(nIsZero(h)));
864  nDelete(&h);
865  return FALSE;
866}
867static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
868{
869  res->data = (char *)((int)u->Data()>(int)v->Data());
870  return FALSE;
871}
872static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
873{
874  number h=nSub((number)u->Data(),(number)v->Data());
875  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
876  nDelete(&h);
877  return FALSE;
878}
879static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
880{
881  res->data = (char *)((int)u->Data() <= (int)v->Data());
882  return FALSE;
883}
884static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
885{
886  number h=nSub((number)v->Data(),(number)u->Data());
887  res->data = (char *) (nGreaterZero(h)||nIsZero(h));
888  nDelete(&h);
889  return FALSE;
890}
891static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
892{
893  res->data = (char *)((int)u->Data() < (int)v->Data());
894  return FALSE;
895}
896static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
897{
898  number h=nSub((number)v->Data(),(number)u->Data());
899  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
900  nDelete(&h);
901  return FALSE;
902}
903static BOOLEAN jjDIV_I(leftv res, leftv u, leftv v)
904{
905  int a= (int) u->Data();
906  int b= (int) v->Data();
907  if (b==0)
908  {
909    WerrorS("div. by 0");
910    return TRUE;
911  }
912  //int c=a%ABS(b);
913  //if(c<0) c+=ABS(b);
914  //res->data = (char *)((a-c) / b);
915  res->data = (char *)(a / b);
916  return FALSE;
917}
918static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
919{
920  number q=(number)v->Data();
921  if (nIsZero(q))
922  {
923    WerrorS("div. by 0");
924    return TRUE;
925  }
926  q = nDiv((number)u->Data(),q);
927  nNormalize(q);
928  res->data = (char *)q;
929  return FALSE;
930}
931static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
932{
933  poly q=(poly)v->Data();
934  if (q==NULL)
935  {
936    WerrorS("div. by 0");
937    return TRUE;
938  }
939  if (pNext(q)!=NULL)
940  {
941#ifdef HAVE_FACTORY
942    res->data=(void*)(singclap_pdivide((poly)(u->Data()),
943                                       (poly)(v->Data())));
944#else
945    WerrorS("division only by a monomial");
946    return TRUE;
947#endif
948  }
949  else
950  {
951    res->data = (char *)pDivideM((poly)u->CopyD(POLY_CMD),pHead(q));
952  }
953  return FALSE;
954}
955static BOOLEAN jjMOD_I(leftv res, leftv u, leftv v)
956{
957  int a=(int)u->Data();
958  int b=ABS((int)v->Data());
959  if (errorreported) return TRUE;
960  if (b==0)
961  {
962    WerrorS("div. by 0");
963    return TRUE;
964  }
965  int c=a%b;
966  if(c<0) c+=b;
967  res->data = (char *)c;
968  return FALSE;
969}
970static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
971{
972  res->data = (char *)((int)u->Data() == (int)v->Data());
973  jjEQUAL_REST(res,u,v);
974  return FALSE;
975}
976static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
977{
978  res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
979  jjEQUAL_REST(res,u,v);
980  return FALSE;
981}
982static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
983{
984  res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
985  jjEQUAL_REST(res,u,v);
986  return FALSE;
987}
988static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
989{
990  poly p=(poly)u->Data();
991  poly q=(poly)v->Data();
992  if (p==NULL)
993  {
994    res->data=(char *)(q==NULL);
995  }
996  else
997  {
998    if (q==NULL) res->data=(char *)FALSE;
999    else
1000    {
1001      int r=pComp(p,q);
1002      if (r==0)
1003      {
1004        p=pSub(pCopy(p),pCopy(q));
1005        res->data = (char *) (p==NULL);
1006        pDelete(&p);
1007      }
1008      else
1009        res->data = (char *) FALSE;
1010    }
1011  }
1012  jjEQUAL_REST(res,u,v);
1013  return FALSE;
1014}
1015static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1016{
1017  res->data = (char *)((int)u->Data() && (int)v->Data());
1018  return FALSE;
1019}
1020static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1021{
1022  res->data = (char *)((int)u->Data() || (int)v->Data());
1023  return FALSE;
1024}
1025static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1026{
1027  res->rtyp=u->rtyp; u->rtyp=0;
1028  res->data=u->data; u->data=NULL;
1029  res->name=u->name; u->name=NULL;
1030  res->e=u->e;       u->e=NULL;
1031  if (res->e==NULL) res->e=jjMakeSub(v);
1032  else
1033  {
1034    Subexpr sh=res->e;
1035    while (sh->next != NULL) sh=sh->next;
1036    sh->next=jjMakeSub(v);
1037  }
1038  return FALSE;
1039}
1040static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1041{
1042  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1043  {
1044    WerrorS("indexed object must have a name");
1045    return TRUE;
1046  }
1047  intvec * iv=(intvec *)v->Data();
1048  leftv p=NULL;
1049  int i;
1050  sleftv t;
1051
1052  memset(&t,0,sizeof(t));
1053  t.rtyp=INT_CMD;
1054  for (i=0;i<iv->length(); i++)
1055  {
1056    t.data=(char *)(*iv)[i];
1057    if (p==NULL)
1058    {
1059      p=res;
1060    }
1061    else
1062    {
1063      p->next=(leftv)Alloc0(sizeof(sleftv));
1064      p=p->next;
1065    }
1066    p->rtyp=IDHDL;
1067    p->data=u->data;
1068    p->name=u->name;
1069    p->flag|=u->flag;
1070    p->e=jjMakeSub(&t);
1071  }
1072  u->rtyp=0;
1073  u->data=NULL;
1074  u->name=NULL;
1075  return FALSE;
1076}
1077static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1078{
1079  poly p=(poly)u->Data();
1080  int i=(int)v->Data();
1081  int j=0;
1082  while (p!=NULL)
1083  {
1084    j++;
1085    if (j==i)
1086    {
1087      res->data=(char *)pHead(p);
1088      return FALSE;
1089    }
1090    pIter(p);
1091  }
1092  return FALSE;
1093}
1094static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1095{
1096  poly p=(poly)u->Data();
1097  poly r=NULL;
1098  intvec *iv=(intvec *)v->CopyD();
1099  int i;
1100  int sum=0;
1101  for(i=iv->length()-1;i>=0;i--)
1102    sum+=(*iv)[i];
1103  int j=0;
1104  while ((p!=NULL) && (sum>0))
1105  {
1106    j++;
1107    for(i=iv->length()-1;i>=0;i--)
1108    {
1109      if (j==(*iv)[i])
1110      {
1111        r=pAdd(r,pHead(p));
1112        sum-=j;
1113        (*iv)[i]=0;
1114        break;
1115      }
1116    }
1117    pIter(p);
1118  }
1119  delete iv;
1120  res->data=(char *)r;
1121  return FALSE;
1122}
1123static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1124{
1125  poly p=(poly)u->CopyD();
1126  poly r=p; // pointer to the beginning of component i
1127  poly o=NULL;
1128  int i=(int)v->Data();
1129  while (p!=NULL)
1130  {
1131    if (pGetComp(p)!=i)
1132    {
1133      if (r==p) r=pNext(p);
1134      if (o!=NULL)
1135      {
1136        pDelete1(&pNext(o));
1137        p=pNext(o);
1138      }
1139      else
1140        pDelete1(&p);
1141    }
1142    else
1143    {
1144      pSetComp(p, 0);
1145      o=p;
1146      p=pNext(o);
1147    }
1148  }
1149  res->data=(char *)r;
1150  return FALSE;
1151}
1152static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1153{
1154  poly p=(poly)u->CopyD();
1155  if (p!=NULL)
1156  {
1157    poly r=pOne();
1158    poly hp=r;
1159    intvec *iv=(intvec *)v->Data();
1160    int i;
1161    loop
1162    {
1163      for(i=0;i<iv->length();i++)
1164      {
1165        if (pGetComp(p)==(*iv)[i])
1166        {
1167          poly h;
1168          pSplit(p,&h);
1169          pNext(hp)=p;
1170          p=h;
1171          pIter(hp);
1172          break;
1173        }
1174      }
1175      if (p==NULL) break;
1176      if (i==iv->length())
1177      {
1178        pDelete1(&p);
1179        if (p==NULL) break;
1180      }
1181    }
1182    pDelete1(&r);
1183    res->data=(char *)r;
1184  }
1185  return FALSE;
1186}
1187static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1188{
1189  if(u->name==NULL) return TRUE;
1190  char * n = (char *)AllocL(strlen(u->name) + 6);
1191  sprintf(n,"%s(%d)",u->name,(int)v->Data());
1192  FreeL((ADDRESS)u->name);
1193  u->name=NULL;
1194  syMake(res,n);
1195  return FALSE;
1196}
1197static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1198{
1199  intvec * iv=(intvec *)v->Data();
1200  leftv p=NULL;
1201  int i;
1202  char *n;
1203
1204  for (i=0;i<iv->length(); i++)
1205  {
1206    if (p==NULL)
1207    {
1208      p=res;
1209    }
1210    else
1211    {
1212      p->next=(leftv)Alloc0(sizeof(sleftv));
1213      p=p->next;
1214    }
1215    n = (char *)AllocL(strlen(u->name) + 6);
1216    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1217    syMake(p,n);
1218  }
1219  FreeL((ADDRESS)u->name);
1220  u->name=NULL;
1221  return FALSE;
1222}
1223static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1224{
1225  leftv sl = iiMake_proc((idhdl)u->data,v);
1226  if (sl==NULL)
1227  {
1228    return TRUE;
1229  }
1230  else
1231  {
1232    memcpy(res,sl,sizeof(sleftv));
1233  }
1234  return FALSE;
1235}
1236static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1237{
1238  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1239  leftv sl=NULL;
1240  if (v->e==NULL)
1241  {
1242    idhdl h=(idhdl)u->data;
1243    sl=iiMap(IDMAP(h),v->name);
1244  }
1245  //else
1246  //{
1247  //  WerrorS("map_id(<name>) expected");
1248  //}
1249  if (sl==NULL) return TRUE;
1250  memcpy(res,sl,sizeof(sleftv));
1251  Free((ADDRESS)sl,sizeof(*sl));
1252  return FALSE;
1253}
1254static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1255{
1256  u->next=(leftv)Alloc(sizeof(sleftv));
1257  memcpy(u->next,v,sizeof(sleftv));
1258  BOOLEAN r=iiExprArithM(res,u,iiOp);
1259  v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
1260  return r;
1261}
1262static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1263{
1264  res->data=(char *)mpCoeffProc((poly)u->Data(),(poly)v->Data());
1265  return FALSE;
1266}
1267static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1268{
1269  int i=pVar((poly)v->Data());
1270  if (i==0)
1271  {
1272    WerrorS("ringvar expected");
1273    return TRUE;
1274  }
1275  res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1276  return FALSE;
1277}
1278static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1279{
1280  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1281  return FALSE;
1282}
1283static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1284{
1285  short *iv=iv2array((intvec *)v->Data());
1286  res->data = (char *)pDegW((poly)u->Data(),iv);
1287  Free((ADDRESS)iv,(pVariables+1)*sizeof(short));
1288  return FALSE;
1289}
1290static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1291{
1292  int i=pVar((poly)v->Data());
1293  if (i==0)
1294  {
1295    WerrorS("ringvar expected");
1296    return TRUE;
1297  }
1298  res->data=(char *)pDiff((poly)(u->Data()),i);
1299  return FALSE;
1300}
1301static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1302{
1303  int i=pVar((poly)v->Data());
1304  if (i==0)
1305  {
1306    WerrorS("ringvar expected");
1307    return TRUE;
1308  }
1309  res->data=(char *)idDiff((matrix)(u->Data()),i);
1310  return FALSE;
1311}
1312static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1313{
1314  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1315  return FALSE;
1316}
1317
1318static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1319{
1320  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1321  setFlag(res,FLAG_STD);
1322  return FALSE;
1323}
1324static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1325{
1326  assumeStdFlag(v);
1327  if(currQuotient==NULL)
1328    res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1329  else
1330  {
1331    ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1332    res->data = (char *)scDimInt((ideal)(v->Data()),q);
1333    idDelete(&q);
1334  }
1335  return FALSE;
1336}
1337static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1338{
1339  int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1340  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1341
1342  while ( p1!=0 )
1343  {
1344    q=p0 / p1;
1345    r=p0 % p1;
1346    p0 = p1; p1 = r;
1347    r = g0 - g1 * q;
1348    g0 = g1; g1 = r;
1349    r = f0 - f1 * q;
1350    f0 = f1; f1 = r;
1351  }
1352  int a = f0;
1353  int b = g0;
1354  if ( (int)u->Data() < 0 ) a=-a;
1355  if ( (int)v->Data() < 0 ) b=-b;
1356  lists L=(lists)Alloc(sizeof(slists));
1357  L->Init(3);
1358  L->m[0].rtyp=INT_CMD;
1359  L->m[0].data=(void *)p0;
1360  L->m[1].rtyp=INT_CMD;
1361  L->m[1].data=(void *)a;
1362  L->m[2].rtyp=INT_CMD;
1363  L->m[2].data=(void *)b;
1364  res->rtyp=LIST_CMD;
1365  res->data=(char *)L;
1366  return FALSE;
1367}
1368#ifdef HAVE_FACTORY
1369static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1370{
1371  res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL,
1372           (ideal)w->Data());
1373  setFlag(res,FLAG_STD);
1374  return FALSE;
1375}
1376#endif
1377static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1378{
1379  ring r=(ring)u->Data();
1380  idhdl w;
1381
1382  if ((iiOp!=IMAP_CMD)
1383  && ((currRing->ch != r->ch)
1384    || ((currRing->N != r->N)&& (iiOp==FETCH_CMD)))
1385  )
1386    goto err_fetch;
1387  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1388  {
1389    int *perm=NULL;
1390    int *par_perm=NULL;
1391    int par_perm_size=0;
1392    BOOLEAN bo;
1393    if (iiOp==IMAP_CMD)
1394    {
1395      if (!nSetMap(r->ch,r->parameter,r->P,r->minpoly))
1396      {
1397        if (iiOp!=IMAP_CMD)
1398          goto err_fetch;
1399        par_perm_size=rPar(r);
1400        if (r->ch==1)
1401        {
1402          if ((currRing->ch!=0)
1403          && (currRing->ch!=1))
1404            goto err_fetch;
1405        }
1406        else if(r->ch<(-1))
1407        {
1408          if ((currRing->ch==(-currRing->ch))
1409          && (currRing->ch!=currRing->ch))
1410            goto err_fetch;
1411        }
1412        BITSET save_test=test;
1413        naSetChar(r->ch,TRUE,r->parameter,r->P);
1414        nSetChar(currRing->ch,TRUE,currRing->parameter,currRing->P);
1415        test=save_test;
1416      }
1417      perm=(int *)Alloc0((r->N+1)*sizeof(int));
1418      if (par_perm_size!=0)
1419        par_perm=(int *)Alloc0(par_perm_size*sizeof(int));
1420      maFindPerm(r->names,       r->N,       r->parameter,        r->P,
1421                 currRing->names,currRing->N,currRing->parameter, currRing->P,
1422                 perm,par_perm);
1423    }
1424    sleftv tmpW;
1425    memset(&tmpW,0,sizeof(sleftv));
1426    tmpW.rtyp=IDTYP(w);
1427    tmpW.data=IDDATA(w);
1428    if ((bo=maApplyFetch(iiOp,NULL,res,&tmpW, r, perm,par_perm,par_perm_size)))
1429    {
1430      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1431    }
1432    if (perm!=NULL)
1433      Free((ADDRESS)perm,(r->N+1)*sizeof(int));
1434    if (par_perm!=NULL)
1435      Free((ADDRESS)par_perm,par_perm_size*sizeof(int));
1436    return bo;
1437  }
1438  else
1439  {
1440    Werror("%s undefined in %s",v->Name(),u->Name());
1441  }
1442  return TRUE;
1443err_fetch:
1444  Werror("no identity map from %s",u->Name());
1445  return TRUE;
1446}
1447static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1448{
1449  /*4
1450  * look for the substring what in the string where
1451  * return the position of the first char of what in where
1452  * or 0
1453  */
1454  char *where=(char *)u->Data();
1455  char *what=(char *)v->Data();
1456  char *found = strstr(where,what);
1457  if (found != NULL)
1458  {
1459    res->data=(char *)((found-where)+1);
1460  }
1461  /*else res->data=NULL;*/
1462  return FALSE;
1463}
1464static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1465{
1466  int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1467  int q, r;
1468
1469  while ( p1!=0 )
1470  {
1471    q=p0 / p1;
1472    r=p0 % p1;
1473    p0 = p1; p1 = r;
1474  }
1475  res->rtyp=INT_CMD;
1476  res->data=(char *)p0;
1477  return FALSE;
1478}
1479static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1480{
1481  assumeStdFlag(u);
1482  intvec *module_w=(intvec*)atGet(u,"isHomog");
1483  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1484  switch((int)v->Data())
1485  {
1486    case 1:
1487      res->data=(void *)iv;
1488      return FALSE;
1489    case 2:
1490      res->data=(void *)hSecondSeries(iv);
1491      delete iv;
1492      return FALSE;
1493  }
1494  WerrorS(feNotImplemented);
1495  delete iv;
1496  return TRUE;
1497}
1498static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1499{
1500  int i=pVar((poly)v->Data());
1501  if (i==0)
1502  {
1503    WerrorS("ringvar expected");
1504    return TRUE;
1505  }
1506  res->data = (char *)pHomogen((poly)u->Data(),i);
1507  return FALSE;
1508}
1509static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1510{
1511  int i=pVar((poly)v->Data());
1512  if (i==0)
1513  {
1514    WerrorS("ringvar expected");
1515    return TRUE;
1516  }
1517  res->data = (char *)idHomogen((ideal)u->Data(),i);
1518  return FALSE;
1519}
1520static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1521{
1522  assumeStdFlag(u);
1523  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(v->Data()),
1524                    currQuotient);
1525  return FALSE;
1526}
1527static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1528{
1529  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1530  setFlag(res,FLAG_STD);
1531  return FALSE;
1532}
1533static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1534{
1535  res->data = (char *)pJet((poly)u->Data(),(int)v->Data());
1536  return FALSE;
1537}
1538static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1539{
1540  res->data = (char *)idJet((ideal)u->Data(),(int)v->Data());
1541  return FALSE;
1542}
1543static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1544{
1545  assumeStdFlag(u);
1546  res->data = (char *)scKBase((int)v->Data(),
1547                              (ideal)(u->Data()),currQuotient);
1548  return FALSE;
1549}
1550static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1551{
1552  return mpKoszul(res, u,v);
1553}
1554static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1555{
1556  sleftv h;
1557  memset(&h,0,sizeof(sleftv));
1558  h.rtyp=INT_CMD;
1559  h.data=(void *)IDELEMS((ideal)v->Data());
1560  return mpKoszul(res, &h, u, v);
1561}
1562static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1563{
1564  ideal m;
1565  int ul= IDELEMS((ideal)u->Data());
1566  int vl= IDELEMS((ideal)v->Data());
1567  if (hasFlag(u,FLAG_STD))
1568  {
1569    m = idLift((ideal)u->Data(),(ideal)v->Data());
1570    res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1571  }
1572  else
1573  {
1574    // matrix ma=mpNew(1,1);
1575    // ideal mo=idLiftStd((ideal)u->CopyD(),currQuotient,&ma,testHomog);
1576    // m = idLift(mo,(ideal)v->Data());
1577    // matrix r=idModule2formatedMatrix(m, IDELEMS(mo),vl);
1578    // idDelete(&mo);
1579    // // idDelete(&m); already done by idModule2formatedMatrix
1580    // res->data=(char *)mpMult(ma,r);
1581    // idDelete((ideal *)&ma);
1582    // idDelete((ideal *)&r);
1583    m = idLiftNonStB((ideal)u->Data(),(ideal)v->Data());
1584    res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1585  }
1586  return FALSE;
1587}
1588static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
1589{
1590  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
1591  idhdl h=(idhdl)v->data;
1592  res->data = (char *)idLiftStd((ideal)u->CopyD(), currQuotient,
1593              &(h->data.umatrix),testHomog);
1594  setFlag(res,FLAG_STD);
1595  return FALSE;
1596}
1597static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
1598{
1599  res->data = (char *)idMinors((matrix)u->Data(),(int)v->Data());
1600  return FALSE;
1601}
1602static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
1603{
1604  res->data = (char *)idModulo((ideal)u->Data(),(ideal)v->Data());
1605  return FALSE;
1606}
1607static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
1608{
1609  char *opt=(char *)v->Data();
1610  int mode=0;
1611  while(*opt!='\0')
1612  {
1613    if (*opt=='i') mode |= PROT_I;
1614    else if (*opt=='o') mode |= PROT_O;
1615    opt++;
1616  }
1617  monitor((char *)(u->Data()),mode);
1618  return FALSE;
1619}
1620static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
1621{
1622  idhdl h=(idhdl)u->data;
1623  int i=(int)v->Data();
1624  int p=0;
1625  if ((0<i)
1626  && (IDRING(h)->parameter!=NULL)
1627  && (i<=(p=rPar(IDRING(h)))))
1628    res->data=mstrdup(IDRING(h)->parameter[i-1]);
1629  else
1630  {
1631    Werror("par number %d out of range 1..%d",i,p);
1632    return TRUE;
1633  }
1634  return FALSE;
1635}
1636static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
1637{
1638  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
1639    hasFlag(u,FLAG_STD));
1640  idDelMultiples((ideal)(res->data));
1641  return FALSE;
1642}
1643static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
1644{
1645  int i=(int)u->Data();
1646  int j=(int)v->Data();
1647#ifdef buildin_rand
1648  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
1649#else
1650  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
1651#endif
1652  return FALSE;
1653}
1654static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
1655{
1656  si_link l=(si_link)u->Data();
1657  leftv r=slRead(l,v);
1658  if (r==NULL)
1659  {
1660    const char *s;
1661    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
1662    else                            s=sNoName;
1663    Werror("cannot read from `%s`",s);
1664    return TRUE;
1665  }
1666  memcpy(res,r,sizeof(sleftv));
1667  Free((ADDRESS)r,sizeof(sleftv));
1668  return FALSE;
1669}
1670static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
1671{
1672  assumeStdFlag(v);
1673  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
1674  return FALSE;
1675}
1676static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
1677{
1678  assumeStdFlag(v);
1679  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data());
1680  return FALSE;
1681}
1682static BOOLEAN jjRES(leftv res, leftv u, leftv v)
1683{
1684  int maxl=(int)v->Data();
1685  if (maxl<0)
1686  {
1687    WerrorS("length for res must not be negative");
1688    return TRUE;
1689  }
1690  int l=0;
1691  //resolvente r;
1692  syStrategy r;
1693  intvec **weights=NULL;
1694  int wmaxl=maxl;
1695  ideal u_id=(ideal)u->Data();
1696  maxl--;
1697  if ((maxl==-1) && (iiOp!=MRES_CMD))
1698    maxl = pVariables-1;
1699  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
1700  {
1701    //if (BTEST1(28))
1702    //{
1703    //  r=syMinRes(u_id,maxl,&l, iiOp==MRES_CMD);
1704    //}
1705    //else
1706    {
1707      intvec * iv=(intvec*)atGet(u,"isHomog");
1708      //if (iv!=NULL)
1709      //{
1710      //  weights = (intvec**)Alloc0(sizeof(intvec*));
1711      //  weights[0] = ivCopy(iv);
1712      //  l=1;
1713      //}
1714      //r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
1715      r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
1716    }
1717  }
1718  else if (iiOp==SRES_CMD)
1719  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
1720    r=sySchreyer(u_id,maxl+1);
1721  else /* LRES */
1722  {
1723    int dummy;
1724    if((currQuotient!=NULL)||
1725    (!idHomIdeal (u_id,NULL)))
1726    {
1727       WerrorS
1728       ("`lres` can not be called in q ring or with inhomogeneous input");
1729       return TRUE;
1730    }
1731    r=syLaScala3(u_id,&dummy);
1732  }
1733  if (r==NULL) return TRUE;
1734  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
1735  r->list_length=wmaxl;
1736  res->data=(void *)r;
1737  return FALSE;
1738}
1739static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
1740{
1741  ring r;
1742  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
1743  res->data = (char *)r;
1744  return (i==-1);
1745}
1746#define SIMPL_LMDIV 32
1747#define SIMPL_LMEQ  16
1748#define SIMPL_MULT 8
1749#define SIMPL_EQU  4
1750#define SIMPL_NULL 2
1751#define SIMPL_NORM 1
1752static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
1753{
1754  int sw = (int)v->Data();
1755  ideal id = (ideal)u->CopyD();
1756  if (sw & SIMPL_LMDIV)
1757  {
1758    idDelDiv(id);
1759  }
1760  if (sw & SIMPL_LMEQ)
1761  {
1762    idDelLmEquals(id);
1763  }
1764  if (sw & SIMPL_NULL)
1765  {
1766    idSkipZeroes(id);
1767  }
1768  if (sw & SIMPL_NORM)
1769  {
1770    idNorm(id);
1771  }
1772  if (sw & SIMPL_MULT)
1773  {
1774    idDelMultiples(id);
1775  }
1776  else if(sw & SIMPL_EQU)
1777  {
1778    idDelEquals(id);
1779  }
1780  res->data = (char * )id;
1781  return FALSE;
1782}
1783static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
1784{
1785  res->data = mstrdup(slStatus((si_link) u->Data(), (char *) v->Data()));
1786  return FALSE;
1787}
1788static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
1789{
1790  int sw = (int)v->Data();
1791  poly p = (poly)u->CopyD();
1792  if (sw & SIMPL_NORM)
1793  {
1794    pNorm(p);
1795  }
1796  res->data = (char * )p;
1797  return FALSE;
1798}
1799static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
1800{
1801  ideal result;
1802  intvec *w=(intvec *)atGet(u,"isHomog");
1803  tHomog hom=testHomog;
1804  if (w!=NULL)
1805  {
1806    w=ivCopy(w);
1807    hom=isHomog;
1808  }
1809  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
1810  idSkipZeroes(result);
1811  res->data = (char *)result;
1812  setFlag(res,FLAG_STD);
1813  if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
1814  return FALSE;
1815}
1816static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
1817{
1818  ideal result;
1819  intvec *w=(intvec *)atGet(u,"isHomog");
1820  tHomog hom=testHomog;
1821  if (w!=NULL)
1822  {
1823    w=ivCopy(w);
1824    hom=isHomog;
1825  }
1826  ideal i1=(ideal)u->Data();
1827  ideal i0=idInit(1,i1->rank);
1828  i0->m[0]=(poly)v->Data();
1829  i1=idSimpleAdd(i1,i0);
1830  i0->m[0]=NULL;
1831  idDelete(&i0);
1832  BITSET save_test=test;
1833  test|=Sy_bit(OPT_SB_1);
1834  result=kStd(i1,currQuotient,hom,&w);
1835  test=save_test;
1836  idDelete(&i1);
1837  idSkipZeroes(result);
1838  res->data = (char *)result;
1839  setFlag(res,FLAG_STD);
1840  if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
1841  return FALSE;
1842}
1843static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
1844{
1845  idhdl h=(idhdl)u->data;
1846  int i=(int)v->Data();
1847  if ((0<i) && (i<=IDRING(h)->N))
1848    res->data=mstrdup(IDRING(h)->names[i-1]);
1849  else
1850  {
1851    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
1852    return TRUE;
1853  }
1854  return FALSE;
1855}
1856static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
1857{
1858  res->data = (char *)mpWedge((matrix)u->Data(),(int)v->Data());
1859  return FALSE;
1860}
1861#define jjWRONG2 (proc2)jjWRONG
1862#define jjWRONG3 (proc3)jjWRONG
1863static BOOLEAN jjWRONG(leftv res, leftv u)
1864{
1865  return TRUE;
1866}
1867/*=================== operations with 2 args.: table =================*/
1868struct sValCmd2 dArith2[]=
1869{
1870// operations:
1871// proc        cmd              res             arg1        arg2
1872 {jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD        PROFILER}
1873,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD     PROFILER}
1874,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
1875,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD PROFILER}
1876,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
1877,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
1878,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD PROFILER}
1879,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
1880,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
1881,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD PROFILER}
1882,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1883,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD PROFILER}
1884,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1885,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD PROFILER}
1886,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD PROFILER}
1887,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
1888,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD PROFILER}
1889,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD PROFILER}
1890,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1891,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
1892,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
1893,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD PROFILER}
1894,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
1895,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
1896,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1897,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1898,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD PROFILER}
1899,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
1900,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1901,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
1902,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
1903,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD PROFILER}
1904,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
1905,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
1906,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD PROFILER}
1907,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
1908,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD PROFILER}
1909,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD PROFILER}
1910,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD PROFILER}
1911,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
1912,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
1913,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD PROFILER}
1914,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD PROFILER}
1915,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD PROFILER}
1916,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD PROFILER}
1917,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD PROFILER}
1918,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
1919,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1920,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD PROFILER}
1921,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1922,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD PROFILER}
1923,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD PROFILER}
1924,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
1925,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
1926,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
1927,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
1928,{jjDIV_I,     '/',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1929,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1930,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1931,{jjDIV_I,     INTDIV,         INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1932,{jjOP_IV_I,   INTDIV,         INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1933,{jjOP_IV_I,   INTDIV,         INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1934,{jjMOD_I,     '%',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1935,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
1936,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
1937,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1938,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD PROFILER}
1939,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
1940,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
1941,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1942,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1943,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1944,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1945,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1946,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1947,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1948,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1949,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1950,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1951,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1952,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1953,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1954,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1955,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1956,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1957,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1958,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1959,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1960,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1961,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1962,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1963,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1964,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1965,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1966,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1967,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1968,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1969,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1970,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1971,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1972,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1973,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1974,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1975,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1976,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1977,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1978,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD PROFILER}
1979,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD PROFILER}
1980,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD PROFILER}
1981,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD PROFILER}
1982,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD PROFILER}
1983,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
1984,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
1985,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
1986,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
1987,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1988,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD PROFILER}
1989,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD PROFILER}
1990,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD PROFILER}
1991,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD PROFILER}
1992,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD PROFILER}
1993,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
1994,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
1995,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
1996,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD PROFILER}
1997,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD PROFILER}
1998,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD PROFILER}
1999,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD PROFILER}
2000,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD PROFILER}
2001,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD PROFILER}
2002,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD PROFILER}
2003,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD PROFILER}
2004,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2005,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD PROFILER}
2006,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD PROFILER}
2007,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD PROFILER}
2008,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD PROFILER}
2009,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD PROFILER}
2010,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD PROFILER}
2011,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD PROFILER}
2012// and the procedures with 2 arguments:
2013,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD PROFILER}
2014,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD PROFILER}
2015,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD PROFILER}
2016,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD PROFILER}
2017,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2018,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD PROFILER}
2019,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD PROFILER}
2020,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2021,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2022,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2023,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2024,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2025,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
2026,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD PROFILER}
2027,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD PROFILER}
2028,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2029,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2030,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD PROFILER}
2031#ifdef HAVE_FACTORY
2032,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2033,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD PROFILER}
2034,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD PROFILER}
2035#else
2036,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2037,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD PROFILER}
2038,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD PROFILER}
2039#endif
2040,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE PROFILER}
2041,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE PROFILER}
2042#ifdef HAVE_FGLM
2043,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD PROFILER}
2044,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD PROFILER}
2045#else
2046,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD PROFILER}
2047,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD PROFILER}
2048#endif
2049,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2050,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2051#ifdef HAVE_FACTORY
2052,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2053#else
2054,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2055#endif
2056,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD PROFILER}
2057,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD PROFILER}
2058,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2059,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2060,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2061,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2062,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD PROFILER}
2063,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE PROFILER}
2064,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE PROFILER}
2065,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2066,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD PROFILER}
2067,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2068,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2069,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2070,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2071,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD PROFILER}
2072,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2073,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2074,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2075,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD PROFILER}
2076,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD PROFILER}
2077,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD PROFILER}
2078,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2079,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD PROFILER}
2080,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD PROFILER}
2081,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD PROFILER}
2082,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD PROFILER}
2083,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2084,{jjRES,       LRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2085,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD PROFILER}
2086,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD PROFILER}
2087,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2088,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2089,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD PROFILER}
2090//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2091//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD PROFILER}
2092,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2093,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2094,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD PROFILER}
2095,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD PROFILER}
2096,{jjPRINT_FORMAT, PRINT_CMD,   NONE,           DEF_CMD,    STRING_CMD PROFILER}
2097,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2098,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
2099,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2100,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2101,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD PROFILER}
2102,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD PROFILER}
2103,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD PROFILER}
2104,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD PROFILER}
2105,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2106,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2107,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
2108//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2109//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD PROFILER}
2110,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2111,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2112,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD PROFILER}
2113,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2114,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD PROFILER}
2115,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2116,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2117//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2118//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD PROFILER}
2119,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2120,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2121,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD PROFILER}
2122,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2123,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD PROFILER}
2124,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD PROFILER}
2125,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD PROFILER}
2126,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD PROFILER}
2127,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD PROFILER}
2128,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD PROFILER}
2129,{NULL,        0,              0,              0,          0 PROFILER}
2130};
2131/*=================== operations with 1 arg.: static proc =================*/
2132static BOOLEAN jjDUMMY(leftv res, leftv u)
2133{
2134  res->data = (char *)u->CopyD();
2135  return FALSE;
2136}
2137static BOOLEAN jjNULL(leftv res, leftv u)
2138{
2139  return FALSE;
2140}
2141//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2142//{
2143//  res->data = (char *)((int)u->Data()+1);
2144//  return FALSE;
2145//}
2146//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
2147//{
2148//  res->data = (char *)((int)u->Data()-1);
2149//  return FALSE;
2150//}
2151static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2152{
2153  if (IDTYP((idhdl)u->data)==INT_CMD)
2154  {
2155    if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
2156    else                IDINT((idhdl)u->data)--;
2157    return FALSE;
2158  }
2159  return TRUE;
2160}
2161static BOOLEAN jjUMINUS_I(leftv res, leftv u)
2162{
2163  res->data = (char *)(-(int)u->Data());
2164  return FALSE;
2165}
2166static BOOLEAN jjUMINUS_N(leftv res, leftv u)
2167{
2168  number n=nNeg((number)u->CopyD());
2169  res->data = (char *)n;
2170  return FALSE;
2171}
2172static BOOLEAN jjUMINUS_P(leftv res, leftv u)
2173{
2174  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
2175  return FALSE;
2176}
2177static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
2178{
2179  poly m1=pISet(-1);
2180  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
2181  return FALSE;
2182}
2183static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
2184{
2185  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
2186  (*iv)*=(-1);
2187  res->data = (char *)iv;
2188  return FALSE;
2189}
2190static BOOLEAN jjPROC1(leftv res, leftv u)
2191{
2192  if ((u->rtyp!=IDHDL) || (u->e!=NULL))
2193    return TRUE;
2194  leftv sl = iiMake_proc((idhdl) u->data,NULL);
2195  if (sl==NULL)
2196  {
2197    return TRUE;
2198  }
2199  else
2200  {
2201    memcpy(res,sl,sizeof(sleftv));
2202  }
2203  return FALSE;
2204}
2205static BOOLEAN jjBAREISS(leftv res, leftv v)
2206{
2207  matrix m=(matrix)v->Data();
2208  lists l=mpBareiss(m,FALSE);
2209  res->data = (char *)l;
2210  return FALSE;
2211}
2212static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
2213{
2214  intvec *m=(intvec *)v->CopyD();
2215  ivTriangMat(m,1,1);
2216  res->data = (char *)m;
2217  return FALSE;
2218}
2219static BOOLEAN jjCALL1MANY(leftv res, leftv u)
2220{
2221  return iiExprArithM(res,u,iiOp);
2222}
2223static BOOLEAN jjCHAR(leftv res, leftv v)
2224{
2225  res->data = (char *)rChar((ring)v->Data());
2226  return FALSE;
2227}
2228static BOOLEAN jjCOLS(leftv res, leftv v)
2229{
2230  res->data = (char *)MATCOLS((matrix)(v->Data()));
2231  return FALSE;
2232}
2233static BOOLEAN jjCOLS_IV(leftv res, leftv v)
2234{
2235  res->data = (char *)((intvec*)(v->Data()))->cols();
2236  return FALSE;
2237}
2238static BOOLEAN jjCONTENT(leftv res, leftv v)
2239{
2240  poly p=(poly)v->CopyD();
2241  if (p!=NULL) pCleardenom(p);
2242  res->data = (char *)p;
2243  return FALSE;
2244}
2245static BOOLEAN jjCOUNT_N(leftv res, leftv v)
2246{
2247  res->data = (char *)nSize((number)v->Data());
2248  return FALSE;
2249}
2250static BOOLEAN jjCOUNT_L(leftv res, leftv v)
2251{
2252  lists l=(lists)v->Data();
2253  res->data = (char *)(l->nr+1);
2254  return FALSE;
2255}
2256static BOOLEAN jjCOUNT_M(leftv res, leftv v)
2257{
2258  matrix m=(matrix)v->Data();
2259  res->data = (char *)(MATROWS(m)*MATCOLS(m));
2260  return FALSE;
2261}
2262static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
2263{
2264  res->data = (char *)((intvec*)(v->Data()))->length();
2265  return FALSE;
2266}
2267static BOOLEAN jjDEG(leftv res, leftv v)
2268{
2269  int dummy;
2270  poly p=(poly)v->Data();
2271  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy);
2272  else res->data=(char *)-1;
2273  return FALSE;
2274}
2275static BOOLEAN jjDEGREE(leftv res, leftv v)
2276{
2277  assumeStdFlag(v);
2278  scDegree((ideal)v->Data(),currQuotient);
2279  return FALSE;
2280}
2281static BOOLEAN jjDEFINED(leftv res, leftv v)
2282{
2283  if ((v->rtyp==IDHDL)
2284  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
2285  {
2286    res->data=(void *)(IDLEV((idhdl)v->data)+1);
2287  }
2288  else if (v->rtyp!=0) res->data=(void *)(-1);
2289  return FALSE;
2290}
2291#ifdef HAVE_FACTORY
2292static BOOLEAN jjDET(leftv res, leftv v)
2293{
2294  int i,j;
2295  matrix m=(matrix)v->Data();
2296  if (currRing->parameter==NULL)
2297  {
2298    for(i=m->rows();i>0;i--)
2299    {
2300      for(j=m->cols();j>0;j--)
2301      {
2302        if((MATELEM(m,i,j)!=NULL)
2303        && (!pIsConstant(MATELEM(m,i,j))))
2304        {
2305          goto nonconst;
2306        }
2307      }
2308    }
2309    res->data = (char *)singclap_det(m);
2310    return FALSE;
2311  }
2312nonconst:
2313  res->data = (char *)mpDet(m);
2314  return FALSE;
2315}
2316static BOOLEAN jjDET_I(leftv res, leftv v)
2317{
2318  intvec * m=(intvec*)v->Data();
2319  int i,j;
2320  i=m->rows();j=m->cols();
2321  if(i==j)
2322    res->data = (char *)singclap_det_i(m);
2323  else
2324  {
2325    Werror("det of %d x %d intmat",i,j);
2326    return TRUE;
2327  }
2328  return FALSE;
2329}
2330#endif
2331static BOOLEAN jjDIM(leftv res, leftv v)
2332{
2333  assumeStdFlag(v);
2334  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
2335  return FALSE;
2336}
2337static BOOLEAN jjDUMP(leftv res, leftv v)
2338{
2339  si_link l = (si_link)v->Data();
2340  if (slDump(l))
2341  {
2342    const char *s;
2343    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2344    else                            s=sNoName;
2345    Werror("cannot dump to `%s`",s);
2346    return TRUE;
2347  }
2348  else
2349    return FALSE;
2350}
2351static BOOLEAN jjE(leftv res, leftv v)
2352{
2353  res->data = (char *)pOne();
2354  pSetComp((poly)res->data,(int)v->Data());
2355  return FALSE;
2356}
2357static BOOLEAN jjGETDUMP(leftv res, leftv v)
2358{
2359  si_link l = (si_link)v->Data();
2360  if (slGetDump(l))
2361  {
2362    const char *s;
2363    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2364    else                            s=sNoName;
2365    Werror("cannot get dump from `%s`",s);
2366    return TRUE;
2367  }
2368  else
2369    return FALSE;
2370}
2371#ifdef HAVE_FACTORY
2372static BOOLEAN jjFACSTD(leftv res, leftv v)
2373{
2374  res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
2375  setFlag(res,FLAG_STD);
2376  return FALSE;
2377}
2378#endif
2379static BOOLEAN jjHILBERT(leftv res, leftv v)
2380{
2381  assumeStdFlag(v);
2382  intvec *module_w=(intvec*)atGet(v,"isHomog");
2383  //scHilbertPoly((ideal)v->Data(),currQuotient);
2384  hLookSeries((ideal)v->Data(),module_w,currQuotient);
2385  return FALSE;
2386}
2387static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
2388{
2389  res->data=(void *)hSecondSeries((intvec *)v->Data());
2390  return FALSE;
2391}
2392static BOOLEAN jjHOMOG1(leftv res, leftv v)
2393{
2394  intvec *w;
2395  res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
2396  if ((v->rtyp==IDHDL)&&(w!=NULL))
2397    atSet((idhdl)v->data,mstrdup("isHomog"),w,INTVEC_CMD);
2398  return FALSE;
2399}
2400static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
2401{
2402  matrix mat=(matrix)v->CopyD();
2403  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
2404  MATROWS(mat)=1;
2405  mat->rank=1;
2406  res->data=(char *)mat;
2407  return FALSE;
2408}
2409static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
2410{
2411  map m=(map)v->CopyD();
2412  FreeL((ADDRESS)m->preimage);
2413  m->preimage=NULL;
2414  ideal I=(ideal)m;
2415  I->rank=1;
2416  res->data=(char *)I;
2417  return FALSE;
2418}
2419static BOOLEAN jjIDEAL_R(leftv res, leftv v)
2420{
2421  if (currRing!=NULL)
2422  {
2423    ring q=(ring)v->Data();
2424    if ((q->ch==currRing->ch)
2425    && (q->N==currRing->N)) /* && varnames equ. */
2426    {
2427      if (q->qideal==NULL)
2428        res->data=(char *)idInit(1,1);
2429      else
2430        res->data=(char *)idCopy(q->qideal);
2431      return FALSE;
2432    }
2433  }
2434  return TRUE;
2435}
2436static BOOLEAN jjIm2Iv(leftv res, leftv v)
2437{
2438  intvec *iv = (intvec *)v->CopyD();
2439  iv->makeVector();
2440  res->data = iv;
2441  return FALSE;
2442}
2443static BOOLEAN jjINDEPSET(leftv res, leftv v)
2444{
2445  assumeStdFlag(v);
2446  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
2447  return FALSE;
2448}
2449static BOOLEAN jjINTERRED(leftv res, leftv v)
2450{
2451  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
2452  //if (result==NULL) return TRUE;
2453  idSkipZeroes(result);
2454  res->data = result;
2455  return FALSE;
2456}
2457static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
2458{
2459  res->data = (char *)pVar((poly)v->Data());
2460  return FALSE;
2461}
2462static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
2463{
2464  res->data = (char *)(rIsRingVar((char *)v->Data())+1);
2465  return FALSE;
2466}
2467static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
2468{
2469  res->data = (char *)0;
2470  return FALSE;
2471}
2472static BOOLEAN jjJACOB_P(leftv res, leftv v)
2473{
2474  ideal i=idInit(pVariables,1);
2475  int k;
2476  for (k=pVariables;k>0;k--)
2477  {
2478    i->m[k-1]=pDiff(pCopy((poly)(v->Data())),k);
2479  }
2480  res->data = (char *)i;
2481  return FALSE;
2482}
2483static BOOLEAN jjKBASE(leftv res, leftv v)
2484{
2485  assumeStdFlag(v);
2486  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
2487  return FALSE;
2488}
2489static BOOLEAN jjKLAMMER_LIB(leftv res, leftv u)
2490{
2491  char * s=(char *)u->Data();
2492  return iiLibCmd(s);
2493}
2494#ifdef MDEBUG
2495static BOOLEAN jjpHead(leftv res, leftv v)
2496{
2497  res->data=(char *)pHead((poly)v->Data());
2498  return FALSE;
2499}
2500#endif
2501static BOOLEAN jjL2R(leftv res, leftv v)
2502{
2503  res->data=(char *)syConvList((lists)v->Data());
2504  return FALSE;
2505}
2506static BOOLEAN jjLEADCOEF(leftv res, leftv v)
2507{
2508  poly p=(poly)v->Data();
2509  if (p==NULL)
2510  {
2511    res->data=(char *)nInit(0);
2512  }
2513  else
2514  {
2515    res->data=(char *)nCopy(pGetCoeff(p));
2516  }
2517  return FALSE;
2518}
2519static BOOLEAN jjLEADEXP(leftv res, leftv v)
2520{
2521  poly p=(poly)v->Data();
2522  intvec *iv=new intvec(pVariables);
2523  if (p!=NULL)
2524  {
2525    for(int i = pVariables;i;i--)
2526    {
2527      (*iv)[i-1]=pGetExp(p,i);
2528    }
2529  }
2530  res->data=(char *)iv;
2531  return FALSE;
2532}
2533static BOOLEAN jjMEMORY(leftv res, leftv v)
2534{
2535#ifdef MM_COUNT
2536  switch(((int)v->Data()))
2537  {
2538  case 0:
2539    res->data = (char *)mmMemUsed();
2540    break;
2541  case 1:
2542    res->data = (char *)mmMemReal();
2543    break;
2544#ifdef HAVE_SBRK
2545  case 2:
2546    res->data = (char *)mmMemPhysical();
2547    break;
2548#endif
2549  default:
2550#ifdef MM_STAT
2551    mmStat((int)v->Data());
2552#endif
2553    res->data = (char *)0;
2554  }
2555  return FALSE;
2556#else
2557  res->data = (char *)0;
2558  return FALSE;
2559#endif
2560}
2561static BOOLEAN jjMONITOR1(leftv res, leftv v)
2562{
2563  monitor((char *)(v->Data()),PROT_I);
2564  return FALSE;
2565}
2566static BOOLEAN jjMSTD(leftv res, leftv v)
2567{
2568  res->data=(void *)min_std((ideal)v->Data(),currQuotient,testHomog,NULL);
2569  return FALSE;
2570}
2571static BOOLEAN jjMULT(leftv res, leftv v)
2572{
2573  assumeStdFlag(v);
2574  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
2575  return FALSE;
2576}
2577static BOOLEAN jjNAMEOF(leftv res, leftv v)
2578{
2579  res->data = (char *)v->name;
2580  if (res->data==NULL) res->data=mstrdup("");
2581  v->name=NULL;
2582  return FALSE;
2583}
2584static BOOLEAN jjNAMES(leftv res, leftv v)
2585{
2586  res->data=ipNameList(((ring)v->Data())->idroot);
2587  return FALSE;
2588}
2589static BOOLEAN jjNVARS(leftv res, leftv v)
2590{
2591  res->data = (char *)(((ring)(v->Data()))->N);
2592  return FALSE;
2593}
2594static BOOLEAN jjOpenClose(leftv res, leftv v)
2595{
2596  si_link l=(si_link)v->Data();
2597  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
2598  else                return slClose(l);
2599}
2600static BOOLEAN jjORD(leftv res, leftv v)
2601{
2602  poly p=(poly)v->Data();
2603  res->data=(char *)( p==NULL ? -1 : pFDeg(p) );
2604  return FALSE;
2605}
2606static BOOLEAN jjPAR1(leftv res, leftv v)
2607{
2608  int i=(int)v->Data();
2609  int p=0;
2610  p=rPar(currRing);
2611  if ((0<i) && (i<=p))
2612  {
2613    res->data=(char *)nPar(i);
2614  }
2615  else
2616  {
2617    Werror("par number %d out of range 1..%d",i,p);
2618    return TRUE;
2619  }
2620  return FALSE;
2621}
2622static BOOLEAN jjPARDEG(leftv res, leftv v)
2623{
2624  res->data = (char *)nParDeg((number)v->Data());
2625  return FALSE;
2626}
2627static BOOLEAN jjPARSTR1(leftv res, leftv v)
2628{
2629  if (currRing==NULL)
2630  {
2631    WerrorS("no ring active");
2632    return TRUE;
2633  }
2634  int i=(int)v->Data();
2635  int p=0;
2636  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
2637    res->data=mstrdup(currRing->parameter[i-1]);
2638  else
2639  {
2640    Werror("par number %d out of range 1..%d",i,p);
2641    return TRUE;
2642  }
2643  return FALSE;
2644}
2645static BOOLEAN jjP2I(leftv res, leftv v)
2646{
2647  poly p=(poly)v->Data();
2648  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
2649  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
2650  {
2651    WerrorS("poly must be constant");
2652    return TRUE;
2653  }
2654  res->data = (char *)nInt(pGetCoeff(p));
2655  return FALSE;
2656}
2657static BOOLEAN jjPRIME(leftv res, leftv v)
2658{
2659  int i = IsPrime((int)(v->Data()));
2660  res->data = (char *)(i > 1 ? i : 2);
2661  return FALSE;
2662}
2663static BOOLEAN jjP2N(leftv res, leftv v)
2664{
2665  number n;
2666  poly p;
2667  if (((p=(poly)v->Data())!=NULL)
2668  && (pIsConstant(p)))
2669  {
2670    n=nCopy(pGetCoeff(p));
2671  }
2672  else
2673  {
2674    n=nInit(0);
2675  }
2676  res->data = (char *)n;
2677  return FALSE;
2678}
2679static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
2680{
2681  char *s= (char *)v->Data();
2682  int i = 1;
2683  int l = strlen(s);
2684  while (cmds[i].tokval!=0)
2685  {
2686    if (strcmp(s, cmds[i].name) == 0)
2687    {
2688      res->data = (char *)1;
2689      return FALSE;
2690    }
2691    i++;
2692  }
2693  //res->data = (char *)0;
2694  return FALSE;
2695}
2696static BOOLEAN jjREAD(leftv res, leftv v)
2697{
2698  return jjREAD2(res,v,NULL);
2699}
2700static BOOLEAN jjREGULARITY(leftv res, leftv v)
2701{
2702  res->data = (char *)iiRegularity((lists)v->Data());
2703  return FALSE;
2704}
2705static BOOLEAN jjROWS(leftv res, leftv v)
2706{
2707  ideal i = (ideal)v->Data();
2708  res->data = (char *)i->rank;
2709  return FALSE;
2710}
2711static BOOLEAN jjROWS_IV(leftv res, leftv v)
2712{
2713  res->data = (char *)((intvec*)(v->Data()))->rows();
2714  return FALSE;
2715}
2716static BOOLEAN jjRPAR(leftv res, leftv v)
2717{
2718  res->data = (char *)((ring)v->Data())->P;
2719  return FALSE;
2720}
2721static BOOLEAN jjSTD(leftv res, leftv v)
2722{
2723  ideal result;
2724  intvec *w=(intvec *)atGet(v,"isHomog");
2725  tHomog hom=testHomog;
2726  if (w!=NULL)
2727  {
2728    w=ivCopy(w);
2729    hom=isHomog;
2730  }
2731  //if (hasFlag(v,FLAG_STD))
2732  //  result=stdred((ideal)v->Data(),currQuotient,hom,&w);
2733  //else
2734    result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
2735  idSkipZeroes(result);
2736  res->data = (char *)result;
2737  setFlag(res,FLAG_STD);
2738  if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
2739  return FALSE;
2740}
2741static BOOLEAN jjSTRING(leftv res, leftv v)
2742{
2743  res->data = (char *)v->String();
2744  if (res->data==NULL)
2745  {
2746    Werror("cannot convert %s to string",Tok2Cmdname(v->Typ()));
2747    return TRUE;
2748  }
2749  return FALSE;
2750}
2751static BOOLEAN jjSort_Id(leftv res, leftv v)
2752{
2753  res->data = (char *)idSort((ideal)v->Data());
2754  return FALSE;
2755}
2756static BOOLEAN jjSTRING_PROC(leftv res, leftv v)
2757{
2758  procinfov pi = IDPROC((idhdl)v->data);
2759  if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
2760  //if(pi->language == LANG_SINGULAR)
2761  {
2762    //if(pi->data.s.body==NULL)
2763    //  iiGetLibProcBuffer(IDPROC((idhdl)v->data));
2764    res->data=mstrdup(pi->data.s.body);
2765  }
2766  else
2767    res->data=mstrdup("");
2768  return FALSE;
2769}
2770static BOOLEAN jjSYZYGY(leftv res, leftv v)
2771{
2772  intvec *w=NULL;
2773  res->data = (char *)idSyzygies((ideal)v->Data(),currQuotient,testHomog,&w);
2774  if (w!=NULL) delete w;
2775  return FALSE;
2776}
2777static BOOLEAN jjTRACE_IV(leftv res, leftv v)
2778{
2779  res->data = (char *)ivTrace((intvec*)(v->Data()));
2780  return FALSE;
2781}
2782static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
2783{
2784  res->data = (char *)ivTranp((intvec*)(v->Data()));
2785  return FALSE;
2786}
2787static BOOLEAN jjTYPEOF(leftv res, leftv v)
2788{
2789  switch ((int)v->data)
2790  {
2791    case INT_CMD:     res->data=mstrdup("int"); break;
2792    case POLY_CMD:   res->data=mstrdup("poly"); break;
2793    case VECTOR_CMD:  res->data=mstrdup("vector"); break;
2794    case STRING_CMD:  res->data=mstrdup("string"); break;
2795    case INTVEC_CMD:  res->data=mstrdup("intvec"); break;
2796    case IDEAL_CMD:   res->data=mstrdup("ideal"); break;
2797    case MATRIX_CMD: res->data=mstrdup("matrix"); break;
2798    case MODUL_CMD:   res->data=mstrdup("module"); break;
2799    case MAP_CMD:     res->data=mstrdup("map"); break;
2800    case PROC_CMD:    res->data=mstrdup("proc"); break;
2801    case RING_CMD:    res->data=mstrdup("ring"); break;
2802    case QRING_CMD:   res->data=mstrdup("qring"); break;
2803    case INTMAT_CMD:  res->data=mstrdup("intmat"); break;
2804    case NUMBER_CMD:  res->data=mstrdup("number"); break;
2805    case LIST_CMD:   res->data=mstrdup("list"); break;
2806    case PACKAGE_CMD: res->data=mstrdup("package"); break;
2807    case LINK_CMD:   res->data=mstrdup("link"); break;
2808    case RESOLUTION_CMD:res->data=mstrdup("resolution");break;
2809    case DEF_CMD:
2810    case NONE:    res->data=mstrdup("none"); break;
2811    default:       res->data=mstrdup("?unknown type?");
2812  }
2813  return FALSE;
2814}
2815static BOOLEAN jjVAR1(leftv res, leftv v)
2816{
2817  int i=(int)v->Data();
2818  if ((0<i) && (i<=currRing->N))
2819  {
2820    poly p=pOne();
2821    pSetExp(p,i,1);
2822    pSetm(p);
2823    res->data=(char *)p;
2824  }
2825  else
2826  {
2827    Werror("var number %d out of range 1..%d",i,currRing->N);
2828    return TRUE;
2829  }
2830  return FALSE;
2831}
2832static BOOLEAN jjVARSTR1(leftv res, leftv v)
2833{
2834  if (currRing==NULL)
2835  {
2836    WerrorS("no ring active");
2837    return TRUE;
2838  }
2839  int i=(int)v->Data();
2840  if ((0<i) && (i<=currRing->N))
2841    res->data=mstrdup(currRing->names[i-1]);
2842  else
2843  {
2844    Werror("var number %d out of range 1..%d",i,currRing->N);
2845    return TRUE;
2846  }
2847  return FALSE;
2848}
2849static BOOLEAN jjVDIM(leftv res, leftv v)
2850{
2851  assumeStdFlag(v);
2852  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
2853  return FALSE;
2854}
2855/*=================== operations with 1 arg.: table =================*/
2856
2857#ifdef INIT_BUG
2858#define XS(A) -((short)A)
2859#define jjstrlen       (proc1)1
2860#define jjpLength      (proc1)2
2861#define jjidElem       (proc1)3
2862#define jjmpDet        (proc1)4
2863#define jjidFreeModule (proc1)5
2864#define jjidVec2Ideal  (proc1)6
2865#define jjrCharStr     (proc1)7
2866#ifndef MDEBUG
2867#define jjpHead        (proc1)8
2868#endif
2869#define jjidHead       (proc1)9
2870#define jjidMaxIdeal   (proc1)10
2871#define jjidMinBase    (proc1)11
2872#define jjsyMinBase    (proc1)12
2873#define jjpMaxComp     (proc1)13
2874#define jjmpTrace      (proc1)14
2875#define jjmpTransp     (proc1)15
2876#define jjrOrdStr      (proc1)16
2877#define jjrVarStr      (proc1)18
2878#define jjrParStr      (proc1)19
2879#define jjidMinEmbedding (proc1)20
2880#define jjBETTI_R        (proc1)21
2881#define jjCOUNT_R        (proc1)22
2882#define jjDIM_R          (proc1)23
2883#define jjMINRES_R       (proc1)24
2884
2885extern struct sValCmd1 dArith1[];
2886void jjInitTab1()
2887{
2888  int i=0;
2889  for (;dArith1[i].cmd!=0;i++)
2890  {
2891    if (dArith1[i].res<0)
2892    {
2893      switch ((int)dArith1[i].p)
2894      {
2895        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
2896        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
2897        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
2898        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
2899#ifndef HAVE_FACTORY
2900        case (int)jjmpDet:        dArith1[i].p=(proc1)mpDet; break;
2901#endif
2902        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
2903        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
2904#ifndef MDEBUG
2905        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
2906#endif
2907        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
2908        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
2909        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
2910        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
2911        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxComp; break;
2912        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
2913        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
2914        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
2915        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
2916        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
2917        case (int)jjidMinEmbedding: dArith1[i].p=(proc1)idMinEmbedding; break;
2918        case (int)jjBETTI_R:      dArith1[i].p=(proc1)syBettiOfComputation; break;
2919        case (int)jjCOUNT_R:      dArith1[i].p=(proc1)syLength; break;
2920        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
2921        case (int)jjMINRES_R:     dArith1[i].p=(proc1)syMinimize; break;
2922#ifdef GENTABLE
2923        default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
2924#endif
2925      }
2926    }
2927  }
2928}
2929#else
2930#if defined(PROC_BUG)
2931#define XS(A) A
2932static BOOLEAN jjstrlen(leftv res, leftv v)
2933{
2934  res->data = (char *)strlen((char *)v->Data());
2935  return FALSE;
2936}
2937static BOOLEAN jjpLength(leftv res, leftv v)
2938{
2939  res->data = (char *)pLength((poly)v->Data());
2940  return FALSE;
2941}
2942static BOOLEAN jjidElem(leftv res, leftv v)
2943{
2944  res->data = (char *)idElem((ideal)v->Data());
2945  return FALSE;
2946}
2947static BOOLEAN jjmpDet(leftv res, leftv v)
2948{
2949  res->data = (char *)mpDet((matrix)v->Data());
2950  return FALSE;
2951}
2952static BOOLEAN jjidFreeModule(leftv res, leftv v)
2953{
2954  res->data = (char *)idFreeModule((int)v->Data());
2955  return FALSE;
2956}
2957static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
2958{
2959  res->data = (char *)idVec2Ideal((poly)v->Data());
2960  return FALSE;
2961}
2962static BOOLEAN jjrCharStr(leftv res, leftv v)
2963{
2964  res->data = rCharStr((ring)v->Data());
2965  return FALSE;
2966}
2967#ifndef MDEBUG
2968static BOOLEAN jjpHead(leftv res, leftv v)
2969{
2970  res->data = (char *)pHead((poly)v->Data());
2971  return FALSE;
2972}
2973#endif
2974static BOOLEAN jjidHead(leftv res, leftv v)
2975{
2976  res->data = (char *)idHead((ideal)v->Data());
2977  return FALSE;
2978}
2979static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
2980{
2981  res->data = (char *)idMaxIdeal((int)v->Data());
2982  return FALSE;
2983}
2984static BOOLEAN jjidMinBase(leftv res, leftv v)
2985{
2986  res->data = (char *)idMinBase((ideal)v->Data());
2987  return FALSE;
2988}
2989static BOOLEAN jjsyMinBase(leftv res, leftv v)
2990{
2991  res->data = (char *)syMinBase((ideal)v->Data());
2992  return FALSE;
2993}
2994static BOOLEAN jjpMaxComp(leftv res, leftv v)
2995{
2996  res->data = (char *)pMaxComp((poly)v->Data());
2997  return FALSE;
2998}
2999static BOOLEAN jjmpTrace(leftv res, leftv v)
3000{
3001  res->data = (char *)mpTrace((matrix)v->Data());
3002  return FALSE;
3003}
3004static BOOLEAN jjmpTransp(leftv res, leftv v)
3005{
3006  res->data = (char *)mpTransp((matrix)v->Data());
3007  return FALSE;
3008}
3009static BOOLEAN jjrOrdStr(leftv res, leftv v)
3010{
3011  res->data = rOrdStr((ring)v->Data());
3012  return FALSE;
3013}
3014static BOOLEAN jjrVarStr(leftv res, leftv v)
3015{
3016  res->data = rVarStr((ring)v->Data());
3017  return FALSE;
3018}
3019static BOOLEAN jjrParStr(leftv res, leftv v)
3020{
3021  res->data = rParStr((ring)v->Data());
3022  return FALSE;
3023}
3024static BOOLEAN jjidMinEmbedding(leftv res, leftv v)
3025{
3026  res->data = (char *)idMinEmbedding((ideal)v->Data());
3027  return FALSE;
3028}
3029static BOOLEAN jjBETTI_R(leftv res, leftv v)
3030{
3031  res->data=(char *)syBettiOfComputation((syStrategy)v->Data());
3032  return FALSE;
3033}
3034static BOOLEAN jjCOUNT_R(leftv res, leftv v)
3035{
3036  res->data=(char *)syLength((syStrategy)v->Data());
3037  return FALSE;
3038}
3039static BOOLEAN jjDIM_R(leftv res, leftv v)
3040{
3041  res->data = (char *)syDim((syStrategy)v->Data());
3042  return FALSE;
3043}
3044static BOOLEAN jjMINRES_R(leftv res, leftv v)
3045{
3046  res->data=(char *)syMinimize((syStrategy)v->Data());
3047  return FALSE;
3048}
3049#else
3050#define XS(A)          -((short)A)
3051#define jjstrlen       (proc1)strlen
3052#define jjpLength      (proc1)pLength
3053#define jjidElem       (proc1)idElem
3054#define jjmpDet        (proc1)mpDet
3055#define jjidFreeModule (proc1)idFreeModule
3056#define jjidVec2Ideal  (proc1)idVec2Ideal
3057#define jjrCharStr     (proc1)rCharStr
3058#ifndef MDEBUG
3059#define jjpHead        (proc1)pHead
3060#endif
3061#define jjidHead       (proc1)idHead
3062#define jjidMaxIdeal   (proc1)idMaxIdeal
3063#define jjidMinBase    (proc1)idMinBase
3064#define jjsyMinBase    (proc1)syMinBase
3065#define jjpMaxComp     (proc1)pMaxComp
3066#define jjmpTrace      (proc1)mpTrace
3067#define jjmpTransp     (proc1)mpTransp
3068#define jjrOrdStr      (proc1)rOrdStr
3069#define jjrVarStr      (proc1)rVarStr
3070#define jjrParStr      (proc1)rParStr
3071#define jjidMinEmbedding (proc1)idMinEmbedding
3072#define jjBETTI_R        (proc1)syBettiOfComputation
3073#define jjCOUNT_R        (proc1)syLength
3074#define jjDIM_R        (proc1)syDim
3075#define jjMINRES_R     (proc1)syMinimize
3076#endif
3077#endif
3078BOOLEAN jjnInt(leftv res, leftv u)
3079{
3080  number n=(number)u->CopyD();
3081  res->data=(char *)nInt(n);
3082  nDelete(&n);
3083  return FALSE;
3084}
3085#define s short
3086struct sValCmd1 dArith1[]=
3087{
3088// operations:
3089// proc         cmd               res             arg
3090// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD }
3091//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD }
3092 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL }
3093,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL }
3094,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD }
3095,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD }
3096,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD }
3097,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD }
3098,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD }
3099,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD }
3100,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD }
3101,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD }
3102,{jjKLAMMER_LIB,'(',             NONE,           STRING_CMD }
3103// and the procedures with 1 argument:
3104,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD }
3105,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD }
3106,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MATRIX_CMD }
3107,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD }
3108,{jjBETTI_R,    BETTI_CMD,       XS(INTMAT_CMD), RESOLUTION_CMD }
3109,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD }
3110,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD }
3111#ifdef HAVE_FACTORY
3112,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD }
3113#else
3114,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD }
3115#endif
3116,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD }
3117,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD }
3118,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD }
3119,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD }
3120,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD }
3121,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD }
3122,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD }
3123,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD }
3124,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD }
3125,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD }
3126,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD }
3127,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD }
3128,{jjCOUNT_R,    COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD }
3129,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD }
3130,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD }
3131,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD }
3132,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD }
3133,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD }
3134,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD }
3135,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD }
3136,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD }
3137,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD }
3138,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD }
3139,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE }
3140,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD }
3141,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD }
3142,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD }
3143,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD }
3144,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD }
3145#ifdef HAVE_FACTORY
3146,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD }
3147,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD }
3148#else
3149,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD }
3150,{jjmpDet,      DET_CMD,         XS(POLY_CMD),   MATRIX_CMD }
3151#endif
3152,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD }
3153,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD }
3154,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD }
3155,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD }
3156,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD }
3157#ifdef HAVE_FACTORY
3158,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD }
3159#else
3160,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD }
3161#endif
3162#ifdef HAVE_FGLM
3163,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD}
3164#else
3165,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD}
3166#endif
3167,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD }
3168#ifdef HAVE_FACTORY
3169,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD }
3170#else
3171,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD }
3172#endif
3173,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD }
3174,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD }
3175,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD }
3176,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD }
3177,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD }
3178,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD }
3179,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD }
3180,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD }
3181,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD }
3182,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD }
3183,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD }
3184,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD }
3185,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD }
3186,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD }
3187,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD }
3188,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD }
3189,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD }
3190,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD }
3191,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD }
3192,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD }
3193,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD }
3194,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD }
3195,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD }
3196,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE }
3197,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD }
3198,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD }
3199,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD }
3200,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD }
3201,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL }
3202#ifdef MDEBUG
3203,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD }
3204#else
3205,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD }
3206#endif
3207,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD }
3208#ifdef MDEBUG
3209,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD }
3210#else
3211,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD }
3212#endif
3213,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD }
3214,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD }
3215,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD }
3216,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD }
3217,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD }
3218,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD }
3219,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE}
3220,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD }
3221,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD }
3222,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD }
3223,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD }
3224,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD }
3225,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD }
3226,{jjMINRES_R,   MINRES_CMD,      XS(RESOLUTION_CMD), RESOLUTION_CMD }
3227,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD }
3228,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD }
3229,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD }
3230,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD }
3231,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD }
3232,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE }
3233,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD }
3234,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD }
3235,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD }
3236,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD }
3237,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD }
3238,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD }
3239,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD }
3240,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD }
3241,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD }
3242,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD }
3243,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD }
3244,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD }
3245,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3246,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD }
3247,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD }
3248,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD }
3249,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD }
3250,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3251,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD }
3252,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD }
3253,{jjPRINT_GEN,  PRINT_CMD,       NONE,           INT_CMD }
3254,{jjPRINT_INTVEC,PRINT_CMD,      NONE,           INTVEC_CMD }
3255,{jjPRINT_INTMAT,PRINT_CMD,      NONE,           INTMAT_CMD }
3256,{jjPRINT_GEN,  PRINT_CMD,       NONE,           STRING_CMD }
3257,{jjPRINT_GEN,  PRINT_CMD,       NONE,           POLY_CMD }
3258,{jjPRINT_V,    PRINT_CMD,       NONE,           VECTOR_CMD }
3259,{jjPRINT_GEN,  PRINT_CMD,       NONE,           IDEAL_CMD }
3260,{jjPRINT_MA,   PRINT_CMD,       NONE,           MATRIX_CMD }
3261,{jjPRINT_LIST, PRINT_CMD,       NONE,           LIST_CMD }
3262,{jjPRINT_GEN,  PRINT_CMD,       NONE,           RESOLUTION_CMD }
3263,{jjidMinEmbedding, PRUNE_CMD,   XS(MODUL_CMD),  MODUL_CMD }
3264,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD }
3265,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD }
3266,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE}
3267,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD }
3268,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD }
3269,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD }
3270,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD }
3271,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD }
3272,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD }
3273,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD }
3274,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD }
3275,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD }
3276,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD }
3277,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD }
3278,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD }
3279,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD }
3280,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD }
3281,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD }
3282,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD }
3283,{jjSTRING,     STRING_CMD,      STRING_CMD,     INT_CMD }
3284,{jjSTRING,     STRING_CMD,      STRING_CMD,     POLY_CMD }
3285,{jjSTRING,     STRING_CMD,      STRING_CMD,     VECTOR_CMD }
3286,{jjSTRING,     STRING_CMD,      STRING_CMD,     NUMBER_CMD }
3287,{jjSTRING,     STRING_CMD,      STRING_CMD,     MATRIX_CMD }
3288,{jjSTRING,     STRING_CMD,      STRING_CMD,     MODUL_CMD }
3289,{jjSTRING,     STRING_CMD,      STRING_CMD,     IDEAL_CMD }
3290,{jjSTRING,     STRING_CMD,      STRING_CMD,     MAP_CMD }
3291,{jjSTRING,     STRING_CMD,      STRING_CMD,     INTVEC_CMD }
3292,{jjSTRING,     STRING_CMD,      STRING_CMD,     INTMAT_CMD }
3293,{jjSTRING_PROC,STRING_CMD,      STRING_CMD,     PROC_CMD }
3294,{jjSTRING,     STRING_CMD,      STRING_CMD,     RING_CMD }
3295,{jjSTRING,     STRING_CMD,      STRING_CMD,     QRING_CMD }
3296,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD }
3297,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD }
3298,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD }
3299,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD }
3300,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD }
3301,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD }
3302,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD }
3303,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD }
3304,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD }
3305,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD }
3306,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE }
3307,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD }
3308,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD }
3309,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD }
3310,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD }
3311,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD }
3312,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD }
3313,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3314,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD }
3315,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD }
3316,{NULL,         0,               0,              0}
3317};
3318#undef s
3319/*=================== operations with 3 args.: static proc =================*/
3320static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
3321{
3322  char *s= (char *)u->Data();
3323  int   r = (int)v->Data();
3324  int   c = (int)w->Data();
3325  int l = strlen(s);
3326
3327  if ( (r<1) || (r>l) || (c<0) )
3328  {
3329    Werror("wrong range[%d,%d] in string %s",r,c,u->Name());
3330    return TRUE;
3331  }
3332  res->data = (char *)AllocL(c+1);
3333  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
3334  return FALSE;
3335}
3336static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
3337{
3338  intvec *iv = (intvec *)u->Data();
3339  int   r = (int)v->Data();
3340  int   c = (int)w->Data();
3341  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
3342  {
3343    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
3344           r,c,u->Name(),iv->rows(),iv->cols());
3345    return TRUE;
3346  }
3347  res->data=u->data;
3348  u->data=NULL;
3349  res->rtyp=u->rtyp;
3350  u->rtyp=0;
3351  res->name=u->name;
3352  u->name=NULL;
3353  Subexpr e=jjMakeSub(v);
3354          e->next=jjMakeSub(w);
3355  if (u->e==NULL) res->e=e;
3356  else
3357  {
3358    Subexpr h=u->e;
3359    while (h->next!=NULL) h=h->next;
3360    h->next=e;
3361    res->e=u->e;
3362    u->e=NULL;
3363  }
3364  return FALSE;
3365}
3366static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
3367{
3368  matrix m= (matrix)u->Data();
3369  int   r = (int)v->Data();
3370  int   c = (int)w->Data();
3371  //Print("gen. elem %d, %d\n",r,c);
3372  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
3373  {
3374    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Name(),
3375      MATROWS(m),MATCOLS(m));
3376    return TRUE;
3377  }
3378  res->data=u->data;
3379  u->data=NULL;
3380  res->rtyp=u->rtyp;
3381  u->rtyp=0;
3382  res->name=u->name;
3383  u->name=NULL;
3384  Subexpr e=jjMakeSub(v);
3385          e->next=jjMakeSub(w);
3386  if (u->e==NULL)
3387    res->e=e;
3388  else
3389  {
3390    Subexpr h=u->e;
3391    while (h->next!=NULL) h=h->next;
3392    h->next=e;
3393    res->e=u->e;
3394    u->e=NULL;
3395  }
3396  return FALSE;
3397}
3398static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
3399{
3400  sleftv t;
3401  sleftv ut;
3402  leftv p=NULL;
3403  intvec *iv=(intvec *)w->Data();
3404  int l;
3405  BOOLEAN nok;
3406
3407  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3408  {
3409    WerrorS("cannot build expression lists from unnamed objects");
3410    return TRUE;
3411  }
3412  memcpy(&ut,u,sizeof(ut));
3413  memset(&t,0,sizeof(t));
3414  t.rtyp=INT_CMD;
3415  for (l=0;l< iv->length(); l++)
3416  {
3417    t.data=(char *)(*iv)[l];
3418    if (p==NULL)
3419    {
3420      p=res;
3421    }
3422    else
3423    {
3424      p->next=(leftv)Alloc0(sizeof(sleftv));
3425      p=p->next;
3426    }
3427    memcpy(u,&ut,sizeof(ut));
3428    if (u->Typ() == MATRIX_CMD)
3429      nok=jjBRACK_Ma(p,u,v,&t);
3430    else /* INTMAT_CMD */
3431      nok=jjBRACK_Im(p,u,v,&t);
3432    if (nok)
3433    {
3434      while (res->next!=NULL)
3435      {
3436        p=res->next->next;
3437        Free((ADDRESS)res->next,sizeof(sleftv));
3438        // res->e aufraeumen !!!!
3439        res->next=p;
3440      }
3441      return TRUE;
3442    }
3443  }
3444  return FALSE;
3445}
3446static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
3447{
3448  sleftv t;
3449  sleftv ut;
3450  leftv p=NULL;
3451  intvec *iv=(intvec *)v->Data();
3452  int l;
3453  BOOLEAN nok;
3454
3455  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3456  {
3457    WerrorS("cannot build expression lists from unnamed objects");
3458    return TRUE;
3459  }
3460  memcpy(&ut,u,sizeof(ut));
3461  memset(&t,0,sizeof(t));
3462  t.rtyp=INT_CMD;
3463  for (l=0;l< iv->length(); l++)
3464  {
3465    t.data=(char *)((*iv)[l]);
3466    if (p==NULL)
3467    {
3468      p=res;
3469    }
3470    else
3471    {
3472      p->next=(leftv)Alloc0(sizeof(sleftv));
3473      p=p->next;
3474    }
3475    memcpy(u,&ut,sizeof(ut));
3476    if (u->Typ() == MATRIX_CMD)
3477      nok=jjBRACK_Ma(p,u,&t,w);
3478    else /* INTMAT_CMD */
3479      nok=jjBRACK_Im(p,u,&t,w);
3480    if (nok)
3481    {
3482      while (res->next!=NULL)
3483      {
3484        p=res->next->next;
3485        Free((ADDRESS)res->next,sizeof(sleftv));
3486        // res->e aufraeumen !!
3487        res->next=p;
3488      }
3489      return TRUE;
3490    }
3491  }
3492  return FALSE;
3493}
3494static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
3495{
3496  sleftv t1,t2,ut;
3497  leftv p=NULL;
3498  intvec *vv=(intvec *)v->Data();
3499  intvec *wv=(intvec *)w->Data();
3500  int vl;
3501  int wl;
3502  BOOLEAN nok;
3503
3504  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3505  {
3506    WerrorS("cannot build expression lists from unnamed objects");
3507    return TRUE;
3508  }
3509  memcpy(&ut,u,sizeof(ut));
3510  memset(&t1,0,sizeof(sleftv));
3511  memset(&t2,0,sizeof(sleftv));
3512  t1.rtyp=INT_CMD;
3513  t2.rtyp=INT_CMD;
3514  for (vl=0;vl< vv->length(); vl++)
3515  {
3516    t1.data=(char *)((*vv)[vl]);
3517    for (wl=0;wl< wv->length(); wl++)
3518    {
3519      t2.data=(char *)((*wv)[wl]);
3520      if (p==NULL)
3521      {
3522        p=res;
3523      }
3524      else
3525      {
3526        p->next=(leftv)Alloc0(sizeof(sleftv));
3527        p=p->next;
3528      }
3529      memcpy(u,&ut,sizeof(ut));
3530      if (u->Typ() == MATRIX_CMD)
3531        nok=jjBRACK_Ma(p,u,&t1,&t2);
3532      else /* INTMAT_CMD */
3533        nok=jjBRACK_Im(p,u,&t1,&t2);
3534      if (nok)
3535      {
3536        res->CleanUp();
3537        return TRUE;
3538      }
3539    }
3540  }
3541  return FALSE;
3542}
3543static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
3544{
3545  v->next=(leftv)Alloc(sizeof(sleftv));
3546  memcpy(v->next,w,sizeof(sleftv));
3547  BOOLEAN r=iiExprArith2(res,u,'(',v);
3548  v->rtyp=0; v->data=NULL;
3549  w->rtyp=0; w->data=NULL;
3550  return r;
3551}
3552static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
3553{
3554  u->next=(leftv)Alloc(sizeof(sleftv));
3555  memcpy(u->next,v,sizeof(sleftv));
3556  u->next->next=(leftv)Alloc(sizeof(sleftv));
3557  memcpy(u->next->next,w,sizeof(sleftv));
3558  BOOLEAN r=iiExprArithM(res,u,iiOp);
3559  v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
3560  w->rtyp=0; w->data=NULL;
3561  return r;
3562}
3563static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
3564{
3565  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
3566  {
3567    WerrorS("3rd argument must be a name of a matrix");
3568    return TRUE;
3569  }
3570  ideal i=(ideal)u->Data();
3571  int rank=(int)i->rank;
3572  BOOLEAN r=jjCOEFFS_Id(res,u,v);
3573  if (r) return TRUE;
3574  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3575  return FALSE;
3576}
3577static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
3578{
3579  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
3580           (ideal)(v->Data()),(poly)(w->Data()));
3581  return FALSE;
3582}
3583static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
3584{
3585  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
3586  {
3587    WerrorS("3rd argument must be a name of a matrix");
3588    return TRUE;
3589  }
3590  poly p=(poly)u->CopyD();
3591  ideal i=idInit(1,1);
3592  i->m[0]=p;
3593  sleftv t;
3594  memset(&t,0,sizeof(t));
3595  t.data=(char *)i;
3596  t.rtyp=IDEAL_CMD;
3597  int rank=1;
3598  if (u->Typ()==VECTOR_CMD)
3599  {
3600    i->rank=rank=pMaxComp(p);
3601    t.rtyp=MODUL_CMD;
3602  }
3603  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
3604  t.CleanUp();
3605  if (r) return TRUE;
3606  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3607  return FALSE;
3608}
3609static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
3610{
3611  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
3612    (intvec *)w->Data());
3613  setFlag(res,FLAG_STD);
3614  return FALSE;
3615}
3616static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
3617{
3618  /*4
3619  * look for the substring what in the string where
3620  * starting at position n
3621  * return the position of the first char of what in where
3622  * or 0
3623  */
3624  int n=(int)w->Data();
3625  char *where=(char *)u->Data();
3626  char *what=(char *)v->Data();
3627  char *found;
3628  if ((1>n)||(n>(int)strlen(where)))
3629  {
3630    Werror("start position %d out of range",n);
3631    return TRUE;
3632  }
3633  found = strchr(where+n-1,*what);
3634  if (*(what+1)!='\0')
3635  {
3636    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
3637    {
3638      found=strchr(found+1,*what);
3639    }
3640  }
3641  if (found != NULL)
3642  {
3643    res->data=(char *)((found-where)+1);
3644  }
3645  return FALSE;
3646}
3647static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
3648{
3649  short *iw=iv2array((intvec *)w->Data());
3650  res->data = (char *)pJetW((poly)u->Data(),(int)v->Data(),iw);
3651  Free((ADDRESS)iw,(pVariables+1)*sizeof(short));
3652  return FALSE;
3653}
3654static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
3655{
3656  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
3657                             (intvec *)w->Data());
3658  return FALSE;
3659}
3660static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
3661{
3662  idhdl h,rr;
3663  map mapping;
3664
3665  rr=(idhdl)u->data;
3666  if ((h=IDRING(rr)->idroot->get(v->name,myynest))!=NULL)
3667  {
3668    if (h->typ==MAP_CMD)
3669    {
3670      mapping=IDMAP(h);
3671    }
3672    else if (h->typ==IDEAL_CMD)
3673    {
3674      mapping=IDMAP(h);
3675    }
3676    else
3677    {
3678      Werror("`%s` is no map nor ideal",IDID(h));
3679      return TRUE;
3680    }
3681  }
3682  else
3683  {
3684    Werror("`%s` is not defined in `%s`",v->name,u->name);
3685    return TRUE;
3686  }
3687  if ((h=IDRING(rr)->idroot->get(w->name,myynest))!=NULL)
3688  {
3689    if (h->typ==IDEAL_CMD)
3690    {
3691      res->data=(char *)maGetPreimage(IDRING(rr),mapping,IDIDEAL(h));
3692    }
3693    else
3694    {
3695      Werror("`%s` is no ideal",IDID(h));
3696      return TRUE;
3697    }
3698  }
3699  else
3700  {
3701    Werror("`%s` is not defined in `%s`",w->name,u->name);
3702    return TRUE;
3703  }
3704  return FALSE;
3705}
3706static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
3707{
3708  int di, k;
3709  int i=(int)u->Data();
3710  int r=(int)v->Data();
3711  int c=(int)w->Data();
3712  intvec *iv = new intvec(r, c, 0);
3713  if (iv->rows()==0)
3714  {
3715    delete iv;
3716    return TRUE;
3717  }
3718  if (i!=0)
3719  {
3720    if (i<0) i = -i;
3721    di = 2 * i + 1;
3722    for (k=0; k<iv->length(); k++)
3723    {
3724#ifdef buildin_rand
3725      (*iv)[k] = ((siRand() % di) - i);
3726#else
3727      (*iv)[k] = ((rand() % di) - i);
3728#endif
3729    }
3730  }
3731  res->data = (char *)iv;
3732  return FALSE;
3733}
3734static BOOLEAN jjSUBST_Test(leftv v,leftv w,
3735  int &ringvar, poly &monomexpr)
3736{
3737  monomexpr=(poly)w->Data();
3738  if (pLength(monomexpr)>1)
3739  {
3740    Werror("`%s` substitutes a ringvar only by a term",
3741      Tok2Cmdname(SUBST_CMD));
3742    return TRUE;
3743  }
3744  if (!(ringvar=pVar((poly)v->Data())))
3745  {
3746    WerrorS("ringvar expected");
3747    return TRUE;
3748  }
3749  return FALSE;
3750}
3751static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
3752{
3753  int ringvar;
3754  poly monomexpr;
3755  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
3756  if (nok) return TRUE;
3757  res->data = pSubst((poly)u->CopyD(POLY_CMD),ringvar,monomexpr);
3758  return FALSE;
3759}
3760static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
3761{
3762  int ringvar;
3763  poly monomexpr;
3764  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
3765  if (nok) return TRUE;
3766  res->data = idSubst((ideal)u->CopyD(IDEAL_CMD),ringvar,monomexpr);
3767  return FALSE;
3768}
3769static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
3770{
3771  matrix m=mpNew((int)v->Data(),(int)w->Data());
3772  ideal I=(ideal)u->CopyD(IDEAL_CMD);
3773  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
3774  //for(i=i-1;i>=0;i--)
3775  //{
3776  //  m->m[i]=I->m[i];
3777  //  I->m[i]=NULL;
3778  //}
3779  memcpy4(m->m,I->m,i*sizeof(poly));
3780  memset(I->m,0,i*sizeof(poly));
3781  idDelete(&I);
3782  res->data = (char *)m;
3783  return FALSE;
3784}
3785static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
3786{
3787  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
3788           (int)v->Data(),(int)w->Data());
3789  return FALSE;
3790}
3791static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
3792{
3793  matrix m=mpNew((int)v->Data(),(int)w->Data());
3794  matrix I=(matrix)u->CopyD(MATRIX_CMD);
3795  int r=min(MATROWS(I),(int)v->Data());
3796  int c=min(MATCOLS(I),(int)w->Data());
3797  int i,j;
3798  for(i=r;i>0;i--)
3799  {
3800    for(j=c;j>0;j--)
3801    {
3802      MATELEM(m,i,j)=MATELEM(I,i,j);
3803      MATELEM(I,i,j)=NULL;
3804    }
3805  }
3806  idDelete((ideal *)&I);
3807  res->data = (char *)m;
3808  return FALSE;
3809}
3810static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
3811{
3812  assumeStdFlag(v);
3813  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
3814    0,(int)w->Data());
3815  return FALSE;
3816}
3817static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
3818{
3819  assumeStdFlag(v);
3820  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
3821    0,(int)w->Data());
3822  return FALSE;
3823}
3824#ifdef OLD_RES
3825static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
3826{
3827  int maxl=(int)v->Data();
3828  int l=0;
3829  resolvente r;
3830  intvec **weights=NULL;
3831  int wmaxl=maxl;
3832  maxl--;
3833  if ((maxl==-1) && (iiOp!=MRES_CMD))
3834    maxl = pVariables-1;
3835  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
3836  {
3837    if (BTEST1(28))
3838    {
3839      r=syMinRes((ideal)u->Data(),maxl,&l,iiOp==MRES_CMD);
3840    }
3841    else
3842    {
3843      intvec * iv=(intvec*)atGet(u,"isHomog");
3844      if (iv!=NULL)
3845      {
3846        weights = (intvec**)Alloc0(sizeof(intvec*));
3847        weights[0] = ivCopy(iv);
3848        l=1;
3849      }
3850      r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
3851    }
3852  }
3853  else
3854    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
3855  if (r==NULL) return TRUE;
3856  int t3=u->Typ();
3857  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
3858  return FALSE;
3859  return TRUE;
3860}
3861#endif
3862static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
3863{
3864  int yes;
3865  jjSTATUS2(res, u, v);
3866  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
3867  FreeL((ADDRESS) res->data);
3868  res->data = (void *) yes;
3869  return FALSE;
3870}
3871
3872/*=================== operations with 3 args.: table =================*/
3873struct sValCmd3 dArith3[]=
3874{
3875// operations:
3876// proc             cmd          res         arg1        arg2        arg3
3877 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD }
3878,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD }
3879,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD }
3880,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD }
3881,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
3882,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD }
3883,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD }
3884,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD }
3885,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
3886,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD }
3887,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD }
3888,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD }
3889,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD }
3890,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD }
3891,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD }
3892,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD }
3893,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD }
3894,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
3895,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD }
3896,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
3897//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD }
3898,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD }
3899,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD }
3900,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD }
3901,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
3902,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD }
3903,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD }
3904,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD }
3905,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
3906,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD }
3907,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD }
3908,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD }
3909,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
3910#ifdef OLD_RES
3911,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
3912,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
3913#endif
3914,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE }
3915,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE }
3916,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD }
3917,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD }
3918,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD }
3919,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD }
3920,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD }
3921,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD }
3922,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD }
3923#ifdef OLD_RES
3924,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
3925,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
3926#endif
3927#ifdef HAVE_FACTORY
3928,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
3929#else
3930,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
3931#endif
3932#ifdef OLD_RES
3933,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
3934,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
3935#endif
3936,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD}
3937,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
3938,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD }
3939,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD }
3940,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD }
3941,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD }
3942,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD }
3943,{NULL,             0,          0,          0,          0,          0 }
3944};
3945/*=================== operations with many arg.: static proc =================*/
3946static BOOLEAN jjCALL1ARG(leftv res, leftv v)
3947{
3948  return iiExprArith1(res,v,iiOp);
3949}
3950static BOOLEAN jjCALL2ARG(leftv res, leftv u)
3951{
3952  leftv v=u->next;
3953  u->next=NULL;
3954  BOOLEAN b=iiExprArith2(res,u,iiOp,v);
3955  u->next=v;
3956  return b;
3957}
3958static BOOLEAN jjCOEF_M(leftv res, leftv v)
3959{
3960  if((v->Typ() != VECTOR_CMD)
3961  || (v->next->Typ() != POLY_CMD)
3962  || (v->next->next->Typ() != MATRIX_CMD)
3963  || (v->next->next->next->Typ() != MATRIX_CMD))
3964     return TRUE;
3965  if (v->next->next->rtyp!=IDHDL) return TRUE;
3966  idhdl c=(idhdl)v->next->next->data;
3967  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
3968  idhdl m=(idhdl)v->next->next->next->data;
3969  idDelete((ideal *)&(c->data.uideal));
3970  idDelete((ideal *)&(m->data.uideal));
3971  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
3972    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
3973  return FALSE;
3974}
3975static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
3976{
3977  int s=1;
3978  leftv h=v;
3979  if (h!=NULL) s=exprlist_length(h);
3980  ideal id=idInit(s,1);
3981  int rank=1;
3982  int i=0;
3983  poly p=NULL;
3984  while (h!=NULL)
3985  {
3986    switch(h->Typ())
3987    {
3988      case POLY_CMD:
3989      {
3990        p=(poly)h->CopyD();
3991        break;
3992      }
3993      case INT_CMD:
3994      {
3995        number n=nInit((int)h->Data());
3996        if (!nIsZero(n))
3997        {
3998          p=pOne();
3999          pSetCoeff(p,n);
4000        }
4001        else
4002        {
4003          //p=NULL;
4004          nDelete(&n);
4005        }
4006        break;
4007      }
4008      case NUMBER_CMD:
4009      {
4010        number n=(number)h->CopyD();
4011        if (!nIsZero(n))
4012        {
4013          p=pOne();
4014          pSetCoeff(p,n);
4015        }
4016        else
4017        {
4018          //p=NULL;
4019          nDelete(&n);
4020        }
4021        break;
4022      }
4023      case VECTOR_CMD:
4024      {
4025        p=(poly)h->CopyD();
4026        if (iiOp!=MODUL_CMD)
4027        {
4028          idDelete(&id);
4029          pDelete(&p);
4030          return TRUE;
4031        }
4032        rank=max(rank,pMaxComp(p));
4033        break;
4034      }
4035      default:
4036      {
4037        idDelete(&id);
4038        return TRUE;
4039      }
4040    }
4041    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4042    {
4043      pSetCompP(p,1);
4044    }
4045    id->m[i]=p;
4046    i++;
4047    h=h->next;
4048  }
4049  id->rank=rank;
4050  res->data=(char *)id;
4051  return FALSE;
4052}
4053static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4054{
4055  leftv h=v;
4056  int l=v->listLength();
4057  resolvente r=(resolvente)Alloc0(l*sizeof(ideal));
4058  BOOLEAN *copied=(BOOLEAN *)Alloc0(l*sizeof(BOOLEAN));
4059  int t=0;
4060  // try to convert to IDEAL_CMD
4061  while (h!=NULL)
4062  {
4063    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4064    {
4065      t=IDEAL_CMD;
4066    }
4067    else break;
4068    h=h->next;
4069  }
4070  // if failure, try MODUL_CMD
4071  if (t==0)
4072  {
4073    h=v;
4074    while (h!=NULL)
4075    {
4076      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4077      {
4078        t=MODUL_CMD;
4079      }
4080      else break;
4081      h=h->next;
4082    }
4083  }
4084  // check for success  in converting
4085  if (t==0)
4086  {
4087    WerrorS("cannot convert to ideal or module");
4088    return TRUE;
4089  }
4090  // call idMultSect
4091  h=v;
4092  int i=0;
4093  sleftv tmp;
4094  while (h!=NULL)
4095  {
4096    if (h->Typ()==t)
4097    {
4098      r[i]=(ideal)h->Data(); /*no copy*/
4099      h=h->next;
4100    }
4101    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4102    {
4103      Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4104      Free((ADDRESS)r,l*sizeof(ideal));
4105      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4106      return TRUE;
4107    }
4108    else
4109    {
4110      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
4111      copied[i]=TRUE;
4112      h=tmp.next;
4113    }
4114    i++;
4115  }
4116  res->rtyp=t;
4117  res->data=(char *)idMultSect(r,i);
4118  while(i>0)
4119  {
4120    i--;
4121    if (copied[i]) idDelete(&(r[i]));
4122  }
4123  Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4124  Free((ADDRESS)r,l*sizeof(ideal));
4125  return FALSE;
4126}
4127static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4128{
4129  int i=0;
4130  leftv h=v;
4131  if (h!=NULL) i=exprlist_length(h);
4132  intvec *iv=new intvec(i);
4133  i=0;
4134  while (h!=NULL)
4135  {
4136    if(h->Typ()==INT_CMD)
4137    {
4138      (*iv)[i]=(int)h->Data();
4139    }
4140    else
4141    {
4142      delete iv;
4143      return TRUE;
4144    }
4145    i++;
4146    h=h->next;
4147  }
4148  res->data=(char *)iv;
4149  return FALSE;
4150}
4151static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4152{
4153  leftv v=u->next;
4154  BOOLEAN b;
4155  if(v==NULL)
4156    b=iiExprArith1(res,u,iiOp);
4157  else
4158  {
4159    u->next=NULL;
4160    b=iiExprArith2(res,u,iiOp,v);
4161    u->next=v;
4162  }
4163  return b;
4164}
4165static BOOLEAN jjLIST_PL(leftv res, leftv v)
4166{
4167  int sl=0;
4168  if (v!=NULL) sl = v->listLength();
4169  lists L;
4170  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4171  {
4172    L=syConvRes((syStrategy)v->Data());
4173  }
4174  else
4175  {
4176    L=(lists)Alloc(sizeof(slists));
4177    leftv h=NULL;
4178    int i;
4179    int rt;
4180
4181    L->Init(sl);
4182    for (i=0;i<sl;i++)
4183    {
4184      if (h!=NULL) { /* e.g. not in the first step:
4185                     * h is the pointer to the old sleftv,
4186                     * v is the pointer to the next sleftv
4187                     * (in this moment) */
4188                     h->next=v;
4189                   }
4190      h=v;
4191      v=v->next;
4192      h->next=NULL;
4193      rt=h->Typ();
4194      if (rt==0)
4195      {
4196        L->Clean();
4197        Werror("`%s` is undefined",h->Name());
4198        return TRUE;
4199      }
4200      if ((rt==RING_CMD)||(rt==QRING_CMD))
4201      {
4202        L->m[i].rtyp=rt;
4203        L->m[i].data=h->Data();
4204        ((ring)L->m[i].data)->ref++;
4205      }
4206      else
4207        L->m[i].Copy(h);
4208    }
4209  }
4210  res->data=(char *)L;
4211  return FALSE;
4212}
4213static BOOLEAN jjNAMES0(leftv res, leftv v)
4214{
4215  res->data=(void *)ipNameList(idroot);
4216  return FALSE;
4217}
4218static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4219{
4220  if(v==NULL)
4221  {
4222    res->data=(char *)showOption();
4223    return FALSE;
4224  }
4225  res->rtyp=NONE;
4226  return setOption(res,v);
4227}
4228static BOOLEAN jjRESERVED0(leftv res, leftv v)
4229{
4230  int i=1;
4231  loop
4232  {
4233    Print("%-20s",cmds[i].name);
4234    i++;
4235    if(cmds[i].name==NULL)
4236      break;
4237    if ((i%3)==1) PrintLn();
4238  }
4239  PrintLn();
4240  return FALSE;
4241}
4242static BOOLEAN jjSTRING_PL(leftv res, leftv v)
4243{
4244  if ((v!=NULL)&&(v->next==NULL))
4245    return iiExprArith1(res,v,iiOp);
4246  int sl=0;
4247  leftv h=v,nachher;
4248  sleftv tmpR;
4249  BOOLEAN bo;
4250  char *sum=NULL;
4251  while(h!=NULL)
4252  {
4253    /* convert to string =================================*/
4254    nachher=h->next;
4255    h->next=NULL;
4256    bo=iiExprArith1(&tmpR,h,iiOp);
4257    if(bo)
4258    {
4259      h->next=nachher;
4260      FreeL(sum);
4261      return TRUE;
4262    }
4263    /* append to 'sum' =================================*/
4264    if(sum==NULL)
4265    {
4266      sum=(char *)tmpR.data;
4267      sl=strlen(sum);
4268    }
4269    else
4270    {
4271      int nl=strlen((char *)tmpR.data);
4272      char *s=(char *)AllocL(sl+nl+1);
4273      memcpy(s,sum,sl);
4274      memcpy(s+sl,(char *)tmpR.data,nl);
4275      s[sl+nl]='\0';
4276      sl+=nl;
4277      FreeL(sum);
4278      sum=s;
4279    }
4280    /* next sleftv =================================*/
4281    h->next=nachher;
4282    h=nachher;
4283  }
4284  if (sum==NULL) sum=mstrdup("");
4285  res->data=(char *)sum;
4286  return FALSE;
4287}
4288static BOOLEAN jjTEST(leftv res, leftv v)
4289{
4290  do
4291  {
4292    if (v->Typ()!=INT_CMD)
4293      return TRUE;
4294    test_cmd((int)v->Data());
4295    v=v->next;
4296  }
4297  while (v!=NULL);
4298  return FALSE;
4299}
4300/*=================== operations with many arg.: table =================*/
4301/* number_of_args:  -1: any, -2: any >0, .. */
4302struct sValCmdM dArithM[]=
4303{
4304// operations:
4305// proc         cmd               res            number_of_args
4306 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2  }
4307,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2  }
4308,{jjCOEF_M,    COEF_CMD,        NONE,               4  }
4309,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2 }
4310,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1  }
4311,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1 }
4312,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2  }
4313,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2 }
4314,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1  }
4315,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -1 }
4316,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1 }
4317,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1  }
4318,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1 }
4319,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1 }
4320,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0 }
4321,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 }
4322,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1 }
4323,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0 }
4324,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1 }
4325,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2 }
4326,{jjTEST,      TEST_CMD,        NONE,               -2 }
4327,{iiWRITE,     WRITE_CMD,       NONE,               -2 }
4328,{NULL,        0,               0,                  0  }
4329};
4330#ifdef MDEBUG
4331static Subexpr jjDBMakeSub(leftv e,char *f, int l)
4332#else
4333static Subexpr jjMakeSub(leftv e)
4334#endif
4335{
4336  // assume: e->Typ()==INT_CMD
4337#ifdef MDEBUG
4338  Subexpr r=(Subexpr)mmDBAllocBlock0(sizeof(*r),f,l);
4339#else
4340  Subexpr r=(Subexpr)Alloc0(sizeof(*r));
4341#endif
4342  r->start =(int)e->Data();
4343  return r;
4344}
4345
4346/*================ generating tables ============================*/
4347#ifdef GENTABLE
4348extern struct sValAssign dAssign[];
4349struct sValCmdTab dArithTab1[]={ {0,0}};
4350#define JJTAB1LEN 0
4351struct sValCmdTab dArithTab2[]={ {0,0}};
4352#define JJTAB2LEN 0
4353void ttGen1()
4354{
4355  FILE *outfile = myfopen("iparith.inc","w");
4356  int i,j,l1=0,l2=0;
4357  currRing=(ring)Alloc(sizeof(*currRing));
4358  fprintf(outfile,
4359  "/****************************************\n"
4360  "*  Computer Algebra System SINGULAR     *\n"
4361  "****************************************/\n\n");
4362/*-------------------------------------------------------------------*/
4363  fprintf(outfile,"// syntax table for Singular\n//\n");
4364  fprintf(outfile,"// - search for an exact match of the argument types\n");
4365  fprintf(outfile,"// - otherwise search for the first possibility\n");
4366  fprintf(outfile,"//   with converted types of the arguments\n");
4367  fprintf(outfile,"// - otherwise report an error\n//\n");
4368
4369  int op;
4370  i=0;
4371  while ((op=dArith1[i].cmd)!=0)
4372  {
4373    if (dArith1[i].p==jjWRONG)
4374      fprintf(outfile,"// DUMMY ");
4375    char *s = iiTwoOps(op);
4376    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
4377          s,
4378          Tok2Cmdname(dArith1[i].arg),
4379          Tok2Cmdname(ABS(dArith1[i].res)));
4380    i++;
4381  }
4382  fprintf(outfile,"/*---------------------------------------------*/\n");
4383  i=0;
4384  while ((op=dArith2[i].cmd)!=0)
4385  {
4386    if (dArith2[i].p==jjWRONG2)
4387      fprintf(outfile,"// DUMMY ");
4388    char *s = iiTwoOps(op);
4389    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
4390          s,
4391          Tok2Cmdname(dArith2[i].arg1),
4392          Tok2Cmdname(dArith2[i].arg2),
4393          Tok2Cmdname(dArith2[i].res));
4394    i++;
4395  }
4396  fprintf(outfile,"/*---------------------------------------------*/\n");
4397  i=0;
4398  while ((op=dArith3[i].cmd)!=0)
4399  {
4400    char *s = iiTwoOps(op);
4401    if (dArith3[i].p==jjWRONG3)
4402      fprintf(outfile,"// DUMMY ");
4403    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
4404          s,
4405          Tok2Cmdname(dArith3[i].arg1),
4406          Tok2Cmdname(dArith3[i].arg2),
4407          Tok2Cmdname(dArith3[i].arg3),
4408          Tok2Cmdname(dArith3[i].res));
4409    i++;
4410  }
4411  fprintf(outfile,"/*---------------------------------------------*/\n");
4412  i=0;
4413  while ((op=dArithM[i].cmd)!=0)
4414  {
4415    char *s = iiTwoOps(op);
4416    fprintf(outfile,"// operation: %s (...)  ->  %s",
4417          s,
4418          Tok2Cmdname(dArithM[i].res));
4419    switch(dArithM[i].number_of_args)
4420    {
4421      case -2:
4422         fprintf(outfile," ( number of arguments >0 )\n");
4423         break;
4424      case -1:
4425         fprintf(outfile," ( any number of arguments )\n");
4426         break;
4427      default:
4428         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
4429         break;
4430    }
4431    i++;
4432  }
4433  fprintf(outfile,"/*---------------------------------------------*/\n");
4434  i=0;
4435  while ((op=dAssign[i].res)!=0)
4436  {
4437    fprintf(outfile,"// assign: %s =  %s\n",
4438          Tok2Cmdname(op/*dAssign[i].res*/),
4439          Tok2Cmdname(dAssign[i].arg));
4440    i++;
4441  }
4442/*-------------------------------------------------------------------*/
4443  fprintf(outfile,"/*---------------------------------------------*/\n");
4444  for (j=257;j<=MAX_TOK+1;j++)
4445  {
4446    for(i=257;i<=MAX_TOK+1;i++)
4447    {
4448      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
4449      && iiTestConvert(i,j))
4450      {
4451        fprintf(outfile,"// convert %s -> %s\n",
4452          Tok2Cmdname(i), Tok2Cmdname(j));
4453        if (j==ANY_TYPE) break;
4454      }
4455    }
4456  }
4457  fprintf(outfile,"/*---------------------------------------------*/\n");
4458  char ops[]="=><+*/[.^,%(;";
4459  for(i=0;ops[i]!='\0';i++)
4460    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
4461  for (i=257;i<=MAX_TOK;i++)
4462  {
4463    char *s=iiTwoOps(i);
4464    if (s[0]!='$')
4465    {
4466      fprintf(outfile,"// token %d : %s\n", i, s);
4467    }
4468  }
4469/*-------------------------------------------------------------------*/
4470  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
4471/*-------------------------------------------------------------------*/
4472  fprintf(outfile,"/*---------------------------------------------*/\n");
4473  fprintf(outfile,
4474  "struct sValCmdTab dArithTab1[]=\n"
4475  "{\n");
4476  for (j=1;j<=MAX_TOK+1;j++)
4477  {
4478    for(i=0;dArith1[i].cmd!=0;i++)
4479    {
4480      if (dArith1[i].cmd==j)
4481      {
4482        fprintf(outfile," { %d,%d },\n",j,i);
4483        l1++;
4484        break;
4485      }
4486    }
4487  }
4488  fprintf(outfile," { 10000,0 }\n};\n");
4489  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
4490/*-------------------------------------------------------------------*/
4491  fprintf(outfile,
4492  "struct sValCmdTab dArithTab2[]=\n"
4493  "{\n");
4494  for (j=1;j<=MAX_TOK+1;j++)
4495  {
4496    for(i=0;dArith2[i].cmd!=0;i++)
4497    {
4498      if (dArith2[i].cmd==j)
4499      {
4500        fprintf(outfile," { %d,%d },\n",j,i);
4501        l2++;
4502        break;
4503      }
4504    }
4505  }
4506  fprintf(outfile," { 10000,0 }\n};\n");
4507  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
4508  fclose(outfile);
4509}
4510/*-------------------------------------------------------------------*/
4511void ttGen2()
4512{
4513  FILE *outfile = myfopen("iparith.inc","a");
4514  fprintf(outfile,
4515  "/****************************************\n"
4516  "*  Computer Algebra System SINGULAR     *\n"
4517  "****************************************/\n\n");
4518/*-------------------------------------------------------------------*/
4519  fprintf(outfile,"// identifier table for Singular\n//\n");
4520
4521  fprintf(outfile,
4522  "cmdnames cmds[] =\n"
4523  "{  // name-string     alias  tokval toktype\n"
4524  "{ \"$INVALID$\",            0,  -1, 0},\n");
4525  int i=1;
4526  int m=-1;
4527  int id_nr=0;
4528  BOOLEAN f=FALSE;
4529  loop
4530  {
4531    while (cmds[i].tokval!=0)
4532    {
4533      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
4534      {
4535        if(m==-1)
4536        {
4537          m=i;
4538          f=TRUE;
4539        }
4540        else if(strcmp(cmds[m].name,cmds[i].name)>0)
4541        {
4542          m=i;
4543          f=TRUE;
4544        }
4545      }
4546      i++;
4547    }
4548    if(f)
4549    {
4550      id_nr++;
4551      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
4552      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
4553                                             20-strlen(cmds[m].name),
4554                                             cmds[m].alias,
4555                                             cmds[m].tokval);
4556      switch(cmds[m].toktype)
4557      {
4558        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
4559        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
4560        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
4561        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
4562        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
4563        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
4564        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
4565        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
4566        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
4567        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
4568        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
4569        case NONE:             fprintf(outfile,"NONE },\n"); break;
4570        default:               if((cmds[m].toktype>' ')
4571                               &&(cmds[m].toktype<127))
4572                               {
4573                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
4574                               }
4575                               else
4576                               {
4577                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
4578                               }
4579                               break;
4580      }
4581      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
4582      cmds[m].name=NULL;
4583      m=-1;
4584      i=1;
4585      f=FALSE;
4586    }
4587    else break;
4588  }
4589  fprintf(outfile,
4590"/* list of scanner identifiers/only for feread/reservedName */\n");
4591  f=FALSE;
4592  i=1;m=-1;
4593  loop
4594  {
4595    while (cmds[i].tokval!=0)
4596    {
4597      if (cmds[i].name!=NULL)
4598      {
4599        if(m==-1)
4600        {
4601          m=i;
4602          f=TRUE;
4603        }
4604        else if(strcmp(cmds[m].name,cmds[i].name)>0)
4605        {
4606          m=i;
4607          f=TRUE;
4608        }
4609      }
4610      i++;
4611    }
4612    if(f)
4613    {
4614      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
4615                                             20-strlen(cmds[m].name),
4616                                             0/*cmds[m].alias*/
4617                                             /*-1 cmds[m].tokval*/
4618                                             /*0 cmds[m].toktype*/);
4619      cmds[m].name=NULL;
4620      m=-1;
4621      i=1;
4622      f=FALSE;
4623    }
4624    else break;
4625  }
4626  fprintf(outfile,
4627"/* end of list marker */\n"
4628"  { NULL, 0, 0, 0}\n"
4629"};\n"
4630"#ifdef HAVE_RTIMER\n"
4631"#define LAST_IDENTIFIER %d\n"
4632"#else\n"
4633"#define LAST_IDENTIFIER %d\n"
4634"#endif\n",id_nr,id_nr-1);
4635  fclose(outfile);
4636}
4637/*-------------------------------------------------------------------*/
4638#if 0
4639void ttGen3()
4640{
4641  FILE *outfile = myfopen("mpsr_tok.inc","w");
4642  fprintf(outfile,
4643  "/****************************************\n"
4644  "*  Computer Algebra System SINGULAR     *\n"
4645  "****************************************/\n\n");
4646/*-------------------------------------------------------------------*/
4647  fprintf(outfile,"// token table for Singular\n//\n");
4648
4649  fprintf(outfile,
4650  "short vtok[] =\n"
4651  "{\n");
4652  // operations with 1 arg: ===========================================
4653  int i=0;
4654  while (dArith1[i].cmd!=0)
4655  {
4656    if ((dArith1[i].p!=jjWRONG)
4657    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
4658    {
4659      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
4660    }
4661    i++;
4662  }
4663  // operations with 2 args: ===========================================
4664  i=0;
4665  while (dArith2[i].cmd!=0)
4666  {
4667    if ((dArith2[i].p!=jjWRONG2)
4668    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
4669    {
4670      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
4671    }
4672    i++;
4673  }
4674  // operations with 3 args: ===========================================
4675  i=0;
4676  while (dArith3[i].cmd!=0)
4677  {
4678    if (
4679    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
4680    {
4681      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
4682    }
4683    i++;
4684  }
4685  // operations with many args: ===========================================
4686  i=0;
4687  while (dArithM[i].cmd!=0)
4688  {
4689    if (
4690    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
4691    {
4692      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
4693    }
4694    i++;
4695  }
4696  // ====================================================================
4697  fprintf(outfile,
4698  "/* end of list marker */\n"
4699  " %d };\n",MAX_TOK);
4700  fclose(outfile);
4701}
4702#endif
4703/*-------------------------------------------------------------------*/
4704#else
4705#include "iparith.inc"
4706#endif
4707
4708/*=================== operations with 2 args. ============================*/
4709
4710BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
4711{
4712#ifndef GENTABLE
4713
4714  memset(res,0,sizeof(sleftv));
4715
4716  if (!errorreported)
4717  {
4718#ifdef SIQ
4719    if (siq>0)
4720    {
4721      //Print("siq:%d\n",siq);
4722      command d=(command)Alloc0(sizeof(ip_command));
4723      memcpy(&d->arg1,a,sizeof(sleftv));
4724      memcpy(&d->arg2,b,sizeof(sleftv));
4725      d->argc=2;
4726      d->op=op;
4727      res->data=(char *)d;
4728      res->rtyp=COMMAND;
4729      return FALSE;
4730    }
4731#endif
4732    int at=a->Typ();
4733    int bt=b->Typ();
4734    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4735
4736    iiOp=op;
4737    while (dArith2[i].cmd==op)
4738    {
4739      if ((at==dArith2[i].arg1)
4740      && (bt==dArith2[i].arg2))
4741      {
4742        res->rtyp=dArith2[i].res;
4743        if (dArith2[i].p(res,a,b))
4744        {
4745          break;// leave loop, goto error handling
4746        }
4747        a->CleanUp();
4748        b->CleanUp();
4749        //Print("op: %d,result typ:%d\n",op,res->rtyp);
4750        return FALSE;
4751      }
4752      i++;
4753    }
4754    // implicite type conversion ----------------------------------------------
4755    if (dArith2[i].cmd!=op)
4756    {
4757      int ai,bi;
4758      leftv an = (leftv)Alloc0(sizeof(sleftv));
4759      leftv bn = (leftv)Alloc0(sizeof(sleftv));
4760      BOOLEAN failed=FALSE;
4761      i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4762      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
4763      while (dArith2[i].cmd==op)
4764      {
4765        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
4766        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
4767        {
4768          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
4769          {
4770            res->rtyp=dArith2[i].res;
4771            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
4772            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
4773            || (dArith2[i].p(res,an,bn)));
4774            // everything done, clean up temp. variables
4775            if (failed)
4776            {
4777              // leave loop, goto error handling
4778              break;
4779            }
4780            else
4781            {
4782              // everything ok, clean up and return
4783              an->CleanUp();
4784              bn->CleanUp();
4785              Free((ADDRESS)an,sizeof(sleftv));
4786              Free((ADDRESS)bn,sizeof(sleftv));
4787              a->CleanUp();
4788              b->CleanUp();
4789              return FALSE;
4790            }
4791          }
4792        }
4793        i++;
4794      }
4795      an->CleanUp();
4796      bn->CleanUp();
4797      Free((ADDRESS)an,sizeof(sleftv));
4798      Free((ADDRESS)bn,sizeof(sleftv));
4799    }
4800    // error handling ---------------------------------------------------
4801    const char *s=NULL;
4802    if (!errorreported)
4803    {
4804      if ((at==0) && (a->Name()!=sNoName))
4805      {
4806        s=a->Name();
4807      }
4808      else if ((bt==0) && (b->Name()!=sNoName))
4809      {
4810        s=b->Name();
4811      }
4812      if (s!=NULL)
4813        Werror("`%s` is not defined",s);
4814      else
4815      {
4816        i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4817        s = iiTwoOps(op);
4818        if (proccall)
4819        {
4820          Werror("%s(`%s`,`%s`) is not supported"
4821                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
4822        }
4823        else
4824        {
4825          Werror("`%s` %s `%s` is not supported"
4826                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
4827        }
4828        if (BVERBOSE(V_SHOW_USE))
4829        {
4830          while (dArith2[i].cmd==op)
4831          {
4832            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
4833            && (dArith2[i].res!=0)
4834            && (dArith2[i].p!=jjWRONG2))
4835            {
4836              if (proccall)
4837                Werror("expected %s(`%s`,`%s`)"
4838                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
4839              else
4840                Werror("expected `%s` %s `%s`"
4841                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
4842            }
4843            i++;
4844          }
4845        }
4846      }
4847    }
4848    res->rtyp = UNKNOWN;
4849  }
4850  a->CleanUp();
4851  b->CleanUp();
4852#endif
4853  return TRUE;
4854}
4855
4856/*==================== operations with 1 arg. ===============================*/
4857
4858BOOLEAN iiExprArith1(leftv res, leftv a, int op)
4859{
4860#ifndef GENTABLE
4861  memset(res,0,sizeof(sleftv));
4862
4863  if (!errorreported)
4864  {
4865#ifdef SIQ
4866    if (siq>0)
4867    {
4868      //Print("siq:%d\n",siq);
4869      command d=(command)Alloc0(sizeof(ip_command));
4870      memcpy(&d->arg1,a,sizeof(sleftv));
4871      d->op=op;
4872      d->argc=1;
4873      res->data=(char *)d;
4874      res->rtyp=COMMAND;
4875      return FALSE;
4876    }
4877#endif
4878    int at=a->Typ();
4879    BOOLEAN failed=FALSE;
4880
4881    iiOp=op;
4882    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
4883    while (dArith1[i].cmd==op)
4884    {
4885      if (at==dArith1[i].arg)
4886      {
4887        res->rtyp=dArith1[i].res;
4888        if (dArith1[i].res<0)
4889        {
4890          res->rtyp=-res->rtyp;
4891          #ifdef PROC_BUG
4892          dArith1[i].p(res,a);
4893          #else
4894          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
4895          #endif
4896        }
4897        else if (dArith1[i].p(res,a))
4898        {
4899          break;// leave loop, goto error handling
4900        }
4901        if (a->Next()!=NULL)
4902        {
4903          res->next=(leftv)Alloc(sizeof(sleftv));
4904          failed=iiExprArith1(res->next,a->next,op);
4905        }
4906        a->CleanUp();
4907        return failed;
4908      }
4909      i++;
4910    }
4911    // implicite type conversion --------------------------------------------
4912    if (dArith1[i].cmd!=op)
4913    {
4914      int ai;
4915      leftv an = (leftv)Alloc0(sizeof(sleftv));
4916      i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
4917      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
4918      while (dArith1[i].cmd==op)
4919      {
4920        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
4921        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
4922        {
4923          res->rtyp=dArith1[i].res;
4924          if (dArith1[i].res<0)
4925          {
4926            res->rtyp=-res->rtyp;
4927            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
4928            if (!failed)
4929            {
4930              #ifdef PROC_BUG
4931              dArith1[i].p(res,a);
4932              #else
4933              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
4934              #endif
4935            }
4936          }
4937          else
4938          {
4939            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
4940            || (dArith1[i].p(res,an)));
4941          }
4942          // everything done, clean up temp. variables
4943          if (failed)
4944          {
4945            // leave loop, goto error handling
4946            break;
4947          }
4948          else
4949          {
4950            // everything ok, clean up and return
4951            an->CleanUp();
4952            Free((ADDRESS)an,sizeof(sleftv));
4953            a->CleanUp();
4954            return FALSE;
4955          }
4956        }
4957        i++;
4958      }
4959      an->CleanUp();
4960      Free((ADDRESS)an,sizeof(sleftv));
4961    }
4962    // error handling
4963    if (!errorreported)
4964    {
4965      if ((at==0) && (a->Name()!=sNoName))
4966      {
4967        Werror("`%s` is not defined",a->Name());
4968      }
4969      else
4970      {
4971        i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
4972        char *s = iiTwoOps(op);
4973        Werror("%s(`%s`) is not supported"
4974                ,s,Tok2Cmdname(at));
4975        if (BVERBOSE(V_SHOW_USE))
4976        {
4977          while (dArith1[i].cmd==op)
4978          {
4979            if ((dArith1[i].res!=0)
4980            && (dArith1[i].p!=jjWRONG))
4981              Werror("expected %s(`%s`)"
4982                ,s,Tok2Cmdname(dArith1[i].arg));
4983            i++;
4984          }
4985        }
4986      }
4987    }
4988    res->rtyp = UNKNOWN;
4989  }
4990  a->CleanUp();
4991#endif
4992  return TRUE;
4993}
4994
4995/*=================== operations with 3 args. ============================*/
4996
4997BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
4998{
4999#ifndef GENTABLE
5000  memset(res,0,sizeof(sleftv));
5001
5002  if (!errorreported)
5003  {
5004#ifdef SIQ
5005    if (siq>0)
5006    {
5007      //Print("siq:%d\n",siq);
5008      command d=(command)Alloc0(sizeof(ip_command));
5009      memcpy(&d->arg1,a,sizeof(sleftv));
5010      memcpy(&d->arg2,b,sizeof(sleftv));
5011      memcpy(&d->arg3,c,sizeof(sleftv));
5012      d->op=op;
5013      d->argc=3;
5014      res->data=(char *)d;
5015      res->rtyp=COMMAND;
5016      return FALSE;
5017    }
5018#endif
5019    int at=a->Typ();
5020    int bt=b->Typ();
5021    int ct=c->Typ();
5022
5023    iiOp=op;
5024    int i=0;
5025    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5026    while (dArith3[i].cmd==op)
5027    {
5028      if ((at==dArith3[i].arg1)
5029      && (bt==dArith3[i].arg2)
5030      && (ct==dArith3[i].arg3))
5031      {
5032        res->rtyp=dArith3[i].res;
5033        if (dArith3[i].p(res,a,b,c))
5034        {
5035          break;// leave loop, goto error handling
5036        }
5037        a->CleanUp();
5038        b->CleanUp();
5039        c->CleanUp();
5040        return FALSE;
5041      }
5042      i++;
5043    }
5044    // implicite type conversion ----------------------------------------------
5045    if (dArith3[i].cmd!=op)
5046    {
5047      int ai,bi,ci;
5048      leftv an = (leftv)Alloc0(sizeof(sleftv));
5049      leftv bn = (leftv)Alloc0(sizeof(sleftv));
5050      leftv cn = (leftv)Alloc0(sizeof(sleftv));
5051      BOOLEAN failed=FALSE;
5052      i=0;
5053      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5054      while (dArith3[i].cmd==op)
5055      {
5056        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
5057        {
5058          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
5059          {
5060            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
5061            {
5062              res->rtyp=dArith3[i].res;
5063              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
5064                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
5065                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
5066                || (dArith3[i].p(res,an,bn,cn)));
5067              // everything done, clean up temp. variables
5068              if (failed)
5069              {
5070                // leave loop, goto error handling
5071                break;
5072              }
5073              else
5074              {
5075                // everything ok, clean up and return
5076                an->CleanUp();
5077                bn->CleanUp();
5078                cn->CleanUp();
5079                Free((ADDRESS)an,sizeof(sleftv));
5080                Free((ADDRESS)bn,sizeof(sleftv));
5081                Free((ADDRESS)cn,sizeof(sleftv));
5082                a->CleanUp();
5083                b->CleanUp();
5084                c->CleanUp();
5085        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5086                return FALSE;
5087              }
5088            }
5089          }
5090        }
5091        i++;
5092      }
5093      an->CleanUp();
5094      bn->CleanUp();
5095      cn->CleanUp();
5096      Free((ADDRESS)an,sizeof(sleftv));
5097      Free((ADDRESS)bn,sizeof(sleftv));
5098      Free((ADDRESS)cn,sizeof(sleftv));
5099    }
5100    // error handling ---------------------------------------------------
5101    if (!errorreported)
5102    {
5103      const char *s=NULL;
5104      if ((at==0) && (a->Name()!=sNoName))
5105      {
5106        s=a->Name();
5107      }
5108      else if ((bt==0) && (b->Name()!=sNoName))
5109      {
5110        s=b->Name();
5111      }
5112      else if ((ct==0) && (c->Name()!=sNoName))
5113      {
5114        s=c->Name();
5115      }
5116      if (s!=NULL)
5117        Werror("`%s` is not defined",s);
5118      else
5119      {
5120        i=0;
5121        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5122        char *s = iiTwoOps(op);
5123        Werror("%s(`%s`,`%s`,`%s`) is not supported"
5124                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
5125        if (BVERBOSE(V_SHOW_USE))
5126        {
5127          while (dArith3[i].cmd==op)
5128          {
5129            if(((at==dArith3[i].arg1)
5130            ||(bt==dArith3[i].arg2)
5131            ||(ct==dArith3[i].arg3))
5132            && (dArith3[i].res!=0))
5133            {
5134              Werror("expected %s(`%s`,`%s`,`%s`)"
5135                  ,s,Tok2Cmdname(dArith3[i].arg1)
5136                  ,Tok2Cmdname(dArith3[i].arg2)
5137                  ,Tok2Cmdname(dArith3[i].arg3));
5138            }
5139            i++;
5140          }
5141        }
5142      }
5143    }
5144    res->rtyp = UNKNOWN;
5145  }
5146  a->CleanUp();
5147  b->CleanUp();
5148  c->CleanUp();
5149        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5150#endif
5151  return TRUE;
5152}
5153/*==================== operations with many arg. ===============================*/
5154
5155BOOLEAN iiExprArithM(leftv res, leftv a, int op)
5156{
5157#ifndef GENTABLE
5158  memset(res,0,sizeof(sleftv));
5159
5160  if (!errorreported)
5161  {
5162#ifdef SIQ
5163    if (siq>0)
5164    {
5165      //Print("siq:%d\n",siq);
5166      command d=(command)Alloc0(sizeof(ip_command));
5167      d->op=op;
5168      res->data=(char *)d;
5169      if (a!=NULL)
5170      {
5171        d->argc=a->listLength();
5172        // else : d->argc=0;
5173        memcpy(&d->arg1,a,sizeof(sleftv));
5174        switch(d->argc)
5175        {
5176          case 3:
5177            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
5178            a->next->next->rtyp=0;
5179            a->next->next->data=NULL;
5180            a->next->next->name=NULL;
5181            a->next->next->attribute=NULL;
5182          case 2:
5183            memcpy(&d->arg2,a->next,sizeof(sleftv));
5184            a->next->rtyp=0;
5185            a->next->name=NULL;
5186            a->next->data=NULL;
5187            a->next->attribute=NULL;
5188            d->arg2.next=NULL;
5189          case 1:
5190            d->arg1.next=NULL;
5191        }
5192        if (d->argc>3) a->next=NULL;
5193        a->rtyp=0;
5194        a->data=NULL;
5195        a->name=NULL;
5196        a->CleanUp();
5197      }
5198      res->rtyp=COMMAND;
5199      return FALSE;
5200    }
5201#endif
5202    BOOLEAN failed=FALSE;
5203    int args=0;
5204    if (a!=NULL) args=a->listLength();
5205
5206    iiOp=op;
5207    int i=0;
5208    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
5209    int ii=i;
5210    while (dArithM[i].cmd==op)
5211    {
5212      if ((args==dArithM[i].number_of_args)
5213      || (dArithM[i].number_of_args==-1)
5214      || ((dArithM[i].number_of_args==-2)&&(args>0)))
5215      {
5216        res->rtyp=dArithM[i].res;
5217        if (dArithM[i].p(res,a))
5218        {
5219          break;// leave loop, goto error handling
5220        }
5221        if (a!=NULL) a->CleanUp();
5222        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5223        return failed;
5224      }
5225      i++;
5226    }
5227    // error handling
5228    if (!errorreported)
5229    {
5230      if ((a->rtyp==0) && (a->Name()!=sNoName))
5231      {
5232        Werror("`%s` is not defined",a->Name());
5233      }
5234      else
5235      {
5236        char *s = iiTwoOps(op);
5237        Werror("%s(...) is not supported",s);
5238      }
5239    }
5240    res->rtyp = UNKNOWN;
5241  }
5242  if (a!=NULL) a->CleanUp();
5243        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5244#endif
5245  return TRUE;
5246}
5247
5248/*=================== general utilities ============================*/
5249int IsCmd(char *n, int & tok)
5250{
5251  int an=1;
5252  int i,v;
5253#ifndef GENTABLE
5254  int en=LAST_IDENTIFIER;
5255
5256  loop
5257  {
5258    if(an>=en-1)
5259    {
5260      if (strcmp(n, cmds[an].name) == 0)
5261      {
5262        i=an;
5263        break;
5264      }
5265      else if (strcmp(n, cmds[en].name) == 0)
5266      {
5267        i=en;
5268        break;
5269      }
5270      else
5271      {
5272        return 0;
5273      }
5274    }
5275    i=(an+en)/2;
5276    v=strcmp(n,cmds[i].name);
5277    if(v<0)
5278    {
5279      en=i;
5280    }
5281    else if(v>0)
5282    {
5283      an=i;
5284    }
5285    else /*v==0*/
5286    {
5287      break;
5288    }
5289  }
5290  lastreserved=cmds[i].name;
5291  tok=cmds[i].tokval;
5292  if(cmds[i].alias==2)
5293  {
5294    Warn("outdated identifier `%s` used - please change your code",
5295    cmds[i].name);
5296    cmds[i].alias=1;
5297  }
5298  if (currRingHdl==NULL)
5299  {
5300    #ifdef SIQ
5301    if (siq<=0)
5302    {
5303    #endif
5304      if ((tok>=BEGIN_RING) && (tok<=END_RING))
5305      {
5306         Werror("no ring active");
5307         return 0;
5308      }
5309    #ifdef SIQ
5310    }
5311    #endif
5312  }
5313  if (!expected_parms)
5314  {
5315    switch (tok)
5316    {
5317      case IDEAL_CMD:
5318      case INT_CMD:
5319      case INTVEC_CMD:
5320      case MAP_CMD:
5321      case MATRIX_CMD:
5322      case MODUL_CMD:
5323      case POLY_CMD:
5324      case PROC_CMD:
5325      case RING_CMD:
5326      case STRING_CMD:
5327        cmdtok = tok;
5328        break;
5329    }
5330  }
5331#endif
5332  return cmds[i].toktype;
5333}
5334static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
5335{
5336#ifndef GENTABLE
5337  int a=0;
5338  int e=len;
5339  int p=len/2;
5340  while ( a!=e)
5341  {
5342     if (op==dArithTab[p].cmd) return dArithTab[p].start;
5343     else if (op<dArithTab[p].cmd)
5344     { e=p; p=a+(e-a)/2;}
5345     else
5346     { a=p; p=p+(e-p)/2; }
5347  }
5348#endif
5349  return -1;
5350}
5351
Note: See TracBrowser for help on using the repository browser.