source: git/Singular/iparith.cc @ 84a6a7

fieker-DuValspielwiese
Last change on this file since 84a6a7 was d7626fe, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes: std(i,j), + bigint preparation git-svn-id: file:///usr/local/Singular/svn/trunk@9167 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 219.4 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.399 2006-05-29 12:34:41 Singular Exp $ */
5
6/*
7* ABSTRACT: table driven kernel interface, used by interpreter
8*/
9
10#include <stdlib.h>
11#include <string.h>
12#include <ctype.h>
13#include <stdio.h>
14#include <time.h>
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "omalloc.h"
22#include "polys.h"
23#include "febase.h"
24#include "sdb.h"
25#include "longalg.h"
26#include "ideals.h"
27#include "matpol.h"
28#include "kstd1.h"
29#include "timer.h"
30#include "ring.h"
31#include "subexpr.h"
32#include "lists.h"
33#include "longalg.h"
34#include "numbers.h"
35#include "stairc.h"
36#include "maps.h"
37#include "maps_ip.h"
38#include "syz.h"
39#include "weight.h"
40#include "ipconv.h"
41#include "ipprint.h"
42#include "sing_dld.h"
43#include "attrib.h"
44#include "silink.h"
45#include "sparsmat.h"
46#include "units.h"
47#include "janet.h"
48#include "GMPrat.h"
49#include "tgb.h"
50#include "walkProc.h"
51#include "mod_raw.h"
52#ifdef HAVE_FACTORY
53#include "clapsing.h"
54#include "kstdfac.h"
55#endif
56#ifdef HAVE_FGLM
57#include "fglm.h"
58#endif
59
60#include "ipshell.h"
61
62#include "mpr_inout.h"
63
64#ifdef HAVE_PLURAL
65#include "gring.h"
66#define ALLOW_PLURAL    ,1
67#define ALLOW_PLURAL_N   1
68#define NO_PLURAL       ,0
69#define NO_PLURAL_N      0
70#define COMM_PLURAL     ,2
71#define COMM_PLURAL_N    2
72#else
73#define ALLOW_PLURAL
74#define NO_PLURAL
75#define COMM_PLURAL
76#endif
77
78/*=============== types =====================*/
79struct sValCmdTab
80{
81  short cmd;
82  short start;
83};
84
85typedef sValCmdTab jjValCmdTab[];
86
87/* ifdef GENTABLE: definitions are in ipshell.h */
88#ifndef GENTABLE
89typedef char * (*Proc1)(char *);
90struct sValCmd1
91{
92  proc1 p;
93  short cmd;
94  short res;
95  short arg;
96#ifdef HAVE_PLURAL
97  short valid_for_plural;
98#endif
99};
100
101typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
102struct sValCmd2
103{
104  proc2 p;
105  short cmd;
106  short res;
107  short arg1;
108  short arg2;
109#ifdef HAVE_PLURAL
110  short valid_for_plural;
111#endif
112};
113
114typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
115struct sValCmd3
116{
117  proc3 p;
118  short cmd;
119  short res;
120  short arg1;
121  short arg2;
122  short arg3;
123#ifdef HAVE_PLURAL
124  short valid_for_plural;
125#endif
126};
127struct sValCmdM
128{
129  proc1 p;
130  short cmd;
131  short res;
132  short number_of_args; /* -1: any, -2: any >0, .. */
133#ifdef HAVE_PLURAL
134  short valid_for_plural;
135#endif
136};
137#endif
138
139/*============= proc =======================*/
140static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
141static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
142#ifdef MDEBUG
143#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
144static Subexpr jjDBMakeSub(leftv e,char *f, int l);
145#else
146static Subexpr jjMakeSub(leftv e);
147#endif
148
149/*============= vars ======================*/
150extern int cmdtok;
151extern BOOLEAN expected_parms;
152
153#define ii_div_by_0 "div. by 0"
154#define ii_not_for_plural "not implemented for non-commutative rings"
155
156int iiOp; /* the current operation*/
157
158#ifdef GENTABLE
159cmdnames cmds[] =
160{  // name-string alias tokval          toktype
161  { "$INVALID$",   0, -1,                 0},
162  { "and",         0, '&' ,               LOGIC_OP},
163  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
164  { "bareiss",     0, BAREISS_CMD ,       CMD_123},
165  { "betti",       0, BETTI_CMD ,         CMD_12},
166  { "bigint",      0, BIGINT_CMD ,        ROOT_DECL},
167  #ifdef HAVE_PLURAL
168  { "bracket",     0, BRACKET_CMD ,       CMD_2},
169  #endif
170  { "break",       0, BREAK_CMD ,         BREAK_CMD},
171  { "breakpoint",  0, BREAKPOINT_CMD ,    CMD_M},
172  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
173  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
174  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
175  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
176  { "close",       0, CLOSE_CMD ,         CMD_1},
177  { "coef",        0, COEF_CMD ,          CMD_M},
178  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
179  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
180  { "contract",    0, CONTRACT_CMD ,      CMD_2},
181  { "convhull",    0, NEWTONPOLY_CMD,     CMD_1},
182  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
183  { "def",         0, DEF_CMD ,           ROOT_DECL},
184  { "defined",     0, DEFINED_CMD ,       CMD_1},
185  { "deg",         0, DEG_CMD ,           CMD_12},
186  { "degree",      0, DEGREE_CMD ,        CMD_1},
187  { "delete",      0, DELETE_CMD ,        CMD_2},
188  { "det",         0, DET_CMD ,           CMD_1},
189  { "diff",        0, DIFF_CMD ,          CMD_2},
190  { "dim",         0, DIM_CMD ,           CMD_1},
191  { "div",         0, INTDIV_CMD ,        MULDIV_OP},
192  { "division",    0, DIVISION_CMD ,      CMD_M},
193  { "dump",        0, DUMP_CMD,           CMD_1},
194  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
195  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
196  { "ERROR",       0, ERROR_CMD ,         CMD_1},
197  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
198  { "else",        0, ELSE_CMD ,          ELSE_CMD},
199  #ifdef HAVE_PLURAL
200  { "envelope",    0, ENVELOPE_CMD ,       CMD_1},
201  #endif
202  { "eval",        0, EVAL ,              EVAL},
203  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
204  { "execute",     0, EXECUTE_CMD ,       CMD_1},
205  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
206  { "exportto",    0, EXPORTTO_CMD ,      CMD_2},
207  { "factorize",   0, FAC_CMD ,           CMD_12},
208  { "fetch",       0, FETCH_CMD ,         CMD_2},
209  { "fglm",        0, FGLM_CMD ,          CMD_2},
210  { "fglmquot",    0, FGLMQUOT_CMD,       CMD_2},
211  { "find",        0, FIND_CMD ,          CMD_23},
212  { "finduni",     0, FINDUNI_CMD,        CMD_1},
213  { "forif",       0, IF_CMD ,            IF_CMD},
214  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
215  { "facstd",      0, FACSTD_CMD ,        CMD_12},
216  { "frwalk",      0, FWALK_CMD ,         CMD_23},
217  { "gen",         0, E_CMD ,             CMD_1},
218  { "getdump",     0, GETDUMP_CMD,        CMD_1},
219  { "gcd",         0, GCD_CMD ,           CMD_2},
220  { "GCD",         2, GCD_CMD ,           CMD_2},
221  { "hilb",        0, HILBERT_CMD ,       CMD_123},
222  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
223  { "homog",       0, HOMOG_CMD ,         CMD_12},
224  { "hres",        0, HRES_CMD ,          CMD_2},
225  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
226  { "if",          0, IF_CMD ,            IF_CMD},
227  { "imap",        0, IMAP_CMD ,          CMD_2},
228  { "impart",      0, IMPART_CMD ,        CMD_1},
229  { "importfrom",  0, IMPORTFROM_CMD ,    CMD_2},
230  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
231  { "insert",      0, INSERT_CMD ,        CMD_23},
232  { "int",         0, INT_CMD ,           ROOT_DECL},
233  { "interred",    0, INTERRED_CMD ,      CMD_1},
234  { "intersect",   0, INTERSECT_CMD ,     CMD_M},
235  { "intmat",      0, INTMAT_CMD ,        INTMAT_CMD},
236  { "intvec",      0, INTVEC_CMD ,        ROOT_DECL_LIST},
237  { "jacob",       0, JACOB_CMD ,         CMD_1},
238  { "janet",       0, JANET_CMD ,         CMD_12},
239  { "jet",         0, JET_CMD ,           CMD_M},
240  { "kbase",       0, KBASE_CMD ,         CMD_12},
241  { "keepring",    0, KEEPRING_CMD ,      KEEPRING_CMD},
242  { "kill",        0, KILL_CMD ,          KILL_CMD},
243  { "killattrib",  0, KILLATTR_CMD ,      CMD_12},
244  { "koszul",      0, KOSZUL_CMD ,        CMD_23},
245  { "kres",        0, KRES_CMD ,          CMD_2},
246  { "laguerre",    0, LAGSOLVE_CMD,       CMD_3},
247  { "lead",        0, LEAD_CMD ,          CMD_1},
248  { "leadcoef",    0, LEADCOEF_CMD ,      CMD_1},
249  { "leadexp",     0, LEADEXP_CMD ,       CMD_1},
250  { "leadmonom",   0, LEADMONOM_CMD ,     CMD_1},
251  { "LIB",         0, LIB_CMD ,           SYSVAR},
252  { "lift",        0, LIFT_CMD ,          CMD_23},
253  { "liftstd",     0, LIFTSTD_CMD ,       CMD_2},
254  { "link",        0, LINK_CMD ,          ROOT_DECL},
255  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
256  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
257  { "load",        0, LOAD_CMD ,          CMD_12},
258  { "lres",        0, LRES_CMD ,          CMD_2},
259  { "map",         0, MAP_CMD ,           RING_DECL},
260  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
261  { "maxideal",    0, MAXID_CMD ,         CMD_1},
262  { "memory",      0, MEMORY_CMD ,        CMD_1},
263  { "minbase",     0, MINBASE_CMD ,       CMD_1},
264  { "minor",       0, MINOR_CMD ,         CMD_23},
265  { "minres",      0, MINRES_CMD ,        CMD_1},
266  { "mod",         0, INTMOD_CMD ,        MULDIV_OP},
267  { "module",      0, MODUL_CMD ,         MODUL_CMD},
268  { "modulo",      0, MODULO_CMD ,        CMD_2},
269  { "monitor",     0, MONITOR_CMD ,       CMD_12},
270  { "mpresmat",    0, MPRES_CMD,          CMD_2},
271  { "mult",        0, MULTIPLICITY_CMD ,  CMD_1},
272  #ifdef OLD_RES
273  { "mres",        0, MRES_CMD ,          CMD_23},
274  #else
275  { "mres",        0, MRES_CMD ,          CMD_2},
276  #endif
277  { "mstd",        0, MSTD_CMD ,          CMD_1},
278  { "nameof",      0, NAMEOF_CMD ,        CMD_1},
279  { "names",       0, NAMES_CMD ,         CMD_M},
280  #ifdef HAVE_PLURAL
281  { "ncalgebra",   0, NCALGEBRA_CMD ,     CMD_2},
282  #endif
283  { "ncols",       0, COLS_CMD ,          CMD_1},
284  { "not",         0, NOT ,               NOT},
285  { "npars",       0, NPARS_CMD ,         CMD_1},
286  #ifdef OLD_RES
287  { "nres",        0, RES_CMD ,           CMD_23},
288  #else
289  { "nres",        0, RES_CMD ,           CMD_2},
290  #endif
291  { "nrows",       0, ROWS_CMD ,          CMD_1},
292  { "number",      0, NUMBER_CMD ,        RING_DECL},
293  { "nvars",       0, NVARS_CMD ,         CMD_1},
294  { "open",        0, OPEN_CMD ,          CMD_1},
295  #ifdef HAVE_PLURAL
296  { "oppose",      0, OPPOSE_CMD ,        CMD_2},
297  { "opposite",    0, OPPOSITE_CMD ,      CMD_1},
298  #endif
299  { "option",      0, OPTION_CMD ,        CMD_M},
300  { "or",          0, '|' ,               LOGIC_OP},
301  { "ord",         0, ORD_CMD ,           CMD_1},
302  { "ordstr",      0, ORDSTR_CMD ,        CMD_1},
303  { "package",     0, PACKAGE_CMD ,       ROOT_DECL},
304  { "par",         0, PAR_CMD ,           CMD_1},
305  { "parameter",   0, PARAMETER ,         PARAMETER},
306  { "pardeg",      0, PARDEG_CMD ,        CMD_1},
307  { "parstr",      0, PARSTR_CMD ,        CMD_12},
308  { "poly",        0, POLY_CMD ,          RING_DECL},
309  { "preimage",    0, PREIMAGE_CMD ,      CMD_13},
310  { "prime",       0, PRIME_CMD ,         CMD_1},
311  { "print",       0, PRINT_CMD ,         CMD_12},
312  { "prune",       0, PRUNE_CMD ,         CMD_1},
313  { "proc",        0, PROC_CMD ,          PROC_CMD},
314  { "qhweight",    0, QHWEIGHT_CMD ,      CMD_1},
315  { "qring",       0, QRING_CMD ,         ROOT_DECL},
316  { "quote",       0, QUOTE ,             QUOTE},
317  { "quotient",    0, QUOTIENT_CMD ,      CMD_2},
318  { "random",      0, RANDOM_CMD ,        CMD_23},
319  { "read",        0, READ_CMD ,          CMD_12},
320  { "reduce",      0, REDUCE_CMD ,        CMD_M},
321  { "regularity",  0, REGULARITY_CMD ,    CMD_1},
322  { "repart",      0, REPART_CMD ,        CMD_1},
323  { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
324  { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},
325  { "resultant",   0, RESULTANT_CMD,      CMD_3},
326  { "return",      0, RETURN ,            RETURN},
327  { "RETURN",      0, END_GRAMMAR ,       RETURN},
328  { "ring",        0, RING_CMD ,          RING_CMD},
329  { "ringlist",    0, RINGLIST_CMD ,      CMD_1},
330  { "rvar",        0, IS_RINGVAR ,        CMD_1},
331  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
332  { "simplex",     0, SIMPLEX_CMD,        CMD_M},
333  { "simplify",    0, SIMPLIFY_CMD ,      CMD_2},
334  { "size",        0, COUNT_CMD ,         CMD_1},
335  { "slimgb",      0, SLIM_GB_CMD ,       CMD_1},
336  { "sortvec",     0, SORTVEC_CMD ,       CMD_1},
337  #ifdef OLD_RES
338  { "sres",        0, SRES_CMD ,          CMD_23},
339  #else
340  { "sres",        0, SRES_CMD ,          CMD_2},
341  #endif
342  { "status",      0, STATUS_CMD,         CMD_M},
343  { "std",         0, STD_CMD ,           CMD_123},
344  { "string",      0, STRING_CMD ,        ROOT_DECL_LIST},
345  { "subst",       0, SUBST_CMD ,         CMD_M},
346  { "system",      0, SYSTEM_CMD,         CMD_M},
347  { "syz",         0, SYZYGY_CMD ,        CMD_1},
348  { "test",        0, TEST_CMD ,          CMD_M},
349  { "trace",       0, TRACE_CMD ,         CMD_1},
350  { "transpose",   0, TRANSPOSE_CMD ,     CMD_1},
351  #ifdef HAVE_PLURAL
352  { "twostd",      0, TWOSTD_CMD ,        CMD_1},
353  #endif
354  { "type",        0, TYPE_CMD ,          TYPE_CMD},
355  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
356  { "uressolve",   0, URSOLVE_CMD,        CMD_M},
357  { "vandermonde", 0, VANDER_CMD,         CMD_3},
358  { "var",         0, VAR_CMD ,           CMD_1},
359  { "varstr",      0, VARSTR_CMD ,        CMD_12},
360  { "vdim",        0, VDIM_CMD ,          CMD_1},
361  { "vector",      0, VECTOR_CMD ,        RING_DECL},
362  { "wedge",       0, WEDGE_CMD ,         CMD_2},
363  { "weight",      0, WEIGHT_CMD ,        CMD_1},
364  { "whileif",     0, IF_CMD ,            IF_CMD},
365  { "write",       0, WRITE_CMD ,         CMD_M},
366/* delete for next version:*/
367  { "IN",          1, LEAD_CMD ,          CMD_1},
368  { "NF",          1, REDUCE_CMD ,        CMD_M},
369  { "multiplicity",1, MULTIPLICITY_CMD ,  CMD_1},
370  { "verbose",     2, OPTION_CMD ,        CMD_M},
371//  { "rank",        1, ROWS_CMD ,          CMD_1},
372//  { "Current",     0, -1 ,                SYSVAR},
373//  { "Top",         0, -1 ,                SYSVAR},
374//  { "Up",          0, -1 ,                SYSVAR},
375
376/* set sys vars*/
377  { "degBound",    0, VMAXDEG ,           SYSVAR},
378  { "echo",        0, VECHO ,             SYSVAR},
379  { "minpoly",     0, VMINPOLY ,          SYSVAR},
380  { "multBound",   0, VMAXMULT ,          SYSVAR},
381  { "noether",     0, VNOETHER ,          SYSVAR},
382  { "pagelength",  0, VPAGELENGTH ,       SYSVAR},
383  { "pagewidth",   0, VCOLMAX ,           SYSVAR},
384  { "printlevel",  0, VPRINTLEVEL ,       SYSVAR},
385  { "short",       0, VSHORTOUT ,         SYSVAR},
386  { "timer",       0, VTIMER ,            SYSVAR},
387  { "rtimer",      0, VRTIMER,            SYSVAR},
388  { "TRACE",       0, TRACE ,             SYSVAR},
389  { "voice",       0, VOICE ,             SYSVAR},
390
391/* other reserved words:scanner.l */
392  { "pause",       2, -1 ,             0},
393  { "while",       0, -1 ,             0},
394  { "for",         0, -1 ,             0},
395  { "help",        0, -1 ,             0},
396  { "newline",     0, -1 ,             0},
397  { "exit",        0, -1 ,             0},
398  { "quit",        0, -1 ,             0},
399/* end of list marker */
400  { NULL, 0, 0, 0}
401};
402#endif
403
404/*=================== operations with 2 args.: static proc =================*/
405static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
406{
407  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
408  int bb = (int)(long)(v->Data());
409  if (errorreported) return TRUE;
410  switch (iiOp)
411  {
412    case '+': (*aa) += bb; break;
413    case '-': (*aa) -= bb; break;
414    case '*': (*aa) *= bb; break;
415    case '/':
416    case INTDIV_CMD: (*aa) /= bb; break;
417    case '%':
418    case INTMOD_CMD: (*aa) %= bb; break;
419  }
420  res->data=(char *)aa;
421  return FALSE;
422}
423static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
424{
425  return jjOP_IV_I(res,v,u);
426}
427static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
428{
429  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
430  int bb = (int)(long)(v->Data());
431  int i=si_min(aa->rows(),aa->cols());
432  switch (iiOp)
433  {
434    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
435              break;
436    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
437              break;
438  }
439  res->data=(char *)aa;
440  return FALSE;
441}
442static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
443{
444  return jjOP_IM_I(res,v,u);
445}
446static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
447{
448  res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
449  return FALSE;
450}
451static void jjEQUAL_REST(leftv res,leftv u,leftv v);
452static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
453{
454  intvec*    a = (intvec * )(u->Data());
455  intvec*    b = (intvec * )(v->Data());
456  int r=a->compare(b);
457  switch  (iiOp)
458  {
459    case '<':
460      res->data  = (char *) (r<0);
461      break;
462    case '>':
463      res->data  = (char *) (r>0);
464      break;
465    case LE:
466      res->data  = (char *) (r<=0);
467      break;
468    case GE:
469      res->data  = (char *) (r>=0);
470      break;
471    case EQUAL_EQUAL:
472    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
473      res->data  = (char *) (r==0);
474      break;
475  }
476  jjEQUAL_REST(res,u,v);
477  return r==-2;
478}
479static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
480{
481  intvec* a = (intvec * )(u->Data());
482  int     b = (int)(long)(v->Data());
483  int r=a->compare(b);
484  switch  (iiOp)
485  {
486    case '<':
487      res->data  = (char *) (r<0);
488      break;
489    case '>':
490      res->data  = (char *) (r>0);
491      break;
492    case LE:
493      res->data  = (char *) (r<=0);
494      break;
495    case GE:
496      res->data  = (char *) (r>=0);
497      break;
498    case EQUAL_EQUAL:
499    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
500      res->data  = (char *) (r==0);
501      break;
502  }
503  jjEQUAL_REST(res,u,v);
504  return FALSE;
505}
506static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
507{
508  poly p=(poly)u->Data();
509  poly q=(poly)v->Data();
510  int r=pCmp(p,q);
511  if (r==0)
512  {
513    /* compare lead coeffs */
514    number h=nSub(pGetCoeff(p),pGetCoeff(q));
515    r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
516    nDelete(&h);
517  }
518  else if (p==NULL)
519  {
520    if (q==NULL)
521    {
522      /* compare 0, 0 */
523      r=0;
524    }
525    else if(pIsConstant(q))
526    {
527      /* compare 0, const */
528      r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
529    }
530  }
531  else if (q==NULL)
532  {
533    if (pIsConstant(p))
534    {
535      /* compare const, 0 */
536      r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
537    }
538  }
539  switch  (iiOp)
540  {
541    case '<':
542      res->data  = (char *) (r < 0);
543      break;
544    case '>':
545      res->data  = (char *) (r > 0);
546      break;
547    case LE:
548      res->data  = (char *) (r <= 0);
549      break;
550    case GE:
551      res->data  = (char *) (r >= 0);
552      break;
553    //case EQUAL_EQUAL:
554    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
555    //  res->data  = (char *) (r == 0);
556    //  break;
557  }
558  jjEQUAL_REST(res,u,v);
559  return FALSE;
560}
561static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
562{
563  char*    a = (char * )(u->Data());
564  char*    b = (char * )(v->Data());
565  int result = strcmp(a,b);
566  switch  (iiOp)
567  {
568    case '<':
569      res->data  = (char *) (result  < 0);
570      break;
571    case '>':
572      res->data  = (char *) (result  > 0);
573      break;
574    case LE:
575      res->data  = (char *) (result  <= 0);
576      break;
577    case GE:
578      res->data  = (char *) (result  >= 0);
579      break;
580    case EQUAL_EQUAL:
581    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
582      res->data  = (char *) (result  == 0);
583      break;
584  }
585  jjEQUAL_REST(res,u,v);
586  return FALSE;
587}
588static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
589{
590  if (u->Next()!=NULL)
591  {
592    u=u->next;
593    res->next = (leftv)omAllocBin(sleftv_bin);
594    return iiExprArith2(res->next,u,iiOp,v);
595  }
596  else if (v->Next()!=NULL)
597  {
598    v=v->next;
599    res->next = (leftv)omAllocBin(sleftv_bin);
600    return iiExprArith2(res->next,u,iiOp,v);
601  }
602  return FALSE;
603}
604static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
605{
606  int b=(int)(long)u->Data();
607  int e=(int)(long)v->Data();
608  int rc = 1;
609  BOOLEAN overflow=FALSE;
610  if (e >= 0)
611  {
612    if (b==0)
613    {
614      rc=0;
615    }
616    else
617    {
618      int oldrc;
619      while ((e--)!=0)
620      {
621        oldrc=rc;
622        rc *= b;
623        if (!overflow)
624        {
625          if(rc/b!=oldrc) overflow=TRUE;
626        }
627      }
628      if (overflow)
629        WarnS("int overflow(^), result may be wrong");
630    }
631    res->data = (char *)rc;
632    if (u!=NULL) return jjOP_REST(res,u,v);
633    return FALSE;
634  }
635  else
636  {
637    WerrorS("exponent must be non-negative");
638    return TRUE;
639  }
640}
641static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
642{
643  int e=(int)(long)v->Data();
644  number n=(number)u->CopyD(NUMBER_CMD);
645  if (e<0)
646  {
647    number m=nInvers(n);
648    nDelete(&n);
649    n=m;
650    e=-e;
651  }
652  nPower(n,e,(number*)&res->data);
653  nDelete(&n);
654  if (u!=NULL) return jjOP_REST(res,u,v);
655  return FALSE;
656}
657static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
658{
659  res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)(long)v->Data());
660  if (u!=NULL) return jjOP_REST(res,u,v);
661  return FALSE;
662}
663static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
664{
665  res->data = (char *)idPower((ideal)(u->Data()),(int)(long)(v->Data()));
666  if (u!=NULL) return jjOP_REST(res,u,v);
667  return FALSE;
668}
669static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
670{
671  u=u->next;
672  v=v->next;
673  if (u==NULL)
674  {
675    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
676    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
677    {
678      do
679      {
680        if (res->next==NULL)
681          res->next = (leftv)omAlloc0Bin(sleftv_bin);
682        leftv tmp_v=v->next;
683        v->next=NULL;
684        BOOLEAN b=iiExprArith1(res->next,v,'-');
685        v->next=tmp_v;
686        if (b)
687          return TRUE;
688        v=tmp_v;
689        res=res->next;
690      } while (v!=NULL);
691      return FALSE;
692    }
693    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
694    {
695      res->next = (leftv)omAlloc0Bin(sleftv_bin);
696      res=res->next;
697      res->data = v->CopyD();
698      res->rtyp = v->Typ();
699      v=v->next;
700      if (v==NULL) return FALSE;
701    }
702  }
703  if (v!=NULL)                     /* u<>NULL, v<>NULL */
704  {
705    do
706    {
707      res->next = (leftv)omAlloc0Bin(sleftv_bin);
708      leftv tmp_u=u->next; u->next=NULL;
709      leftv tmp_v=v->next; v->next=NULL;
710      BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
711      u->next=tmp_u;
712      v->next=tmp_v;
713      if (b)
714        return TRUE;
715      u=tmp_u;
716      v=tmp_v;
717      res=res->next;
718    } while ((u!=NULL) && (v!=NULL));
719    return FALSE;
720  }
721  loop                             /* u<>NULL, v==NULL */
722  {
723    res->next = (leftv)omAlloc0Bin(sleftv_bin);
724    res=res->next;
725    res->data = u->CopyD();
726    res->rtyp = u->Typ();
727    u=u->next;
728    if (u==NULL) return FALSE;
729  }
730}
731static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
732{
733#ifdef HAVE_NS
734  idhdl packhdl;
735
736  switch(u->Typ())
737  {
738      case 0:
739        Print("%s of type 'ANY'. Trying load.\n", v->name);
740        if(iiTryLoadLib(u, u->name))
741        {
742          Werror("'%s' no such package", u->name);
743          return TRUE;
744        }
745        syMake(u,u->name,NULL);
746        // else: use next case !!! no break !!!
747
748      case PACKAGE_CMD:
749        packhdl = (idhdl)u->data;
750        if((!IDPACKAGE(packhdl)->loaded)
751        && (IDPACKAGE(packhdl)->language > LANG_TOP))
752        {
753          //if(iiReLoadLib(packhdl))
754          //  Werror("unable to reload package '%s'", IDID(packhdl));
755          Werror("'%s' not loaded", u->name);
756          return TRUE;
757        }
758        if(v->rtyp == IDHDL)
759        {
760          v->name = omStrDup(v->name);
761        }
762        v->req_packhdl=IDPACKAGE(packhdl);
763        v->packhdl=IDPACKAGE(packhdl);
764        syMake(v, v->name, packhdl);
765        memcpy(res, v, sizeof(sleftv));
766        memset(v, 0, sizeof(sleftv));
767        break;
768
769      case DEF_CMD:
770        break;
771
772      default:
773        WerrorS("<package>::<id> expected");
774        return TRUE;
775  }
776#else
777  WerrorS("package is not supported in this version");
778#endif /* HAVE_NS */
779  return FALSE;
780}
781static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
782{
783  unsigned int a=(unsigned int)(unsigned long)u->Data();
784  unsigned int b=(unsigned int)(unsigned long)v->Data();
785  unsigned int c=a+b;
786  res->data = (char *)c;
787  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
788  {
789    WarnS("int overflow(+), result may be wrong");
790  }
791  return jjPLUSMINUS_Gen(res,u,v);
792}
793static BOOLEAN jjPLUS_BI(leftv res, leftv u, leftv v)
794{
795  res->data = (char *)(nlAdd((number)u->Data(), (number)v->Data()));
796  return jjPLUSMINUS_Gen(res,u,v);
797}
798static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
799{
800  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
801  return jjPLUSMINUS_Gen(res,u,v);
802}
803static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
804{
805  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
806  return jjPLUSMINUS_Gen(res,u,v);
807}
808static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
809{
810  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
811  if (res->data==NULL)
812  {
813     WerrorS("intmat size not compatible");
814     return TRUE;
815  }
816  return jjPLUSMINUS_Gen(res,u,v);
817  return FALSE;
818}
819static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
820{
821  res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
822  if (res->data==NULL)
823  {
824     WerrorS("matrix size not compatible");
825     return TRUE;
826  }
827  return jjPLUSMINUS_Gen(res,u,v);
828}
829static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
830{
831  matrix m=(matrix)u->Data();
832  matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
833  if (iiOp=='+')
834    res->data = (char *)mpAdd(m , p);
835  else
836    res->data = (char *)mpSub(m , p);
837  idDelete((ideal *)&p);
838  return jjPLUSMINUS_Gen(res,u,v);
839}
840static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
841{
842  return jjPLUS_MA_P(res,v,u);
843}
844static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
845{
846  char*    a = (char * )(u->Data());
847  char*    b = (char * )(v->Data());
848  char*    r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
849  strcpy(r,a);
850  strcat(r,b);
851  res->data=r;
852  return jjPLUSMINUS_Gen(res,u,v);
853}
854static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
855{
856  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
857  return jjPLUSMINUS_Gen(res,u,v);
858}
859static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
860{
861  unsigned int a=(unsigned int)(unsigned long)u->Data();
862  unsigned int b=(unsigned int)(unsigned long)v->Data();
863  unsigned int c=a-b;
864  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
865  {
866    WarnS("int overflow(-), result may be wrong");
867  }
868  res->data = (char *)c;
869  return jjPLUSMINUS_Gen(res,u,v);
870}
871static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
872{
873  res->data = (char *)(nlSub((number)u->Data(), (number)v->Data()));
874  return jjPLUSMINUS_Gen(res,u,v);
875}
876static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
877{
878  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
879  return jjPLUSMINUS_Gen(res,u,v);
880}
881static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
882{
883  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
884  return jjPLUSMINUS_Gen(res,u,v);
885}
886static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
887{
888  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
889  if (res->data==NULL)
890  {
891     WerrorS("intmat size not compatible");
892     return TRUE;
893  }
894  return jjPLUSMINUS_Gen(res,u,v);
895}
896static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
897{
898  res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
899  if (res->data==NULL)
900  {
901     WerrorS("matrix size not compatible");
902     return TRUE;
903  }
904  return jjPLUSMINUS_Gen(res,u,v);
905  return FALSE;
906}
907static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
908{
909  int a=(int)(long)u->Data();
910  int b=(int)(long)v->Data();
911  int c=a * b;
912  if ((b!=0) && (c/b !=a))
913    WarnS("int overflow(*), result may be wrong");
914  res->data = (char *)c;
915  if ((u->Next()!=NULL) || (v->Next()!=NULL))
916    return jjOP_REST(res,u,v);
917  return FALSE;
918}
919static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
920{
921  res->data = (char *)(nlMult( (number)u->Data(), (number)v->Data()));
922  if ((v->next!=NULL) || (u->next!=NULL))
923    return jjOP_REST(res,u,v);
924  return FALSE;
925}
926static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
927{
928  res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
929  if ((v->next!=NULL) || (u->next!=NULL))
930    return jjOP_REST(res,u,v);
931  return FALSE;
932}
933static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
934{
935  poly a;
936  poly b;
937
938  if (v->next==NULL)
939  {
940    a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
941    if (u->next==NULL)
942    {
943      b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
944      res->data = (char *)(pMult( a, b));
945      return FALSE;
946    }
947    // u->next exists: copy v
948    b=pCopy((poly)v->Data());
949    res->data = (char *)(pMult( a, b));
950    return jjOP_REST(res,u,v);
951  }
952  // v->next exists: copy u
953  a=pCopy((poly)u->Data());
954  b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
955  res->data = (char *)(pMult( a, b));
956  return jjOP_REST(res,u,v);
957}
958static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
959{
960  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
961  if ((v->next!=NULL) || (u->next!=NULL))
962    return jjOP_REST(res,u,v);
963  return FALSE;
964}
965static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
966{
967  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
968  if (res->data==NULL)
969  {
970     WerrorS("intmat size not compatible");
971     return TRUE;
972  }
973  if ((v->next!=NULL) || (u->next!=NULL))
974    return jjOP_REST(res,u,v);
975  return FALSE;
976}
977static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
978{
979  poly p=(poly)v->CopyD(POLY_CMD);
980  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
981  ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
982  if (r>0) I->rank=r;
983  res->data = (char *)I;
984  return FALSE;
985}
986static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
987{
988  return jjTIMES_MA_P1(res,v,u);
989}
990static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
991{
992  number n=(number)v->CopyD(NUMBER_CMD);
993  poly p=pOne();
994  pSetCoeff(p,n);
995  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
996  return FALSE;
997}
998static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
999{
1000  return jjTIMES_MA_N1(res,v,u);
1001}
1002static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
1003{
1004  res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data());
1005  return FALSE;
1006}
1007static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1008{
1009  return jjTIMES_MA_I1(res,v,u);
1010}
1011static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1012{
1013  res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
1014  if (res->data==NULL)
1015  {
1016     WerrorS("matrix size not compatible");
1017     return TRUE;
1018  }
1019  if ((v->next!=NULL) || (u->next!=NULL))
1020    return jjOP_REST(res,u,v);
1021  return FALSE;
1022}
1023static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1024{
1025  res->data = (char *)((int)((long)u->Data()) >= (int)((long)v->Data()));
1026  return FALSE;
1027}
1028static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1029{
1030  number h=nSub((number)u->Data(),(number)v->Data());
1031  res->data = (char *) (nGreaterZero(h)||(nIsZero(h)));
1032  nDelete(&h);
1033  return FALSE;
1034}
1035static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1036{
1037  res->data = (char *)((int)((long)u->Data()) > (int)((long)v->Data()));
1038  return FALSE;
1039}
1040static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1041{
1042  number h=nSub((number)u->Data(),(number)v->Data());
1043  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1044  nDelete(&h);
1045  return FALSE;
1046}
1047static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1048{
1049  res->data = (char *)((int)((long)u->Data()) <= (int)((long)v->Data()));
1050  return FALSE;
1051}
1052static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1053{
1054  number h=nSub((number)v->Data(),(number)u->Data());
1055  res->data = (char *) (nGreaterZero(h)||nIsZero(h));
1056  nDelete(&h);
1057  return FALSE;
1058}
1059static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1060{
1061  res->data = (char *)((int)((long)u->Data()) < (int)((long)v->Data()));
1062  return FALSE;
1063}
1064static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1065{
1066  number h=nSub((number)v->Data(),(number)u->Data());
1067  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1068  nDelete(&h);
1069  return FALSE;
1070}
1071static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1072{
1073  int a= (int)(long)u->Data();
1074  int b= (int)(long)v->Data();
1075  if (b==0)
1076  {
1077    WerrorS(ii_div_by_0);
1078    return TRUE;
1079  }
1080  int bb=ABS(b);
1081  int c=a%bb;
1082  if(c<0) c+=bb;
1083  int r=0;
1084  switch (iiOp)
1085  {
1086    case INTMOD_CMD:
1087        r=c;            break;
1088    case '%':
1089        r= (a % b);     break;
1090    case INTDIV_CMD:
1091        r=((a-c) /b);   break;
1092    case '/':
1093        r= (a / b);     break;
1094  }
1095  res->data=(void *)r;
1096  return FALSE;
1097}
1098static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
1099{
1100  number q=(number)v->Data();
1101  if (nlIsZero(q))
1102  {
1103    WerrorS(ii_div_by_0);
1104    return TRUE;
1105  }
1106  q = nlIntDiv((number)u->Data(),q);
1107  nlNormalize(q);
1108  res->data = (char *)q;
1109  return FALSE;
1110}
1111static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1112{
1113  number q=(number)v->Data();
1114  if (nIsZero(q))
1115  {
1116    WerrorS(ii_div_by_0);
1117    return TRUE;
1118  }
1119  q = nDiv((number)u->Data(),q);
1120  nNormalize(q);
1121  res->data = (char *)q;
1122  return FALSE;
1123}
1124static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1125{
1126  poly q=(poly)v->Data();
1127  if (q==NULL)
1128  {
1129    WerrorS(ii_div_by_0);
1130    return TRUE;
1131  }
1132  poly p=(poly)(u->Data());
1133  if (p==NULL)
1134  {
1135    res->data=NULL;
1136    return FALSE;
1137  }
1138  if (pNext(q)!=NULL)
1139  {
1140#ifdef HAVE_FACTORY
1141    if(pGetComp(p)==0)
1142    {
1143      res->data=(void*)(singclap_pdivide(p /*(poly)(u->Data())*/ ,
1144                                         q /*(poly)(v->Data())*/ ));
1145    }
1146    else
1147    {
1148      int comps=pMaxComp(p);
1149      ideal I=idInit(comps,1);
1150      p=pCopy(p);
1151      poly h;
1152      int i;
1153      // conversion to a list of polys:
1154      while (p!=NULL)
1155      {
1156        i=pGetComp(p)-1;
1157        h=pNext(p);
1158        pNext(p)=NULL;
1159        pSetComp(p,0);
1160        I->m[i]=pAdd(I->m[i],p);
1161        p=h;
1162      }
1163      // division and conversion to vector:
1164      h=NULL;
1165      p=NULL;
1166      for(i=comps-1;i>=0;i--)
1167      {
1168        if (I->m[i]!=NULL)
1169        {
1170          h=singclap_pdivide(I->m[i],q);
1171          pSetCompP(h,i+1);
1172          p=pAdd(p,h);
1173        }
1174      }
1175      idDelete(&I);
1176      res->data=(void *)p;
1177    }
1178#else
1179    WerrorS("division only by a monomial");
1180    return TRUE;
1181#endif
1182  }
1183  else
1184  {
1185    res->data = (char *)pDivideM(pCopy(p),pHead(q));
1186  }
1187  return FALSE;
1188}
1189static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1190{
1191  poly q=(poly)v->Data();
1192  if (q==NULL)
1193  {
1194    WerrorS(ii_div_by_0);
1195    return TRUE;
1196  }
1197  matrix m=(matrix)(u->Data());
1198  int r=m->rows();
1199  int c=m->cols();
1200  matrix mm=mpNew(r,c);
1201  int i,j;
1202  for(i=r;i>0;i--)
1203  {
1204    for(j=c;j>0;j--)
1205    {
1206      if (pNext(q)!=NULL)
1207      {
1208      #ifdef HAVE_FACTORY
1209        MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1210                                           q /*(poly)(v->Data())*/ );
1211      #else
1212        WerrorS("division only by a monomial");
1213        return TRUE;
1214      #endif
1215      }
1216      else
1217        MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1218    }
1219  }
1220  res->data=(char *)mm;
1221  return FALSE;
1222}
1223static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1224{
1225  res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1226  jjEQUAL_REST(res,u,v);
1227  return FALSE;
1228}
1229static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1230{
1231  res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
1232  jjEQUAL_REST(res,u,v);
1233  return FALSE;
1234}
1235static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1236{
1237  res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
1238  jjEQUAL_REST(res,u,v);
1239  return FALSE;
1240}
1241static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1242{
1243  poly p=(poly)u->Data();
1244  poly q=(poly)v->Data();
1245  res->data = (char *) (pEqualPolys(p,q));
1246  jjEQUAL_REST(res,u,v);
1247  return FALSE;
1248}
1249static void jjEQUAL_REST(leftv res,leftv u,leftv v)
1250{
1251  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1252  {
1253    int save_iiOp=iiOp;
1254    if (iiOp==NOTEQUAL)
1255      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
1256    else
1257      iiExprArith2(res,u->next,iiOp,v->next);
1258    iiOp=save_iiOp;
1259  }
1260  if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1261}
1262static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1263{
1264  res->data = (char *)((long)u->Data() && (long)v->Data());
1265  return FALSE;
1266}
1267static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1268{
1269  res->data = (char *)((long)u->Data() || (long)v->Data());
1270  return FALSE;
1271}
1272static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1273{
1274  res->rtyp=u->rtyp; u->rtyp=0;
1275  res->data=u->data; u->data=NULL;
1276  res->name=u->name; u->name=NULL;
1277  res->attribute=u->attribute; u->attribute=NULL;
1278  res->e=u->e;       u->e=NULL;
1279  if (res->e==NULL) res->e=jjMakeSub(v);
1280  else
1281  {
1282    Subexpr sh=res->e;
1283    while (sh->next != NULL) sh=sh->next;
1284    sh->next=jjMakeSub(v);
1285  }
1286  return FALSE;
1287}
1288static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1289{
1290  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1291  {
1292    WerrorS("indexed object must have a name");
1293    return TRUE;
1294  }
1295  intvec * iv=(intvec *)v->Data();
1296  leftv p=NULL;
1297  int i;
1298  sleftv t;
1299
1300  memset(&t,0,sizeof(t));
1301  t.rtyp=INT_CMD;
1302  for (i=0;i<iv->length(); i++)
1303  {
1304    t.data=(char *)(*iv)[i];
1305    if (p==NULL)
1306    {
1307      p=res;
1308    }
1309    else
1310    {
1311      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1312      p=p->next;
1313    }
1314    p->rtyp=IDHDL;
1315    p->data=u->data;
1316    p->name=u->name;
1317    p->flag=u->flag;
1318    p->attribute=u->attribute;
1319    p->e=jjMakeSub(&t);
1320  }
1321  u->rtyp=0;
1322  u->data=NULL;
1323  u->name=NULL;
1324  return FALSE;
1325}
1326static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1327{
1328  poly p=(poly)u->Data();
1329  int i=(int)(long)v->Data();
1330  int j=0;
1331  while (p!=NULL)
1332  {
1333    j++;
1334    if (j==i)
1335    {
1336      res->data=(char *)pHead(p);
1337      return FALSE;
1338    }
1339    pIter(p);
1340  }
1341  return FALSE;
1342}
1343static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1344{
1345  poly p=(poly)u->Data();
1346  poly r=NULL;
1347  intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1348  int i;
1349  int sum=0;
1350  for(i=iv->length()-1;i>=0;i--)
1351    sum+=(*iv)[i];
1352  int j=0;
1353  while ((p!=NULL) && (sum>0))
1354  {
1355    j++;
1356    for(i=iv->length()-1;i>=0;i--)
1357    {
1358      if (j==(*iv)[i])
1359      {
1360        r=pAdd(r,pHead(p));
1361        sum-=j;
1362        (*iv)[i]=0;
1363        break;
1364      }
1365    }
1366    pIter(p);
1367  }
1368  delete iv;
1369  res->data=(char *)r;
1370  return FALSE;
1371}
1372static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1373{
1374  poly p=(poly)u->CopyD(VECTOR_CMD);
1375  poly r=p; // pointer to the beginning of component i
1376  poly o=NULL;
1377  int i=(int)(long)v->Data();
1378  while (p!=NULL)
1379  {
1380    if (pGetComp(p)!=i)
1381    {
1382      if (r==p) r=pNext(p);
1383      if (o!=NULL)
1384      {
1385        pDeleteLm(&pNext(o));
1386        p=pNext(o);
1387      }
1388      else
1389        pDeleteLm(&p);
1390    }
1391    else
1392    {
1393      pSetComp(p, 0);
1394      o=p;
1395      p=pNext(o);
1396    }
1397  }
1398  res->data=(char *)r;
1399  return FALSE;
1400}
1401static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1402{
1403  poly p=(poly)u->CopyD(VECTOR_CMD);
1404  if (p!=NULL)
1405  {
1406    poly r=pOne();
1407    poly hp=r;
1408    intvec *iv=(intvec *)v->Data();
1409    int i;
1410    loop
1411    {
1412      for(i=0;i<iv->length();i++)
1413      {
1414        if (pGetComp(p)==(*iv)[i])
1415        {
1416          poly h;
1417          pSplit(p,&h);
1418          pNext(hp)=p;
1419          p=h;
1420          pIter(hp);
1421          break;
1422        }
1423      }
1424      if (p==NULL) break;
1425      if (i==iv->length())
1426      {
1427        pDeleteLm(&p);
1428        if (p==NULL) break;
1429      }
1430    }
1431    pDeleteLm(&r);
1432    res->data=(char *)r;
1433  }
1434  return FALSE;
1435}
1436static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v);
1437static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1438{
1439  if(u->name==NULL) return TRUE;
1440  char * nn = (char *)omAlloc(strlen(u->name) + 14);
1441  sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1442  omFree((ADDRESS)u->name);
1443  u->name=NULL;
1444  char *n=omStrDup(nn);
1445  omFree((ADDRESS)nn);
1446  syMake(res,n);
1447  if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1448  return FALSE;
1449}
1450static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1451{
1452  intvec * iv=(intvec *)v->Data();
1453  leftv p=NULL;
1454  int i;
1455  int slen = strlen(u->name) + 14;
1456  char *n = (char*) omAlloc(slen);
1457
1458  for (i=0;i<iv->length(); i++)
1459  {
1460    if (p==NULL)
1461    {
1462      p=res;
1463    }
1464    else
1465    {
1466      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1467      p=p->next;
1468    }
1469    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1470    syMake(p,omStrDup(n));
1471  }
1472  omFree((ADDRESS)u->name);
1473  u->name = NULL;
1474  omFreeSize(n, slen);
1475  if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1476  return FALSE;
1477}
1478static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
1479{
1480  leftv tmp=(leftv)omAllocBin(sleftv_bin);
1481  memset(tmp,0,sizeof(sleftv));
1482  BOOLEAN b;
1483  if (v->Typ()==INTVEC_CMD)
1484    b=jjKLAMMER_IV(tmp,u,v);
1485  else
1486    b=jjKLAMMER(tmp,u,v);
1487  if (b)
1488  {
1489    omFreeBin(tmp,sleftv_bin);
1490    return TRUE;
1491  }
1492  leftv h=res;
1493  while (h->next!=NULL) h=h->next;
1494  h->next=tmp;
1495  return FALSE;
1496}
1497static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1498{
1499  idrec tmp_proc;
1500  Subexpr e;
1501  void *d;
1502  int typ;
1503  BOOLEAN t=FALSE;
1504  if (u->rtyp!=IDHDL)
1505  {
1506    tmp_proc.id="_auto";
1507    tmp_proc.typ=PROC_CMD;
1508    tmp_proc.data.pinf=(procinfo *)u->Data();
1509    tmp_proc.ref=1;
1510    d=u->data; u->data=(void *)&tmp_proc;
1511    e=u->e; u->e=NULL;
1512    t=TRUE;
1513    typ=u->rtyp; u->rtyp=IDHDL;
1514  }
1515#ifdef HAVE_NS
1516  leftv sl;
1517  if (u->req_packhdl==currPack)
1518    sl = iiMake_proc((idhdl)u->data,NULL,v);
1519  else
1520    sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1521#else /* HAVE_NS */
1522  leftv sl = iiMake_proc((idhdl)u->data,v);
1523#endif /* HAVE_NS */
1524  if (t)
1525  {
1526    u->rtyp=typ;
1527    u->data=d;
1528    u->e=e;
1529  }
1530  if (sl==NULL)
1531  {
1532    return TRUE;
1533  }
1534  else
1535  {
1536    memcpy(res,sl,sizeof(sleftv));
1537  }
1538  return FALSE;
1539}
1540static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1541{
1542  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1543  leftv sl=NULL;
1544  if ((v->e==NULL)&&(v->name!=NULL))
1545  {
1546    map m=(map)u->Data();
1547    sl=iiMap(m,v->name);
1548  }
1549  else
1550  {
1551    Werror("%s(<name>) expected",u->Name());
1552  }
1553  if (sl==NULL) return TRUE;
1554  memcpy(res,sl,sizeof(sleftv));
1555  omFreeBin((ADDRESS)sl, sleftv_bin);
1556  return FALSE;
1557}
1558static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1559{
1560  u->next=(leftv)omAllocBin(sleftv_bin);
1561  memcpy(u->next,v,sizeof(sleftv));
1562  BOOLEAN r=iiExprArithM(res,u,iiOp);
1563  // iiExprArithM did the CleanUp
1564  return r;
1565}
1566static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1567{
1568  poly p=(poly)v->Data();
1569  if ((p==NULL)||(pNext(p)!=NULL)) return TRUE;
1570  res->data=(char *)mpCoeffProc((poly)u->Data(),p /*(poly)v->Data()*/);
1571  return FALSE;
1572}
1573static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1574{
1575  int i=pVar((poly)v->Data());
1576  if (i==0)
1577  {
1578    WerrorS("ringvar expected");
1579    return TRUE;
1580  }
1581  res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1582  return FALSE;
1583}
1584static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1585{
1586  poly p = pInit();
1587  int i;
1588
1589  for (i=1; i<=pVariables; i++)
1590  {
1591    pSetExp(p, i, 1);
1592  }
1593  pSetm(p);
1594  res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1595                                    (ideal)(v->Data()), p);
1596  pDelete(&p);
1597  return FALSE;
1598}
1599static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1600{
1601  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1602  return FALSE;
1603}
1604static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1605{
1606  short *iv=iv2array((intvec *)v->Data());
1607  ideal I=(ideal)u->Data();
1608  int d=-1;
1609  int i;
1610  for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)pDegW(I->m[i],iv));
1611  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1612  res->data = (char *)d;
1613  return FALSE;
1614}
1615static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1616{
1617  short *iv=iv2array((intvec *)v->Data());
1618  res->data = (char *)pDegW((poly)u->Data(),iv);
1619  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1620  return FALSE;
1621}
1622static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1623{
1624  int i=pVar((poly)v->Data());
1625  if (i==0)
1626  {
1627    WerrorS("ringvar expected");
1628    return TRUE;
1629  }
1630  res->data=(char *)pDiff((poly)(u->Data()),i);
1631  return FALSE;
1632}
1633static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1634{
1635  int i=pVar((poly)v->Data());
1636  if (i==0)
1637  {
1638    WerrorS("ringvar expected");
1639    return TRUE;
1640  }
1641  res->data=(char *)idDiff((matrix)(u->Data()),i);
1642  return FALSE;
1643}
1644static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1645{
1646  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1647  return FALSE;
1648}
1649static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1650{
1651  assumeStdFlag(v);
1652  if(currQuotient==NULL)
1653    res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1654  else
1655  {
1656    ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1657    res->data = (char *)scDimInt((ideal)(v->Data()),q);
1658    idDelete(&q);
1659  }
1660  return FALSE;
1661}
1662static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1663{
1664  ideal vi=(ideal)v->Data();
1665  int vl= IDELEMS(vi);
1666  ideal ui=(ideal)u->Data();
1667  int ul= IDELEMS(ui);
1668  ideal R; matrix U;
1669  ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1670  // now make sure that all matices have the corect size:
1671  matrix T = idModule2formatedMatrix(m,vl,ul);
1672  if (MATCOLS(U) != ul)
1673  {
1674    int mul=si_min(ul,MATCOLS(U));
1675    matrix UU=mpNew(ul,ul);
1676    int i,j;
1677    for(i=mul;i>0;i--)
1678    {
1679      for(j=mul;j>0;j--)
1680      {
1681        MATELEM(UU,i,j)=MATELEM(U,i,j);
1682        MATELEM(U,i,j)=NULL;
1683      }
1684    }
1685    idDelete((ideal *)&U);
1686    U=UU;
1687  }
1688  lists L=(lists)omAllocBin(slists_bin);
1689  L->Init(3);
1690  L->m[0].rtyp=MATRIX_CMD;   L->m[0].data=(void *)T;
1691  L->m[1].rtyp=u->Typ();     L->m[1].data=(void *)R;
1692  L->m[2].rtyp=MATRIX_CMD;   L->m[2].data=(void *)U;
1693  res->data=(char *)L;
1694  return FALSE;
1695}
1696static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1697{
1698  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1699  setFlag(res,FLAG_STD);
1700  return FALSE;
1701}
1702static BOOLEAN jjEXPORTTO(leftv res, leftv u, leftv v)
1703{
1704#ifdef HAVE_NS
1705  //Print("exportto %s -> %s\n",v->Name(),u->Name() );
1706  return iiExport(v,0,(idhdl)u->data);
1707#else
1708  return TRUE;
1709#endif
1710}
1711static BOOLEAN jjERROR(leftv res, leftv u)
1712{
1713  WerrorS((char *)u->Data());
1714  return TRUE;
1715}
1716static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1717{
1718  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1719  int p0=ABS(uu),p1=ABS(vv);
1720  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1721
1722  while ( p1!=0 )
1723  {
1724    q=p0 / p1;
1725    r=p0 % p1;
1726    p0 = p1; p1 = r;
1727    r = g0 - g1 * q;
1728    g0 = g1; g1 = r;
1729    r = f0 - f1 * q;
1730    f0 = f1; f1 = r;
1731  }
1732  int a = f0;
1733  int b = g0;
1734  if ( uu /*(int)(long)u->Data()*/ < 0 ) a=-a;
1735  if ( vv /*(int)(long)v->Data()*/ < 0 ) b=-b;
1736  lists L=(lists)omAllocBin(slists_bin);
1737  L->Init(3);
1738  L->m[0].rtyp=INT_CMD;   L->m[0].data=(void *)p0;
1739  L->m[1].rtyp=INT_CMD;   L->m[1].data=(void *)a;
1740  L->m[2].rtyp=INT_CMD;   L->m[2].data=(void *)b;
1741  res->rtyp=LIST_CMD;
1742  res->data=(char *)L;
1743  return FALSE;
1744}
1745#ifdef HAVE_FACTORY
1746static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1747{
1748  poly r,pa,pb;
1749  BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1750  if (ret) return TRUE;
1751  lists L=(lists)omAllocBin(slists_bin);
1752  L->Init(3);
1753  res->data=(char *)L;
1754  L->m[0].data=(void *)r;
1755  L->m[0].rtyp=POLY_CMD;
1756  L->m[1].data=(void *)pa;
1757  L->m[1].rtyp=POLY_CMD;
1758  L->m[2].data=(void *)pb;
1759  L->m[2].rtyp=POLY_CMD;
1760  return FALSE;
1761}
1762static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1763{
1764  ideal_list p,h;
1765  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
1766  p=h;
1767  int l=0;
1768  while (p!=NULL) { p=p->next;l++; }
1769  lists L=(lists)omAllocBin(slists_bin);
1770  L->Init(l);
1771  l=0;
1772  while(h!=NULL)
1773  {
1774    L->m[l].data=(char *)h->d;
1775    L->m[l].rtyp=IDEAL_CMD;
1776    p=h->next;
1777    omFreeSize(h,sizeof(*h));
1778    h=p;
1779    l++;
1780  }
1781  res->data=(void *)L;
1782  return FALSE;
1783}
1784#endif
1785static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1786{
1787  ring r=(ring)u->Data();
1788  idhdl w;
1789  int op=iiOp;
1790  nMapFunc nMap;
1791
1792  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1793  {
1794    int *perm=NULL;
1795    int *par_perm=NULL;
1796    int par_perm_size=0;
1797    BOOLEAN bo;
1798    //if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1799    if ((nMap=nSetMap(r))==NULL)
1800    {
1801      if (rEqual(r,currRing))
1802      {
1803        nMap=nCopy;
1804      }
1805      else
1806      // Allow imap/fetch to be make an exception only for:
1807      if ( (rField_is_Q_a(r) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
1808            (rField_is_Q() || rField_is_Q_a() ||
1809             (rField_is_Zp() || rField_is_Zp_a())))
1810           ||
1811           (rField_is_Zp_a(r) &&  // Zp(a..) -> Zp(a..) || Zp
1812            (rField_is_Zp(currRing, rInternalChar(r)) ||
1813             rField_is_Zp_a(currRing, rInternalChar(r)))) )
1814      {
1815        par_perm_size=rPar(r);
1816        BITSET save_test=test;
1817        naSetChar(rInternalChar(r),r);
1818        nSetChar(currRing);
1819        test=save_test;
1820      }
1821      else
1822      {
1823        goto err_fetch;
1824      }
1825    }
1826    if ((iiOp!=FETCH_CMD) || (r->N!=pVariables) || (rPar(r)!=rPar(currRing)))
1827    {
1828      perm=(int *)omAlloc0((r->N+1)*sizeof(int));
1829      if (par_perm_size!=0)
1830        par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
1831      op=IMAP_CMD;
1832      if (iiOp==IMAP_CMD)
1833      {
1834        maFindPerm(r->names,       r->N,       r->parameter,        r->P,
1835                   currRing->names,currRing->N,currRing->parameter, currRing->P,
1836                   perm,par_perm, currRing->ch);
1837      }
1838      else
1839      {
1840        int i;
1841        if (par_perm_size!=0)
1842          for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
1843        for(i=si_min(r->N,pVariables);i>0;i--) perm[i]=i;
1844      }
1845    }
1846    if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1847    {
1848      int i;
1849      for(i=0;i<si_min(r->N,pVariables);i++)
1850      {
1851        Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
1852      }
1853      for(i=0;i<si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
1854      {
1855        Print("// par nr %d: %s -> %s\n",
1856              i,r->parameter[i],currRing->parameter[i]);
1857      }
1858    }
1859    sleftv tmpW;
1860    memset(&tmpW,0,sizeof(sleftv));
1861    tmpW.rtyp=IDTYP(w);
1862    tmpW.data=IDDATA(w);
1863    if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1864                         perm,par_perm,par_perm_size,nMap)))
1865    {
1866      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1867    }
1868    if (perm!=NULL)
1869      omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
1870    if (par_perm!=NULL)
1871      omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
1872    return bo;
1873  }
1874  else
1875  {
1876    Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1877  }
1878  return TRUE;
1879err_fetch:
1880  Werror("no identity map from %s",u->Fullname());
1881  return TRUE;
1882}
1883static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1884{
1885  /*4
1886  * look for the substring what in the string where
1887  * return the position of the first char of what in where
1888  * or 0
1889  */
1890  char *where=(char *)u->Data();
1891  char *what=(char *)v->Data();
1892  char *found = strstr(where,what);
1893  if (found != NULL)
1894  {
1895    res->data=(char *)((found-where)+1);
1896  }
1897  /*else res->data=NULL;*/
1898  return FALSE;
1899}
1900static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
1901{
1902  res->data=(char *)fractalWalkProc(u,v);
1903  setFlag( res, FLAG_STD );
1904  return FALSE;
1905}
1906static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1907{
1908  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1909  int p0=ABS(uu),p1=ABS(vv);
1910  int r;
1911
1912  while ( p1!=0 )
1913  {
1914    r=p0 % p1;
1915    p0 = p1; p1 = r;
1916  }
1917  res->rtyp=INT_CMD;
1918  res->data=(char *)p0;
1919  return FALSE;
1920}
1921static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
1922{
1923  number a=(number) u->Data();
1924  number b=(number) v->Data();
1925  if (nIsZero(a))
1926  {
1927    if (nIsZero(b)) res->data=(char *)nInit(1);
1928    else            res->data=(char *)nCopy(b);
1929  }
1930  else
1931  {
1932    if (nIsZero(b))  res->data=(char *)nCopy(a);
1933    else res->data=(char *)nGcd(a, b, currRing);
1934  }
1935  return FALSE;
1936}
1937#ifdef HAVE_FACTORY
1938static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
1939{
1940  res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
1941                                 (poly)(v->CopyD(POLY_CMD)));
1942  return FALSE;
1943}
1944#endif
1945static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1946{
1947  assumeStdFlag(u);
1948  intvec *module_w=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
1949  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1950  switch((int)(long)v->Data())
1951  {
1952    case 1:
1953      res->data=(void *)iv;
1954      return FALSE;
1955    case 2:
1956      res->data=(void *)hSecondSeries(iv);
1957      delete iv;
1958      return FALSE;
1959  }
1960  WerrorS(feNotImplemented);
1961  delete iv;
1962  return TRUE;
1963}
1964static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1965{
1966  int i=pVar((poly)v->Data());
1967  if (i==0)
1968  {
1969    WerrorS("ringvar expected");
1970    return TRUE;
1971  }
1972  res->data = (char *)pHomogen((poly)u->Data(),i);
1973  return FALSE;
1974}
1975static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1976{
1977  int i=pVar((poly)v->Data());
1978  if (i==0)
1979  {
1980    WerrorS("ringvar expected");
1981    return TRUE;
1982  }
1983  res->data = (char *)idHomogen((ideal)u->Data(),i);
1984  return FALSE;
1985}
1986static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1987{
1988  assumeStdFlag(u);
1989  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
1990                    currQuotient);
1991  return FALSE;
1992}
1993static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1994{
1995  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1996  setFlag(res,FLAG_STD);
1997  return FALSE;
1998}
1999static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2000{
2001  return jjStdJanetBasis(res,u,(int)(long)v->Data());
2002}
2003static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2004{
2005  res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2006  return FALSE;
2007}
2008static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2009{
2010  res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
2011  return FALSE;
2012}
2013static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2014{
2015  assumeStdFlag(u);
2016  res->data = (char *)scKBase((int)(long)v->Data(),
2017                              (ideal)(u->Data()),currQuotient);
2018  return FALSE;
2019}
2020static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2021{
2022  return mpKoszul(res, u,v);
2023}
2024static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2025{
2026  sleftv h;
2027  memset(&h,0,sizeof(sleftv));
2028  h.rtyp=INT_CMD;
2029  h.data=(void *)IDELEMS((ideal)v->Data());
2030  return mpKoszul(res, u, &h, v);
2031}
2032static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2033{
2034  ideal m;
2035  BITSET save_test=test;
2036  int ul= IDELEMS((ideal)u->Data());
2037  int vl= IDELEMS((ideal)v->Data());
2038  m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
2039  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
2040  test=save_test;
2041  return FALSE;
2042}
2043static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2044{
2045  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
2046  idhdl h=(idhdl)v->data;
2047  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2048  res->data = (char *)idLiftStd((ideal)u->Data(),
2049                                &(h->data.umatrix),testHomog);
2050  setFlag(res,FLAG_STD);
2051  return FALSE;
2052}
2053static BOOLEAN jjLOAD2(leftv res, leftv v, leftv w)
2054{
2055  return jjLOAD(res, v,(int)(long)w->Data());
2056}
2057static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2058{
2059  res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2060  return (res->data==NULL);
2061}
2062static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2063{
2064  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2065  tHomog hom=testHomog;
2066  if (w_u!=NULL)
2067  {
2068    w_u=ivCopy(w_u);
2069    hom=isHomog;
2070  }
2071  intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2072  if (w_v!=NULL)
2073  {
2074    w_v=ivCopy(w_v);
2075    hom=isHomog;
2076  }
2077  if ((w_u!=NULL) && (w_v==NULL))
2078    w_v=ivCopy(w_u);
2079  if ((w_v!=NULL) && (w_u==NULL))
2080    w_u=ivCopy(w_v);
2081  ideal u_id=(ideal)u->Data();
2082  ideal v_id=(ideal)v->Data();
2083  if (w_u!=NULL)
2084  {
2085     if ((*w_u).compare((w_v))!=0)
2086     {
2087       WarnS("incompatible weights");
2088       delete w_u; w_u=NULL;
2089       hom=testHomog;
2090     }
2091     else
2092     {
2093       if ((!idTestHomModule(u_id,currQuotient,w_v))
2094       || (!idTestHomModule(v_id,currQuotient,w_v)))
2095       {
2096         WarnS("wrong weights");
2097         delete w_u; w_u=NULL;
2098         hom=testHomog;
2099       }
2100     }
2101  }
2102  res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2103  if (w_u!=NULL)
2104  {
2105    atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2106  }
2107  delete w_v;
2108  return FALSE;
2109}
2110static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2111{
2112  number q=(number)v->Data();
2113  if (nIsZero(q))
2114  {
2115    WerrorS(ii_div_by_0);
2116    return TRUE;
2117  }
2118  res->data =(char *) nIntMod((number)u->Data(),q);
2119  return FALSE;
2120}
2121static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2122{
2123  char *opt=(char *)v->Data();
2124  int mode=0;
2125  while(*opt!='\0')
2126  {
2127    if (*opt=='i') mode |= PROT_I;
2128    else if (*opt=='o') mode |= PROT_O;
2129    opt++;
2130  }
2131  monitor((char *)(u->Data()),mode);
2132  return FALSE;
2133}
2134static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2135{
2136  idhdl h=(idhdl)u->data;
2137  int i=(int)(long)v->Data();
2138  int p=0;
2139  if ((0<i)
2140  && (IDRING(h)->parameter!=NULL)
2141  && (i<=(p=rPar(IDRING(h)))))
2142    res->data=omStrDup(IDRING(h)->parameter[i-1]);
2143  else
2144  {
2145    Werror("par number %d out of range 1..%d",i,p);
2146    return TRUE;
2147  }
2148  return FALSE;
2149}
2150
2151#ifdef HAVE_PLURAL
2152static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2153{
2154  return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2155}
2156
2157static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2158{
2159  return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2160}
2161
2162static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2163{
2164  return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2165}
2166
2167static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2168{
2169  return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2170}
2171
2172static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2173{
2174  if (rIsPluralRing(currRing))
2175  {
2176    poly p = (poly)a->CopyD(POLY_CMD);
2177    poly q = (poly)b->Data();
2178    res->data = nc_p_Bracket_qq(p,q);
2179  }
2180  else res->data=NULL;
2181  return FALSE;
2182}
2183
2184static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2185{
2186  /* number, poly, vector, ideal, module, matrix */
2187  ring  r = (ring)a->Data();
2188  if (r == currRing)
2189  {
2190    res->data = b->Data();
2191    res->rtyp = b->rtyp;
2192    return FALSE;
2193  }
2194  if (!rIsLikeOpposite(currRing, r))
2195  {
2196    Werror("%s is not an opposite ring to current ring",a->Fullname());
2197    return TRUE;
2198  }
2199  idhdl w;
2200  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2201  {
2202    int argtype = IDTYP(w);
2203    switch (argtype)
2204    {
2205    case NUMBER_CMD:
2206      {
2207        /* since basefields are equal, we can apply nCopy */
2208        res->data = nCopy((number)IDDATA(w));
2209        res->rtyp = argtype;
2210        break;
2211      }
2212    case POLY_CMD:
2213    case VECTOR_CMD:
2214      {
2215        poly    q = (poly)IDDATA(w);
2216        res->data = pOppose(r,q);
2217        res->rtyp = argtype;
2218        break;
2219      }
2220    case IDEAL_CMD:
2221    case MODUL_CMD:
2222      {
2223        ideal   Q = (ideal)IDDATA(w);
2224        res->data = idOppose(r,Q);
2225        res->rtyp = argtype;
2226        break;
2227      }
2228    case MATRIX_CMD:
2229      {
2230        ring save = currRing;
2231        rChangeCurrRing(r);
2232        matrix  m = (matrix)IDDATA(w);
2233        ideal   Q = idMatrix2Module(mpCopy(m));
2234        rChangeCurrRing(save);
2235        ideal   S = idOppose(r,Q);
2236        id_Delete(&Q, r);
2237        res->data = idModule2Matrix(S);
2238        res->rtyp = argtype;
2239        break;
2240      }
2241    default:
2242      {
2243        WerrorS("unsupported type in oppose");
2244        return TRUE;
2245      }
2246    }
2247  }
2248  else
2249  {
2250    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2251    return TRUE;
2252  }
2253  return FALSE;
2254}
2255#endif /* HAVE_PLURAL */
2256
2257static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2258{
2259  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2260    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2261  idDelMultiples((ideal)(res->data));
2262  return FALSE;
2263}
2264static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2265{
2266  int i=(int)(long)u->Data();
2267  int j=(int)(long)v->Data();
2268#ifdef buildin_rand
2269  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
2270#else
2271  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
2272#endif
2273  return FALSE;
2274}
2275static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2276{
2277  si_link l=(si_link)u->Data();
2278  leftv r=slRead(l,v);
2279  if (r==NULL)
2280  {
2281    const char *s;
2282    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2283    else                            s=sNoName;
2284    Werror("cannot read from `%s`",s);
2285    return TRUE;
2286  }
2287  memcpy(res,r,sizeof(sleftv));
2288  omFreeBin((ADDRESS)r, sleftv_bin);
2289  return FALSE;
2290}
2291static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2292{
2293  assumeStdFlag(v);
2294  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2295  return FALSE;
2296}
2297static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2298{
2299  assumeStdFlag(v);
2300  ideal ui=(ideal)u->Data();
2301  idTest(ui);
2302  ideal vi=(ideal)v->Data();
2303  idTest(vi);
2304  res->data = (char *)kNF(vi,currQuotient,ui);
2305  return FALSE;
2306}
2307#if 0
2308static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2309{
2310  int maxl=(int)(long)v->Data();
2311  if (maxl<0)
2312  {
2313    WerrorS("length for res must not be negative");
2314    return TRUE;
2315  }
2316  int l=0;
2317  //resolvente r;
2318  syStrategy r;
2319  intvec *weights=NULL;
2320  int wmaxl=maxl;
2321  ideal u_id=(ideal)u->Data();
2322
2323  maxl--;
2324  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2325  {
2326    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2327    if (currQuotient!=NULL)
2328    {
2329      Warn(
2330      "full resolution in a qring may be infinite, setting max length to %d",
2331      maxl+1);
2332    }
2333  }
2334  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2335  if (weights!=NULL)
2336  {
2337    if (!idTestHomModule(u_id,currQuotient,weights))
2338    {
2339      WarnS("wrong weights given:");weights->show();PrintLn();
2340      weights=NULL;
2341    }
2342  }
2343
2344  intvec *ww=NULL;
2345  int add_row_shift=0;
2346  if (weights!=NULL)
2347  {
2348     ww=ivCopy(weights);
2349     add_row_shift = ww->min_in();
2350     (*ww) -= add_row_shift;
2351  }
2352  else
2353    idHomModule(u_id,currQuotient,&ww);
2354  weights=ww;
2355
2356  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2357  {
2358    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2359  }
2360  else if (iiOp==SRES_CMD)
2361  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2362    r=sySchreyer(u_id,maxl+1);
2363  else if (iiOp == LRES_CMD)
2364  {
2365    int dummy;
2366    if((currQuotient!=NULL)||
2367    (!idHomIdeal (u_id,NULL)))
2368    {
2369       WerrorS
2370       ("`lres` not implemented for inhomogeneous input or qring");
2371       return TRUE;
2372    }
2373    r=syLaScala3(u_id,&dummy);
2374  }
2375  else if (iiOp == KRES_CMD)
2376  {
2377    int dummy;
2378    if((currQuotient!=NULL)||
2379    (!idHomIdeal (u_id,NULL)))
2380    {
2381       WerrorS
2382       ("`kres` not implemented for inhomogeneous input or qring");
2383       return TRUE;
2384    }
2385    r=syKosz(u_id,&dummy);
2386  }
2387  else
2388  {
2389    int dummy;
2390    if((currQuotient!=NULL)||
2391    (!idHomIdeal (u_id,NULL)))
2392    {
2393       WerrorS
2394       ("`hres` not implemented for inhomogeneous input or qring");
2395       return TRUE;
2396    }
2397    r=syHilb(u_id,&dummy);
2398  }
2399  if (r==NULL) return TRUE;
2400  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2401  r->list_length=wmaxl;
2402  res->data=(void *)r;
2403  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2404  {
2405    intvec *w=ivCopy(r->weights[0]);
2406    if (weights!=NULL) (*w) += add_row_shift;
2407    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2408    delete w;
2409  }
2410  else
2411  {
2412//#if 0
2413// need to set weights for ALL components (sres)
2414    if (weights!=NULL)
2415    {
2416      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2417      r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2418      (r->weights)[0] = ivCopy(weights);
2419    }
2420//#endif
2421  }
2422  if (ww!=NULL) { delete ww; ww=NULL; }
2423  return FALSE;
2424}
2425#else
2426static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2427{
2428  int maxl=(int)(long)v->Data();
2429  if (maxl<0)
2430  {
2431    WerrorS("length for res must not be negative");
2432    return TRUE;
2433  }
2434  int l=0;
2435  //resolvente r;
2436  syStrategy r;
2437  intvec *weights=NULL;
2438  int wmaxl=maxl;
2439  ideal u_id=(ideal)u->Data();
2440
2441  maxl--;
2442  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2443  {
2444    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2445    if (currQuotient!=NULL)
2446    {
2447      Warn(
2448      "full resolution in a qring may be infinite, setting max length to %d",
2449      maxl+1);
2450    }
2451  }
2452  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2453  if (weights!=NULL)
2454  {
2455    if (!idTestHomModule(u_id,currQuotient,weights))
2456    {
2457      WarnS("wrong weights given:");weights->show();PrintLn();
2458      weights=NULL;
2459    }
2460  }
2461  intvec *ww=NULL;
2462  int add_row_shift=0;
2463  if (weights!=NULL)
2464  {
2465     ww=ivCopy(weights);
2466     add_row_shift = ww->min_in();
2467     (*ww) -= add_row_shift;
2468  }
2469
2470  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2471  {
2472    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2473  }
2474  else if (iiOp==SRES_CMD)
2475  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2476    r=sySchreyer(u_id,maxl+1);
2477  else if (iiOp == LRES_CMD)
2478  {
2479    int dummy;
2480    if((currQuotient!=NULL)||
2481    (!idHomIdeal (u_id,NULL)))
2482    {
2483       WerrorS
2484       ("`lres` not implemented for inhomogeneous input or qring");
2485       return TRUE;
2486    }
2487    r=syLaScala3(u_id,&dummy);
2488  }
2489  else if (iiOp == KRES_CMD)
2490  {
2491    int dummy;
2492    if((currQuotient!=NULL)||
2493    (!idHomIdeal (u_id,NULL)))
2494    {
2495       WerrorS
2496       ("`kres` not implemented for inhomogeneous input or qring");
2497       return TRUE;
2498    }
2499    r=syKosz(u_id,&dummy);
2500  }
2501  else
2502  {
2503    int dummy;
2504    if((currQuotient!=NULL)||
2505    (!idHomIdeal (u_id,NULL)))
2506    {
2507       WerrorS
2508       ("`hres` not implemented for inhomogeneous input or qring");
2509       return TRUE;
2510    }
2511    r=syHilb(u_id,&dummy);
2512  }
2513  if (r==NULL) return TRUE;
2514  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2515  r->list_length=wmaxl;
2516  res->data=(void *)r;
2517  if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2518  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2519  {
2520    ww=ivCopy(r->weights[0]);
2521    if (weights!=NULL) (*ww) += add_row_shift;
2522    atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2523  }
2524  else
2525  {
2526    if (weights!=NULL)
2527    {
2528      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2529    }
2530  }
2531  return FALSE;
2532}
2533#endif
2534static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2535{
2536  ring r;
2537  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2538  res->data = (char *)r;
2539  return (i==-1);
2540}
2541#define SIMPL_LMDIV 32
2542#define SIMPL_LMEQ  16
2543#define SIMPL_MULT 8
2544#define SIMPL_EQU  4
2545#define SIMPL_NULL 2
2546#define SIMPL_NORM 1
2547static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2548{
2549  int sw = (int)(long)v->Data();
2550  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2551  ideal id = (ideal)u->CopyD(IDEAL_CMD);
2552  if (sw & SIMPL_LMDIV)
2553  {
2554    idDelDiv(id);
2555  }
2556  if (sw & SIMPL_LMEQ)
2557  {
2558    idDelLmEquals(id);
2559  }
2560  if (sw & SIMPL_NULL)
2561  {
2562    idSkipZeroes(id);
2563  }
2564  if (sw & SIMPL_NORM)
2565  {
2566    idNorm(id);
2567  }
2568  if (sw & SIMPL_MULT)
2569  {
2570    idDelMultiples(id);
2571  }
2572  else if(sw & SIMPL_EQU)
2573  {
2574    idDelEquals(id);
2575  }
2576  res->data = (char * )id;
2577  return FALSE;
2578}
2579#ifdef HAVE_FACTORY
2580extern int singclap_factorize_retry;
2581static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2582{
2583  intvec *v=NULL;
2584  int sw=(int)(long)dummy->Data();
2585  int fac_sw=sw;
2586  if ((sw<0)||(sw>2)) fac_sw=1;
2587  singclap_factorize_retry=0;
2588  ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2589  if (f==NULL)
2590    return TRUE;
2591  switch(sw)
2592  {
2593    case 0:
2594    case 2:
2595    {
2596      lists l=(lists)omAllocBin(slists_bin);
2597      l->Init(2);
2598      l->m[0].rtyp=IDEAL_CMD;
2599      l->m[0].data=(void *)f;
2600      l->m[1].rtyp=INTVEC_CMD;
2601      l->m[1].data=(void *)v;
2602      res->data=(void *)l;
2603      res->rtyp=LIST_CMD;
2604      return FALSE;
2605    }
2606    case 1:
2607      res->data=(void *)f;
2608      return FALSE;
2609    case 3:
2610      {
2611        poly p=f->m[0];
2612        int i=IDELEMS(f);
2613        f->m[0]=NULL;
2614        while(i>1)
2615        {
2616          i--;
2617          p=pMult(p,f->m[i]);
2618          f->m[i]=NULL;
2619        }
2620        res->data=(void *)p;
2621        res->rtyp=POLY_CMD;
2622      }
2623      return FALSE;
2624  }
2625  WerrorS("invalid switch");
2626  return TRUE;
2627}
2628#endif
2629static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2630{
2631  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2632  return FALSE;
2633}
2634static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2635{
2636  int sw = (int)(long)v->Data();
2637  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2638  poly p = (poly)u->CopyD(POLY_CMD);
2639  if (sw & SIMPL_NORM)
2640  {
2641    pNorm(p);
2642  }
2643  res->data = (char * )p;
2644  return FALSE;
2645}
2646static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2647{
2648  ideal result;
2649  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2650  tHomog hom=testHomog;
2651  ideal u_id=(ideal)(u->Data());
2652  if (w!=NULL)
2653  {
2654    if (!idTestHomModule(u_id,currQuotient,w))
2655    {
2656      WarnS("wrong weights");
2657      w=NULL;
2658    }
2659    else
2660    {
2661      w=ivCopy(w);
2662      hom=isHomog;
2663    }
2664  }
2665  result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
2666  idSkipZeroes(result);
2667  res->data = (char *)result;
2668  setFlag(res,FLAG_STD);
2669  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2670  return FALSE;
2671}
2672static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2673{
2674  ideal result;
2675  assumeStdFlag(u);
2676  ideal i1=(ideal)(u->Data());
2677  ideal i0;
2678  int r=v->Typ();
2679  if ((/*v->Typ()*/r==POLY_CMD) ||(r==VECTOR_CMD))
2680  {
2681    i0=idInit(1,i1->rank);
2682    i0->m[0]=(poly)v->Data();
2683  }
2684  else /*IDEAL*/
2685  {
2686    i0=(ideal)v->Data();
2687  }
2688  i1=idSimpleAdd(i1,i0);
2689  memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
2690  idDelete(&i0);
2691  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2692  tHomog hom=testHomog;
2693  if (w!=NULL)
2694  {
2695    if (!idTestHomModule(i1,currQuotient,w))
2696    {
2697      // no warnung: this is legal, if i in std(i,p)
2698      // is homogeneous, but p not
2699      w=NULL;
2700    }
2701    else
2702    {
2703      w=ivCopy(w);
2704      hom=isHomog;
2705    }
2706  }
2707  BITSET save_test=test;
2708  test|=Sy_bit(OPT_SB_1);
2709  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2710  test=save_test;
2711  idDelete(&i1);
2712  idSkipZeroes(result);
2713  res->data = (char *)result;
2714  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
2715  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2716  return FALSE;
2717}
2718static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2719{
2720  idhdl h=(idhdl)u->data;
2721  int i=(int)(long)v->Data();
2722  if ((0<i) && (i<=IDRING(h)->N))
2723    res->data=omStrDup(IDRING(h)->names[i-1]);
2724  else
2725  {
2726    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2727    return TRUE;
2728  }
2729  return FALSE;
2730}
2731static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2732{
2733  res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2734  return FALSE;
2735}
2736#define jjWRONG2 (proc2)jjWRONG
2737#define jjWRONG3 (proc3)jjWRONG
2738static BOOLEAN jjWRONG(leftv res, leftv u)
2739{
2740  return TRUE;
2741}
2742
2743static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2744{
2745  char * s=(char *)u->Data();
2746  if(strcmp(s, "with")==0)
2747    return jjLOAD(res, v, TRUE);
2748  WerrorS("invalid second argument");
2749  WerrorS("load(\"libname\" [,\"with\"]);");
2750  return TRUE;
2751}
2752
2753/*=================== operations with 2 args.: table =================*/
2754
2755struct sValCmd2 dArith2[]=
2756{
2757// operations:
2758// proc        cmd              res             arg1        arg2   plural
2759 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2760,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2761,{jjPLUS_BI,   '+',           BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2762,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2763,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2764,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2765,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2766,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2767,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
2768,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2769,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2770,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
2771,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2772,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2773,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2774,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2775,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2776,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2777,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
2778,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
2779,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  RING_CMD ALLOW_PLURAL}
2780,{jjRSUM,      '+',            QRING_CMD,      RING_CMD,   QRING_CMD ALLOW_PLURAL}
2781,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  QRING_CMD ALLOW_PLURAL}
2782,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2783,{jjMINUS_BI,  '-',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2784,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2785,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2786,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2787,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2788,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2789,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2790,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2791,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2792,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2793,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2794,{jjTIMES_BI,  '*',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2795,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2796,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2797,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
2798,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2799,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2800,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2801,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2802,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2803,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2804,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2805,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2806,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2807,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
2808,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2809,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2810,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2811,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD ALLOW_PLURAL}
2812,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2813,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2814,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2815,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2816,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2817,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2818,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2819,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2820,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2821,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2822,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2823,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2824,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2825,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2826,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2827,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2828,{jjDIV_BI,    INTDIV_CMD,     BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2829,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2830,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2831,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2832,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2833,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2834,{jjMOD_N,     '%',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2835,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2836,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2837,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2838,{jjMOD_N,     INTMOD_CMD,     NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2839,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2840,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2841,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2842,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2843,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2844,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2845,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2846,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2847,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2848,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2849,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2850,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2851,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2852,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2853,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2854,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2855,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2856,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2857,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2858,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2859,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2860,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2861,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2862,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2863,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2864,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2865,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2866,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2867,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2868,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2869,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2870,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2871,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2872,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2873,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2874,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2875,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2876,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2877,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2878,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2879,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2880,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2881,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2882,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2883,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2884,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2885,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2886,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2887,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2888,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2889,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2890,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2891,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2892,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2893,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2894,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2895,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2896,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2897,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2898,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
2899,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2900,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2901,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2902,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
2903,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2904,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2905,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2906,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
2907,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2908,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2909,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2910,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2911,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2912,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2913,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2914,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2915,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
2916,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2917,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2918// and the procedures with 2 arguments:
2919,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
2920,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2921,{jjBETTI2,    BETTI_CMD,      INTMAT_CMD,     LIST_CMD,   INT_CMD ALLOW_PLURAL}
2922,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2923,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2924,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2925#ifdef HAVE_PLURAL
2926,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2927#endif
2928,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2929,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2930,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2931,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2932,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2933,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2934,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2935,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2936,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2937,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
2938,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2939,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2940,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2941,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2942,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2943,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2944,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2945,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2946,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2947,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
2948,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2949,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2950,{jjEXPORTTO,  EXPORTTO_CMD,   NONE,           PACKAGE_CMD, IDHDL ALLOW_PLURAL}
2951,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
2952#ifdef HAVE_FACTORY
2953,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2954,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2955,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2956#else
2957,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2958,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2959,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2960#endif
2961,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2962,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2963#ifdef HAVE_FGLM
2964,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2965,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2966,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
2967#else
2968,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2969,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2970,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2971#endif
2972,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2973,{jjFWALK,     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2974
2975,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2976,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2977#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
2978,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2979#else
2980,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2981#endif
2982,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
2983,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
2984,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2985,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2986,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2987,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2988,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2989,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2990,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2991,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2992,{jjIMPORTFROM,IMPORTFROM_CMD, NONE,           PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
2993,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2994,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
2995,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2996,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2997,{jjJanetBasis2, JANET_CMD,    IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2998,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2999,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3000,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3001,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3002,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
3003,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3004,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3005,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
3006,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
3007,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
3008,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3009,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3010,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3011,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
3012,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
3013,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3014,{jjLOAD2,     LOAD_CMD,       NONE,           STRING_CMD, INT_CMD ALLOW_PLURAL}
3015,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3016,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
3017,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3018,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3019,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3020,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
3021//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3022//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3023,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3024,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3025#ifdef HAVE_PLURAL
3026,{jjPlural_num_poly, NCALGEBRA_CMD,  NONE,  POLY_CMD,   POLY_CMD   NO_PLURAL}
3027,{jjPlural_num_mat,  NCALGEBRA_CMD,  NONE,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
3028,{jjPlural_mat_poly, NCALGEBRA_CMD,  NONE,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
3029,{jjPlural_mat_mat,  NCALGEBRA_CMD,  NONE,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3030#endif
3031#ifdef HAVE_PLURAL
3032,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
3033,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, QRING_CMD,   DEF_CMD ALLOW_PLURAL}
3034#endif
3035,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
3036,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3037,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
3038,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3039,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3040,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3041,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3042,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
3043,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
3044,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3045,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3046,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3047,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3048,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3049//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3050//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3051,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3052,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3053,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
3054,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
3055,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3056,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3057,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3058//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3059//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3060,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3061,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
3062,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3063,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3064,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
3065,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3066,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3067,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
3068,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
3069,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
3070,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3071,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
3072,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
3073,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
3074,{NULL,        0,              0,              0,          0 NO_PLURAL}
3075};
3076/*=================== operations with 1 arg.: static proc =================*/
3077static BOOLEAN jjDUMMY(leftv res, leftv u)
3078{
3079  res->data = (char *)u->CopyD();
3080  return FALSE;
3081}
3082static BOOLEAN jjNULL(leftv res, leftv u)
3083{
3084  return FALSE;
3085}
3086//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3087//{
3088//  res->data = (char *)((int)(long)u->Data()+1);
3089//  return FALSE;
3090//}
3091//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3092//{
3093//  res->data = (char *)((int)(long)u->Data()-1);
3094//  return FALSE;
3095//}
3096static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3097{
3098  if (IDTYP((idhdl)u->data)==INT_CMD)
3099  {
3100    int i=IDINT((idhdl)u->data);
3101    if (iiOp==PLUSPLUS) i++;
3102    else                i--;
3103    IDDATA((idhdl)u->data)=(char *)i;
3104    return FALSE;
3105  }
3106  return TRUE;
3107}
3108static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3109{
3110  res->data = (char *)(-(int)(long)u->Data());
3111  return FALSE;
3112}
3113static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3114{
3115  number n=(number)u->CopyD(NUMBER_CMD);
3116  n=nNeg(n);
3117  res->data = (char *)n;
3118  return FALSE;
3119}
3120static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3121{
3122  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3123  return FALSE;
3124}
3125static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3126{
3127  poly m1=pISet(-1);
3128  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3129  return FALSE;
3130}
3131static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3132{
3133  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3134  (*iv)*=(-1);
3135  res->data = (char *)iv;
3136  return FALSE;
3137}
3138static BOOLEAN jjPROC1(leftv res, leftv u)
3139{
3140  return jjPROC(res,u,NULL);
3141}
3142static BOOLEAN jjBAREISS(leftv res, leftv v)
3143{
3144  //matrix m=(matrix)v->Data();
3145  //lists l=mpBareiss(m,FALSE);
3146  intvec *iv;
3147  ideal m;
3148  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3149  lists l=(lists)omAllocBin(slists_bin);
3150  l->Init(2);
3151  l->m[0].rtyp=MODUL_CMD;
3152  l->m[1].rtyp=INTVEC_CMD;
3153  l->m[0].data=(void *)m;
3154  l->m[1].data=(void *)iv;
3155  res->data = (char *)l;
3156  return FALSE;
3157}
3158//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3159//{
3160//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3161//  ivTriangMat(m);
3162//  res->data = (char *)m;
3163//  return FALSE;
3164//}
3165static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3166{
3167  return iiExprArithM(res,u,iiOp);
3168}
3169static BOOLEAN jjCHAR(leftv res, leftv v)
3170{
3171  res->data = (char *)rChar((ring)v->Data());
3172  return FALSE;
3173}
3174static BOOLEAN jjCOLS(leftv res, leftv v)
3175{
3176  res->data = (char *)MATCOLS((matrix)(v->Data()));
3177  return FALSE;
3178}
3179static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3180{
3181  res->data = (char *)((intvec*)(v->Data()))->cols();
3182  return FALSE;
3183}
3184static BOOLEAN jjCONTENT(leftv res, leftv v)
3185{
3186  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3187  poly p=(poly)v->CopyD(POLY_CMD);
3188  if (p!=NULL) pCleardenom(p);
3189  res->data = (char *)p;
3190  return FALSE;
3191}
3192static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3193{
3194  res->data = (char *)nSize((number)v->Data());
3195  return FALSE;
3196}
3197static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3198{
3199  lists l=(lists)v->Data();
3200  res->data = (char *)(l->nr+1);
3201  return FALSE;
3202}
3203static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3204{
3205  matrix m=(matrix)v->Data();
3206  res->data = (char *)(MATROWS(m)*MATCOLS(m));
3207  return FALSE;
3208}
3209static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3210{
3211  res->data = (char *)((intvec*)(v->Data()))->length();
3212  return FALSE;
3213}
3214static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3215{
3216  ring r=(ring)v->Data();
3217  int elems=-1;
3218  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
3219  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3220  {
3221#ifdef HAVE_FACTORY
3222    extern int ipower ( int b, int n ); /* factory/cf_util */
3223    elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3224#else
3225    elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3226#endif
3227  }
3228  res->data = (char *)elems;
3229  return FALSE;
3230}
3231static BOOLEAN jjDEG(leftv res, leftv v)
3232{
3233  int dummy;
3234  poly p=(poly)v->Data();
3235  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3236  else res->data=(char *)-1;
3237  return FALSE;
3238}
3239static BOOLEAN jjDEG_M(leftv res, leftv u)
3240{
3241  ideal I=(ideal)u->Data();
3242  int d=-1;
3243  int dummy;
3244  int i;
3245  for(i=IDELEMS(I);i>=0;i--)
3246    if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3247  res->data = (char *)d;
3248  return FALSE;
3249}
3250static BOOLEAN jjDEGREE(leftv res, leftv v)
3251{
3252  assumeStdFlag(v);
3253  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3254  scDegree((ideal)v->Data(),module_w,currQuotient);
3255  return FALSE;
3256}
3257static BOOLEAN jjDEFINED(leftv res, leftv v)
3258{
3259  if ((v->rtyp==IDHDL)
3260  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3261  {
3262    res->data=(void *)(IDLEV((idhdl)v->data)+1);
3263  }
3264  else if (v->rtyp!=0) res->data=(void *)(-1);
3265  return FALSE;
3266}
3267#ifdef HAVE_FACTORY
3268static BOOLEAN jjDET(leftv res, leftv v)
3269{
3270  matrix m=(matrix)v->Data();
3271  poly p;
3272  if (smCheckDet((ideal)m,m->cols(),TRUE))
3273  {
3274    ideal I=idMatrix2Module(mpCopy(m));
3275    p=smCallDet(I);
3276    idDelete(&I);
3277  }
3278  else
3279    p=singclap_det(m);
3280  res ->data = (char *)p;
3281  return FALSE;
3282}
3283static BOOLEAN jjDET_I(leftv res, leftv v)
3284{
3285  intvec * m=(intvec*)v->Data();
3286  int i,j;
3287  i=m->rows();j=m->cols();
3288  if(i==j)
3289    res->data = (char *)singclap_det_i(m);
3290  else
3291  {
3292    Werror("det of %d x %d intmat",i,j);
3293    return TRUE;
3294  }
3295  return FALSE;
3296}
3297static BOOLEAN jjDET_S(leftv res, leftv v)
3298{
3299  ideal I=(ideal)v->Data();
3300  poly p;
3301  if (smCheckDet(I,IDELEMS(I),FALSE))
3302  {
3303    matrix m=idModule2Matrix(idCopy(I));
3304    p=singclap_det(m);
3305    idDelete((ideal *)&m);
3306  }
3307  else
3308    p=smCallDet(I);
3309  res->data = (char *)p;
3310  return FALSE;
3311}
3312#endif
3313static BOOLEAN jjDIM(leftv res, leftv v)
3314{
3315  assumeStdFlag(v);
3316  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
3317  return FALSE;
3318}
3319static BOOLEAN jjDUMP(leftv res, leftv v)
3320{
3321  si_link l = (si_link)v->Data();
3322  if (slDump(l))
3323  {
3324    const char *s;
3325    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3326    else                            s=sNoName;
3327    Werror("cannot dump to `%s`",s);
3328    return TRUE;
3329  }
3330  else
3331    return FALSE;
3332}
3333static BOOLEAN jjE(leftv res, leftv v)
3334{
3335  res->data = (char *)pOne();
3336  pSetComp((poly)res->data,(int)(long)v->Data());
3337  pSetm((poly)res->data);
3338  return FALSE;
3339}
3340static BOOLEAN jjEXECUTE(leftv res, leftv v)
3341{
3342  char * d = (char *)v->Data();
3343  char * s = (char *)omAlloc(strlen(d) + 13);
3344  strcpy( s, (char *)d);
3345  strcat( s, "\n;RETURN();\n");
3346  newBuffer(s,BT_execute);
3347  return yyparse();
3348}
3349#ifdef HAVE_FACTORY
3350static BOOLEAN jjFACSTD(leftv res, leftv v)
3351{
3352  ideal_list p,h;
3353  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3354  p=h;
3355  int l=0;
3356  while (p!=NULL) { p=p->next;l++; }
3357  lists L=(lists)omAllocBin(slists_bin);
3358  L->Init(l);
3359  l=0;
3360  while(h!=NULL)
3361  {
3362    L->m[l].data=(char *)h->d;
3363    L->m[l].rtyp=IDEAL_CMD;
3364    p=h->next;
3365    omFreeSize(h,sizeof(*h));
3366    h=p;
3367    l++;
3368  }
3369  res->data=(void *)L;
3370  return FALSE;
3371}
3372static BOOLEAN jjFAC_P(leftv res, leftv u)
3373{
3374  intvec *v=NULL;
3375  singclap_factorize_retry=0;
3376  ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3377  if (f==NULL) return TRUE;
3378  ivTest(v);
3379  lists l=(lists)omAllocBin(slists_bin);
3380  l->Init(2);
3381  l->m[0].rtyp=IDEAL_CMD;
3382  l->m[0].data=(void *)f;
3383  l->m[1].rtyp=INTVEC_CMD;
3384  l->m[1].data=(void *)v;
3385  res->data=(void *)l;
3386  return FALSE;
3387}
3388#endif
3389static BOOLEAN jjGETDUMP(leftv res, leftv v)
3390{
3391  si_link l = (si_link)v->Data();
3392  if (slGetDump(l))
3393  {
3394    const char *s;
3395    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3396    else                            s=sNoName;
3397    Werror("cannot get dump from `%s`",s);
3398    return TRUE;
3399  }
3400  else
3401    return FALSE;
3402}
3403static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3404{
3405  assumeStdFlag(v);
3406  ideal I=(ideal)v->Data();
3407  res->data=(void *)iiHighCorner(I,0);
3408  return FALSE;
3409}
3410static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3411{
3412  assumeStdFlag(v);
3413  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3414  BOOLEAN delete_w=FALSE;
3415  ideal I=(ideal)v->Data();
3416  int i;
3417  poly p=NULL,po=NULL;
3418  int rk=idRankFreeModule(I);
3419  if (w==NULL)
3420  {
3421    w = new intvec(rk);
3422    delete_w=TRUE;
3423  }
3424  for(i=rk;i>0;i--)
3425  {
3426    p=iiHighCorner(I,i);
3427    if (p==NULL)
3428    {
3429      WerrorS("module must be zero-dimensional");
3430      if (delete_w) delete w;
3431      return TRUE;
3432    }
3433    if (po==NULL)
3434    {
3435      po=p;
3436    }
3437    else
3438    {
3439      // now po!=NULL, p!=NULL
3440      int d=(pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - pFDeg(p,currRing)+(*w)[i-1]);
3441      if (d==0)
3442        d=pLmCmp(po,p);
3443      if (d > 0)
3444      {
3445        pDelete(&p);
3446      }
3447      else // (d < 0)
3448      {
3449        pDelete(&po); po=p;
3450      }
3451    }
3452  }
3453  if (delete_w) delete w;
3454  res->data=(void *)po;
3455  return FALSE;
3456}
3457static BOOLEAN jjHILBERT(leftv res, leftv v)
3458{
3459  assumeStdFlag(v);
3460  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3461  //scHilbertPoly((ideal)v->Data(),currQuotient);
3462  hLookSeries((ideal)v->Data(),module_w,currQuotient);
3463  return FALSE;
3464}
3465static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3466{
3467  res->data=(void *)hSecondSeries((intvec *)v->Data());
3468  return FALSE;
3469}
3470static BOOLEAN jjHOMOG1(leftv res, leftv v)
3471{
3472  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3473  ideal v_id=(ideal)v->Data();
3474  if (w==NULL)
3475  {
3476    res->data=(void *)idHomModule(v_id,currQuotient,&w);
3477    if ((res->data!=NULL) && (v->rtyp==IDHDL))
3478    {
3479      char *isHomog=omStrDup("isHomog");
3480      if (v->e==NULL)
3481        atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3482      else
3483        atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3484    }
3485    else if (w!=NULL) delete w;
3486  }
3487  else
3488    res->data=(void *)idTestHomModule(v_id,currQuotient,w);
3489  return FALSE;
3490}
3491static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3492{
3493  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3494  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3495  if (IDELEMS((ideal)mat)==0)
3496  {
3497    idDelete((ideal *)&mat);
3498    mat=(matrix)idInit(1,1);
3499  }
3500  else
3501  {
3502    MATROWS(mat)=1;
3503    mat->rank=1;
3504    idTest((ideal)mat);
3505  }
3506  res->data=(char *)mat;
3507  return FALSE;
3508}
3509static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3510{
3511  map m=(map)v->CopyD(MAP_CMD);
3512  omFree((ADDRESS)m->preimage);
3513  m->preimage=NULL;
3514  ideal I=(ideal)m;
3515  I->rank=1;
3516  res->data=(char *)I;
3517  return FALSE;
3518}
3519static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3520{
3521  if (currRing!=NULL)
3522  {
3523    ring q=(ring)v->Data();
3524    if (rEqual(currRing, q, 0))
3525    {
3526      if (q->qideal==NULL)
3527        res->data=(char *)idInit(1,1);
3528      else
3529        res->data=(char *)idCopy(q->qideal);
3530      return FALSE;
3531    }
3532  }
3533  WerrorS("can only get ideal from identical qring");
3534  return TRUE;
3535}
3536static BOOLEAN jjIm2Iv(leftv res, leftv v)
3537{
3538  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3539  iv->makeVector();
3540  res->data = iv;
3541  return FALSE;
3542}
3543static BOOLEAN jjIMPART(leftv res, leftv v)
3544{
3545  res->data = (char *)nImPart((number)v->Data());
3546  return FALSE;
3547}
3548static BOOLEAN jjINDEPSET(leftv res, leftv v)
3549{
3550  assumeStdFlag(v);
3551  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3552  return FALSE;
3553}
3554static BOOLEAN jjINTERRED(leftv res, leftv v)
3555{
3556  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3557  //if (result==NULL) return TRUE;
3558  res->data = result;
3559  return FALSE;
3560}
3561static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3562{
3563  res->data = (char *)pVar((poly)v->Data());
3564  return FALSE;
3565}
3566static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3567{
3568  res->data = (char *)(r_IsRingVar((char *)v->Data(), currRing)+1);
3569  return FALSE;
3570}
3571static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3572{
3573  res->data = (char *)0;
3574  return FALSE;
3575}
3576static BOOLEAN jjJACOB_P(leftv res, leftv v)
3577{
3578  ideal i=idInit(pVariables,1);
3579  int k;
3580  poly p=(poly)(v->Data());
3581  for (k=pVariables;k>0;k--)
3582  {
3583    i->m[k-1]=pDiff(p,k);
3584  }
3585  res->data = (char *)i;
3586  return FALSE;
3587}
3588static BOOLEAN jjKBASE(leftv res, leftv v)
3589{
3590  assumeStdFlag(v);
3591  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3592  return FALSE;
3593}
3594#ifdef MDEBUG
3595static BOOLEAN jjpHead(leftv res, leftv v)
3596{
3597  res->data=(char *)pHead((poly)v->Data());
3598  return FALSE;
3599}
3600#endif
3601static BOOLEAN jjL2R(leftv res, leftv v)
3602{
3603  res->data=(char *)syConvList((lists)v->Data());
3604  if (res->data != NULL)
3605    return FALSE;
3606  else
3607    return TRUE;
3608}
3609static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3610{
3611  poly p=(poly)v->Data();
3612  if (p==NULL)
3613  {
3614    res->data=(char *)nInit(0);
3615  }
3616  else
3617  {
3618    res->data=(char *)nCopy(pGetCoeff(p));
3619  }
3620  return FALSE;
3621}
3622static BOOLEAN jjLEADEXP(leftv res, leftv v)
3623{
3624  poly p=(poly)v->Data();
3625  int s=pVariables;
3626  if (v->Typ()==VECTOR_CMD) s++;
3627  intvec *iv=new intvec(s);
3628  if (p!=NULL)
3629  {
3630    for(int i = pVariables;i;i--)
3631    {
3632      (*iv)[i-1]=pGetExp(p,i);
3633    }
3634    if (s!=pVariables)
3635      (*iv)[pVariables]=pGetComp(p);
3636  }
3637  res->data=(char *)iv;
3638  return FALSE;
3639}
3640static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3641{
3642  poly p=(poly)v->Data();
3643  if (p == NULL)
3644  {
3645    res->data = (char*) NULL;
3646  }
3647  else
3648  {
3649    poly lm = pLmInit(p);
3650    pSetCoeff(lm, nInit(1));
3651    res->data = (char*) lm;
3652  }
3653  return FALSE;
3654}
3655static BOOLEAN jjLISTRING(leftv res, leftv v)
3656{
3657  ring r=rCompose((lists)v->Data());
3658  if (r==NULL) return TRUE;
3659  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3660  res->data=(char *)r;
3661  return FALSE;
3662}
3663static BOOLEAN jjMEMORY(leftv res, leftv v)
3664{
3665  omUpdateInfo();
3666  switch(((int)(long)v->Data()))
3667  {
3668  case 0:
3669    res->data = (char *)om_Info.UsedBytes;
3670    break;
3671  case 1:
3672    res->data = (char *)om_Info.CurrentBytesSystem;
3673    break;
3674  case 2:
3675    res->data = (char *)om_Info.MaxBytesSystem;
3676    break;
3677
3678  default:
3679    omPrintStats(stdout);
3680    omPrintInfo(stdout);
3681    omPrintBinStats(stdout);
3682    res->data = (char *)0;
3683  }
3684  return FALSE;
3685  res->data = (char *)0;
3686  return FALSE;
3687}
3688static BOOLEAN jjMONITOR1(leftv res, leftv v)
3689{
3690  monitor((char *)(v->Data()),PROT_I);
3691  return FALSE;
3692}
3693static BOOLEAN jjMSTD(leftv res, leftv v)
3694{
3695  int t=v->Typ();
3696  ideal r,m;
3697  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3698  lists l=(lists)omAllocBin(slists_bin);
3699  l->Init(2);
3700  l->m[0].rtyp=t;
3701  l->m[0].data=(char *)r;
3702  setFlag(&(l->m[0]),FLAG_STD);
3703  l->m[1].rtyp=t;
3704  l->m[1].data=(char *)m;
3705  res->data=(char *)l;
3706  return FALSE;
3707}
3708static BOOLEAN jjMULT(leftv res, leftv v)
3709{
3710  assumeStdFlag(v);
3711  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3712  return FALSE;
3713}
3714static BOOLEAN jjMINRES_R(leftv res, leftv v)
3715{
3716  intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3717  res->data=(char *)syMinimize((syStrategy)v->Data());
3718  if (weights!=NULL)
3719    atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3720  return FALSE;
3721}
3722static BOOLEAN jjNAMEOF(leftv res, leftv v)
3723{
3724  res->data = (char *)v->name;
3725  if (res->data==NULL) res->data=omStrDup("");
3726  v->name=NULL;
3727  return FALSE;
3728}
3729static BOOLEAN jjNAMES(leftv res, leftv v)
3730{
3731  res->data=ipNameList(((ring)v->Data())->idroot);
3732  return FALSE;
3733}
3734static BOOLEAN jjNVARS(leftv res, leftv v)
3735{
3736  res->data = (char *)(((ring)(v->Data()))->N);
3737  return FALSE;
3738}
3739static BOOLEAN jjOpenClose(leftv res, leftv v)
3740{
3741  si_link l=(si_link)v->Data();
3742  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3743  else                return slClose(l);
3744}
3745static BOOLEAN jjORD(leftv res, leftv v)
3746{
3747  poly p=(poly)v->Data();
3748  res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3749  return FALSE;
3750}
3751static BOOLEAN jjPAR1(leftv res, leftv v)
3752{
3753  int i=(int)(long)v->Data();
3754  int p=0;
3755  p=rPar(currRing);
3756  if ((0<i) && (i<=p))
3757  {
3758    res->data=(char *)nPar(i);
3759  }
3760  else
3761  {
3762    Werror("par number %d out of range 1..%d",i,p);
3763    return TRUE;
3764  }
3765  return FALSE;
3766}
3767static BOOLEAN jjPARDEG(leftv res, leftv v)
3768{
3769  res->data = (char *)nParDeg((number)v->Data());
3770  return FALSE;
3771}
3772static BOOLEAN jjPARSTR1(leftv res, leftv v)
3773{
3774  if (currRing==NULL)
3775  {
3776    WerrorS("no ring active");
3777    return TRUE;
3778  }
3779  int i=(int)(long)v->Data();
3780  int p=0;
3781  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3782    res->data=omStrDup(currRing->parameter[i-1]);
3783  else
3784  {
3785    Werror("par number %d out of range 1..%d",i,p);
3786    return TRUE;
3787  }
3788  return FALSE;
3789}
3790static BOOLEAN jjP2I(leftv res, leftv v)
3791{
3792  poly p=(poly)v->Data();
3793  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3794  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3795  {
3796    WerrorS("poly must be constant");
3797    return TRUE;
3798  }
3799  res->data = (char *)nInt(pGetCoeff(p));
3800  return FALSE;
3801}
3802static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3803{
3804  map mapping=(map)v->Data();
3805  syMake(res,omStrDup(mapping->preimage));
3806  return FALSE;
3807}
3808static BOOLEAN jjPRIME(leftv res, leftv v)
3809{
3810  int i = IsPrime((int)(long)(v->Data()));
3811  res->data = (char *)(i > 1 ? i : 2);
3812  return FALSE;
3813}
3814static BOOLEAN jjPRUNE(leftv res, leftv v)
3815{
3816  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3817  ideal v_id=(ideal)v->Data();
3818  if (w!=NULL)
3819  {
3820    if (!idTestHomModule(v_id,currQuotient,w))
3821    {
3822      WarnS("wrong weights");
3823      w=NULL;
3824      // and continue at the non-homog case below
3825    }
3826    else
3827    {
3828      w=ivCopy(w);
3829      intvec **ww=&w;
3830      res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3831      atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3832      return FALSE;
3833    }
3834  }
3835  res->data = (char *)idMinEmbedding(v_id);
3836  return FALSE;
3837}
3838static BOOLEAN jjP2N(leftv res, leftv v)
3839{
3840  number n;
3841  poly p;
3842  if (((p=(poly)v->Data())!=NULL)
3843  && (pIsConstant(p)))
3844  {
3845    n=nCopy(pGetCoeff(p));
3846  }
3847  else
3848  {
3849    n=nInit(0);
3850  }
3851  res->data = (char *)n;
3852  return FALSE;
3853}
3854static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3855{
3856  char *s= (char *)v->Data();
3857  int i = 1;
3858  int l = strlen(s);
3859  while (cmds[i].tokval!=0)
3860  {
3861    if (strcmp(s, cmds[i].name) == 0)
3862    {
3863      res->data = (char *)1;
3864      return FALSE;
3865    }
3866    i++;
3867  }
3868  //res->data = (char *)0;
3869  return FALSE;
3870}
3871static BOOLEAN jjREAD(leftv res, leftv v)
3872{
3873  return jjREAD2(res,v,NULL);
3874}
3875static BOOLEAN jjREGULARITY(leftv res, leftv v)
3876{
3877  res->data = (char *)iiRegularity((lists)v->Data());
3878  return FALSE;
3879}
3880static BOOLEAN jjREPART(leftv res, leftv v)
3881{
3882  res->data = (char *)nRePart((number)v->Data());
3883  return FALSE;
3884}
3885static BOOLEAN jjRINGLIST(leftv res, leftv v)
3886{
3887  ring r=(ring)v->Data();
3888  if (r!=NULL)
3889    res->data = (char *)rDecompose((ring)v->Data());
3890  return (r==NULL);
3891}
3892static BOOLEAN jjROWS(leftv res, leftv v)
3893{
3894  ideal i = (ideal)v->Data();
3895  res->data = (char *)i->rank;
3896  return FALSE;
3897}
3898static BOOLEAN jjROWS_IV(leftv res, leftv v)
3899{
3900  res->data = (char *)((intvec*)(v->Data()))->rows();
3901  return FALSE;
3902}
3903static BOOLEAN jjRPAR(leftv res, leftv v)
3904{
3905  res->data = (char *)rPar(((ring)v->Data()));
3906  return FALSE;
3907}
3908static BOOLEAN jjSLIM_GB(leftv res, leftv u)
3909{
3910  if (currQuotient!=NULL)
3911  {
3912    Werror("qring not supported by slimgb at the moment");
3913    return TRUE;
3914  }
3915  if (pOrdSgn!=1)
3916  {
3917    Werror("ordering must be global for slimgb");
3918    return TRUE;
3919  }
3920  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3921  tHomog hom=testHomog;
3922  ideal u_id=(ideal)u->Data();
3923  if (w!=NULL)
3924  {
3925    if (!idTestHomModule(u_id,currQuotient,w))
3926    {
3927      WarnS("wrong weights");
3928      w=NULL;
3929    }
3930    else
3931    {
3932      w=ivCopy(w);
3933      hom=isHomog;
3934    }
3935  }
3936   
3937  assume(u_id->rank>=idRankFreeModule(u_id));
3938  res->data=(char *)t_rep_gb(currRing, 
3939    u_id,u_id->rank);
3940  //res->data=(char *)t_rep_gb(currRing, u_id);
3941 
3942  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
3943  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3944  return FALSE;
3945}
3946static BOOLEAN jjSTD(leftv res, leftv v)
3947{
3948  ideal result;
3949  ideal v_id=(ideal)v->Data();
3950  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3951  tHomog hom=testHomog;
3952  if (w!=NULL)
3953  {
3954    if (!idTestHomModule(v_id,currQuotient,w))
3955    {
3956      WarnS("wrong weights");
3957      w=NULL;
3958    }
3959    else
3960    {
3961      hom=isHomog;
3962      w=ivCopy(w);
3963    }
3964  }
3965  result=kStd(v_id,currQuotient,hom,&w);
3966  idSkipZeroes(result);
3967  res->data = (char *)result;
3968  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
3969  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3970  return FALSE;
3971}
3972static BOOLEAN jjSort_Id(leftv res, leftv v)
3973{
3974  res->data = (char *)idSort((ideal)v->Data());
3975  return FALSE;
3976}
3977#if 1
3978static BOOLEAN jjSYZYGY(leftv res, leftv v)
3979{
3980  intvec *w=NULL;
3981  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3982  if (w!=NULL) delete w;
3983  return FALSE;
3984}
3985#else
3986// activate, if idSyz hadle moduke weights correctly !
3987static BOOLEAN jjSYZYGY(leftv res, leftv v)
3988{
3989  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3990  ideal v_id=(ideal)v->Data();
3991  tHomog hom=testHomog;
3992  int add_row_shift=0;
3993  if (w!=NULL)
3994  {
3995    w=ivCopy(w);
3996    add_row_shift=w->min_in();
3997    (*w)-=add_row_shift;
3998    if (idTestHomModule(v_id,currQuotient,w))
3999      hom=isHomog;
4000    else
4001    {
4002      //WarnS("wrong weights");
4003      delete w; w=NULL;
4004      hom=testHomog;
4005    }
4006  }
4007  res->data = (char *)idSyzygies(v_id,hom,&w);
4008  if (w!=NULL)
4009  {
4010    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4011  }
4012  return FALSE;
4013}
4014#endif
4015static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4016{
4017  res->data = (char *)ivTrace((intvec*)(v->Data()));
4018  return FALSE;
4019}
4020static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4021{
4022  res->data = (char *)ivTranp((intvec*)(v->Data()));
4023  return FALSE;
4024}
4025
4026#ifdef HAVE_PLURAL
4027
4028static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4029{
4030  ring    r = (ring)a->Data();
4031  if (rIsPluralRing(r))
4032  {
4033    res->data = rOpposite(r);
4034  }
4035  else res->data = rCopy(r);
4036  return FALSE;
4037}
4038
4039static BOOLEAN jjENVELOPE(leftv res, leftv a)
4040{
4041  ring    r = (ring)a->Data();
4042  if (rIsPluralRing(r))
4043  {
4044    //    ideal   i;
4045//     if (a->rtyp == QRING_CMD)
4046//     {
4047//       i = r->qideal;
4048//       r->qideal = NULL;
4049//     }
4050    ring s = rEnvelope(r);
4051//     if (a->rtyp == QRING_CMD)
4052//     {
4053//       ideal is  = idOppose(r,i); /* twostd? */
4054//       is        = idAdd(is,i);
4055//       s->qideal = i;
4056//     }
4057    res->data = s;
4058  }
4059  else  res->data = rCopy(r);
4060  return FALSE;
4061}
4062
4063static BOOLEAN jjTWOSTD(leftv res, leftv a)
4064{
4065  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
4066  else  res->data=(ideal)a->Data();
4067  setFlag(res,FLAG_STD);
4068  setFlag(res,FLAG_TWOSTD);
4069  return FALSE;
4070}
4071#endif
4072
4073static BOOLEAN jjTYPEOF(leftv res, leftv v)
4074{
4075  switch ((int)(long)v->data)
4076  {
4077    case INT_CMD:     res->data=omStrDup("int"); break;
4078    case POLY_CMD:   res->data=omStrDup("poly"); break;
4079    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
4080    case STRING_CMD:  res->data=omStrDup("string"); break;
4081    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
4082    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
4083    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4084    case MODUL_CMD:   res->data=omStrDup("module"); break;
4085    case MAP_CMD:     res->data=omStrDup("map"); break;
4086    case PROC_CMD:    res->data=omStrDup("proc"); break;
4087    case RING_CMD:    res->data=omStrDup("ring"); break;
4088    case QRING_CMD:   res->data=omStrDup("qring"); break;
4089    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
4090    case NUMBER_CMD:  res->data=omStrDup("number"); break;
4091    case BIGINT_CMD:  res->data=omStrDup("bigint"); break;
4092    case LIST_CMD:   res->data=omStrDup("list"); break;
4093    case PACKAGE_CMD: res->data=omStrDup("package"); break;
4094    case LINK_CMD:   res->data=omStrDup("link"); break;
4095    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4096    case DEF_CMD:
4097    case NONE:    res->data=omStrDup("none"); break;
4098    default:       res->data=omStrDup("?unknown type?");
4099  }
4100  return FALSE;
4101}
4102static BOOLEAN jjVAR1(leftv res, leftv v)
4103{
4104  int i=(int)(long)v->Data();
4105  if ((0<i) && (i<=currRing->N))
4106  {
4107    poly p=pOne();
4108    pSetExp(p,i,1);
4109    pSetm(p);
4110    res->data=(char *)p;
4111  }
4112  else
4113  {
4114    Werror("var number %d out of range 1..%d",i,currRing->N);
4115    return TRUE;
4116  }
4117  return FALSE;
4118}
4119static BOOLEAN jjVARSTR1(leftv res, leftv v)
4120{
4121  if (currRing==NULL)
4122  {
4123    WerrorS("no ring active");
4124    return TRUE;
4125  }
4126  int i=(int)(long)v->Data();
4127  if ((0<i) && (i<=currRing->N))
4128    res->data=omStrDup(currRing->names[i-1]);
4129  else
4130  {
4131    Werror("var number %d out of range 1..%d",i,currRing->N);
4132    return TRUE;
4133  }
4134  return FALSE;
4135}
4136static BOOLEAN jjVDIM(leftv res, leftv v)
4137{
4138  assumeStdFlag(v);
4139  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
4140  return FALSE;
4141}
4142
4143static BOOLEAN jjLOAD1(leftv res, leftv v)
4144{
4145  return jjLOAD(res, v,iiOp==LIB_CMD);
4146}
4147static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4148{
4149#ifdef HAVE_NS
4150  char * s=(char *)v->CopyD();
4151  char libnamebuf[256];
4152  lib_types LT = type_of_LIB(s, libnamebuf);
4153#ifdef HAVE_DYNAMIC_LOADING
4154  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN autoexport);
4155#endif /* HAVE_DYNAMIC_LOADING */
4156  switch(LT)
4157  {
4158      default:
4159      case LT_NONE:
4160        Werror("%s: unknown type", s);
4161        break;
4162      case LT_NOTFOUND:
4163        Werror("cannot open %s", s);
4164        break;
4165
4166      case LT_SINGULAR:
4167      {
4168        char *plib = iiConvName(s);
4169        idhdl pl = IDROOT->get(plib,0);
4170        if (pl==NULL)
4171        {
4172          pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4173          IDPACKAGE(pl)->language = LANG_SINGULAR;
4174          IDPACKAGE(pl)->libname=omStrDup(plib);
4175        }
4176        else if (IDTYP(pl)!=PACKAGE_CMD)
4177        {
4178          Werror("can not create package `%s`",plib);
4179          omFree(plib);
4180          return TRUE;
4181        }
4182        package savepack=currPack;
4183        currPack=IDPACKAGE(pl);
4184        IDPACKAGE(pl)->loaded=TRUE;
4185        char libnamebuf[256];
4186        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4187        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4188        currPack=savepack;
4189        IDPACKAGE(pl)->loaded=(!bo);
4190        return bo;
4191      }
4192      case LT_MACH_O:
4193      case LT_ELF:
4194      case LT_HPUX:
4195#ifdef HAVE_DYNAMIC_LOADING
4196        return load_modules(s, libnamebuf, autoexport);
4197#else /* HAVE_DYNAMIC_LOADING */
4198        WerrorS("Dynamic modules are not supported by this version of Singular");
4199        break;
4200#endif /* HAVE_DYNAMIC_LOADING */
4201  }
4202#endif
4203  return TRUE;
4204}
4205
4206/*=================== operations with 1 arg.: table =================*/
4207
4208#ifdef INIT_BUG
4209#define XS(A) -((short)A)
4210#define jjstrlen       (proc1)1
4211#define jjpLength      (proc1)2
4212#define jjidElem       (proc1)3
4213#define jjmpDetBareiss (proc1)4
4214#define jjidFreeModule (proc1)5
4215#define jjidVec2Ideal  (proc1)6
4216#define jjrCharStr     (proc1)7
4217#ifndef MDEBUG
4218#define jjpHead        (proc1)8
4219#endif
4220#define jjidHead       (proc1)9
4221#define jjidMaxIdeal   (proc1)10
4222#define jjidMinBase    (proc1)11
4223#define jjsyMinBase    (proc1)12
4224#define jjpMaxComp     (proc1)13
4225#define jjmpTrace      (proc1)14
4226#define jjmpTransp     (proc1)15
4227#define jjrOrdStr      (proc1)16
4228#define jjrVarStr      (proc1)18
4229#define jjrParStr      (proc1)19
4230#define jjCOUNT_RES    (proc1)22
4231#define jjDIM_R        (proc1)23
4232#define jjidTransp     (proc1)24
4233
4234extern struct sValCmd1 dArith1[];
4235void jjInitTab1()
4236{
4237  int i=0;
4238  for (;dArith1[i].cmd!=0;i++)
4239  {
4240    if (dArith1[i].res<0)
4241    {
4242      switch ((int)dArith1[i].p)
4243      {
4244        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
4245        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
4246        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
4247        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
4248#ifndef HAVE_FACTORY
4249        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4250#endif
4251        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4252        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
4253#ifndef MDEBUG
4254        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
4255#endif
4256        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
4257        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
4258        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
4259        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
4260        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
4261        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
4262        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
4263        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
4264        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
4265        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
4266        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
4267        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
4268        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
4269#ifdef GENTABLE
4270        default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4271#endif
4272      }
4273    }
4274  }
4275}
4276#else
4277#if defined(PROC_BUG)
4278#define XS(A) A
4279static BOOLEAN jjstrlen(leftv res, leftv v)
4280{
4281  res->data = (char *)strlen((char *)v->Data());
4282  return FALSE;
4283}
4284static BOOLEAN jjpLength(leftv res, leftv v)
4285{
4286  res->data = (char *)pLength((poly)v->Data());
4287  return FALSE;
4288}
4289static BOOLEAN jjidElem(leftv res, leftv v)
4290{
4291  res->data = (char *)idElem((ideal)v->Data());
4292  return FALSE;
4293}
4294static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4295{
4296  res->data = (char *)mpDetBareiss((matrix)v->Data());
4297  return FALSE;
4298}
4299static BOOLEAN jjidFreeModule(leftv res, leftv v)
4300{
4301  res->data = (char *)idFreeModule((int)(long)v->Data());
4302  return FALSE;
4303}
4304static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4305{
4306  res->data = (char *)idVec2Ideal((poly)v->Data());
4307  return FALSE;
4308}
4309static BOOLEAN jjrCharStr(leftv res, leftv v)
4310{
4311  res->data = rCharStr((ring)v->Data());
4312  return FALSE;
4313}
4314#ifndef MDEBUG
4315static BOOLEAN jjpHead(leftv res, leftv v)
4316{
4317  res->data = (char *)pHead((poly)v->Data());
4318  return FALSE;
4319}
4320#endif
4321static BOOLEAN jjidHead(leftv res, leftv v)
4322{
4323  res->data = (char *)idHead((ideal)v->Data());
4324  return FALSE;
4325}
4326static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4327{
4328  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4329  return FALSE;
4330}
4331static BOOLEAN jjidMinBase(leftv res, leftv v)
4332{
4333  res->data = (char *)idMinBase((ideal)v->Data());
4334  return FALSE;
4335}
4336static BOOLEAN jjsyMinBase(leftv res, leftv v)
4337{
4338  res->data = (char *)syMinBase((ideal)v->Data());
4339  return FALSE;
4340}
4341static BOOLEAN jjpMaxComp(leftv res, leftv v)
4342{
4343  res->data = (char *)pMaxComp((poly)v->Data());
4344  return FALSE;
4345}
4346static BOOLEAN jjmpTrace(leftv res, leftv v)
4347{
4348  res->data = (char *)mpTrace((matrix)v->Data());
4349  return FALSE;
4350}
4351static BOOLEAN jjmpTransp(leftv res, leftv v)
4352{
4353  res->data = (char *)mpTransp((matrix)v->Data());
4354  return FALSE;
4355}
4356static BOOLEAN jjrOrdStr(leftv res, leftv v)
4357{
4358  res->data = rOrdStr((ring)v->Data());
4359  return FALSE;
4360}
4361static BOOLEAN jjrVarStr(leftv res, leftv v)
4362{
4363  res->data = rVarStr((ring)v->Data());
4364  return FALSE;
4365}
4366static BOOLEAN jjrParStr(leftv res, leftv v)
4367{
4368  res->data = rParStr((ring)v->Data());
4369  return FALSE;
4370}
4371static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4372{
4373  res->data=(char *)syLength((syStrategy)v->Data());
4374  return FALSE;
4375}
4376static BOOLEAN jjDIM_R(leftv res, leftv v)
4377{
4378  res->data = (char *)syDim((syStrategy)v->Data());
4379  return FALSE;
4380}
4381static BOOLEAN jjidTransp(leftv res, leftv v)
4382{
4383  res->data = (char *)idTransp((ideal)v->Data());
4384  return FALSE;
4385}
4386#else
4387#define XS(A)          -((short)A)
4388#define jjstrlen       (proc1)strlen
4389#define jjpLength      (proc1)pLength
4390#define jjidElem       (proc1)idElem
4391#define jjmpDetBareiss (proc1)mpDetBareiss
4392#define jjidFreeModule (proc1)idFreeModule
4393#define jjidVec2Ideal  (proc1)idVec2Ideal
4394#define jjrCharStr     (proc1)rCharStr
4395#ifndef MDEBUG
4396#define jjpHead        (proc1)pHeadProc
4397#endif
4398#define jjidHead       (proc1)idHead
4399#define jjidMaxIdeal   (proc1)idMaxIdeal
4400#define jjidMinBase    (proc1)idMinBase
4401#define jjsyMinBase    (proc1)syMinBase
4402#define jjpMaxComp     (proc1)pMaxCompProc
4403#define jjmpTrace      (proc1)mpTrace
4404#define jjmpTransp     (proc1)mpTransp
4405#define jjrOrdStr      (proc1)rOrdStr
4406#define jjrVarStr      (proc1)rVarStr
4407#define jjrParStr      (proc1)rParStr
4408#define jjCOUNT_RES    (proc1)syLength
4409#define jjDIM_R        (proc1)syDim
4410#define jjidTransp     (proc1)idTransp
4411#endif
4412#endif
4413static BOOLEAN jjnInt(leftv res, leftv u)
4414{
4415  number n=(number)u->CopyD(NUMBER_CMD);
4416  res->data=(char *)nInt(n);
4417  nDelete(&n);
4418  return FALSE;
4419}
4420#define s short
4421struct sValCmd1 dArith1[]=
4422{
4423// operations:
4424// proc         cmd               res             arg           plural
4425// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4426//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4427 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4428,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4429,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4430,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4431,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4432,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4433,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4434,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4435,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4436,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4437,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4438// and the procedures with 1 argument:
4439,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4440//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4441,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4442,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4443,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4444,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4445,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4446,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4447,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4448#ifdef HAVE_FACTORY
4449,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4450#else
4451,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4452#endif
4453,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4454,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4455,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4456//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4457,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4458,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4459,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4460,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4461,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4462,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4463,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4464,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4465,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4466,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
4467,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
4468,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4469,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
4470,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
4471,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4472,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4473,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4474,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
4475,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4476,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
4477,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4478,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4479,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4480,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4481,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
4482,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
4483,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
4484#ifdef HAVE_FACTORY
4485,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4486,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
4487,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
4488#else
4489,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4490,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
4491#endif
4492,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
4493,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
4494,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4495,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4496,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
4497,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4498,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
4499#ifdef HAVE_FACTORY
4500,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4501#else
4502,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4503#endif
4504#ifdef HAVE_FGLM
4505,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4506#else
4507,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4508#endif
4509,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
4510#ifdef HAVE_FACTORY
4511,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4512#else
4513,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4514#endif
4515,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
4516,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
4517,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
4518,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
4519,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
4520,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
4521,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4522,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4523,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
4524,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
4525,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
4526,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
4527,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
4528,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4529,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4530,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
4531,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
4532,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4533,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4534,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4535,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
4536,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4537,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4538,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4539,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4540,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
4541,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
4542,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
4543,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4544,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4545,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4546,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4547,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
4548#ifdef MDEBUG
4549,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4550#else
4551,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
4552#endif
4553,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
4554#ifdef MDEBUG
4555,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4556#else
4557,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
4558#endif
4559,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4560,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4561,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4562,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
4563,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4564,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4565,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4566,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
4567,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
4568,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
4569,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4570,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4571,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
4572,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
4573,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
4574,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
4575,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
4576,{jjMINRES_R,   MINRES_CMD,      RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4577,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4578,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4579,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
4580,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
4581,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4582,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
4583,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4584,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
4585,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4586,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4587,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4588,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4589,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4590,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4591,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4592,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4593,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4594,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4595,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4596,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4597,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4598,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
4599,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4600,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4601,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4602,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4603,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4604,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
4605,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
4606,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
4607,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
4608,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4609,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4610,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4611,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
4612,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
4613,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
4614,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4615,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
4616,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
4617,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4618,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4619,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4620,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
4621,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
4622//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
4623,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4624,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4625,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4626,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4627,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4628,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4629,{jjSLIM_GB,    SLIM_GB_CMD,     MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4630,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4631,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4632,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4633,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4634,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
4635,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
4636,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4637,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4638#ifdef HAVE_PLURAL
4639,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4640,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4641,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4642,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4643,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4644#endif
4645,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
4646,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
4647,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4648,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
4649,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4650,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4651,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
4652,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4653,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4654,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4655,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4656,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4657,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
4658,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4659,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4660,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4661,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4662,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4663,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4664,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4665,{NULL,         0,               0,              0              NO_PLURAL}
4666};
4667#undef s
4668/*=================== operations with 3 args.: static proc =================*/
4669static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4670{
4671  char *s= (char *)u->Data();
4672  int   r = (int)(long)v->Data();
4673  int   c = (int)(long)w->Data();
4674  int l = strlen(s);
4675
4676  if ( (r<1) || (r>l) || (c<0) )
4677  {
4678    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4679    return TRUE;
4680  }
4681  res->data = (char *)omAlloc(c+1);
4682  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4683  return FALSE;
4684}
4685static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4686{
4687  intvec *iv = (intvec *)u->Data();
4688  int   r = (int)(long)v->Data();
4689  int   c = (int)(long)w->Data();
4690  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4691  {
4692    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4693           r,c,u->Fullname(),iv->rows(),iv->cols());
4694    return TRUE;
4695  }
4696  res->data=u->data; u->data=NULL;
4697  res->rtyp=u->rtyp; u->rtyp=0;
4698  res->name=u->name; u->name=NULL;
4699  res->attribute=u->attribute; u->attribute=NULL;
4700  Subexpr e=jjMakeSub(v);
4701          e->next=jjMakeSub(w);
4702  if (u->e==NULL) res->e=e;
4703  else
4704  {
4705    Subexpr h=u->e;
4706    while (h->next!=NULL) h=h->next;
4707    h->next=e;
4708    res->e=u->e;
4709    u->e=NULL;
4710  }
4711  return FALSE;
4712}
4713static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4714{
4715  matrix m= (matrix)u->Data();
4716  int   r = (int)(long)v->Data();
4717  int   c = (int)(long)w->Data();
4718  //Print("gen. elem %d, %d\n",r,c);
4719  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4720  {
4721    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4722      MATROWS(m),MATCOLS(m));
4723    return TRUE;
4724  }
4725  res->data=u->data; u->data=NULL;
4726  res->rtyp=u->rtyp; u->rtyp=0;
4727  res->name=u->name; u->name=NULL;
4728  res->attribute=u->attribute; u->attribute=NULL;
4729  Subexpr e=jjMakeSub(v);
4730          e->next=jjMakeSub(w);
4731  if (u->e==NULL)
4732    res->e=e;
4733  else
4734  {
4735    Subexpr h=u->e;
4736    while (h->next!=NULL) h=h->next;
4737    h->next=e;
4738    res->e=u->e;
4739    u->e=NULL;
4740  }
4741  return FALSE;
4742}
4743static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4744{
4745  sleftv t;
4746  sleftv ut;
4747  leftv p=NULL;
4748  intvec *iv=(intvec *)w->Data();
4749  int l;
4750  BOOLEAN nok;
4751
4752  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4753  {
4754    WerrorS("cannot build expression lists from unnamed objects");
4755    return TRUE;
4756  }
4757  memcpy(&ut,u,sizeof(ut));
4758  memset(&t,0,sizeof(t));
4759  t.rtyp=INT_CMD;
4760  for (l=0;l< iv->length(); l++)
4761  {
4762    t.data=(char *)(*iv)[l];
4763    if (p==NULL)
4764    {
4765      p=res;
4766    }
4767    else
4768    {
4769      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4770      p=p->next;
4771    }
4772    memcpy(u,&ut,sizeof(ut));
4773    if (u->Typ() == MATRIX_CMD)
4774      nok=jjBRACK_Ma(p,u,v,&t);
4775    else /* INTMAT_CMD */
4776      nok=jjBRACK_Im(p,u,v,&t);
4777    if (nok)
4778    {
4779      while (res->next!=NULL)
4780      {
4781        p=res->next->next;
4782        omFreeBin((ADDRESS)res->next, sleftv_bin);
4783        // res->e aufraeumen !!!!
4784        res->next=p;
4785      }
4786      return TRUE;
4787    }
4788  }
4789  return FALSE;
4790}
4791static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4792{
4793  sleftv t;
4794  sleftv ut;
4795  leftv p=NULL;
4796  intvec *iv=(intvec *)v->Data();
4797  int l;
4798  BOOLEAN nok;
4799
4800  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4801  {
4802    WerrorS("cannot build expression lists from unnamed objects");
4803    return TRUE;
4804  }
4805  memcpy(&ut,u,sizeof(ut));
4806  memset(&t,0,sizeof(t));
4807  t.rtyp=INT_CMD;
4808  for (l=0;l< iv->length(); l++)
4809  {
4810    t.data=(char *)((*iv)[l]);
4811    if (p==NULL)
4812    {
4813      p=res;
4814    }
4815    else
4816    {
4817      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4818      p=p->next;
4819    }
4820    memcpy(u,&ut,sizeof(ut));
4821    if (u->Typ() == MATRIX_CMD)
4822      nok=jjBRACK_Ma(p,u,&t,w);
4823    else /* INTMAT_CMD */
4824      nok=jjBRACK_Im(p,u,&t,w);
4825    if (nok)
4826    {
4827      while (res->next!=NULL)
4828      {
4829        p=res->next->next;
4830        omFreeBin((ADDRESS)res->next, sleftv_bin);
4831        // res->e aufraeumen !!
4832        res->next=p;
4833      }
4834      return TRUE;
4835    }
4836  }
4837  return FALSE;
4838}
4839static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4840{
4841  sleftv t1,t2,ut;
4842  leftv p=NULL;
4843  intvec *vv=(intvec *)v->Data();
4844  intvec *wv=(intvec *)w->Data();
4845  int vl;
4846  int wl;
4847  BOOLEAN nok;
4848
4849  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4850  {
4851    WerrorS("cannot build expression lists from unnamed objects");
4852    return TRUE;
4853  }
4854  memcpy(&ut,u,sizeof(ut));
4855  memset(&t1,0,sizeof(sleftv));
4856  memset(&t2,0,sizeof(sleftv));
4857  t1.rtyp=INT_CMD;
4858  t2.rtyp=INT_CMD;
4859  for (vl=0;vl< vv->length(); vl++)
4860  {
4861    t1.data=(char *)((*vv)[vl]);
4862    for (wl=0;wl< wv->length(); wl++)
4863    {
4864      t2.data=(char *)((*wv)[wl]);
4865      if (p==NULL)
4866      {
4867        p=res;
4868      }
4869      else
4870      {
4871        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4872        p=p->next;
4873      }
4874      memcpy(u,&ut,sizeof(ut));
4875      if (u->Typ() == MATRIX_CMD)
4876        nok=jjBRACK_Ma(p,u,&t1,&t2);
4877      else /* INTMAT_CMD */
4878        nok=jjBRACK_Im(p,u,&t1,&t2);
4879      if (nok)
4880      {
4881        res->CleanUp();
4882        return TRUE;
4883      }
4884    }
4885  }
4886  return FALSE;
4887}
4888static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4889{
4890  v->next=(leftv)omAllocBin(sleftv_bin);
4891  memcpy(v->next,w,sizeof(sleftv));
4892  memset(w,0,sizeof(sleftv));
4893  return jjPROC(res,u,v);
4894}
4895static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4896{
4897  u->next=(leftv)omAllocBin(sleftv_bin);
4898  memcpy(u->next,v,sizeof(sleftv));
4899  u->next->next=(leftv)omAllocBin(sleftv_bin);
4900  memcpy(u->next->next,w,sizeof(sleftv));
4901  BOOLEAN r=iiExprArithM(res,u,iiOp);
4902  // iiExprArithM did the CleanUp
4903  w->rtyp=0; w->data=NULL;
4904  return r;
4905}
4906static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4907{
4908  intvec *iv;
4909  ideal m;
4910  lists l=(lists)omAllocBin(slists_bin);
4911  int k=(int)(long)w->Data();
4912  if (k>=0)
4913  {
4914    smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
4915    l->Init(2);
4916    l->m[0].rtyp=MODUL_CMD;
4917    l->m[1].rtyp=INTVEC_CMD;
4918    l->m[0].data=(void *)m;
4919    l->m[1].data=(void *)iv;
4920  }
4921  else
4922  {
4923    m=smCallSolv((ideal)u->Data());
4924    l->Init(1);
4925    l->m[0].rtyp=IDEAL_CMD;
4926    l->m[0].data=(void *)m;
4927  }
4928  res->data = (char *)l;
4929  return FALSE;
4930}
4931static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4932{
4933  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4934  {
4935    WerrorS("3rd argument must be a name of a matrix");
4936    return TRUE;
4937  }
4938  ideal i=(ideal)u->Data();
4939  int rank=(int)i->rank;
4940  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4941  if (r) return TRUE;
4942  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4943  return FALSE;
4944}
4945static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4946{
4947  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4948           (ideal)(v->Data()),(poly)(w->Data()));
4949  return FALSE;
4950}
4951static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4952{
4953  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4954  {
4955    WerrorS("3rd argument must be a name of a matrix");
4956    return TRUE;
4957  }
4958  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4959  poly p=(poly)u->CopyD(POLY_CMD);
4960  ideal i=idInit(1,1);
4961  i->m[0]=p;
4962  sleftv t;
4963  memset(&t,0,sizeof(t));
4964  t.data=(char *)i;
4965  t.rtyp=IDEAL_CMD;
4966  int rank=1;
4967  if (u->Typ()==VECTOR_CMD)
4968  {
4969    i->rank=rank=pMaxComp(p);
4970    t.rtyp=MODUL_CMD;
4971  }
4972  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4973  t.CleanUp();
4974  if (r) return TRUE;
4975  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4976  return FALSE;
4977}
4978static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4979{
4980  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4981    (intvec *)w->Data());
4982  setFlag(res,FLAG_STD);
4983  return FALSE;
4984}
4985static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4986{
4987  /*4
4988  * look for the substring what in the string where
4989  * starting at position n
4990  * return the position of the first char of what in where
4991  * or 0
4992  */
4993  int n=(int)(long)w->Data();
4994  char *where=(char *)u->Data();
4995  char *what=(char *)v->Data();
4996  char *found;
4997  if ((1>n)||(n>(int)strlen(where)))
4998  {
4999    Werror("start position %d out of range",n);
5000    return TRUE;
5001  }
5002  found = strchr(where+n-1,*what);
5003  if (*(what+1)!='\0')
5004  {
5005    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5006    {
5007      found=strchr(found+1,*what);
5008    }
5009  }
5010  if (found != NULL)
5011  {
5012    res->data=(char *)((found-where)+1);
5013  }
5014  return FALSE;
5015}
5016static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5017{
5018  if ((int)(long)w->Data()==0)
5019    res->data=(char *)walkProc(u,v);
5020  else
5021    res->data=(char *)fractalWalkProc(u,v);
5022  setFlag( res, FLAG_STD );
5023  return FALSE;
5024}
5025static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5026{
5027  assumeStdFlag(u);
5028  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5029  intvec *wdegree=(intvec*)w->Data();
5030  if (wdegree->length()!=pVariables)
5031  {
5032    Werror("weight vector must have size %d, not %d",
5033           pVariables,wdegree->length());
5034    return TRUE;
5035  }
5036  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5037  switch((int)(long)v->Data())
5038  {
5039    case 1:
5040      res->data=(void *)iv;
5041      return FALSE;
5042    case 2:
5043      res->data=(void *)hSecondSeries(iv);
5044      delete iv;
5045      return FALSE;
5046  }
5047  WerrorS(feNotImplemented);
5048  delete iv;
5049  return TRUE;
5050}
5051static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5052{
5053  intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5054  intvec* arg = (intvec*) u->Data();
5055  int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
5056
5057  for (i=0; i<n; i++)
5058  {
5059    (*im)[i] = (*arg)[i];
5060  }
5061
5062  res->data = (char *)im;
5063  return FALSE;
5064}
5065static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5066{
5067  short *iw=iv2array((intvec *)w->Data());
5068  res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5069  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5070  return FALSE;
5071}
5072static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5073{
5074  if (!pIsUnit((poly)v->Data()))
5075  {
5076    WerrorS("2nd argument must be a unit");
5077    return TRUE;
5078  }
5079  res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5080  return FALSE;
5081}
5082static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5083{
5084  res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5085                             (intvec *)w->Data());
5086  return FALSE;
5087}
5088static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5089{
5090  if (!mpIsDiagUnit((matrix)v->Data()))
5091  {
5092    WerrorS("2nd argument must be a diagonal matrix of units");
5093    return TRUE;
5094  }
5095  res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5096                               (matrix)v->CopyD());
5097  return FALSE;
5098}
5099static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5100{
5101  assumeStdFlag(w);
5102  res->data = (char *)idMinors(
5103                        (matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5104  return FALSE;
5105}
5106static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5107{
5108  idhdl h;
5109  ring rr;
5110  map mapping;
5111
5112  if ((v->name==NULL) || (w->name==NULL))
5113  {
5114    WerrorS("2nd/3rd arguments must have names");
5115    return TRUE;
5116  }
5117  rr=(ring)u->Data();
5118  const char *ring_name=u->Name();
5119  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5120  {
5121    if (h->typ==MAP_CMD)
5122    {
5123      mapping=IDMAP(h);
5124      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5125      if ((preim_ring==NULL)
5126      || (IDRING(preim_ring)!=currRing))
5127      {
5128        Werror("preimage ring `%s` is not the basering",mapping->preimage);
5129        return TRUE;
5130      }
5131    }
5132    else if (h->typ==IDEAL_CMD)
5133    {
5134      mapping=IDMAP(h);
5135    }
5136    else
5137    {
5138      Werror("`%s` is no map nor ideal",IDID(h));
5139      return TRUE;
5140    }
5141  }
5142  else
5143  {
5144    Werror("`%s` is not defined in `%s`",v->name,ring_name);
5145    return TRUE;
5146  }
5147  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5148  {
5149    if (h->typ==IDEAL_CMD)
5150    {
5151      if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5152      || ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5153      {
5154        WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5155      }
5156      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5157      if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5158    }
5159    else
5160    {
5161      Werror("`%s` is no ideal",IDID(h));
5162      return TRUE;
5163    }
5164  }
5165  else
5166  {
5167    Werror("`%s` is not defined in `%s`",w->name,ring_name);
5168    return TRUE;
5169  }
5170  return FALSE;
5171}
5172static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5173{
5174  int di, k;
5175  int i=(int)(long)u->Data();
5176  int r=(int)(long)v->Data();
5177  int c=(int)(long)w->Data();
5178  if ((r<=0) || (c<=0)) return TRUE;
5179  intvec *iv = new intvec(r, c, 0);
5180  if (iv->rows()==0)
5181  {
5182    delete iv;
5183    return TRUE;
5184  }
5185  if (i!=0)
5186  {
5187    if (i<0) i = -i;
5188    di = 2 * i + 1;
5189    for (k=0; k<iv->length(); k++)
5190    {
5191#ifdef buildin_rand
5192      (*iv)[k] = ((siRand() % di) - i);
5193#else
5194      (*iv)[k] = ((rand() % di) - i);
5195#endif
5196    }
5197  }
5198  res->data = (char *)iv;
5199  return FALSE;
5200}
5201static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5202  int &ringvar, poly &monomexpr)
5203{
5204  monomexpr=(poly)w->Data();
5205  poly p=(poly)v->Data();
5206  #if 0
5207  if (pLength(monomexpr)>1)
5208  {
5209    Werror("`%s` substitutes a ringvar only by a term",
5210      Tok2Cmdname(SUBST_CMD));
5211    return TRUE;
5212  }
5213  #endif
5214  if (!(ringvar=pVar(p)))
5215  {
5216    if (rField_is_Extension(currRing))
5217    {
5218      assume(currRing->algring!=NULL);
5219      lnumber n=(lnumber)pGetCoeff(p);
5220      ringvar=-p_Var(n->z,currRing->algring);
5221    }
5222    if(ringvar==0)
5223    {
5224      WerrorS("ringvar/par expected");
5225      return TRUE;
5226    }
5227  }
5228  return FALSE;
5229}
5230static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5231{
5232  int ringvar;
5233  poly monomexpr;
5234  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5235  if (nok) return TRUE;
5236  if (ringvar>0)
5237  {
5238    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5239      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5240    else
5241      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5242  }
5243  else
5244  {
5245    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5246  }
5247  return FALSE;
5248}
5249static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5250{
5251  int ringvar;
5252  poly monomexpr;
5253  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5254  if (nok) return TRUE;
5255  if (ringvar>0)
5256  {
5257    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5258      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5259    else
5260      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5261  }
5262  else
5263  {
5264    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5265  }
5266  return FALSE;
5267}
5268// we do not want to have jjSUBST_Id_X inlined:
5269static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5270                            int input_type);
5271static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5272{
5273  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5274}
5275static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5276{
5277  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5278}
5279static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5280{
5281  sleftv tmp;
5282  memset(&tmp,0,sizeof(tmp));
5283  // do not check the result, conversion from int/number to poly works always
5284  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5285  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5286  tmp.CleanUp();
5287  return b;
5288}
5289static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5290{
5291  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5292  ideal I=(ideal)u->CopyD(IDEAL_CMD);
5293  int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5294  //for(i=i-1;i>=0;i--)
5295  //{
5296  //  m->m[i]=I->m[i];
5297  //  I->m[i]=NULL;
5298  //}
5299  memcpy4(m->m,I->m,i*sizeof(poly));
5300  memset(I->m,0,i*sizeof(poly));
5301  idDelete(&I);
5302  res->data = (char *)m;
5303  return FALSE;
5304}
5305static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5306{
5307  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5308           (int)(long)v->Data(),(int)(long)w->Data());
5309  return FALSE;
5310}
5311static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5312{
5313  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5314  matrix I=(matrix)u->CopyD(MATRIX_CMD);
5315  int r=si_min(MATROWS(I),(int)(long)v->Data());
5316  int c=si_min(MATCOLS(I),(int)(long)w->Data());
5317  int i,j;
5318  for(i=r;i>0;i--)
5319  {
5320    for(j=c;j>0;j--)
5321    {
5322      MATELEM(m,i,j)=MATELEM(I,i,j);
5323      MATELEM(I,i,j)=NULL;
5324    }
5325  }
5326  idDelete((ideal *)&I);
5327  res->data = (char *)m;
5328  return FALSE;
5329}
5330static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5331{
5332  if (w->rtyp!=IDHDL) return TRUE;
5333  BITSET save_test=test;
5334  int ul= IDELEMS((ideal)u->Data());
5335  int vl= IDELEMS((ideal)v->Data());
5336  ideal m
5337    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5338             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5339  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5340  test=save_test;
5341  return FALSE;
5342}
5343static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5344{
5345  assumeStdFlag(v);
5346  if (!idIsZeroDim((ideal)v->Data()))
5347  {
5348    Werror("`%s` must be 0-dimensional",v->Name());
5349    return TRUE;
5350  }
5351  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5352    (poly)w->CopyD());
5353  return FALSE;
5354}
5355static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5356{
5357  assumeStdFlag(v);
5358  if (!idIsZeroDim((ideal)v->Data()))
5359  {
5360    Werror("`%s` must be 0-dimensional",v->Name());
5361    return TRUE;
5362  }
5363  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5364    (matrix)w->CopyD());
5365  return FALSE;
5366}
5367static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5368{
5369  assumeStdFlag(v);
5370  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5371    0,(int)(long)w->Data());
5372  return FALSE;
5373}
5374static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5375{
5376  assumeStdFlag(v);
5377  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5378    0,(int)(long)w->Data());
5379  return FALSE;
5380}
5381#ifdef OLD_RES
5382static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5383{
5384  int maxl=(int)v->Data();
5385  ideal u_id=(ideal)u->Data();
5386  int l=0;
5387  resolvente r;
5388  intvec **weights=NULL;
5389  int wmaxl=maxl;
5390  maxl--;
5391  if ((maxl==-1) && (iiOp!=MRES_CMD))
5392    maxl = pVariables-1;
5393  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5394  {
5395    intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5396    if (iv!=NULL)
5397    {
5398      if (!idTestHomModule(u_id,currQuotient,iv))
5399      {
5400        WarnS("wrong weights");
5401        iv=NULL;
5402      }
5403      else
5404      {
5405        weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5406        weights[0] = ivCopy(iv);
5407        l=1;
5408      }
5409    }
5410    r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
5411  }
5412  else
5413    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5414  if (r==NULL) return TRUE;
5415  int t3=u->Typ();
5416  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5417  return FALSE;
5418}
5419#endif
5420static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5421{
5422  res->data=(void *)rInit(u,v,w);
5423  return (res->data==NULL);
5424}
5425static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5426{
5427  int yes;
5428  jjSTATUS2(res, u, v);
5429  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5430  omFree((ADDRESS) res->data);
5431  res->data = (void *) yes;
5432  return FALSE;
5433}
5434static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5435{
5436  ideal result;
5437  intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5438  tHomog hom=testHomog;
5439  ideal u_id=(ideal)(u->Data());
5440  if (ww!=NULL)
5441  {
5442    if (!idTestHomModule(u_id,currQuotient,ww))
5443    {
5444      WarnS("wrong weights");
5445      ww=NULL;
5446    }
5447    else
5448    {
5449      ww=ivCopy(ww);
5450      hom=isHomog;
5451    }
5452  }
5453  result=kStd(u_id,
5454              currQuotient,
5455              hom,
5456              &ww,                  // module weights
5457              (intvec *)v->Data(),  // hilbert series
5458              0,0,                  // syzComp, newIdeal
5459              (intvec *)w->Data()); // weights of vars
5460  idSkipZeroes(result);
5461  res->data = (char *)result;
5462  setFlag(res,FLAG_STD);
5463  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5464  return FALSE;
5465}
5466
5467/*=================== operations with 3 args.: table =================*/
5468struct sValCmd3 dArith3[]=
5469{
5470// operations:
5471// proc             cmd          res         arg1        arg2        arg3   plural
5472 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5473,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5474,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5475,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5476,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5477,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5478,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5479,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5480,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5481,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5482,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
5483,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
5484,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5485,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5486,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5487,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5488,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
5489,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
5490,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5491,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5492,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
5493,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5494,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5495,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5496,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
5497//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5498,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5499,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5500,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5501,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5502,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5503,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5504,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
5505,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
5506,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5507,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5508,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
5509,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
5510,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5511,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5512,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5513,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5514,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
5515,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5516#ifdef OLD_RES
5517,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5518,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5519#endif
5520,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5521,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5522,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5523,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5524,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
5525,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5526,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5527,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5528,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5529,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5530,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5531,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
5532,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
5533,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5534,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5535#ifdef OLD_RES
5536,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5537,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5538#endif
5539#ifdef HAVE_FACTORY
5540,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5541#else
5542,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5543#endif
5544,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5545#ifdef OLD_RES
5546,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5547,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5548#endif
5549,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
5550,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5551,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5552,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5553,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5554,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5555,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5556,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5557,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5558,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
5559,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
5560,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
5561,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
5562,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
5563,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
5564};
5565/*=================== operations with many arg.: static proc =================*/
5566static BOOLEAN jjBREAK0(leftv res, leftv v)
5567{
5568#ifdef HAVE_SDB
5569  sdb_show_bp();
5570#endif
5571  return FALSE;
5572}
5573static BOOLEAN jjBREAK1(leftv res, leftv v)
5574{
5575#ifdef HAVE_SDB
5576  if(v->Typ()==PROC_CMD)
5577  {
5578    int lineno=0;
5579    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
5580    {
5581      lineno=(int)(long)v->next->Data();
5582    }
5583    return sdb_set_breakpoint(v->Name(),lineno);
5584  }
5585  return TRUE;
5586#else
5587 return FALSE;
5588#endif
5589}
5590static BOOLEAN jjCALL1ARG(leftv res, leftv v)
5591{
5592  return iiExprArith1(res,v,iiOp);
5593}
5594static BOOLEAN jjCALL2ARG(leftv res, leftv u)
5595{
5596  leftv v=u->next;
5597  u->next=NULL;
5598  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
5599  u->next=v;
5600  return b;
5601}
5602static BOOLEAN jjCALL3ARG(leftv res, leftv u)
5603{
5604  leftv v = u->next;
5605  leftv w = v->next;
5606  u->next = NULL;
5607  v->next = NULL;
5608  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5609  u->next = v;
5610  v->next = w;
5611  return b;
5612}
5613
5614static BOOLEAN jjCOEF_M(leftv res, leftv v)
5615{
5616  if((v->Typ() != VECTOR_CMD)
5617  || (v->next->Typ() != POLY_CMD)
5618  || (v->next->next->Typ() != MATRIX_CMD)
5619  || (v->next->next->next->Typ() != MATRIX_CMD))
5620     return TRUE;
5621  if (v->next->next->rtyp!=IDHDL) return TRUE;
5622  idhdl c=(idhdl)v->next->next->data;
5623  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
5624  idhdl m=(idhdl)v->next->next->next->data;
5625  idDelete((ideal *)&(c->data.uideal));
5626  idDelete((ideal *)&(m->data.uideal));
5627  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
5628    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
5629  return FALSE;
5630}
5631
5632static BOOLEAN jjDIVISION4(leftv res, leftv v)
5633{ // may have 3 or 4 arguments
5634  leftv v1=v;
5635  leftv v2=v1->next;
5636  leftv v3=v2->next;
5637  leftv v4=v3->next;
5638  assumeStdFlag(v2);
5639
5640  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
5641  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
5642
5643  if(i1==0||i2==0||v3->Typ()!=INT_CMD||(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
5644  {
5645    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
5646    return TRUE;
5647  }
5648
5649  sleftv w1,w2;
5650  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
5651  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
5652  ideal P=(ideal)w1.Data();
5653  ideal Q=(ideal)w2.Data();
5654
5655  int n=(int)(long)v3->Data();
5656  short *w=NULL;
5657  if(v4!=NULL)
5658  {
5659    w=iv2array((intvec *)v4->Data());
5660    short *w0=w+1;
5661    int i=pVariables;
5662    while(i>0&&*w0>0)
5663    {
5664      w0++;
5665      i--;
5666    }
5667    if(i>0)
5668      WarnS("not all weights are positive!");
5669  }
5670
5671  matrix T;
5672  ideal R;
5673  idLiftW(P,Q,n,T,R,w);
5674
5675  if(w!=NULL)
5676    omFree(w);
5677  lists L=(lists) omAllocBin(slists_bin);
5678  L->Init(2);
5679  L->m[1].rtyp=v1->Typ();
5680  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
5681  {
5682    if(v1->Typ()==POLY_CMD)
5683      pShift(&R->m[0],-1);
5684    L->m[1].data=(void *)R->m[0];
5685    R->m[0]=NULL;
5686    idDelete(&R);
5687  }
5688  else
5689  if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
5690    L->m[1].data=(void *)idModule2Matrix(R);
5691  else
5692    L->m[1].rtyp=MODUL_CMD;
5693  L->m[0].rtyp=MATRIX_CMD;
5694  L->m[0].data=(char *)T;
5695
5696  res->data=L;
5697  res->rtyp=LIST_CMD;
5698
5699  return FALSE;
5700}
5701
5702//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
5703//{
5704//  int l=u->listLength();
5705//  if (l<2) return TRUE;
5706//  BOOLEAN b;
5707//  leftv v=u->next;
5708//  leftv zz=v;
5709//  leftv z=zz;
5710//  u->next=NULL;
5711//  do
5712//  {
5713//    leftv z=z->next;
5714//    b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
5715//    if (b) break;
5716//  } while (z!=NULL);
5717//  u->next=zz;
5718//  return b;
5719//}
5720static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5721{
5722  int s=1;
5723  leftv h=v;
5724  if (h!=NULL) s=exprlist_length(h);
5725  ideal id=idInit(s,1);
5726  int rank=1;
5727  int i=0;
5728  poly p;
5729  while (h!=NULL)
5730  {
5731    switch(h->Typ())
5732    {
5733      case POLY_CMD:
5734      {
5735        p=(poly)h->CopyD(POLY_CMD);
5736        break;
5737      }
5738      case INT_CMD:
5739      {
5740        number n=nInit((int)(long)h->Data());
5741        if (!nIsZero(n))
5742        {
5743          p=pOne();
5744          pSetCoeff(p,n);
5745        }
5746        else
5747        {
5748          p=NULL;
5749          nDelete(&n);
5750        }
5751        break;
5752      }
5753      case NUMBER_CMD:
5754      {
5755        number n=(number)h->CopyD(NUMBER_CMD);
5756        if (!nIsZero(n))
5757        {
5758          p=pOne();
5759          pSetCoeff(p,n);
5760        }
5761        else
5762        {
5763          p=NULL;
5764          nDelete(&n);
5765        }
5766        break;
5767      }
5768      case VECTOR_CMD:
5769      {
5770        p=(poly)h->CopyD(VECTOR_CMD);
5771        if (iiOp!=MODUL_CMD)
5772        {
5773          idDelete(&id);
5774          pDelete(&p);
5775          return TRUE;
5776        }
5777        rank=si_max(rank,(int)pMaxComp(p));
5778        break;
5779      }
5780      default:
5781      {
5782        idDelete(&id);
5783        return TRUE;
5784      }
5785    }
5786    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
5787    {
5788      pSetCompP(p,1);
5789    }
5790    id->m[i]=p;
5791    i++;
5792    h=h->next;
5793  }
5794  id->rank=rank;
5795  res->data=(char *)id;
5796  return FALSE;
5797}
5798static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
5799{
5800  leftv h=v;
5801  int l=v->listLength();
5802  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
5803  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
5804  int t=0;
5805  // try to convert to IDEAL_CMD
5806  while (h!=NULL)
5807  {
5808    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
5809    {
5810      t=IDEAL_CMD;
5811    }
5812    else break;
5813    h=h->next;
5814  }
5815  // if failure, try MODUL_CMD
5816  if (t==0)
5817  {
5818    h=v;
5819    while (h!=NULL)
5820    {
5821      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
5822      {
5823        t=MODUL_CMD;
5824      }
5825      else break;
5826      h=h->next;
5827    }
5828  }
5829  // check for success  in converting
5830  if (t==0)
5831  {
5832    WerrorS("cannot convert to ideal or module");
5833    return TRUE;
5834  }
5835  // call idMultSect
5836  h=v;
5837  int i=0;
5838  sleftv tmp;
5839  while (h!=NULL)
5840  {
5841    if (h->Typ()==t)
5842    {
5843      r[i]=(ideal)h->Data(); /*no copy*/
5844      h=h->next;
5845    }
5846    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
5847    {
5848      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5849      omFreeSize((ADDRESS)r,l*sizeof(ideal));
5850      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
5851      return TRUE;
5852    }
5853    else
5854    {
5855      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
5856      copied[i]=TRUE;
5857      h=tmp.next;
5858    }
5859    i++;
5860  }
5861  res->rtyp=t;
5862  res->data=(char *)idMultSect(r,i);
5863  while(i>0)
5864  {
5865    i--;
5866    if (copied[i]) idDelete(&(r[i]));
5867  }
5868  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5869  omFreeSize((ADDRESS)r,l*sizeof(ideal));
5870  return FALSE;
5871}
5872static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
5873{
5874  int i=0;
5875  leftv h=v;
5876  if (h!=NULL) i=exprlist_length(h);
5877  intvec *iv=new intvec(i);
5878  i=0;
5879  while (h!=NULL)
5880  {
5881    if(h->Typ()==INT_CMD)
5882    {
5883      (*iv)[i]=(int)(long)h->Data();
5884    }
5885    else
5886    {
5887      delete iv;
5888      return TRUE;
5889    }
5890    i++;
5891    h=h->next;
5892  }
5893  res->data=(char *)iv;
5894  return FALSE;
5895}
5896static BOOLEAN jjJET4(leftv res, leftv u)
5897{
5898  leftv u1=u;
5899  leftv u2=u1->next;
5900  leftv u3=u2->next;
5901  leftv u4=u3->next;
5902  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5903     (u4->Typ()==INTVEC_CMD)||
5904     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5905     (u4->Typ()==INTVEC_CMD))
5906  {
5907    if(!pIsUnit((poly)u2->Data()))
5908    {
5909      WerrorS("2nd argument must be a unit");
5910      return TRUE;
5911    }
5912    res->rtyp=u1->Typ();
5913    res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
5914                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
5915    return FALSE;
5916  }
5917  else
5918  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5919     (u4->Typ()==INTVEC_CMD)||
5920     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5921     (u4->Typ()==INTVEC_CMD))
5922  {
5923    if(!mpIsDiagUnit((matrix)u2->Data()))
5924    {
5925      WerrorS("2nd argument must be a diagonal matrix of units");
5926      return TRUE;
5927    }
5928    res->rtyp=u1->Typ();
5929    res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
5930                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
5931    return FALSE;
5932  }
5933  else
5934  {
5935    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
5936           Tok2Cmdname(iiOp));
5937    return TRUE;
5938  }
5939}
5940static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
5941{
5942  if ((yyInRingConstruction)
5943  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
5944  {
5945    memcpy(res,u,sizeof(sleftv));
5946    memset(u,0,sizeof(sleftv));
5947    return FALSE;
5948  }
5949  leftv v=u->next;
5950  BOOLEAN b;
5951  if(v==NULL)
5952    b=iiExprArith1(res,u,iiOp);
5953  else
5954  {
5955    u->next=NULL;
5956    b=iiExprArith2(res,u,iiOp,v);
5957    u->next=v;
5958  }
5959  return b;
5960}
5961static BOOLEAN jjLIST_PL(leftv res, leftv v)
5962{
5963  int sl=0;
5964  if (v!=NULL) sl = v->listLength();
5965  lists L;
5966  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
5967  {
5968    int add_row_shift = 0;
5969    intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
5970    if (weights!=NULL)  add_row_shift=weights->min_in();
5971    L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
5972  }
5973  else
5974  {
5975    L=(lists)omAllocBin(slists_bin);
5976    leftv h=NULL;
5977    int i;
5978    int rt;
5979
5980    L->Init(sl);
5981    for (i=0;i<sl;i++)
5982    {
5983      if (h!=NULL) { /* e.g. not in the first step:
5984                     * h is the pointer to the old sleftv,
5985                     * v is the pointer to the next sleftv
5986                     * (in this moment) */
5987                     h->next=v;
5988                   }
5989      h=v;
5990      v=v->next;
5991      h->next=NULL;
5992      rt=h->Typ();
5993      if (rt==0)
5994      {
5995        L->Clean();
5996        Werror("`%s` is undefined",h->Fullname());
5997        return TRUE;
5998      }
5999      if ((rt==RING_CMD)||(rt==QRING_CMD))
6000      {
6001        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
6002        ((ring)L->m[i].data)->ref++;
6003      }
6004      else
6005        L->m[i].Copy(h);
6006    }
6007  }
6008  res->data=(char *)L;
6009  return FALSE;
6010}
6011static BOOLEAN jjNAMES0(leftv res, leftv v)
6012{
6013  res->data=(void *)ipNameList(IDROOT);
6014  return FALSE;
6015}
6016static BOOLEAN jjOPTION_PL(leftv res, leftv v)
6017{
6018  if(v==NULL)
6019  {
6020    res->data=(char *)showOption();
6021    return FALSE;
6022  }
6023  res->rtyp=NONE;
6024  return setOption(res,v);
6025}
6026static BOOLEAN jjREDUCE4(leftv res, leftv u)
6027{
6028  leftv u1=u;
6029  leftv u2=u1->next;
6030  leftv u3=u2->next;
6031  leftv u4=u3->next;
6032  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
6033  {
6034    int save_d=Kstd1_deg;
6035    Kstd1_deg=(int)(long)u3->Data();
6036    kModW=(intvec *)u4->Data();
6037    BITSET save=verbose;
6038    verbose|=Sy_bit(V_DEG_STOP);
6039    u2->next=NULL;
6040    BOOLEAN r=jjCALL2ARG(res,u);
6041    kModW=NULL;
6042    Kstd1_deg=save_d;
6043    verbose=save;
6044    u->next->next=u3;
6045    return r;
6046  }
6047  else
6048  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6049     (u4->Typ()==INT_CMD))
6050  {
6051    assumeStdFlag(u3);
6052    if(!mpIsDiagUnit((matrix)u2->Data()))
6053    {
6054      WerrorS("2nd argument must be a diagonal matrix of units");
6055      return TRUE;
6056    }
6057    res->rtyp=IDEAL_CMD;
6058    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6059                           mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
6060    return FALSE;
6061  }
6062  else
6063  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6064     (u4->Typ()==INT_CMD))
6065  {
6066    assumeStdFlag(u3);
6067    if(!pIsUnit((poly)u2->Data()))
6068    {
6069      WerrorS("2nd argument must be a unit");
6070      return TRUE;
6071    }
6072    res->rtyp=POLY_CMD;
6073    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6074                           pCopy((poly)u2->Data()),(int)(long)u4->Data());
6075    return FALSE;
6076  }
6077  else
6078  {
6079    Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
6080    return TRUE;
6081  }
6082}
6083static BOOLEAN jjREDUCE5(leftv res, leftv u)
6084{
6085  leftv u1=u;
6086  leftv u2=u1->next;
6087  leftv u3=u2->next;
6088  leftv u4=u3->next;
6089  leftv u5=u4->next;
6090  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6091     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6092  {
6093    assumeStdFlag(u3);
6094    if(!mpIsDiagUnit((matrix)u2->Data()))
6095    {
6096      WerrorS("2nd argument must be a diagonal matrix of units");
6097      return TRUE;
6098    }
6099    res->rtyp=IDEAL_CMD;
6100    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6101                           mpCopy((matrix)u2->Data()),
6102                           (int)(long)u4->Data(),(intvec*)u5->Data());
6103    return FALSE;
6104  }
6105  else
6106  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6107     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6108  {
6109    assumeStdFlag(u3);
6110    if(!pIsUnit((poly)u2->Data()))
6111    {
6112      WerrorS("2nd argument must be a unit");
6113      return TRUE;
6114    }
6115    res->rtyp=POLY_CMD;
6116    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6117                           pCopy((poly)u2->Data()),
6118                           (int)(long)u4->Data(),(intvec*)u5->Data());
6119    return FALSE;
6120  }
6121  else
6122  {
6123    Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
6124           Tok2Cmdname(iiOp));
6125    return TRUE;
6126  }
6127}
6128static BOOLEAN jjRESERVED0(leftv res, leftv v)
6129{
6130  int i=1;
6131  loop
6132  {
6133    Print("%-20s",cmds[i].name);
6134    i++;
6135    if(cmds[i].name==NULL)
6136      break;
6137    if ((i%3)==1) PrintLn();
6138  }
6139  PrintLn();
6140  return FALSE;
6141}
6142static BOOLEAN jjSTRING_PL(leftv res, leftv v)
6143{
6144  if (v == NULL)
6145  {
6146    res->data = omStrDup("");
6147    return FALSE;
6148  }
6149  int n = v->listLength();
6150  if (n == 1)
6151  {
6152    res->data = v->String();
6153    return FALSE;
6154  }
6155
6156  char** slist = (char**) omAlloc(n*sizeof(char*));
6157  int i, j;
6158
6159  for (i=0, j=0; i<n; i++, v = v ->next)
6160  {
6161    slist[i] = v->String();
6162    assume(slist[i] != NULL);
6163    j+=strlen(slist[i]);
6164  }
6165  char* s = (char*) omAlloc((j+1)*sizeof(char));
6166  *s='\0';
6167  for (i=0;i<n;i++)
6168  {
6169    strcat(s, slist[i]);
6170    omFree(slist[i]);
6171  }
6172  omFreeSize(slist, n*sizeof(char*));
6173  res->data = s;
6174  return FALSE;
6175}
6176static BOOLEAN jjTEST(leftv res, leftv v)
6177{
6178  do
6179  {
6180    if (v->Typ()!=INT_CMD)
6181      return TRUE;
6182    test_cmd((int)(long)v->Data());
6183    v=v->next;
6184  }
6185  while (v!=NULL);
6186  return FALSE;
6187}
6188
6189#if defined(__alpha) && !defined(linux)
6190extern "C"
6191{
6192  void usleep(unsigned long usec);
6193};
6194#endif
6195
6196static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6197{
6198  if ((v->Typ() != LINK_CMD) ||
6199      (v->next->Typ() != STRING_CMD) ||
6200      (v->next->next->Typ() != STRING_CMD) ||
6201      (v->next->next->next->Typ() != INT_CMD))
6202    return TRUE;
6203  jjSTATUS3(res, v, v->next, v->next->next);
6204#if defined(HAVE_USLEEP)
6205  if (((long) res->data) == 0L)
6206  {
6207    int i_s = (int)(long) v->next->next->next->Data();
6208    if (i_s > 0)
6209    {
6210      usleep((int)(long) v->next->next->next->Data());
6211      jjSTATUS3(res, v, v->next, v->next->next);
6212    }
6213  }
6214#elif defined(HAVE_SLEEP)
6215  if (((int) res->data) == 0)
6216  {
6217    int i_s = (int) v->next->next->next->Data();
6218    if (i_s > 0)
6219    {
6220      sleep((is - 1)/1000000 + 1);
6221      jjSTATUS3(res, v, v->next, v->next->next);
6222    }
6223  }
6224#endif
6225  return FALSE;
6226}
6227static BOOLEAN jjSUBST_M(leftv res, leftv u)
6228{
6229  leftv v = u->next; // number of args > 0
6230  if (v==NULL) return TRUE;
6231  leftv w = v->next;
6232  if (w==NULL) return TRUE;
6233  leftv rest = w->next;;
6234
6235  u->next = NULL;
6236  v->next = NULL;
6237  w->next = NULL;
6238  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6239  if ((rest!=NULL) && (!b))
6240  {
6241    sleftv tmp_res;
6242    leftv tmp_next=res->next;
6243    res->next=rest;
6244    memset(&tmp_res,0,sizeof(tmp_res));
6245    b = iiExprArithM(&tmp_res,res,iiOp);
6246    memcpy(res,&tmp_res,sizeof(tmp_res));
6247    res->next=tmp_next;
6248  }
6249  u->next = v;
6250  v->next = w;
6251  // rest was w->next, but is already cleaned
6252  return b;
6253}
6254
6255/*=================== operations with many arg.: table =================*/
6256/* number_of_args:  -1: any, -2: any >0, .. */
6257struct sValCmdM dArithM[]=
6258{
6259// operations:
6260// proc         cmd               res            number_of_args plural
6261 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2       ALLOW_PLURAL}
6262,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0        ALLOW_PLURAL}
6263,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2       ALLOW_PLURAL}
6264,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2        ALLOW_PLURAL}
6265,{jjCOEF_M,    COEF_CMD,        NONE,               4        ALLOW_PLURAL}
6266,{jjCALL2ARG,  DIVISION_CMD,    ANY_TYPE/*or set by p*/,2    ALLOW_PLURAL}
6267,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,3    NO_PLURAL}
6268,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,4    NO_PLURAL}
6269,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2       ALLOW_PLURAL}
6270//,{jjEXPORTTO_M,  EXPORTTO_CMD,    NONE,             -2       ALLOW_PLURAL}
6271,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1        ALLOW_PLURAL}
6272,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1       ALLOW_PLURAL}
6273,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2        ALLOW_PLURAL}
6274,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2       ALLOW_PLURAL}
6275,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1        ALLOW_PLURAL}
6276,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2       ALLOW_PLURAL}
6277,{jjCALL2ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 2   ALLOW_PLURAL}
6278,{jjCALL3ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 3   ALLOW_PLURAL}
6279,{jjJET4,      JET_CMD,         POLY_CMD,/*or set by p*/ 4   ALLOW_PLURAL}
6280,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1       ALLOW_PLURAL}
6281,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1        ALLOW_PLURAL}
6282,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1       ALLOW_PLURAL}
6283,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1       ALLOW_PLURAL}
6284,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0       ALLOW_PLURAL}
6285,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 ALLOW_PLURAL}
6286,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  2 ALLOW_PLURAL}
6287,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  3 ALLOW_PLURAL}
6288,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  4 ALLOW_PLURAL}
6289,{jjREDUCE5,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  5 ALLOW_PLURAL}
6290,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1       ALLOW_PLURAL}
6291,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0       ALLOW_PLURAL}
6292,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1       ALLOW_PLURAL}
6293,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3        ALLOW_PLURAL}
6294,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2       ALLOW_PLURAL}
6295,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2       ALLOW_PLURAL}
6296,{jjTEST,      TEST_CMD,        NONE,               -2       ALLOW_PLURAL}
6297,{iiWRITE,     WRITE_CMD,       NONE,               -2       ALLOW_PLURAL}
6298,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2       ALLOW_PLURAL}
6299,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3       ALLOW_PLURAL}
6300,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4       ALLOW_PLURAL}
6301,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6       NO_PLURAL}
6302,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4       NO_PLURAL}
6303,{NULL,        0,               0,                   0       NO_PLURAL}
6304};
6305#ifdef MDEBUG
6306static Subexpr jjDBMakeSub(leftv e,char *f, int l)
6307#else
6308static Subexpr jjMakeSub(leftv e)
6309#endif
6310{
6311  assume( e->Typ()==INT_CMD );
6312  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
6313  r->start =(int)(long)e->Data();
6314  return r;
6315}
6316
6317/*================ generating tables ============================*/
6318#ifdef GENTABLE
6319extern struct sValAssign dAssign[];
6320struct sValCmdTab dArithTab1[]={ {0,0}};
6321#define JJTAB1LEN 0
6322struct sValCmdTab dArithTab2[]={ {0,0}};
6323#define JJTAB2LEN 0
6324void ttGen1()
6325{
6326  FILE *outfile = myfopen("iparith.inc","w");
6327  int i,j,l1=0,l2=0;
6328  currRing=(ring)omAllocBin(sip_sring_bin);
6329  fprintf(outfile,
6330  "/****************************************\n"
6331  "*  Computer Algebra System SINGULAR     *\n"
6332  "****************************************/\n\n");
6333/*-------------------------------------------------------------------*/
6334  fprintf(outfile,"// syntax table for Singular\n//\n");
6335  fprintf(outfile,"// - search for an exact match of the argument types\n");
6336  fprintf(outfile,"// - otherwise search for the first possibility\n");
6337  fprintf(outfile,"//   with converted types of the arguments\n");
6338  fprintf(outfile,"// - otherwise report an error\n//\n");
6339
6340  int op;
6341  i=0;
6342  while ((op=dArith1[i].cmd)!=0)
6343  {
6344    if (dArith1[i].p==jjWRONG)
6345      fprintf(outfile,"// DUMMY ");
6346    char *s = iiTwoOps(op);
6347    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
6348          s,
6349          Tok2Cmdname(dArith1[i].arg),
6350          Tok2Cmdname(ABS(dArith1[i].res)));
6351    i++;
6352  }
6353  fprintf(outfile,"/*---------------------------------------------*/\n");
6354  i=0;
6355  while ((op=dArith2[i].cmd)!=0)
6356  {
6357    if (dArith2[i].p==jjWRONG2)
6358      fprintf(outfile,"// DUMMY ");
6359    char *s = iiTwoOps(op);
6360    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
6361          s,
6362          Tok2Cmdname(dArith2[i].arg1),
6363          Tok2Cmdname(dArith2[i].arg2),
6364          Tok2Cmdname(dArith2[i].res));
6365    i++;
6366  }
6367  fprintf(outfile,"/*---------------------------------------------*/\n");
6368  i=0;
6369  while ((op=dArith3[i].cmd)!=0)
6370  {
6371    char *s = iiTwoOps(op);
6372    if (dArith3[i].p==jjWRONG3)
6373      fprintf(outfile,"// DUMMY ");
6374    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
6375          s,
6376          Tok2Cmdname(dArith3[i].arg1),
6377          Tok2Cmdname(dArith3[i].arg2),
6378          Tok2Cmdname(dArith3[i].arg3),
6379          Tok2Cmdname(dArith3[i].res));
6380    i++;
6381  }
6382  fprintf(outfile,"/*---------------------------------------------*/\n");
6383  i=0;
6384  while ((op=dArithM[i].cmd)!=0)
6385  {
6386    char *s = iiTwoOps(op);
6387    fprintf(outfile,"// operation: %s (...)  ->  %s",
6388          s,
6389          Tok2Cmdname(dArithM[i].res));
6390    switch(dArithM[i].number_of_args)
6391    {
6392      case -2:
6393         fprintf(outfile," ( number of arguments >0 )\n");
6394         break;
6395      case -1:
6396         fprintf(outfile," ( any number of arguments )\n");
6397         break;
6398      default:
6399         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
6400         break;
6401    }
6402    i++;
6403  }
6404  fprintf(outfile,"/*---------------------------------------------*/\n");
6405  i=0;
6406  while ((op=dAssign[i].res)!=0)
6407  {
6408    fprintf(outfile,"// assign: %s =  %s\n",
6409          Tok2Cmdname(op/*dAssign[i].res*/),
6410          Tok2Cmdname(dAssign[i].arg));
6411    i++;
6412  }
6413/*-------------------------------------------------------------------*/
6414  fprintf(outfile,"/*---------------------------------------------*/\n");
6415  for (j=257;j<=MAX_TOK+1;j++)
6416  {
6417    for(i=257;i<=MAX_TOK+1;i++)
6418    {
6419      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
6420      && iiTestConvert(i,j))
6421      {
6422        fprintf(outfile,"// convert %s -> %s\n",
6423          Tok2Cmdname(i), Tok2Cmdname(j));
6424        if (j==ANY_TYPE) break;
6425      }
6426    }
6427  }
6428  fprintf(outfile,"/*---------------------------------------------*/\n");
6429  char ops[]="=><+*/[.^,%(;";
6430  for(i=0;ops[i]!='\0';i++)
6431    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
6432  for (i=257;i<=MAX_TOK;i++)
6433  {
6434    char *s=iiTwoOps(i);
6435    if (s[0]!='$')
6436    {
6437      fprintf(outfile,"// token %d : %s\n", i, s);
6438    }
6439  }
6440/*-------------------------------------------------------------------*/
6441  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
6442/*-------------------------------------------------------------------*/
6443  fprintf(outfile,"/*---------------------------------------------*/\n");
6444  fprintf(outfile,
6445  "struct sValCmdTab dArithTab1[]=\n"
6446  "{\n");
6447  for (j=1;j<=MAX_TOK+1;j++)
6448  {
6449    for(i=0;dArith1[i].cmd!=0;i++)
6450    {
6451      if (dArith1[i].cmd==j)
6452      {
6453        fprintf(outfile," { %d,%d },\n",j,i);
6454        l1++;
6455        break;
6456      }
6457    }
6458  }
6459  fprintf(outfile," { 10000,0 }\n};\n");
6460  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
6461/*-------------------------------------------------------------------*/
6462  fprintf(outfile,
6463  "struct sValCmdTab dArithTab2[]=\n"
6464  "{\n");
6465  for (j=1;j<=MAX_TOK+1;j++)
6466  {
6467    for(i=0;dArith2[i].cmd!=0;i++)
6468    {
6469      if (dArith2[i].cmd==j)
6470      {
6471        fprintf(outfile," { %d,%d },\n",j,i);
6472        l2++;
6473        break;
6474      }
6475    }
6476  }
6477  fprintf(outfile," { 10000,0 }\n};\n");
6478  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
6479  fclose(outfile);
6480}
6481/*-------------------------------------------------------------------*/
6482void ttGen2()
6483{
6484  FILE *outfile = myfopen("iparith.inc","a");
6485  fprintf(outfile,
6486  "/****************************************\n"
6487  "*  Computer Algebra System SINGULAR     *\n"
6488  "****************************************/\n\n");
6489/*-------------------------------------------------------------------*/
6490  fprintf(outfile,"// identifier table for Singular\n//\n");
6491
6492  fprintf(outfile,
6493  "cmdnames cmds[] =\n"
6494  "{  // name-string     alias  tokval toktype\n"
6495  "{ \"$INVALID$\",            0,  -1, 0},\n");
6496  int i=1;
6497  int m=-1;
6498  int id_nr=0;
6499  BOOLEAN f=FALSE;
6500  loop
6501  {
6502    while (cmds[i].tokval!=0)
6503    {
6504      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
6505      {
6506        if(m==-1)
6507        {
6508          m=i;
6509          f=TRUE;
6510        }
6511        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6512        {
6513          m=i;
6514          f=TRUE;
6515        }
6516      }
6517      i++;
6518    }
6519    if(f)
6520    {
6521      id_nr++;
6522      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
6523      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
6524                                             20-strlen(cmds[m].name),
6525                                             cmds[m].alias,
6526                                             cmds[m].tokval);
6527      switch(cmds[m].toktype)
6528      {
6529        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
6530        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
6531        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
6532        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
6533        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
6534        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
6535        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
6536        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
6537        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
6538        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
6539        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
6540        case NONE:             fprintf(outfile,"NONE },\n"); break;
6541        default:               if((cmds[m].toktype>' ')
6542                               &&(cmds[m].toktype<127))
6543                               {
6544                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
6545                               }
6546                               else
6547                               {
6548                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
6549                               }
6550                               break;
6551      }
6552      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
6553      cmds[m].name=NULL;
6554      m=-1;
6555      i=1;
6556      f=FALSE;
6557    }
6558    else break;
6559  }
6560  fprintf(outfile,
6561"/* list of scanner identifiers/only for feread/reservedName */\n");
6562  f=FALSE;
6563  i=1;m=-1;
6564  loop
6565  {
6566    while (cmds[i].tokval!=0)
6567    {
6568      if (cmds[i].name!=NULL)
6569      {
6570        if(m==-1)
6571        {
6572          m=i;
6573          f=TRUE;
6574        }
6575        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6576        {
6577          m=i;
6578          f=TRUE;
6579        }
6580      }
6581      i++;
6582    }
6583    if(f)
6584    {
6585      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
6586                                             20-strlen(cmds[m].name),
6587                                             0/*cmds[m].alias*/
6588                                             /*-1 cmds[m].tokval*/
6589                                             /*0 cmds[m].toktype*/);
6590      cmds[m].name=NULL;
6591      m=-1;
6592      i=1;
6593      f=FALSE;
6594    }
6595    else break;
6596  }
6597  fprintf(outfile,
6598"/* end of list marker */\n"
6599"  { NULL, 0, 0, 0}\n"
6600"};\n"
6601"#ifdef HAVE_RTIMER\n"
6602"#define LAST_IDENTIFIER %d\n"
6603"#else\n"
6604"#define LAST_IDENTIFIER %d\n"
6605"#endif\n",id_nr,id_nr-1);
6606  fclose(outfile);
6607}
6608/*-------------------------------------------------------------------*/
6609#if 0
6610void ttGen3()
6611{
6612  FILE *outfile = myfopen("mpsr_tok.inc","w");
6613  fprintf(outfile,
6614  "/****************************************\n"
6615  "*  Computer Algebra System SINGULAR     *\n"
6616  "****************************************/\n\n");
6617/*-------------------------------------------------------------------*/
6618  fprintf(outfile,"// token table for Singular\n//\n");
6619
6620  fprintf(outfile,
6621  "short vtok[] =\n"
6622  "{\n");
6623  // operations with 1 arg: ===========================================
6624  int i=0;
6625  while (dArith1[i].cmd!=0)
6626  {
6627    if ((dArith1[i].p!=jjWRONG)
6628    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
6629    {
6630      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
6631    }
6632    i++;
6633  }
6634  // operations with 2 args: ===========================================
6635  i=0;
6636  while (dArith2[i].cmd!=0)
6637  {
6638    if ((dArith2[i].p!=jjWRONG2)
6639    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
6640    {
6641      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
6642    }
6643    i++;
6644  }
6645  // operations with 3 args: ===========================================
6646  i=0;
6647  while (dArith3[i].cmd!=0)
6648  {
6649    if (
6650    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
6651    {
6652      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
6653    }
6654    i++;
6655  }
6656  // operations with many args: ===========================================
6657  i=0;
6658  while (dArithM[i].cmd!=0)
6659  {
6660    if (
6661    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
6662    {
6663      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
6664    }
6665    i++;
6666  }
6667  // ====================================================================
6668  fprintf(outfile,
6669  "/* end of list marker */\n"
6670  " %d };\n",MAX_TOK);
6671  fclose(outfile);
6672}
6673#endif
6674void ttGen4()
6675{
6676  FILE *outfile = myfopen("plural_cmd.inc","w");
6677  int i;
6678  char *old_s="";
6679  fprintf(outfile,
6680  "@c *****************************************\n"
6681  "@c *  Computer Algebra System SINGULAR     *\n"
6682  "@c *****************************************\n\n");
6683/*-------------------------------------------------------------------*/
6684  fprintf(outfile,"@multicolumn .45 .45\n");
6685  int op;
6686  i=0;
6687  while ((op=dArith1[i].cmd)!=0)
6688  {
6689    if (dArith1[i].p!=jjWRONG)
6690    {
6691      char *s = iiTwoOps(op);
6692      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6693      {
6694        old_s=s;
6695        switch (dArith1[i].valid_for_plural)
6696        {
6697          case NO_PLURAL_N:
6698            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6699            break;
6700          case ALLOW_PLURAL_N:
6701            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6702            break;
6703          case COMM_PLURAL_N:
6704            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6705            break;
6706        }
6707      }
6708    }
6709    i++;
6710  }
6711  fprintf(outfile,"@c ---------------------------------------------\n");
6712  i=0;
6713  while ((op=dArith2[i].cmd)!=0)
6714  {
6715    if (dArith2[i].p!=jjWRONG2)
6716    {
6717      char *s = iiTwoOps(op);
6718      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6719      {
6720        old_s=s;
6721        switch (dArith2[i].valid_for_plural)
6722        {
6723          case NO_PLURAL_N:
6724            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6725            break;
6726          case ALLOW_PLURAL_N:
6727            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6728            break;
6729          case COMM_PLURAL_N:
6730            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6731            break;
6732        }
6733      }
6734    }
6735    i++;
6736  }
6737  fprintf(outfile,"@c ---------------------------------------------\n");
6738  i=0;
6739  while ((op=dArith3[i].cmd)!=0)
6740  {
6741    char *s = iiTwoOps(op);
6742    if (dArith3[i].p!=jjWRONG3)
6743    {
6744      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6745      {
6746        old_s=s;
6747        switch (dArith3[i].valid_for_plural)
6748        {
6749          case NO_PLURAL_N:
6750            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6751            break;
6752          case ALLOW_PLURAL_N:
6753            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6754            break;
6755          case COMM_PLURAL_N:
6756            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6757            break;
6758        }
6759      }
6760    }
6761    i++;
6762  }
6763  fprintf(outfile,"@c ---------------------------------------------\n");
6764  i=0;
6765  while ((op=dArithM[i].cmd)!=0)
6766  {
6767    char *s = iiTwoOps(op);
6768    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6769    {
6770        old_s=s;
6771        switch (dArithM[i].valid_for_plural)
6772        {
6773          case NO_PLURAL_N:
6774            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6775            break;
6776          case ALLOW_PLURAL_N:
6777            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6778            break;
6779          case COMM_PLURAL_N:
6780            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6781            break;
6782        }
6783    }
6784    i++;
6785  }
6786  fprintf(outfile,"@c ---------------------------------------------\n");
6787  fprintf(outfile,"@end table\n");
6788  fclose(outfile);
6789}
6790/*-------------------------------------------------------------------*/
6791#else
6792#include "iparith.inc"
6793#endif
6794
6795/*=================== operations with 2 args. ============================*/
6796
6797BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
6798{
6799#ifndef GENTABLE
6800  memset(res,0,sizeof(sleftv));
6801
6802  if (!errorreported)
6803  {
6804#ifdef SIQ
6805    if (siq>0)
6806    {
6807      //Print("siq:%d\n",siq);
6808      command d=(command)omAlloc0Bin(ip_command_bin);
6809      memcpy(&d->arg1,a,sizeof(sleftv));
6810      memcpy(&d->arg2,b,sizeof(sleftv));
6811      d->argc=2;
6812      d->op=op;
6813      res->data=(char *)d;
6814      res->rtyp=COMMAND;
6815      return FALSE;
6816    }
6817#endif
6818    int at=a->Typ();
6819    int bt=b->Typ();
6820    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
6821    int index=i;
6822
6823    iiOp=op;
6824    while (dArith2[i].cmd==op)
6825    {
6826      if ((at==dArith2[i].arg1)
6827      && (bt==dArith2[i].arg2))
6828      {
6829        res->rtyp=dArith2[i].res;
6830        #ifdef HAVE_PLURAL
6831        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6832        {
6833          if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6834          {
6835            WerrorS(ii_not_for_plural);
6836            break;
6837          }
6838          else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6839          {
6840            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6841          }
6842          /* else ALLOW_PLURAL */
6843        }
6844        #endif
6845        if (dArith2[i].p(res,a,b))
6846        {
6847          break;// leave loop, goto error handling
6848        }
6849        a->CleanUp();
6850        b->CleanUp();
6851        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6852        return FALSE;
6853      }
6854      i++;
6855    }
6856    // implicite type conversion ----------------------------------------------
6857    if (dArith2[i].cmd!=op)
6858    {
6859      int ai,bi;
6860      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6861      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
6862      BOOLEAN failed=FALSE;
6863      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6864      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
6865      while (dArith2[i].cmd==op)
6866      {
6867        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6868        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
6869        {
6870          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
6871          {
6872            res->rtyp=dArith2[i].res;
6873            #ifdef HAVE_PLURAL
6874            if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6875            {
6876              if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6877              {
6878                WerrorS(ii_not_for_plural);
6879                break;
6880              }
6881              else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6882              {
6883                Warn("assume commutative subalgebra for cmd `%s`",
6884                      Tok2Cmdname(i));
6885              }
6886              /* else ALLOW_PLURAL */
6887            }
6888            #endif
6889            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
6890            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
6891            || (dArith2[i].p(res,an,bn)));
6892            // everything done, clean up temp. variables
6893            if (failed)
6894            {
6895              // leave loop, goto error handling
6896              break;
6897            }
6898            else
6899            {
6900              // everything ok, clean up and return
6901              an->CleanUp();
6902              bn->CleanUp();
6903              omFreeBin((ADDRESS)an, sleftv_bin);
6904              omFreeBin((ADDRESS)bn, sleftv_bin);
6905              a->CleanUp();
6906              b->CleanUp();
6907              return FALSE;
6908            }
6909          }
6910        }
6911        i++;
6912      }
6913      an->CleanUp();
6914      bn->CleanUp();
6915      omFreeBin((ADDRESS)an, sleftv_bin);
6916      omFreeBin((ADDRESS)bn, sleftv_bin);
6917    }
6918    // error handling ---------------------------------------------------
6919    const char *s=NULL;
6920    if (!errorreported)
6921    {
6922      if ((at==0) && (a->Fullname()!=sNoName))
6923      {
6924        s=a->Fullname();
6925      }
6926      else if ((bt==0) && (b->Fullname()!=sNoName))
6927      {
6928        s=b->Fullname();
6929      }
6930      if (s!=NULL)
6931        Werror("`%s` is not defined",s);
6932      else
6933      {
6934        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6935        s = iiTwoOps(op);
6936        if (proccall)
6937        {
6938          Werror("%s(`%s`,`%s`) is not supported"
6939                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
6940        }
6941        else
6942        {
6943          Werror("`%s` %s `%s` is not supported"
6944                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
6945        }
6946        if (BVERBOSE(V_SHOW_USE))
6947        {
6948          while (dArith2[i].cmd==op)
6949          {
6950            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
6951            && (dArith2[i].res!=0)
6952            && (dArith2[i].p!=jjWRONG2))
6953            {
6954              if (proccall)
6955                Werror("expected %s(`%s`,`%s`)"
6956                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6957              else
6958                Werror("expected `%s` %s `%s`"
6959                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
6960            }
6961            i++;
6962          }
6963        }
6964      }
6965    }
6966    res->rtyp = UNKNOWN;
6967  }
6968  a->CleanUp();
6969  b->CleanUp();
6970#endif
6971  return TRUE;
6972}
6973
6974/*==================== operations with 1 arg. ===============================*/
6975
6976BOOLEAN iiExprArith1(leftv res, leftv a, int op)
6977{
6978#ifndef GENTABLE
6979  memset(res,0,sizeof(sleftv));
6980
6981  if (!errorreported)
6982  {
6983#ifdef SIQ
6984    if (siq>0)
6985    {
6986      //Print("siq:%d\n",siq);
6987      command d=(command)omAlloc0Bin(ip_command_bin);
6988      memcpy(&d->arg1,a,sizeof(sleftv));
6989      d->op=op;
6990      d->argc=1;
6991      res->data=(char *)d;
6992      res->rtyp=COMMAND;
6993      return FALSE;
6994    }
6995#endif
6996    int at=a->Typ();
6997    BOOLEAN failed=FALSE;
6998
6999    iiOp=op;
7000    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
7001    int ti = i;
7002    while (dArith1[i].cmd==op)
7003    {
7004      if (at==dArith1[i].arg)
7005      {
7006        int r=res->rtyp=dArith1[i].res;
7007        #ifdef HAVE_PLURAL
7008        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7009        {
7010          if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
7011          {
7012            WerrorS(ii_not_for_plural);
7013            break;
7014          }
7015          else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7016          {
7017            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7018          }
7019          /* else ALLOW_PLURAL */
7020        }
7021        #endif
7022        if (r<0)
7023        {
7024          res->rtyp=-r;
7025          #ifdef PROC_BUG
7026          dArith1[i].p(res,a);
7027          #else
7028          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
7029          #endif
7030        }
7031        else if (dArith1[i].p(res,a))
7032        {
7033          break;// leave loop, goto error handling
7034        }
7035        if (a->Next()!=NULL)
7036        {
7037          res->next=(leftv)omAllocBin(sleftv_bin);
7038          failed=iiExprArith1(res->next,a->next,op);
7039        }
7040        a->CleanUp();
7041        return failed;
7042      }
7043      i++;
7044    }
7045    // implicite type conversion --------------------------------------------
7046    if (dArith1[i].cmd!=op)
7047    {
7048      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7049      i=ti;
7050      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
7051      while (dArith1[i].cmd==op)
7052      {
7053        int ai;
7054        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
7055        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
7056        {
7057          int r=res->rtyp=dArith1[i].res;
7058          #ifdef HAVE_PLURAL
7059          if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7060          {
7061            if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
7062            {
7063              WerrorS(ii_not_for_plural);
7064              break;
7065            }
7066            else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7067            {
7068              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7069            }
7070            /* else ALLOW_PLURAL */
7071          }
7072          #endif
7073          if (r<0)
7074          {
7075            res->rtyp=-r;
7076            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
7077            if (!failed)
7078            {
7079              #ifdef PROC_BUG
7080              dArith1[i].p(res,a);
7081              #else
7082              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
7083              #endif
7084            }
7085          }
7086          else
7087          {
7088            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
7089            || (dArith1[i].p(res,an)));
7090          }
7091          // everything done, clean up temp. variables
7092          if (failed)
7093          {
7094            // leave loop, goto error handling
7095            break;
7096          }
7097          else
7098          {
7099            if (an->Next() != NULL)
7100            {
7101              res->next = (leftv)omAllocBin(sleftv_bin);
7102              failed=iiExprArith1(res->next,an->next,op);
7103            }
7104            // everything ok, clean up and return
7105            an->CleanUp();
7106            omFreeBin((ADDRESS)an, sleftv_bin);
7107            a->CleanUp();
7108            return failed;
7109          }
7110        }
7111        i++;
7112      }
7113      an->CleanUp();
7114      omFreeBin((ADDRESS)an, sleftv_bin);
7115    }
7116    // error handling
7117    if (!errorreported)
7118    {
7119      if ((at==0) && (a->Fullname()!=sNoName))
7120      {
7121        Werror("`%s` is not defined",a->Fullname());
7122      }
7123      else
7124      {
7125        i=ti;
7126        char *s = iiTwoOps(op);
7127        Werror("%s(`%s`) is not supported"
7128                ,s,Tok2Cmdname(at));
7129        if (BVERBOSE(V_SHOW_USE))
7130        {
7131          while (dArith1[i].cmd==op)
7132          {
7133            if ((dArith1[i].res!=0)
7134            && (dArith1[i].p!=jjWRONG))
7135              Werror("expected %s(`%s`)"
7136                ,s,Tok2Cmdname(dArith1[i].arg));
7137            i++;
7138          }
7139        }
7140      }
7141    }
7142    res->rtyp = UNKNOWN;
7143  }
7144  a->CleanUp();
7145#endif
7146  return TRUE;
7147}
7148
7149/*=================== operations with 3 args. ============================*/
7150
7151BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
7152{
7153#ifndef GENTABLE
7154  memset(res,0,sizeof(sleftv));
7155
7156  if (!errorreported)
7157  {
7158#ifdef SIQ
7159    if (siq>0)
7160    {
7161      //Print("siq:%d\n",siq);
7162      command d=(command)omAlloc0Bin(ip_command_bin);
7163      memcpy(&d->arg1,a,sizeof(sleftv));
7164      memcpy(&d->arg2,b,sizeof(sleftv));
7165      memcpy(&d->arg3,c,sizeof(sleftv));
7166      d->op=op;
7167      d->argc=3;
7168      res->data=(char *)d;
7169      res->rtyp=COMMAND;
7170      return FALSE;
7171    }
7172#endif
7173    int at=a->Typ();
7174    int bt=b->Typ();
7175    int ct=c->Typ();
7176
7177    iiOp=op;
7178    int i=0;
7179    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7180    while (dArith3[i].cmd==op)
7181    {
7182      if ((at==dArith3[i].arg1)
7183      && (bt==dArith3[i].arg2)
7184      && (ct==dArith3[i].arg3))
7185      {
7186        res->rtyp=dArith3[i].res;
7187        #ifdef HAVE_PLURAL
7188        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7189        {
7190            if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7191            {
7192              WerrorS(ii_not_for_plural);
7193              break;
7194            }
7195            else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7196            {
7197              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7198            }
7199            /* else ALLOW_PLURAL */
7200        }
7201        #endif
7202        if (dArith3[i].p(res,a,b,c))
7203        {
7204          break;// leave loop, goto error handling
7205        }
7206        a->CleanUp();
7207        b->CleanUp();
7208        c->CleanUp();
7209        return FALSE;
7210      }
7211      i++;
7212    }
7213    // implicite type conversion ----------------------------------------------
7214    if (dArith3[i].cmd!=op)
7215    {
7216      int ai,bi,ci;
7217      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7218      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7219      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
7220      BOOLEAN failed=FALSE;
7221      i=0;
7222      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7223      while (dArith3[i].cmd==op)
7224      {
7225        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
7226        {
7227          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
7228          {
7229            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
7230            {
7231              res->rtyp=dArith3[i].res;
7232              #ifdef HAVE_PLURAL
7233              if ((currRing!=NULL)
7234              && (rIsPluralRing(currRing)))
7235              {
7236                if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7237                {
7238                   WerrorS(ii_not_for_plural);
7239                   break;
7240                 }
7241                 else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7242                 {
7243                   Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7244                 }
7245                 /* else ALLOW_PLURAL */
7246              }
7247              #endif
7248              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
7249                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
7250                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
7251                || (dArith3[i].p(res,an,bn,cn)));
7252              // everything done, clean up temp. variables
7253              if (failed)
7254              {
7255                // leave loop, goto error handling
7256                break;
7257              }
7258              else
7259              {
7260                // everything ok, clean up and return
7261                an->CleanUp();
7262                bn->CleanUp();
7263                cn->CleanUp();
7264                omFreeBin((ADDRESS)an, sleftv_bin);
7265                omFreeBin((ADDRESS)bn, sleftv_bin);
7266                omFreeBin((ADDRESS)cn, sleftv_bin);
7267                a->CleanUp();
7268                b->CleanUp();
7269                c->CleanUp();
7270        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7271                return FALSE;
7272              }
7273            }
7274          }
7275        }
7276        i++;
7277      }
7278      an->CleanUp();
7279      bn->CleanUp();
7280      cn->CleanUp();
7281      omFreeBin((ADDRESS)an, sleftv_bin);
7282      omFreeBin((ADDRESS)bn, sleftv_bin);
7283      omFreeBin((ADDRESS)cn, sleftv_bin);
7284    }
7285    // error handling ---------------------------------------------------
7286    if (!errorreported)
7287    {
7288      const char *s=NULL;
7289      if ((at==0) && (a->Fullname()!=sNoName))
7290      {
7291        s=a->Fullname();
7292      }
7293      else if ((bt==0) && (b->Fullname()!=sNoName))
7294      {
7295        s=b->Fullname();
7296      }
7297      else if ((ct==0) && (c->Fullname()!=sNoName))
7298      {
7299        s=c->Fullname();
7300      }
7301      if (s!=NULL)
7302        Werror("`%s` is not defined",s);
7303      else
7304      {
7305        i=0;
7306        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7307        char *s = iiTwoOps(op);
7308        Werror("%s(`%s`,`%s`,`%s`) is not supported"
7309                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
7310        if (BVERBOSE(V_SHOW_USE))
7311        {
7312          while (dArith3[i].cmd==op)
7313          {
7314            if(((at==dArith3[i].arg1)
7315            ||(bt==dArith3[i].arg2)
7316            ||(ct==dArith3[i].arg3))
7317            && (dArith3[i].res!=0))
7318            {
7319              Werror("expected %s(`%s`,`%s`,`%s`)"
7320                  ,s,Tok2Cmdname(dArith3[i].arg1)
7321                  ,Tok2Cmdname(dArith3[i].arg2)
7322                  ,Tok2Cmdname(dArith3[i].arg3));
7323            }
7324            i++;
7325          }
7326        }
7327      }
7328    }
7329    res->rtyp = UNKNOWN;
7330  }
7331  a->CleanUp();
7332  b->CleanUp();
7333  c->CleanUp();
7334        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7335#endif
7336  return TRUE;
7337}
7338/*==================== operations with many arg. ===============================*/
7339
7340BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
7341{
7342  // cnt = 0: all
7343  // cnt = 1: only first one
7344  leftv next;
7345  BOOLEAN failed = TRUE;
7346  if(v==NULL) return failed;
7347  res->rtyp = LIST_CMD;
7348  if(cnt) v->next = NULL;
7349  next = v->next;             // saving next-pointer
7350  failed = jjLIST_PL(res, v);
7351  v->next = next;             // writeback next-pointer
7352  return failed;
7353}
7354
7355BOOLEAN iiExprArithM(leftv res, leftv a, int op)
7356{
7357#ifndef GENTABLE
7358  memset(res,0,sizeof(sleftv));
7359
7360  if (!errorreported)
7361  {
7362#ifdef SIQ
7363    if (siq>0)
7364    {
7365      //Print("siq:%d\n",siq);
7366      command d=(command)omAlloc0Bin(ip_command_bin);
7367      d->op=op;
7368      res->data=(char *)d;
7369      if (a!=NULL)
7370      {
7371        d->argc=a->listLength();
7372        // else : d->argc=0;
7373        memcpy(&d->arg1,a,sizeof(sleftv));
7374        switch(d->argc)
7375        {
7376          case 3:
7377            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
7378            a->next->next->rtyp=0;
7379            a->next->next->data=NULL;
7380            a->next->next->name=NULL;
7381            a->next->next->attribute=NULL;
7382            /* no break */
7383          case 2:
7384            memcpy(&d->arg2,a->next,sizeof(sleftv));
7385            a->next->rtyp=0;
7386            a->next->name=NULL;
7387            a->next->data=NULL;
7388            a->next->attribute=NULL;
7389            d->arg2.next=NULL;
7390            /* no break */
7391          case 1:
7392            d->arg1.next=NULL;
7393        }
7394        if (d->argc>3) a->next=NULL;
7395        a->rtyp=0;
7396        a->data=NULL;
7397        a->name=NULL;
7398        a->CleanUp();
7399      }
7400      res->rtyp=COMMAND;
7401      return FALSE;
7402    }
7403#endif
7404    BOOLEAN failed=FALSE;
7405    int args=0;
7406    if (a!=NULL) args=a->listLength();
7407
7408    iiOp=op;
7409    int i=0;
7410    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
7411    while (dArithM[i].cmd==op)
7412    {
7413      if ((args==dArithM[i].number_of_args)
7414      || (dArithM[i].number_of_args==-1)
7415      || ((dArithM[i].number_of_args==-2)&&(args>0)))
7416      {
7417        res->rtyp=dArithM[i].res;
7418        #ifdef HAVE_PLURAL
7419        if ((currRing!=NULL)
7420        && (rIsPluralRing(currRing)))
7421        {
7422          if (dArithM[i].valid_for_plural==0 /*NO_PLURAL*/)
7423          {
7424            WerrorS(ii_not_for_plural);
7425            break;
7426          }
7427          else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
7428          {
7429            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7430          }
7431          /* else ALLOW_PLURAL */
7432        }
7433        #endif
7434        if (dArithM[i].p(res,a))
7435        {
7436          break;// leave loop, goto error handling
7437        }
7438        if (a!=NULL) a->CleanUp();
7439        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7440        return failed;
7441      }
7442      i++;
7443    }
7444    // error handling
7445    if (!errorreported)
7446    {
7447      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
7448      {
7449        Werror("`%s` is not defined",a->Fullname());
7450      }
7451      else
7452      {
7453        char *s = iiTwoOps(op);
7454        Werror("%s(...) is not supported",s);
7455      }
7456    }
7457    res->rtyp = UNKNOWN;
7458  }
7459  if (a!=NULL) a->CleanUp();
7460        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7461#endif
7462  return TRUE;
7463}
7464
7465/*=================== general utilities ============================*/
7466int IsCmd(const char *n, int & tok)
7467{
7468  int an=1;
7469  int i,v;
7470#ifndef GENTABLE
7471  int en=LAST_IDENTIFIER;
7472
7473  loop
7474  {
7475    if(an>=en-1)
7476    {
7477      if (strcmp(n, cmds[an].name) == 0)
7478      {
7479        i=an;
7480        break;
7481      }
7482      else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
7483      {
7484        i=en;
7485        break;
7486      }
7487      else
7488      {
7489        return 0;
7490      }
7491    }
7492    i=(an+en)/2;
7493    if (*n < *(cmds[i].name))
7494    {
7495      en=i-1;
7496    }
7497    else if (*n > *(cmds[i].name))
7498    {
7499      an=i+1;
7500    }
7501    else
7502    {
7503      v=strcmp(n,cmds[i].name);
7504      if(v<0)
7505      {
7506        en=i-1;
7507      }
7508      else if(v>0)
7509      {
7510        an=i+1;
7511      }
7512      else /*v==0*/
7513      {
7514        break;
7515      }
7516    }
7517  }
7518  lastreserved=cmds[i].name;
7519  tok=cmds[i].tokval;
7520  if(cmds[i].alias==2)
7521  {
7522    Warn("outdated identifier `%s` used - please change your code",
7523    cmds[i].name);
7524    cmds[i].alias=1;
7525  }
7526  if (currRingHdl==NULL)
7527  {
7528    #ifdef SIQ
7529    if (siq<=0)
7530    {
7531    #endif
7532      if ((tok>=BEGIN_RING) && (tok<=END_RING))
7533      {
7534        WerrorS("no ring active");
7535        return 0;
7536      }
7537    #ifdef SIQ
7538    }
7539    #endif
7540  }
7541  if (!expected_parms)
7542  {
7543    switch (tok)
7544    {
7545      case IDEAL_CMD:
7546      case INT_CMD:
7547      case INTVEC_CMD:
7548      case MAP_CMD:
7549      case MATRIX_CMD:
7550      case MODUL_CMD:
7551      case POLY_CMD:
7552      case PROC_CMD:
7553      case RING_CMD:
7554      case STRING_CMD:
7555        cmdtok = tok;
7556        break;
7557    }
7558  }
7559  return cmds[i].toktype;
7560#else
7561  return 0;
7562#endif
7563}
7564static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
7565{
7566#ifndef GENTABLE
7567  int a=0;
7568  int e=len;
7569  int p=len/2;
7570  do
7571  {
7572     if (op==dArithTab[p].cmd) return dArithTab[p].start;
7573     if (op<dArithTab[p].cmd) e=p-1;
7574     else   a = p+1;
7575     p=a+(e-a)/2;
7576  }
7577  while ( a <= e);
7578
7579#endif
7580  assume(0);
7581  return 0;
7582}
7583
Note: See TracBrowser for help on using the repository browser.