source: git/Singular/iparith.cc @ dfc64d9

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