source: git/Singular/iparith.cc @ b4ab6fb

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