source: git/Singular/iparith.cc @ 4d5149

fieker-DuValspielwiese
Last change on this file since 4d5149 was 4d5149, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes: int and 64bit systems git-svn-id: file:///usr/local/Singular/svn/trunk@8826 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 216.1 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.386 2005-11-30 14:17:42 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)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 ((!idHomModule(u_id,currQuotient,&w_v))
2061       || (!idHomModule(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  if (w!=NULL)
2619  {
2620    w=ivCopy(w);
2621    hom=isHomog;
2622  }
2623  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
2624  idSkipZeroes(result);
2625  res->data = (char *)result;
2626  setFlag(res,FLAG_STD);
2627  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2628  return FALSE;
2629}
2630static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2631{
2632  assumeStdFlag(u);
2633  ideal result;
2634  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2635  tHomog hom=testHomog;
2636  if (w!=NULL)
2637  {
2638    w=ivCopy(w);
2639    hom=isHomog;
2640  }
2641  ideal i1=(ideal)u->Data();
2642  ideal i0=idInit(1,i1->rank);
2643  i0->m[0]=(poly)v->Data();
2644  i1=idSimpleAdd(i1,i0);
2645  i0->m[0]=NULL;
2646  idDelete(&i0);
2647  BITSET save_test=test;
2648  test|=Sy_bit(OPT_SB_1);
2649  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2650  test=save_test;
2651  idDelete(&i1);
2652  idSkipZeroes(result);
2653  res->data = (char *)result;
2654  setFlag(res,FLAG_STD);
2655  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2656  return FALSE;
2657}
2658static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2659{
2660  idhdl h=(idhdl)u->data;
2661  int i=(int)(long)v->Data();
2662  if ((0<i) && (i<=IDRING(h)->N))
2663    res->data=omStrDup(IDRING(h)->names[i-1]);
2664  else
2665  {
2666    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2667    return TRUE;
2668  }
2669  return FALSE;
2670}
2671static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2672{
2673  res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2674  return FALSE;
2675}
2676#define jjWRONG2 (proc2)jjWRONG
2677#define jjWRONG3 (proc3)jjWRONG
2678static BOOLEAN jjWRONG(leftv res, leftv u)
2679{
2680  return TRUE;
2681}
2682
2683static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2684{
2685  char * s=(char *)u->Data();
2686  if(strcmp(s, "with")==0)
2687    return jjLOAD(res, v, TRUE);
2688  WerrorS("invalid second argument");
2689  WerrorS("load(\"libname\" [,\"with\"]);");
2690  return TRUE;
2691}
2692
2693/*=================== operations with 2 args.: table =================*/
2694
2695struct sValCmd2 dArith2[]=
2696{
2697// operations:
2698// proc        cmd              res             arg1        arg2   plural
2699 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2700,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2701,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2702,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2703,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2704,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2705,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2706,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
2707,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2708,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2709,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
2710,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2711,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2712,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2713,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2714,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2715,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2716,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
2717,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
2718,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  RING_CMD ALLOW_PLURAL}
2719,{jjRSUM,      '+',            QRING_CMD,      RING_CMD,   QRING_CMD ALLOW_PLURAL}
2720,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  QRING_CMD ALLOW_PLURAL}
2721,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2722,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2723,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2724,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2725,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2726,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2727,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2728,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2729,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2730,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2731,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2732,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2733,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2734,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
2735,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2736,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2737,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2738,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2739,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2740,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2741,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2742,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2743,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2744,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
2745,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2746,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2747,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2748,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD ALLOW_PLURAL}
2749,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2750,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2751,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2752,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2753,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2754,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2755,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2756,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2757,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2758,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2759,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2760,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2761,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2762,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2763,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2764,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2765,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2766,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2767,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2768,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2769,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2770,{jjMOD_N,     '%',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2771,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2772,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2773,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2774,{jjMOD_N,     INTMOD_CMD,     NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2775,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2776,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2777,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2778,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2779,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2780,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2781,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2782,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2783,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2784,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2785,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2786,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2787,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2788,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2789,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2790,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2791,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2792,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2793,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2794,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2795,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2796,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2797,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2798,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2799,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2800,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2801,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2802,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2803,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2804,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2805,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2806,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2807,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2808,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2809,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2810,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2811,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2812,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2813,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2814,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2815,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2816,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2817,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2818,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2819,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2820,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2821,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2822,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2823,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2824,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2825,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2826,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2827,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2828,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2829,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2830,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2831,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2832,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2833,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2834,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
2835,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2836,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2837,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2838,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
2839,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2840,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2841,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2842,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
2843,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2844,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2845,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2846,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2847,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2848,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2849,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2850,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2851,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
2852,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2853,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2854// and the procedures with 2 arguments:
2855,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
2856,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2857,{jjBETTI2,    BETTI_CMD,      INTMAT_CMD,     LIST_CMD,   INT_CMD ALLOW_PLURAL}
2858,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2859,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2860,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2861#ifdef HAVE_PLURAL
2862,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2863#endif
2864,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2865,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2866,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2867,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2868,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2869,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2870,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2871,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2872,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2873,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
2874,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2875,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2876,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2877,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2878,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2879,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2880,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2881,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2882,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2883,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
2884,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2885,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2886,{jjEXPORTTO,  EXPORTTO_CMD,   NONE,           PACKAGE_CMD, IDHDL ALLOW_PLURAL}
2887,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
2888#ifdef HAVE_FACTORY
2889,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2890,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2891,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2892#else
2893,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2894,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2895,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2896#endif
2897,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2898,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2899#ifdef HAVE_FGLM
2900,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2901,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2902,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
2903#else
2904,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2905,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2906,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2907#endif
2908,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2909,{jjFWALK,     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2910
2911,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2912,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2913#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
2914,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2915#else
2916,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2917#endif
2918,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
2919,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
2920,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2921,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2922,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2923,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2924,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2925,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2926,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2927,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2928,{jjIMPORTFROM,IMPORTFROM_CMD, NONE,           PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
2929,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2930,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
2931,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2932,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2933,{jjJanetBasis2, JANET_CMD,    IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2934,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2935,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2936,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2937,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2938,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
2939,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2940,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2941,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
2942,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
2943,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
2944,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2945,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2946,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2947,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2948,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2949,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2950,{jjLOAD2,     LOAD_CMD,       NONE,           STRING_CMD, INT_CMD ALLOW_PLURAL}
2951,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2952,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
2953,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2954,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2955,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2956,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2957//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2958//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2959,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2960,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2961#ifdef HAVE_PLURAL
2962,{jjPlural_num_poly, NCALGEBRA_CMD,  NONE,  POLY_CMD,   POLY_CMD   NO_PLURAL}
2963,{jjPlural_num_mat,  NCALGEBRA_CMD,  NONE,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
2964,{jjPlural_mat_poly, NCALGEBRA_CMD,  NONE,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
2965,{jjPlural_mat_mat,  NCALGEBRA_CMD,  NONE,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
2966#endif
2967#ifdef HAVE_PLURAL
2968,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
2969,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, QRING_CMD,   DEF_CMD ALLOW_PLURAL}
2970#endif
2971,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2972,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2973,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
2974,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2975,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2976,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2977,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2978,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2979,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2980,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2981,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
2982,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2983,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2984,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2985//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2986//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2987,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2988,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2989,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2990,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2991,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2992,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2993,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2994//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2995//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2996,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2997,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
2998,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
2999,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3000,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
3001,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
3002,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
3003,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
3004,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3005,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
3006,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
3007,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
3008,{NULL,        0,              0,              0,          0 NO_PLURAL}
3009};
3010/*=================== operations with 1 arg.: static proc =================*/
3011static BOOLEAN jjDUMMY(leftv res, leftv u)
3012{
3013  res->data = (char *)u->CopyD();
3014  return FALSE;
3015}
3016static BOOLEAN jjNULL(leftv res, leftv u)
3017{
3018  return FALSE;
3019}
3020//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3021//{
3022//  res->data = (char *)((int)(long)u->Data()+1);
3023//  return FALSE;
3024//}
3025//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3026//{
3027//  res->data = (char *)((int)(long)u->Data()-1);
3028//  return FALSE;
3029//}
3030static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3031{
3032  if (IDTYP((idhdl)u->data)==INT_CMD)
3033  {
3034    if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
3035    else                IDINT((idhdl)u->data)--;
3036    return FALSE;
3037  }
3038  return TRUE;
3039}
3040static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3041{
3042  res->data = (char *)(-(int)(long)u->Data());
3043  return FALSE;
3044}
3045static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3046{
3047  number n=(number)u->CopyD(NUMBER_CMD);
3048  n=nNeg(n);
3049  res->data = (char *)n;
3050  return FALSE;
3051}
3052static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3053{
3054  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3055  return FALSE;
3056}
3057static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3058{
3059  poly m1=pISet(-1);
3060  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3061  return FALSE;
3062}
3063static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3064{
3065  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3066  (*iv)*=(-1);
3067  res->data = (char *)iv;
3068  return FALSE;
3069}
3070static BOOLEAN jjPROC1(leftv res, leftv u)
3071{
3072  return jjPROC(res,u,NULL);
3073}
3074static BOOLEAN jjBAREISS(leftv res, leftv v)
3075{
3076  //matrix m=(matrix)v->Data();
3077  //lists l=mpBareiss(m,FALSE);
3078  intvec *iv;
3079  ideal m;
3080  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3081  lists l=(lists)omAllocBin(slists_bin);
3082  l->Init(2);
3083  l->m[0].rtyp=MODUL_CMD;
3084  l->m[1].rtyp=INTVEC_CMD;
3085  l->m[0].data=(void *)m;
3086  l->m[1].data=(void *)iv;
3087  res->data = (char *)l;
3088  return FALSE;
3089}
3090//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3091//{
3092//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3093//  ivTriangMat(m);
3094//  res->data = (char *)m;
3095//  return FALSE;
3096//}
3097static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3098{
3099  return iiExprArithM(res,u,iiOp);
3100}
3101static BOOLEAN jjCHAR(leftv res, leftv v)
3102{
3103  res->data = (char *)rChar((ring)v->Data());
3104  return FALSE;
3105}
3106static BOOLEAN jjCOLS(leftv res, leftv v)
3107{
3108  res->data = (char *)MATCOLS((matrix)(v->Data()));
3109  return FALSE;
3110}
3111static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3112{
3113  res->data = (char *)((intvec*)(v->Data()))->cols();
3114  return FALSE;
3115}
3116static BOOLEAN jjCONTENT(leftv res, leftv v)
3117{
3118  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3119  poly p=(poly)v->CopyD(POLY_CMD);
3120  if (p!=NULL) pCleardenom(p);
3121  res->data = (char *)p;
3122  return FALSE;
3123}
3124static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3125{
3126  res->data = (char *)nSize((number)v->Data());
3127  return FALSE;
3128}
3129static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3130{
3131  lists l=(lists)v->Data();
3132  res->data = (char *)(l->nr+1);
3133  return FALSE;
3134}
3135static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3136{
3137  matrix m=(matrix)v->Data();
3138  res->data = (char *)(MATROWS(m)*MATCOLS(m));
3139  return FALSE;
3140}
3141static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3142{
3143  res->data = (char *)((intvec*)(v->Data()))->length();
3144  return FALSE;
3145}
3146static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3147{
3148  ring r=(ring)v->Data();
3149  int elems=-1;
3150  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
3151  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3152  {
3153#ifdef HAVE_FACTORY
3154    extern int ipower ( int b, int n ); /* factory/cf_util */
3155    elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3156#else
3157    elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3158#endif
3159  }
3160  res->data = (char *)elems;
3161  return FALSE;
3162}
3163static BOOLEAN jjDEG(leftv res, leftv v)
3164{
3165  int dummy;
3166  poly p=(poly)v->Data();
3167  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3168  else res->data=(char *)-1;
3169  return FALSE;
3170}
3171static BOOLEAN jjDEG_M(leftv res, leftv u)
3172{
3173  ideal I=(ideal)u->Data();
3174  int d=-1;
3175  int dummy;
3176  int i;
3177  for(i=IDELEMS(I);i>=0;i--)
3178    if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3179  res->data = (char *)d;
3180  return FALSE;
3181}
3182static BOOLEAN jjDEGREE(leftv res, leftv v)
3183{
3184  assumeStdFlag(v);
3185  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3186  scDegree((ideal)v->Data(),module_w,currQuotient);
3187  return FALSE;
3188}
3189static BOOLEAN jjDEFINED(leftv res, leftv v)
3190{
3191  if ((v->rtyp==IDHDL)
3192  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3193  {
3194    res->data=(void *)(IDLEV((idhdl)v->data)+1);
3195  }
3196  else if (v->rtyp!=0) res->data=(void *)(-1);
3197  return FALSE;
3198}
3199#ifdef HAVE_FACTORY
3200static BOOLEAN jjDET(leftv res, leftv v)
3201{
3202  matrix m=(matrix)v->Data();
3203  poly p;
3204  if (smCheckDet((ideal)m,m->cols(),TRUE))
3205  {
3206    ideal I=idMatrix2Module(mpCopy(m));
3207    p=smCallDet(I);
3208    idDelete(&I);
3209  }
3210  else
3211    p=singclap_det(m);
3212  res ->data = (char *)p;
3213  return FALSE;
3214}
3215static BOOLEAN jjDET_I(leftv res, leftv v)
3216{
3217  intvec * m=(intvec*)v->Data();
3218  int i,j;
3219  i=m->rows();j=m->cols();
3220  if(i==j)
3221    res->data = (char *)singclap_det_i(m);
3222  else
3223  {
3224    Werror("det of %d x %d intmat",i,j);
3225    return TRUE;
3226  }
3227  return FALSE;
3228}
3229static BOOLEAN jjDET_S(leftv res, leftv v)
3230{
3231  ideal I=(ideal)v->Data();
3232  poly p;
3233  if (smCheckDet(I,IDELEMS(I),FALSE))
3234  {
3235    matrix m=idModule2Matrix(idCopy(I));
3236    p=singclap_det(m);
3237    idDelete((ideal *)&m);
3238  }
3239  else
3240    p=smCallDet(I);
3241  res->data = (char *)p;
3242  return FALSE;
3243}
3244#endif
3245static BOOLEAN jjDIM(leftv res, leftv v)
3246{
3247  assumeStdFlag(v);
3248  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
3249  return FALSE;
3250}
3251static BOOLEAN jjDUMP(leftv res, leftv v)
3252{
3253  si_link l = (si_link)v->Data();
3254  if (slDump(l))
3255  {
3256    const char *s;
3257    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3258    else                            s=sNoName;
3259    Werror("cannot dump to `%s`",s);
3260    return TRUE;
3261  }
3262  else
3263    return FALSE;
3264}
3265static BOOLEAN jjE(leftv res, leftv v)
3266{
3267  res->data = (char *)pOne();
3268  pSetComp((poly)res->data,(int)(long)v->Data());
3269  pSetm((poly)res->data);
3270  return FALSE;
3271}
3272static BOOLEAN jjEXECUTE(leftv res, leftv v)
3273{
3274  char * d = (char *)v->Data();
3275  char * s = (char *)omAlloc(strlen(d) + 13);
3276  strcpy( s, (char *)d);
3277  strcat( s, "\n;RETURN();\n");
3278  newBuffer(s,BT_execute);
3279  return yyparse();
3280}
3281#ifdef HAVE_FACTORY
3282static BOOLEAN jjFACSTD(leftv res, leftv v)
3283{
3284  ideal_list p,h;
3285  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3286  p=h;
3287  int l=0;
3288  while (p!=NULL) { p=p->next;l++; }
3289  lists L=(lists)omAllocBin(slists_bin);
3290  L->Init(l);
3291  l=0;
3292  while(h!=NULL)
3293  {
3294    L->m[l].data=(char *)h->d;
3295    L->m[l].rtyp=IDEAL_CMD;
3296    p=h->next;
3297    omFreeSize(h,sizeof(*h));
3298    h=p;
3299    l++;
3300  }
3301  res->data=(void *)L;
3302  return FALSE;
3303}
3304static BOOLEAN jjFAC_P(leftv res, leftv u)
3305{
3306  intvec *v=NULL;
3307  singclap_factorize_retry=0;
3308  ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3309  if (f==NULL) return TRUE;
3310  ivTest(v);
3311  lists l=(lists)omAllocBin(slists_bin);
3312  l->Init(2);
3313  l->m[0].rtyp=IDEAL_CMD;
3314  l->m[0].data=(void *)f;
3315  l->m[1].rtyp=INTVEC_CMD;
3316  l->m[1].data=(void *)v;
3317  res->data=(void *)l;
3318  return FALSE;
3319}
3320#endif
3321static BOOLEAN jjGETDUMP(leftv res, leftv v)
3322{
3323  si_link l = (si_link)v->Data();
3324  if (slGetDump(l))
3325  {
3326    const char *s;
3327    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3328    else                            s=sNoName;
3329    Werror("cannot get dump from `%s`",s);
3330    return TRUE;
3331  }
3332  else
3333    return FALSE;
3334}
3335static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3336{
3337  assumeStdFlag(v);
3338  ideal I=(ideal)v->Data();
3339  res->data=(void *)iiHighCorner(I,0);
3340  return FALSE;
3341}
3342static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3343{
3344  assumeStdFlag(v);
3345  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3346  BOOLEAN delete_w=FALSE;
3347  ideal I=(ideal)v->Data();
3348  int i;
3349  poly p=NULL,po=NULL;
3350  int rk=idRankFreeModule(I);
3351  if (w==NULL)
3352  {
3353    w = new intvec(rk);
3354    delete_w=TRUE;
3355  }
3356  for(i=rk;i>0;i--)
3357  {
3358    p=iiHighCorner(I,i);
3359    if (p==NULL)
3360    {
3361      WerrorS("module must be zero-dimensional");
3362      if (delete_w) delete w;
3363      return TRUE;
3364    }
3365    if (po==NULL)
3366    {
3367      po=p;
3368    }
3369    else
3370    {
3371      // now po!=NULL, p!=NULL
3372      int d=(pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - pFDeg(p,currRing)+(*w)[i-1]);
3373      if (d==0)
3374        d=pLmCmp(po,p);
3375      if (d > 0)
3376      {
3377        pDelete(&p);
3378      }
3379      else // (d < 0)
3380      {
3381        pDelete(&po); po=p;
3382      }
3383    }
3384  }
3385  if (delete_w) delete w;
3386  res->data=(void *)po;
3387  return FALSE;
3388}
3389static BOOLEAN jjHILBERT(leftv res, leftv v)
3390{
3391  assumeStdFlag(v);
3392  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3393  //scHilbertPoly((ideal)v->Data(),currQuotient);
3394  hLookSeries((ideal)v->Data(),module_w,currQuotient);
3395  return FALSE;
3396}
3397static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3398{
3399  res->data=(void *)hSecondSeries((intvec *)v->Data());
3400  return FALSE;
3401}
3402static BOOLEAN jjHOMOG1(leftv res, leftv v)
3403{
3404  intvec *w;
3405  res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
3406  if ((res->data!=NULL) && (v->rtyp==IDHDL))
3407  {
3408    atSet((idhdl)v->data,omStrDup("isHomog"),w,INTVEC_CMD);
3409  }
3410  else if (w!=NULL) delete w;
3411  return FALSE;
3412}
3413static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3414{
3415  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3416  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3417  if (IDELEMS((ideal)mat)==0)
3418  {
3419    idDelete((ideal *)&mat);
3420    mat=(matrix)idInit(1,1);
3421  }
3422  else
3423  {
3424    MATROWS(mat)=1;
3425    mat->rank=1;
3426    idTest((ideal)mat);
3427  }
3428  res->data=(char *)mat;
3429  return FALSE;
3430}
3431static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3432{
3433  map m=(map)v->CopyD(MAP_CMD);
3434  omFree((ADDRESS)m->preimage);
3435  m->preimage=NULL;
3436  ideal I=(ideal)m;
3437  I->rank=1;
3438  res->data=(char *)I;
3439  return FALSE;
3440}
3441static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3442{
3443  if (currRing!=NULL)
3444  {
3445    ring q=(ring)v->Data();
3446    if (rEqual(currRing, q, 0))
3447    {
3448      if (q->qideal==NULL)
3449        res->data=(char *)idInit(1,1);
3450      else
3451        res->data=(char *)idCopy(q->qideal);
3452      return FALSE;
3453    }
3454  }
3455  WerrorS("can only get ideal from identical qring");
3456  return TRUE;
3457}
3458static BOOLEAN jjIm2Iv(leftv res, leftv v)
3459{
3460  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3461  iv->makeVector();
3462  res->data = iv;
3463  return FALSE;
3464}
3465static BOOLEAN jjIMPART(leftv res, leftv v)
3466{
3467  res->data = (char *)nImPart((number)v->Data());
3468  return FALSE;
3469}
3470static BOOLEAN jjINDEPSET(leftv res, leftv v)
3471{
3472  assumeStdFlag(v);
3473  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3474  return FALSE;
3475}
3476static BOOLEAN jjINTERRED(leftv res, leftv v)
3477{
3478  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3479  //if (result==NULL) return TRUE;
3480  res->data = result;
3481  return FALSE;
3482}
3483static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3484{
3485  res->data = (char *)pVar((poly)v->Data());
3486  return FALSE;
3487}
3488static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3489{
3490  res->data = (char *)(r_IsRingVar((char *)v->Data(), currRing)+1);
3491  return FALSE;
3492}
3493static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3494{
3495  res->data = (char *)0;
3496  return FALSE;
3497}
3498static BOOLEAN jjJACOB_P(leftv res, leftv v)
3499{
3500  ideal i=idInit(pVariables,1);
3501  int k;
3502  poly p=(poly)(v->Data());
3503  for (k=pVariables;k>0;k--)
3504  {
3505    i->m[k-1]=pDiff(p,k);
3506  }
3507  res->data = (char *)i;
3508  return FALSE;
3509}
3510static BOOLEAN jjKBASE(leftv res, leftv v)
3511{
3512  assumeStdFlag(v);
3513  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3514  return FALSE;
3515}
3516#ifdef MDEBUG
3517static BOOLEAN jjpHead(leftv res, leftv v)
3518{
3519  res->data=(char *)pHead((poly)v->Data());
3520  return FALSE;
3521}
3522#endif
3523static BOOLEAN jjL2R(leftv res, leftv v)
3524{
3525  res->data=(char *)syConvList((lists)v->Data());
3526  if (res->data != NULL)
3527    return FALSE;
3528  else
3529    return TRUE;
3530}
3531static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3532{
3533  poly p=(poly)v->Data();
3534  if (p==NULL)
3535  {
3536    res->data=(char *)nInit(0);
3537  }
3538  else
3539  {
3540    res->data=(char *)nCopy(pGetCoeff(p));
3541  }
3542  return FALSE;
3543}
3544static BOOLEAN jjLEADEXP(leftv res, leftv v)
3545{
3546  poly p=(poly)v->Data();
3547  int s=pVariables;
3548  if (v->Typ()==VECTOR_CMD) s++;
3549  intvec *iv=new intvec(s);
3550  if (p!=NULL)
3551  {
3552    for(int i = pVariables;i;i--)
3553    {
3554      (*iv)[i-1]=pGetExp(p,i);
3555    }
3556    if (s!=pVariables)
3557      (*iv)[pVariables]=pGetComp(p);
3558  }
3559  res->data=(char *)iv;
3560  return FALSE;
3561}
3562static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3563{
3564  poly p=(poly)v->Data();
3565  if (p == NULL)
3566  {
3567    res->data = (char*) NULL;
3568  }
3569  else
3570  {
3571    poly lm = pLmInit(p);
3572    pSetCoeff(lm, nInit(1));
3573    res->data = (char*) lm;
3574  }
3575  return FALSE;
3576}
3577static BOOLEAN jjLISTRING(leftv res, leftv v)
3578{
3579  ring r=rCompose((lists)v->Data());
3580  if (r==NULL) return TRUE;
3581  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3582  res->data=(char *)r;
3583  return FALSE;
3584}
3585static BOOLEAN jjMEMORY(leftv res, leftv v)
3586{
3587  omUpdateInfo();
3588  switch(((int)(long)v->Data()))
3589  {
3590  case 0:
3591    res->data = (char *)om_Info.UsedBytes;
3592    break;
3593  case 1:
3594    res->data = (char *)om_Info.CurrentBytesSystem;
3595    break;
3596  case 2:
3597    res->data = (char *)om_Info.MaxBytesSystem;
3598    break;
3599
3600  default:
3601    omPrintStats(stdout);
3602    omPrintInfo(stdout);
3603    omPrintBinStats(stdout);
3604    res->data = (char *)0;
3605  }
3606  return FALSE;
3607  res->data = (char *)0;
3608  return FALSE;
3609}
3610static BOOLEAN jjMONITOR1(leftv res, leftv v)
3611{
3612  monitor((char *)(v->Data()),PROT_I);
3613  return FALSE;
3614}
3615static BOOLEAN jjMSTD(leftv res, leftv v)
3616{
3617  int t=v->Typ();
3618  ideal r,m;
3619  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3620  lists l=(lists)omAllocBin(slists_bin);
3621  l->Init(2);
3622  l->m[0].rtyp=t;
3623  l->m[0].data=(char *)r;
3624  setFlag(&(l->m[0]),FLAG_STD);
3625  l->m[1].rtyp=t;
3626  l->m[1].data=(char *)m;
3627  res->data=(char *)l;
3628  return FALSE;
3629}
3630static BOOLEAN jjMULT(leftv res, leftv v)
3631{
3632  assumeStdFlag(v);
3633  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3634  return FALSE;
3635}
3636static BOOLEAN jjMINRES_R(leftv res, leftv v)
3637{
3638  intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3639  res->data=(char *)syMinimize((syStrategy)v->Data());
3640  if (weights!=NULL) 
3641    atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3642  return FALSE;
3643}
3644static BOOLEAN jjNAMEOF(leftv res, leftv v)
3645{
3646  res->data = (char *)v->name;
3647  if (res->data==NULL) res->data=omStrDup("");
3648  v->name=NULL;
3649  return FALSE;
3650}
3651static BOOLEAN jjNAMES(leftv res, leftv v)
3652{
3653  res->data=ipNameList(((ring)v->Data())->idroot);
3654  return FALSE;
3655}
3656static BOOLEAN jjNVARS(leftv res, leftv v)
3657{
3658  res->data = (char *)(((ring)(v->Data()))->N);
3659  return FALSE;
3660}
3661static BOOLEAN jjOpenClose(leftv res, leftv v)
3662{
3663  si_link l=(si_link)v->Data();
3664  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3665  else                return slClose(l);
3666}
3667static BOOLEAN jjORD(leftv res, leftv v)
3668{
3669  poly p=(poly)v->Data();
3670  res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3671  return FALSE;
3672}
3673static BOOLEAN jjPAR1(leftv res, leftv v)
3674{
3675  int i=(int)(long)v->Data();
3676  int p=0;
3677  p=rPar(currRing);
3678  if ((0<i) && (i<=p))
3679  {
3680    res->data=(char *)nPar(i);
3681  }
3682  else
3683  {
3684    Werror("par number %d out of range 1..%d",i,p);
3685    return TRUE;
3686  }
3687  return FALSE;
3688}
3689static BOOLEAN jjPARDEG(leftv res, leftv v)
3690{
3691  res->data = (char *)nParDeg((number)v->Data());
3692  return FALSE;
3693}
3694static BOOLEAN jjPARSTR1(leftv res, leftv v)
3695{
3696  if (currRing==NULL)
3697  {
3698    WerrorS("no ring active");
3699    return TRUE;
3700  }
3701  int i=(int)(long)v->Data();
3702  int p=0;
3703  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3704    res->data=omStrDup(currRing->parameter[i-1]);
3705  else
3706  {
3707    Werror("par number %d out of range 1..%d",i,p);
3708    return TRUE;
3709  }
3710  return FALSE;
3711}
3712static BOOLEAN jjP2I(leftv res, leftv v)
3713{
3714  poly p=(poly)v->Data();
3715  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3716  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3717  {
3718    WerrorS("poly must be constant");
3719    return TRUE;
3720  }
3721  res->data = (char *)nInt(pGetCoeff(p));
3722  return FALSE;
3723}
3724static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3725{
3726  map mapping=(map)v->Data();
3727  syMake(res,omStrDup(mapping->preimage));
3728  return FALSE;
3729}
3730static BOOLEAN jjPRIME(leftv res, leftv v)
3731{
3732  int i = IsPrime((int)(long)(v->Data()));
3733  res->data = (char *)(i > 1 ? i : 2);
3734  return FALSE;
3735}
3736static BOOLEAN jjPRUNE(leftv res, leftv v)
3737{
3738  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3739  ideal v_id=(ideal)v->Data();
3740  if (w!=NULL)
3741  {
3742    w=ivCopy(w);
3743    intvec **ww=&w;
3744    res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3745    atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3746  }
3747  else
3748    res->data = (char *)idMinEmbedding(v_id);
3749  return FALSE;
3750}
3751static BOOLEAN jjP2N(leftv res, leftv v)
3752{
3753  number n;
3754  poly p;
3755  if (((p=(poly)v->Data())!=NULL)
3756  && (pIsConstant(p)))
3757  {
3758    n=nCopy(pGetCoeff(p));
3759  }
3760  else
3761  {
3762    n=nInit(0);
3763  }
3764  res->data = (char *)n;
3765  return FALSE;
3766}
3767static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3768{
3769  char *s= (char *)v->Data();
3770  int i = 1;
3771  int l = strlen(s);
3772  while (cmds[i].tokval!=0)
3773  {
3774    if (strcmp(s, cmds[i].name) == 0)
3775    {
3776      res->data = (char *)1;
3777      return FALSE;
3778    }
3779    i++;
3780  }
3781  //res->data = (char *)0;
3782  return FALSE;
3783}
3784static BOOLEAN jjREAD(leftv res, leftv v)
3785{
3786  return jjREAD2(res,v,NULL);
3787}
3788static BOOLEAN jjREGULARITY(leftv res, leftv v)
3789{
3790  res->data = (char *)iiRegularity((lists)v->Data());
3791  return FALSE;
3792}
3793static BOOLEAN jjREPART(leftv res, leftv v)
3794{
3795  res->data = (char *)nRePart((number)v->Data());
3796  return FALSE;
3797}
3798static BOOLEAN jjRINGLIST(leftv res, leftv v)
3799{
3800  ring r=(ring)v->Data();
3801  if (r!=NULL)
3802    res->data = (char *)rDecompose((ring)v->Data());
3803  return (r==NULL);
3804}
3805static BOOLEAN jjROWS(leftv res, leftv v)
3806{
3807  ideal i = (ideal)v->Data();
3808  res->data = (char *)i->rank;
3809  return FALSE;
3810}
3811static BOOLEAN jjROWS_IV(leftv res, leftv v)
3812{
3813  res->data = (char *)((intvec*)(v->Data()))->rows();
3814  return FALSE;
3815}
3816static BOOLEAN jjRPAR(leftv res, leftv v)
3817{
3818  res->data = (char *)rPar(((ring)v->Data()));
3819  return FALSE;
3820}
3821static BOOLEAN jjSLIM_GB(leftv res, leftv u)
3822{
3823  if (currQuotient!=NULL)
3824  {
3825    Werror("qring not supported by slimgb at the moment");
3826    return TRUE;
3827  }
3828  if (pOrdSgn!=1)
3829  {
3830    Werror("ordering must be global for slimgb");
3831    return TRUE;
3832  }
3833  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3834  tHomog hom=testHomog;
3835  if (w!=NULL)
3836  {
3837    w=ivCopy(w);
3838    hom=isHomog;
3839  }
3840  res->data=(char *)t_rep_gb(currRing, (ideal)u->Data());
3841  setFlag(res,FLAG_STD);
3842  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3843  return FALSE;
3844}
3845static BOOLEAN jjSTD(leftv res, leftv v)
3846{
3847  ideal result;
3848  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3849  tHomog hom=testHomog;
3850  if (w!=NULL)
3851  {
3852    w=ivCopy(w);
3853    hom=isHomog;
3854  }
3855  result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3856  idSkipZeroes(result);
3857  res->data = (char *)result;
3858  setFlag(res,FLAG_STD);
3859  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3860  return FALSE;
3861}
3862static BOOLEAN jjSort_Id(leftv res, leftv v)
3863{
3864  res->data = (char *)idSort((ideal)v->Data());
3865  return FALSE;
3866}
3867#if 1
3868static BOOLEAN jjSYZYGY(leftv res, leftv v)
3869{
3870  intvec *w=NULL;
3871  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3872  if (w!=NULL) delete w;
3873  return FALSE;
3874}
3875#else
3876// activate, if idSyz hadle moduke weights correctly !
3877static BOOLEAN jjSYZYGY(leftv res, leftv v)
3878{
3879  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3880  ideal v_id=(ideal)v->Data();
3881  tHomog hom=testHomog;
3882  int add_row_shift=0;
3883  if (w!=NULL)
3884  {
3885    w=ivCopy(w);
3886    add_row_shift=w->min_in();
3887    (*w)-=add_row_shift;
3888    if (idHomModule(v_id,currQuotient,&w))
3889      hom=isHomog;
3890    else
3891    {
3892      //WarnS("wrong weights");
3893      delete w; w=NULL;
3894      hom=testHomog;
3895    }
3896  }
3897  res->data = (char *)idSyzygies(v_id,hom,&w);
3898  if (w!=NULL)
3899  {
3900    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3901  }
3902  return FALSE;
3903}
3904#endif
3905static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3906{
3907  res->data = (char *)ivTrace((intvec*)(v->Data()));
3908  return FALSE;
3909}
3910static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3911{
3912  res->data = (char *)ivTranp((intvec*)(v->Data()));
3913  return FALSE;
3914}
3915
3916#ifdef HAVE_PLURAL
3917
3918static BOOLEAN jjOPPOSITE(leftv res, leftv a)
3919{
3920  ring    r = (ring)a->Data();
3921  if (rIsPluralRing(r))
3922  {
3923    res->data = rOpposite(r);
3924  }
3925  else res->data = rCopy(r);
3926  return FALSE;
3927}
3928
3929static BOOLEAN jjENVELOPE(leftv res, leftv a)
3930{
3931  ring    r = (ring)a->Data();
3932  if (rIsPluralRing(r))
3933  {
3934    //    ideal   i;
3935//     if (a->rtyp == QRING_CMD)
3936//     {
3937//       i = r->qideal;
3938//       r->qideal = NULL;
3939//     }
3940    ring s = rEnvelope(r);
3941//     if (a->rtyp == QRING_CMD)
3942//     {
3943//       ideal is  = idOppose(r,i); /* twostd? */
3944//       is        = idAdd(is,i);
3945//       s->qideal = i;
3946//     }
3947    res->data = s;
3948  }
3949  else  res->data = rCopy(r);
3950  return FALSE;
3951}
3952
3953static BOOLEAN jjTWOSTD(leftv res, leftv a)
3954{
3955  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
3956  else  res->data=(ideal)a->Data();
3957  setFlag(res,FLAG_STD);
3958  setFlag(res,FLAG_TWOSTD);
3959  return FALSE;
3960}
3961#endif
3962
3963static BOOLEAN jjTYPEOF(leftv res, leftv v)
3964{
3965  switch ((int)(long)v->data)
3966  {
3967    case INT_CMD:     res->data=omStrDup("int"); break;
3968    case POLY_CMD:   res->data=omStrDup("poly"); break;
3969    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3970    case STRING_CMD:  res->data=omStrDup("string"); break;
3971    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3972    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3973    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3974    case MODUL_CMD:   res->data=omStrDup("module"); break;
3975    case MAP_CMD:     res->data=omStrDup("map"); break;
3976    case PROC_CMD:    res->data=omStrDup("proc"); break;
3977    case RING_CMD:    res->data=omStrDup("ring"); break;
3978    case QRING_CMD:   res->data=omStrDup("qring"); break;
3979    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3980    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3981    case LIST_CMD:   res->data=omStrDup("list"); break;
3982    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3983    case LINK_CMD:   res->data=omStrDup("link"); break;
3984    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3985    case DEF_CMD:
3986    case NONE:    res->data=omStrDup("none"); break;
3987    default:       res->data=omStrDup("?unknown type?");
3988  }
3989  return FALSE;
3990}
3991static BOOLEAN jjVAR1(leftv res, leftv v)
3992{
3993  int i=(int)(long)v->Data();
3994  if ((0<i) && (i<=currRing->N))
3995  {
3996    poly p=pOne();
3997    pSetExp(p,i,1);
3998    pSetm(p);
3999    res->data=(char *)p;
4000  }
4001  else
4002  {
4003    Werror("var number %d out of range 1..%d",i,currRing->N);
4004    return TRUE;
4005  }
4006  return FALSE;
4007}
4008static BOOLEAN jjVARSTR1(leftv res, leftv v)
4009{
4010  if (currRing==NULL)
4011  {
4012    WerrorS("no ring active");
4013    return TRUE;
4014  }
4015  int i=(int)(long)v->Data();
4016  if ((0<i) && (i<=currRing->N))
4017    res->data=omStrDup(currRing->names[i-1]);
4018  else
4019  {
4020    Werror("var number %d out of range 1..%d",i,currRing->N);
4021    return TRUE;
4022  }
4023  return FALSE;
4024}
4025static BOOLEAN jjVDIM(leftv res, leftv v)
4026{
4027  assumeStdFlag(v);
4028  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
4029  return FALSE;
4030}
4031
4032static BOOLEAN jjLOAD1(leftv res, leftv v)
4033{
4034  return jjLOAD(res, v,iiOp==LIB_CMD);
4035}
4036static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4037{
4038#ifdef HAVE_NS
4039  char * s=(char *)v->CopyD();
4040  char libnamebuf[256];
4041  lib_types LT = type_of_LIB(s, libnamebuf);
4042#ifdef HAVE_DYNAMIC_LOADING
4043  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN autoexport);
4044#endif /* HAVE_DYNAMIC_LOADING */
4045  switch(LT)
4046  {
4047      default:
4048      case LT_NONE:
4049        Werror("%s: unknown type", s);
4050        break;
4051      case LT_NOTFOUND:
4052        Werror("cannot open %s", s);
4053        break;
4054
4055      case LT_SINGULAR:
4056      {
4057        char *plib = iiConvName(s);
4058        idhdl pl = IDROOT->get(plib,0);
4059        if (pl==NULL)
4060        {
4061          pl = enterid( plib,0, PACKAGE_CMD, &IDROOT, TRUE );
4062          IDPACKAGE(pl)->language = LANG_SINGULAR;
4063          IDPACKAGE(pl)->libname=omStrDup(plib);
4064        }
4065        else if (IDTYP(pl)!=PACKAGE_CMD)
4066        {
4067          Werror("can not create package `%s`",plib);
4068          omFree(plib);
4069          return TRUE;
4070        }
4071        package savepack=currPack;
4072        currPack=IDPACKAGE(pl);
4073        IDPACKAGE(pl)->loaded=TRUE;
4074        char libnamebuf[256];
4075        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4076        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, FALSE, TRUE);
4077        currPack=savepack;
4078        IDPACKAGE(pl)->loaded=(!bo);
4079        return bo;
4080      }
4081      case LT_MACH_O:
4082      case LT_ELF:
4083      case LT_HPUX:
4084#ifdef HAVE_DYNAMIC_LOADING
4085        return load_modules(s, libnamebuf, autoexport);
4086#else /* HAVE_DYNAMIC_LOADING */
4087        WerrorS("Dynamic modules are not supported by this version of Singular");
4088        break;
4089#endif /* HAVE_DYNAMIC_LOADING */
4090  }
4091#endif
4092  return TRUE;
4093}
4094
4095/*=================== operations with 1 arg.: table =================*/
4096
4097#ifdef INIT_BUG
4098#define XS(A) -((short)A)
4099#define jjstrlen       (proc1)1
4100#define jjpLength      (proc1)2
4101#define jjidElem       (proc1)3
4102#define jjmpDetBareiss (proc1)4
4103#define jjidFreeModule (proc1)5
4104#define jjidVec2Ideal  (proc1)6
4105#define jjrCharStr     (proc1)7
4106#ifndef MDEBUG
4107#define jjpHead        (proc1)8
4108#endif
4109#define jjidHead       (proc1)9
4110#define jjidMaxIdeal   (proc1)10
4111#define jjidMinBase    (proc1)11
4112#define jjsyMinBase    (proc1)12
4113#define jjpMaxComp     (proc1)13
4114#define jjmpTrace      (proc1)14
4115#define jjmpTransp     (proc1)15
4116#define jjrOrdStr      (proc1)16
4117#define jjrVarStr      (proc1)18
4118#define jjrParStr      (proc1)19
4119#define jjCOUNT_RES    (proc1)22
4120#define jjDIM_R        (proc1)23
4121#define jjidTransp     (proc1)24
4122
4123extern struct sValCmd1 dArith1[];
4124void jjInitTab1()
4125{
4126  int i=0;
4127  for (;dArith1[i].cmd!=0;i++)
4128  {
4129    if (dArith1[i].res<0)
4130    {
4131      switch ((int)dArith1[i].p)
4132      {
4133        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
4134        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
4135        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
4136        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
4137#ifndef HAVE_FACTORY
4138        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4139#endif
4140        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4141        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
4142#ifndef MDEBUG
4143        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
4144#endif
4145        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
4146        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
4147        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
4148        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
4149        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
4150        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
4151        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
4152        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
4153        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
4154        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
4155        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
4156        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
4157        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
4158#ifdef GENTABLE
4159        default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4160#endif
4161      }
4162    }
4163  }
4164}
4165#else
4166#if defined(PROC_BUG)
4167#define XS(A) A
4168static BOOLEAN jjstrlen(leftv res, leftv v)
4169{
4170  res->data = (char *)strlen((char *)v->Data());
4171  return FALSE;
4172}
4173static BOOLEAN jjpLength(leftv res, leftv v)
4174{
4175  res->data = (char *)pLength((poly)v->Data());
4176  return FALSE;
4177}
4178static BOOLEAN jjidElem(leftv res, leftv v)
4179{
4180  res->data = (char *)idElem((ideal)v->Data());
4181  return FALSE;
4182}
4183static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4184{
4185  res->data = (char *)mpDetBareiss((matrix)v->Data());
4186  return FALSE;
4187}
4188static BOOLEAN jjidFreeModule(leftv res, leftv v)
4189{
4190  res->data = (char *)idFreeModule((int)(long)v->Data());
4191  return FALSE;
4192}
4193static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4194{
4195  res->data = (char *)idVec2Ideal((poly)v->Data());
4196  return FALSE;
4197}
4198static BOOLEAN jjrCharStr(leftv res, leftv v)
4199{
4200  res->data = rCharStr((ring)v->Data());
4201  return FALSE;
4202}
4203#ifndef MDEBUG
4204static BOOLEAN jjpHead(leftv res, leftv v)
4205{
4206  res->data = (char *)pHead((poly)v->Data());
4207  return FALSE;
4208}
4209#endif
4210static BOOLEAN jjidHead(leftv res, leftv v)
4211{
4212  res->data = (char *)idHead((ideal)v->Data());
4213  return FALSE;
4214}
4215static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4216{
4217  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4218  return FALSE;
4219}
4220static BOOLEAN jjidMinBase(leftv res, leftv v)
4221{
4222  res->data = (char *)idMinBase((ideal)v->Data());
4223  return FALSE;
4224}
4225static BOOLEAN jjsyMinBase(leftv res, leftv v)
4226{
4227  res->data = (char *)syMinBase((ideal)v->Data());
4228  return FALSE;
4229}
4230static BOOLEAN jjpMaxComp(leftv res, leftv v)
4231{
4232  res->data = (char *)pMaxComp((poly)v->Data());
4233  return FALSE;
4234}
4235static BOOLEAN jjmpTrace(leftv res, leftv v)
4236{
4237  res->data = (char *)mpTrace((matrix)v->Data());
4238  return FALSE;
4239}
4240static BOOLEAN jjmpTransp(leftv res, leftv v)
4241{
4242  res->data = (char *)mpTransp((matrix)v->Data());
4243  return FALSE;
4244}
4245static BOOLEAN jjrOrdStr(leftv res, leftv v)
4246{
4247  res->data = rOrdStr((ring)v->Data());
4248  return FALSE;
4249}
4250static BOOLEAN jjrVarStr(leftv res, leftv v)
4251{
4252  res->data = rVarStr((ring)v->Data());
4253  return FALSE;
4254}
4255static BOOLEAN jjrParStr(leftv res, leftv v)
4256{
4257  res->data = rParStr((ring)v->Data());
4258  return FALSE;
4259}
4260static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4261{
4262  res->data=(char *)syLength((syStrategy)v->Data());
4263  return FALSE;
4264}
4265static BOOLEAN jjDIM_R(leftv res, leftv v)
4266{
4267  res->data = (char *)syDim((syStrategy)v->Data());
4268  return FALSE;
4269}
4270static BOOLEAN jjidTransp(leftv res, leftv v)
4271{
4272  res->data = (char *)idTransp((ideal)v->Data());
4273  return FALSE;
4274}
4275#else
4276#define XS(A)          -((short)A)
4277#define jjstrlen       (proc1)strlen
4278#define jjpLength      (proc1)pLength
4279#define jjidElem       (proc1)idElem
4280#define jjmpDetBareiss (proc1)mpDetBareiss
4281#define jjidFreeModule (proc1)idFreeModule
4282#define jjidVec2Ideal  (proc1)idVec2Ideal
4283#define jjrCharStr     (proc1)rCharStr
4284#ifndef MDEBUG
4285#define jjpHead        (proc1)pHeadProc
4286#endif
4287#define jjidHead       (proc1)idHead
4288#define jjidMaxIdeal   (proc1)idMaxIdeal
4289#define jjidMinBase    (proc1)idMinBase
4290#define jjsyMinBase    (proc1)syMinBase
4291#define jjpMaxComp     (proc1)pMaxCompProc
4292#define jjmpTrace      (proc1)mpTrace
4293#define jjmpTransp     (proc1)mpTransp
4294#define jjrOrdStr      (proc1)rOrdStr
4295#define jjrVarStr      (proc1)rVarStr
4296#define jjrParStr      (proc1)rParStr
4297#define jjCOUNT_RES    (proc1)syLength
4298#define jjDIM_R        (proc1)syDim
4299#define jjidTransp     (proc1)idTransp
4300#endif
4301#endif
4302static BOOLEAN jjnInt(leftv res, leftv u)
4303{
4304  number n=(number)u->CopyD(NUMBER_CMD);
4305  res->data=(char *)nInt(n);
4306  nDelete(&n);
4307  return FALSE;
4308}
4309#define s short
4310struct sValCmd1 dArith1[]=
4311{
4312// operations:
4313// proc         cmd               res             arg           plural
4314// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4315//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4316 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4317,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4318,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4319,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4320,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4321,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4322,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4323,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4324,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4325,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4326,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4327// and the procedures with 1 argument:
4328,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4329//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4330,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4331,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4332,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4333,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4334,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4335,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4336,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4337#ifdef HAVE_FACTORY
4338,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4339#else
4340,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4341#endif
4342,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4343,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4344,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4345//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4346,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4347,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4348,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4349,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4350,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4351,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4352,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4353,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4354,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4355,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
4356,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
4357,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4358,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
4359,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
4360,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4361,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4362,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4363,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
4364,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4365,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
4366,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4367,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4368,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4369,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4370,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
4371,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
4372,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
4373#ifdef HAVE_FACTORY
4374,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4375,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
4376,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
4377#else
4378,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4379,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
4380#endif
4381,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
4382,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
4383,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4384,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4385,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
4386,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4387,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
4388#ifdef HAVE_FACTORY
4389,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4390#else
4391,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4392#endif
4393#ifdef HAVE_FGLM
4394,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4395#else
4396,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4397#endif
4398,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
4399#ifdef HAVE_FACTORY
4400,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4401#else
4402,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4403#endif
4404,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
4405,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
4406,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
4407,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
4408,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
4409,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
4410,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4411,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4412,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
4413,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
4414,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
4415,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
4416,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
4417,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4418,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4419,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
4420,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
4421,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4422,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4423,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4424,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
4425,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4426,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4427,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4428,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4429,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
4430,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
4431,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
4432,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4433,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4434,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4435,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4436,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
4437#ifdef MDEBUG
4438,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4439#else
4440,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
4441#endif
4442,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
4443#ifdef MDEBUG
4444,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4445#else
4446,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
4447#endif
4448,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4449,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4450,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4451,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
4452,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4453,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4454,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4455,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
4456,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
4457,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
4458,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4459,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4460,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
4461,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
4462,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
4463,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
4464,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
4465,{jjMINRES_R,   MINRES_CMD,      RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4466,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4467,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4468,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
4469,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
4470,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4471,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
4472,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4473,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
4474,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4475,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4476,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4477,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4478,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4479,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4480,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4481,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4482,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4483,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4484,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4485,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4486,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4487,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
4488,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4489,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4490,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4491,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4492,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4493,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
4494,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
4495,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
4496,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
4497,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4498,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4499,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4500,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
4501,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
4502,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
4503,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4504,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
4505,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
4506,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4507,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4508,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4509,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
4510,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
4511//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
4512,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4513,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4514,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4515,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4516,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4517,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4518,{jjSLIM_GB,    SLIM_GB_CMD,     MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4519,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4520,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4521,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4522,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4523,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
4524,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
4525,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4526,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4527#ifdef HAVE_PLURAL
4528,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4529,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4530,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4531,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4532,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4533#endif
4534,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
4535,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
4536,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4537,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
4538,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4539,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4540,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
4541,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4542,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4543,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4544,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4545,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4546,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
4547,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4548,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4549,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4550,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4551,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4552,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4553,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4554,{NULL,         0,               0,              0              NO_PLURAL}
4555};
4556#undef s
4557/*=================== operations with 3 args.: static proc =================*/
4558static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4559{
4560  char *s= (char *)u->Data();
4561  int   r = (int)(long)v->Data();
4562  int   c = (int)(long)w->Data();
4563  int l = strlen(s);
4564
4565  if ( (r<1) || (r>l) || (c<0) )
4566  {
4567    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4568    return TRUE;
4569  }
4570  res->data = (char *)omAlloc(c+1);
4571  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4572  return FALSE;
4573}
4574static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4575{
4576  intvec *iv = (intvec *)u->Data();
4577  int   r = (int)(long)v->Data();
4578  int   c = (int)(long)w->Data();
4579  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4580  {
4581    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4582           r,c,u->Fullname(),iv->rows(),iv->cols());
4583    return TRUE;
4584  }
4585  res->data=u->data;
4586  u->data=NULL;
4587  res->rtyp=u->rtyp;
4588  u->rtyp=0;
4589  res->name=u->name;
4590  u->name=NULL;
4591  Subexpr e=jjMakeSub(v);
4592          e->next=jjMakeSub(w);
4593  if (u->e==NULL) res->e=e;
4594  else
4595  {
4596    Subexpr h=u->e;
4597    while (h->next!=NULL) h=h->next;
4598    h->next=e;
4599    res->e=u->e;
4600    u->e=NULL;
4601  }
4602  return FALSE;
4603}
4604static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4605{
4606  matrix m= (matrix)u->Data();
4607  int   r = (int)(long)v->Data();
4608  int   c = (int)(long)w->Data();
4609  //Print("gen. elem %d, %d\n",r,c);
4610  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4611  {
4612    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4613      MATROWS(m),MATCOLS(m));
4614    return TRUE;
4615  }
4616  res->data=u->data;
4617  u->data=NULL;
4618  res->rtyp=u->rtyp;
4619  u->rtyp=0;
4620  res->name=u->name;
4621  u->name=NULL;
4622  Subexpr e=jjMakeSub(v);
4623          e->next=jjMakeSub(w);
4624  if (u->e==NULL)
4625    res->e=e;
4626  else
4627  {
4628    Subexpr h=u->e;
4629    while (h->next!=NULL) h=h->next;
4630    h->next=e;
4631    res->e=u->e;
4632    u->e=NULL;
4633  }
4634  return FALSE;
4635}
4636static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4637{
4638  sleftv t;
4639  sleftv ut;
4640  leftv p=NULL;
4641  intvec *iv=(intvec *)w->Data();
4642  int l;
4643  BOOLEAN nok;
4644
4645  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4646  {
4647    WerrorS("cannot build expression lists from unnamed objects");
4648    return TRUE;
4649  }
4650  memcpy(&ut,u,sizeof(ut));
4651  memset(&t,0,sizeof(t));
4652  t.rtyp=INT_CMD;
4653  for (l=0;l< iv->length(); l++)
4654  {
4655    t.data=(char *)(*iv)[l];
4656    if (p==NULL)
4657    {
4658      p=res;
4659    }
4660    else
4661    {
4662      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4663      p=p->next;
4664    }
4665    memcpy(u,&ut,sizeof(ut));
4666    if (u->Typ() == MATRIX_CMD)
4667      nok=jjBRACK_Ma(p,u,v,&t);
4668    else /* INTMAT_CMD */
4669      nok=jjBRACK_Im(p,u,v,&t);
4670    if (nok)
4671    {
4672      while (res->next!=NULL)
4673      {
4674        p=res->next->next;
4675        omFreeBin((ADDRESS)res->next, sleftv_bin);
4676        // res->e aufraeumen !!!!
4677        res->next=p;
4678      }
4679      return TRUE;
4680    }
4681  }
4682  return FALSE;
4683}
4684static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4685{
4686  sleftv t;
4687  sleftv ut;
4688  leftv p=NULL;
4689  intvec *iv=(intvec *)v->Data();
4690  int l;
4691  BOOLEAN nok;
4692
4693  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4694  {
4695    WerrorS("cannot build expression lists from unnamed objects");
4696    return TRUE;
4697  }
4698  memcpy(&ut,u,sizeof(ut));
4699  memset(&t,0,sizeof(t));
4700  t.rtyp=INT_CMD;
4701  for (l=0;l< iv->length(); l++)
4702  {
4703    t.data=(char *)((*iv)[l]);
4704    if (p==NULL)
4705    {
4706      p=res;
4707    }
4708    else
4709    {
4710      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4711      p=p->next;
4712    }
4713    memcpy(u,&ut,sizeof(ut));
4714    if (u->Typ() == MATRIX_CMD)
4715      nok=jjBRACK_Ma(p,u,&t,w);
4716    else /* INTMAT_CMD */
4717      nok=jjBRACK_Im(p,u,&t,w);
4718    if (nok)
4719    {
4720      while (res->next!=NULL)
4721      {
4722        p=res->next->next;
4723        omFreeBin((ADDRESS)res->next, sleftv_bin);
4724        // res->e aufraeumen !!
4725        res->next=p;
4726      }
4727      return TRUE;
4728    }
4729  }
4730  return FALSE;
4731}
4732static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4733{
4734  sleftv t1,t2,ut;
4735  leftv p=NULL;
4736  intvec *vv=(intvec *)v->Data();
4737  intvec *wv=(intvec *)w->Data();
4738  int vl;
4739  int wl;
4740  BOOLEAN nok;
4741
4742  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4743  {
4744    WerrorS("cannot build expression lists from unnamed objects");
4745    return TRUE;
4746  }
4747  memcpy(&ut,u,sizeof(ut));
4748  memset(&t1,0,sizeof(sleftv));
4749  memset(&t2,0,sizeof(sleftv));
4750  t1.rtyp=INT_CMD;
4751  t2.rtyp=INT_CMD;
4752  for (vl=0;vl< vv->length(); vl++)
4753  {
4754    t1.data=(char *)((*vv)[vl]);
4755    for (wl=0;wl< wv->length(); wl++)
4756    {
4757      t2.data=(char *)((*wv)[wl]);
4758      if (p==NULL)
4759      {
4760        p=res;
4761      }
4762      else
4763      {
4764        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4765        p=p->next;
4766      }
4767      memcpy(u,&ut,sizeof(ut));
4768      if (u->Typ() == MATRIX_CMD)
4769        nok=jjBRACK_Ma(p,u,&t1,&t2);
4770      else /* INTMAT_CMD */
4771        nok=jjBRACK_Im(p,u,&t1,&t2);
4772      if (nok)
4773      {
4774        res->CleanUp();
4775        return TRUE;
4776      }
4777    }
4778  }
4779  return FALSE;
4780}
4781static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4782{
4783  v->next=(leftv)omAllocBin(sleftv_bin);
4784  memcpy(v->next,w,sizeof(sleftv));
4785  memset(w,0,sizeof(sleftv));
4786  return jjPROC(res,u,v);
4787}
4788static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4789{
4790  u->next=(leftv)omAllocBin(sleftv_bin);
4791  memcpy(u->next,v,sizeof(sleftv));
4792  u->next->next=(leftv)omAllocBin(sleftv_bin);
4793  memcpy(u->next->next,w,sizeof(sleftv));
4794  BOOLEAN r=iiExprArithM(res,u,iiOp);
4795  // iiExprArithM did the CleanUp
4796  w->rtyp=0; w->data=NULL;
4797  return r;
4798}
4799static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4800{
4801  intvec *iv;
4802  ideal m;
4803  lists l=(lists)omAllocBin(slists_bin);
4804  int k=(int)(long)w->Data();
4805  if (k>=0)
4806  {
4807    smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
4808    l->Init(2);
4809    l->m[0].rtyp=MODUL_CMD;
4810    l->m[1].rtyp=INTVEC_CMD;
4811    l->m[0].data=(void *)m;
4812    l->m[1].data=(void *)iv;
4813  }
4814  else
4815  {
4816    m=smCallSolv((ideal)u->Data());
4817    l->Init(1);
4818    l->m[0].rtyp=IDEAL_CMD;
4819    l->m[0].data=(void *)m;
4820  }
4821  res->data = (char *)l;
4822  return FALSE;
4823}
4824static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4825{
4826  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4827  {
4828    WerrorS("3rd argument must be a name of a matrix");
4829    return TRUE;
4830  }
4831  ideal i=(ideal)u->Data();
4832  int rank=(int)i->rank;
4833  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4834  if (r) return TRUE;
4835  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4836  return FALSE;
4837}
4838static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4839{
4840  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4841           (ideal)(v->Data()),(poly)(w->Data()));
4842  return FALSE;
4843}
4844static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4845{
4846  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4847  {
4848    WerrorS("3rd argument must be a name of a matrix");
4849    return TRUE;
4850  }
4851  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4852  poly p=(poly)u->CopyD(POLY_CMD);
4853  ideal i=idInit(1,1);
4854  i->m[0]=p;
4855  sleftv t;
4856  memset(&t,0,sizeof(t));
4857  t.data=(char *)i;
4858  t.rtyp=IDEAL_CMD;
4859  int rank=1;
4860  if (u->Typ()==VECTOR_CMD)
4861  {
4862    i->rank=rank=pMaxComp(p);
4863    t.rtyp=MODUL_CMD;
4864  }
4865  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4866  t.CleanUp();
4867  if (r) return TRUE;
4868  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4869  return FALSE;
4870}
4871static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4872{
4873  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4874    (intvec *)w->Data());
4875  setFlag(res,FLAG_STD);
4876  return FALSE;
4877}
4878static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4879{
4880  /*4
4881  * look for the substring what in the string where
4882  * starting at position n
4883  * return the position of the first char of what in where
4884  * or 0
4885  */
4886  int n=(int)(long)w->Data();
4887  char *where=(char *)u->Data();
4888  char *what=(char *)v->Data();
4889  char *found;
4890  if ((1>n)||(n>(int)strlen(where)))
4891  {
4892    Werror("start position %d out of range",n);
4893    return TRUE;
4894  }
4895  found = strchr(where+n-1,*what);
4896  if (*(what+1)!='\0')
4897  {
4898    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4899    {
4900      found=strchr(found+1,*what);
4901    }
4902  }
4903  if (found != NULL)
4904  {
4905    res->data=(char *)((found-where)+1);
4906  }
4907  return FALSE;
4908}
4909static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
4910{
4911  if ((int)(long)w->Data()==0)
4912    res->data=(char *)walkProc(u,v);
4913  else
4914    res->data=(char *)fractalWalkProc(u,v);
4915  setFlag( res, FLAG_STD );
4916  return FALSE;
4917}
4918static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4919{
4920  assumeStdFlag(u);
4921  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4922  intvec *wdegree=(intvec*)w->Data();
4923  if (wdegree->length()!=pVariables)
4924  {
4925    Werror("weight vector must have size %d, not %d",
4926           pVariables,wdegree->length());
4927    return TRUE;
4928  }
4929  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4930  switch((int)(long)v->Data())
4931  {
4932    case 1:
4933      res->data=(void *)iv;
4934      return FALSE;
4935    case 2:
4936      res->data=(void *)hSecondSeries(iv);
4937      delete iv;
4938      return FALSE;
4939  }
4940  WerrorS(feNotImplemented);
4941  delete iv;
4942  return TRUE;
4943}
4944static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4945{
4946  intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
4947  intvec* arg = (intvec*) u->Data();
4948  int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
4949
4950  for (i=0; i<n; i++)
4951  {
4952    (*im)[i] = (*arg)[i];
4953  }
4954
4955  res->data = (char *)im;
4956  return FALSE;
4957}
4958static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4959{
4960  short *iw=iv2array((intvec *)w->Data());
4961  res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
4962  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4963  return FALSE;
4964}
4965static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
4966{
4967  if (!pIsUnit((poly)v->Data()))
4968  {
4969    WerrorS("2nd argument must be a unit");
4970    return TRUE;
4971  }
4972  res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4973  return FALSE;
4974}
4975static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4976{
4977  res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
4978                             (intvec *)w->Data());
4979  return FALSE;
4980}
4981static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4982{
4983  if (!mpIsDiagUnit((matrix)v->Data()))
4984  {
4985    WerrorS("2nd argument must be a diagonal matrix of units");
4986    return TRUE;
4987  }
4988  res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
4989                               (matrix)v->CopyD());
4990  return FALSE;
4991}
4992static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4993{
4994  assumeStdFlag(w);
4995  res->data = (char *)idMinors(
4996                        (matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
4997  return FALSE;
4998}
4999static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5000{
5001  idhdl h;
5002  ring rr;
5003  map mapping;
5004
5005  if ((v->name==NULL) || (w->name==NULL))
5006  {
5007    WerrorS("2nd/3rd arguments must have names");
5008    return TRUE;
5009  }
5010  rr=(ring)u->Data();
5011  const char *ring_name=u->Name();
5012  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5013  {
5014    if (h->typ==MAP_CMD)
5015    {
5016      mapping=IDMAP(h);
5017      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5018      if ((preim_ring==NULL)
5019      || (IDRING(preim_ring)!=currRing))
5020      {
5021        Werror("preimage ring `%s` is not the basering",mapping->preimage);
5022        return TRUE;
5023      }
5024    }
5025    else if (h->typ==IDEAL_CMD)
5026    {
5027      mapping=IDMAP(h);
5028    }
5029    else
5030    {
5031      Werror("`%s` is no map nor ideal",IDID(h));
5032      return TRUE;
5033    }
5034  }
5035  else
5036  {
5037    Werror("`%s` is not defined in `%s`",v->name,ring_name);
5038    return TRUE;
5039  }
5040  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5041  {
5042    if (h->typ==IDEAL_CMD)
5043    {
5044      if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5045      || ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5046      {
5047        WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5048      }
5049      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5050      if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5051    }
5052    else
5053    {
5054      Werror("`%s` is no ideal",IDID(h));
5055      return TRUE;
5056    }
5057  }
5058  else
5059  {
5060    Werror("`%s` is not defined in `%s`",w->name,ring_name);
5061    return TRUE;
5062  }
5063  return FALSE;
5064}
5065static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5066{
5067  int di, k;
5068  int i=(int)(long)u->Data();
5069  int r=(int)(long)v->Data();
5070  int c=(int)(long)w->Data();
5071  if ((r<=0) || (c<=0)) return TRUE;
5072  intvec *iv = new intvec(r, c, 0);
5073  if (iv->rows()==0)
5074  {
5075    delete iv;
5076    return TRUE;
5077  }
5078  if (i!=0)
5079  {
5080    if (i<0) i = -i;
5081    di = 2 * i + 1;
5082    for (k=0; k<iv->length(); k++)
5083    {
5084#ifdef buildin_rand
5085      (*iv)[k] = ((siRand() % di) - i);
5086#else
5087      (*iv)[k] = ((rand() % di) - i);
5088#endif
5089    }
5090  }
5091  res->data = (char *)iv;
5092  return FALSE;
5093}
5094static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5095  int &ringvar, poly &monomexpr)
5096{
5097  monomexpr=(poly)w->Data();
5098  poly p=(poly)v->Data();
5099  #if 0
5100  if (pLength(monomexpr)>1)
5101  {
5102    Werror("`%s` substitutes a ringvar only by a term",
5103      Tok2Cmdname(SUBST_CMD));
5104    return TRUE;
5105  }
5106  #endif
5107  if (!(ringvar=pVar(p)))
5108  {
5109    if (rField_is_Extension(currRing))
5110    {
5111      assume(currRing->algring!=NULL);
5112      lnumber n=(lnumber)pGetCoeff(p);
5113      ringvar=-p_Var(n->z,currRing->algring);
5114    }
5115    if(ringvar==0)
5116    {
5117      WerrorS("ringvar/par expected");
5118      return TRUE;
5119    }
5120  }
5121  return FALSE;
5122}
5123static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5124{
5125  int ringvar;
5126  poly monomexpr;
5127  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5128  if (nok) return TRUE;
5129  if (ringvar>0)
5130  {
5131    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5132      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5133    else
5134      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5135  }
5136  else
5137  {
5138    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5139  }
5140  return FALSE;
5141}
5142static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5143{
5144  int ringvar;
5145  poly monomexpr;
5146  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5147  if (nok) return TRUE;
5148  if (ringvar>0)
5149  {
5150    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5151      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5152    else
5153      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5154  }
5155  else
5156  {
5157    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5158  }
5159  return FALSE;
5160}
5161// we do not want to have jjSUBST_Id_X inlined:
5162static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5163                            int input_type);
5164static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5165{
5166  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5167}
5168static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5169{
5170  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5171}
5172static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5173{
5174  sleftv tmp;
5175  memset(&tmp,0,sizeof(tmp));
5176  // do not check the result, conversion from int/number to poly works always
5177  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5178  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5179  tmp.CleanUp();
5180  return b;
5181}
5182static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5183{
5184  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5185  ideal I=(ideal)u->CopyD(IDEAL_CMD);
5186  int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5187  //for(i=i-1;i>=0;i--)
5188  //{
5189  //  m->m[i]=I->m[i];
5190  //  I->m[i]=NULL;
5191  //}
5192  memcpy4(m->m,I->m,i*sizeof(poly));
5193  memset(I->m,0,i*sizeof(poly));
5194  idDelete(&I);
5195  res->data = (char *)m;
5196  return FALSE;
5197}
5198static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5199{
5200  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5201           (int)(long)v->Data(),(int)(long)w->Data());
5202  return FALSE;
5203}
5204static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5205{
5206  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5207  matrix I=(matrix)u->CopyD(MATRIX_CMD);
5208  int r=si_min(MATROWS(I),(int)(long)v->Data());
5209  int c=si_min(MATCOLS(I),(int)(long)w->Data());
5210  int i,j;
5211  for(i=r;i>0;i--)
5212  {
5213    for(j=c;j>0;j--)
5214    {
5215      MATELEM(m,i,j)=MATELEM(I,i,j);
5216      MATELEM(I,i,j)=NULL;
5217    }
5218  }
5219  idDelete((ideal *)&I);
5220  res->data = (char *)m;
5221  return FALSE;
5222}
5223static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5224{
5225  if (w->rtyp!=IDHDL) return TRUE;
5226  BITSET save_test=test;
5227  int ul= IDELEMS((ideal)u->Data());
5228  int vl= IDELEMS((ideal)v->Data());
5229  ideal m
5230    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5231             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5232  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5233  test=save_test;
5234  return FALSE;
5235}
5236static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5237{
5238  assumeStdFlag(v);
5239  if (!idIsZeroDim((ideal)v->Data()))
5240  {
5241    Werror("`%s` must be 0-dimensional",v->Name());
5242    return TRUE;
5243  }
5244  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5245    (poly)w->CopyD());
5246  return FALSE;
5247}
5248static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5249{
5250  assumeStdFlag(v);
5251  if (!idIsZeroDim((ideal)v->Data()))
5252  {
5253    Werror("`%s` must be 0-dimensional",v->Name());
5254    return TRUE;
5255  }
5256  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5257    (matrix)w->CopyD());
5258  return FALSE;
5259}
5260static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5261{
5262  assumeStdFlag(v);
5263  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5264    0,(int)(long)w->Data());
5265  return FALSE;
5266}
5267static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5268{
5269  assumeStdFlag(v);
5270  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5271    0,(int)(long)w->Data());
5272  return FALSE;
5273}
5274#ifdef OLD_RES
5275static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5276{
5277  int maxl=(int)v->Data();
5278  int l=0;
5279  resolvente r;
5280  intvec **weights=NULL;
5281  int wmaxl=maxl;
5282  maxl--;
5283  if ((maxl==-1) && (iiOp!=MRES_CMD))
5284    maxl = pVariables-1;
5285  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5286  {
5287    intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5288    if (iv!=NULL)
5289    {
5290      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5291      weights[0] = ivCopy(iv);
5292      l=1;
5293    }
5294    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
5295  }
5296  else
5297    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5298  if (r==NULL) return TRUE;
5299  int t3=u->Typ();
5300  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5301  return FALSE;
5302  return TRUE;
5303}
5304#endif
5305static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5306{
5307  res->data=(void *)rInit(u,v,w);
5308  return (res->data==NULL);
5309}
5310static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5311{
5312  int yes;
5313  jjSTATUS2(res, u, v);
5314  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5315  omFree((ADDRESS) res->data);
5316  res->data = (void *) yes;
5317  return FALSE;
5318}
5319static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5320{
5321  ideal result;
5322  intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5323  tHomog hom=testHomog;
5324  if (ww!=NULL)
5325  {
5326    ww=ivCopy(ww);
5327    hom=isHomog;
5328  }
5329  result=kStd((ideal)(u->Data()),
5330              currQuotient,
5331              hom,
5332              &ww,                  // module weights
5333              (intvec *)v->Data(),  // hilbert series
5334              0,0,                  // syzComp, newIdeal
5335              (intvec *)w->Data()); // weights of vars
5336  idSkipZeroes(result);
5337  res->data = (char *)result;
5338  setFlag(res,FLAG_STD);
5339  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5340  return FALSE;
5341}
5342
5343/*=================== operations with 3 args.: table =================*/
5344struct sValCmd3 dArith3[]=
5345{
5346// operations:
5347// proc             cmd          res         arg1        arg2        arg3   plural
5348 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5349,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5350,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5351,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5352,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5353,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5354,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5355,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5356,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5357,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5358,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
5359,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
5360,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5361,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5362,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5363,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5364,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
5365,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
5366,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5367,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5368,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
5369,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5370,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5371,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5372,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
5373//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5374,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5375,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5376,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5377,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5378,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5379,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5380,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
5381,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
5382,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5383,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5384,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
5385,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
5386,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5387,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5388,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5389,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5390,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
5391,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5392#ifdef OLD_RES
5393,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5394,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5395#endif
5396,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5397,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5398,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5399,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5400,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
5401,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5402,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5403,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5404,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5405,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5406,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5407,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
5408,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
5409,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5410,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5411#ifdef OLD_RES
5412,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5413,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5414#endif
5415#ifdef HAVE_FACTORY
5416,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5417#else
5418,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5419#endif
5420,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5421#ifdef OLD_RES
5422,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5423,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5424#endif
5425,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
5426,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5427,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5428,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5429,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5430,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5431,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5432,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5433,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5434,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
5435,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
5436,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
5437,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
5438,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
5439,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
5440};
5441/*=================== operations with many arg.: static proc =================*/
5442static BOOLEAN jjBREAK0(leftv res, leftv v)
5443{
5444#ifdef HAVE_SDB
5445  sdb_show_bp();
5446#endif
5447  return FALSE;
5448}
5449static BOOLEAN jjBREAK1(leftv res, leftv v)
5450{
5451#ifdef HAVE_SDB
5452  if(v->Typ()==PROC_CMD)
5453  {
5454    int lineno=0;
5455    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
5456    {
5457      lineno=(int)(long)v->next->Data();
5458    }
5459    return sdb_set_breakpoint(v->Name(),lineno);
5460  }
5461  return TRUE;
5462#else
5463 return FALSE;
5464#endif
5465}
5466static BOOLEAN jjCALL1ARG(leftv res, leftv v)
5467{
5468  return iiExprArith1(res,v,iiOp);
5469}
5470static BOOLEAN jjCALL2ARG(leftv res, leftv u)
5471{
5472  leftv v=u->next;
5473  u->next=NULL;
5474  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
5475  u->next=v;
5476  return b;
5477}
5478static BOOLEAN jjCALL3ARG(leftv res, leftv u)
5479{
5480  leftv v = u->next;
5481  leftv w = v->next;
5482  u->next = NULL;
5483  v->next = NULL;
5484  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5485  u->next = v;
5486  v->next = w;
5487  return b;
5488}
5489
5490static BOOLEAN jjCOEF_M(leftv res, leftv v)
5491{
5492  if((v->Typ() != VECTOR_CMD)
5493  || (v->next->Typ() != POLY_CMD)
5494  || (v->next->next->Typ() != MATRIX_CMD)
5495  || (v->next->next->next->Typ() != MATRIX_CMD))
5496     return TRUE;
5497  if (v->next->next->rtyp!=IDHDL) return TRUE;
5498  idhdl c=(idhdl)v->next->next->data;
5499  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
5500  idhdl m=(idhdl)v->next->next->next->data;
5501  idDelete((ideal *)&(c->data.uideal));
5502  idDelete((ideal *)&(m->data.uideal));
5503  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
5504    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
5505  return FALSE;
5506}
5507
5508static BOOLEAN jjDIVISION4(leftv res, leftv v)
5509{ // may have 3 or 4 arguments
5510  leftv v1=v;
5511  leftv v2=v1->next;
5512  leftv v3=v2->next;
5513  leftv v4=v3->next;
5514  assumeStdFlag(v2);
5515
5516  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
5517  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
5518
5519  if(i1==0||i2==0||v3->Typ()!=INT_CMD||(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
5520  {
5521    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
5522    return TRUE;
5523  }
5524
5525  sleftv w1,w2;
5526  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
5527  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
5528  ideal P=(ideal)w1.Data();
5529  ideal Q=(ideal)w2.Data();
5530
5531  int n=(int)(long)v3->Data();
5532  short *w=NULL;
5533  if(v4!=NULL)
5534  {
5535    w=iv2array((intvec *)v4->Data());
5536    short *w0=w+1;
5537    int i=pVariables;
5538    while(i>0&&*w0>0)
5539    {
5540      w0++;
5541      i--;
5542    }
5543    if(i>0)
5544      WarnS("not all weights are positive!");
5545  }
5546
5547  matrix T;
5548  ideal R;
5549  idLiftW(P,Q,n,T,R,w);
5550
5551  if(w!=NULL)
5552    omFree(w);
5553  lists L=(lists) omAllocBin(slists_bin);
5554  L->Init(2);
5555  L->m[1].rtyp=v1->Typ();
5556  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
5557  {
5558    if(v1->Typ()==POLY_CMD)
5559      pShift(&R->m[0],-1);
5560    L->m[1].data=(void *)R->m[0];
5561    R->m[0]=NULL;
5562    idDelete(&R);
5563  }
5564  else
5565  if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
5566    L->m[1].data=(void *)idModule2Matrix(R);
5567  else
5568    L->m[1].rtyp=MODUL_CMD;
5569  L->m[0].rtyp=MATRIX_CMD;
5570  L->m[0].data=(char *)T;
5571
5572  res->data=L;
5573  res->rtyp=LIST_CMD;
5574
5575  return FALSE;
5576}
5577
5578//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
5579//{
5580//  int l=u->listLength();
5581//  if (l<2) return TRUE;
5582//  BOOLEAN b;
5583//  leftv v=u->next;
5584//  leftv zz=v;
5585//  leftv z=zz;
5586//  u->next=NULL;
5587//  do
5588//  {
5589//    leftv z=z->next;
5590//    b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
5591//    if (b) break;
5592//  } while (z!=NULL);
5593//  u->next=zz;
5594//  return b;
5595//}
5596static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5597{
5598  int s=1;
5599  leftv h=v;
5600  if (h!=NULL) s=exprlist_length(h);
5601  ideal id=idInit(s,1);
5602  int rank=1;
5603  int i=0;
5604  poly p;
5605  while (h!=NULL)
5606  {
5607    switch(h->Typ())
5608    {
5609      case POLY_CMD:
5610      {
5611        p=(poly)h->CopyD(POLY_CMD);
5612        break;
5613      }
5614      case INT_CMD:
5615      {
5616        number n=nInit((int)(long)h->Data());
5617        if (!nIsZero(n))
5618        {
5619          p=pOne();
5620          pSetCoeff(p,n);
5621        }
5622        else
5623        {
5624          p=NULL;
5625          nDelete(&n);
5626        }
5627        break;
5628      }
5629      case NUMBER_CMD:
5630      {
5631        number n=(number)h->CopyD(NUMBER_CMD);
5632        if (!nIsZero(n))
5633        {
5634          p=pOne();
5635          pSetCoeff(p,n);
5636        }
5637        else
5638        {
5639          p=NULL;
5640          nDelete(&n);
5641        }
5642        break;
5643      }
5644      case VECTOR_CMD:
5645      {
5646        p=(poly)h->CopyD(VECTOR_CMD);
5647        if (iiOp!=MODUL_CMD)
5648        {
5649          idDelete(&id);
5650          pDelete(&p);
5651          return TRUE;
5652        }
5653        rank=si_max(rank,(int)pMaxComp(p));
5654        break;
5655      }
5656      default:
5657      {
5658        idDelete(&id);
5659        return TRUE;
5660      }
5661    }
5662    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
5663    {
5664      pSetCompP(p,1);
5665    }
5666    id->m[i]=p;
5667    i++;
5668    h=h->next;
5669  }
5670  id->rank=rank;
5671  res->data=(char *)id;
5672  return FALSE;
5673}
5674static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
5675{
5676  leftv h=v;
5677  int l=v->listLength();
5678  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
5679  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
5680  int t=0;
5681  // try to convert to IDEAL_CMD
5682  while (h!=NULL)
5683  {
5684    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
5685    {
5686      t=IDEAL_CMD;
5687    }
5688    else break;
5689    h=h->next;
5690  }
5691  // if failure, try MODUL_CMD
5692  if (t==0)
5693  {
5694    h=v;
5695    while (h!=NULL)
5696    {
5697      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
5698      {
5699        t=MODUL_CMD;
5700      }
5701      else break;
5702      h=h->next;
5703    }
5704  }
5705  // check for success  in converting
5706  if (t==0)
5707  {
5708    WerrorS("cannot convert to ideal or module");
5709    return TRUE;
5710  }
5711  // call idMultSect
5712  h=v;
5713  int i=0;
5714  sleftv tmp;
5715  while (h!=NULL)
5716  {
5717    if (h->Typ()==t)
5718    {
5719      r[i]=(ideal)h->Data(); /*no copy*/
5720      h=h->next;
5721    }
5722    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
5723    {
5724      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5725      omFreeSize((ADDRESS)r,l*sizeof(ideal));
5726      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
5727      return TRUE;
5728    }
5729    else
5730    {
5731      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
5732      copied[i]=TRUE;
5733      h=tmp.next;
5734    }
5735    i++;
5736  }
5737  res->rtyp=t;
5738  res->data=(char *)idMultSect(r,i);
5739  while(i>0)
5740  {
5741    i--;
5742    if (copied[i]) idDelete(&(r[i]));
5743  }
5744  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5745  omFreeSize((ADDRESS)r,l*sizeof(ideal));
5746  return FALSE;
5747}
5748static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
5749{
5750  int i=0;
5751  leftv h=v;
5752  if (h!=NULL) i=exprlist_length(h);
5753  intvec *iv=new intvec(i);
5754  i=0;
5755  while (h!=NULL)
5756  {
5757    if(h->Typ()==INT_CMD)
5758    {
5759      (*iv)[i]=(int)(long)h->Data();
5760    }
5761    else
5762    {
5763      delete iv;
5764      return TRUE;
5765    }
5766    i++;
5767    h=h->next;
5768  }
5769  res->data=(char *)iv;
5770  return FALSE;
5771}
5772static BOOLEAN jjJET4(leftv res, leftv u)
5773{
5774  leftv u1=u;
5775  leftv u2=u1->next;
5776  leftv u3=u2->next;
5777  leftv u4=u3->next;
5778  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5779     (u4->Typ()==INTVEC_CMD)||
5780     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5781     (u4->Typ()==INTVEC_CMD))
5782  {
5783    if(!pIsUnit((poly)u2->Data()))
5784    {
5785      WerrorS("2nd argument must be a unit");
5786      return TRUE;
5787    }
5788    res->rtyp=u1->Typ();
5789    res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
5790                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
5791    return FALSE;
5792  }
5793  else
5794  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5795     (u4->Typ()==INTVEC_CMD)||
5796     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5797     (u4->Typ()==INTVEC_CMD))
5798  {
5799    if(!mpIsDiagUnit((matrix)u2->Data()))
5800    {
5801      WerrorS("2nd argument must be a diagonal matrix of units");
5802      return TRUE;
5803    }
5804    res->rtyp=u1->Typ();
5805    res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
5806                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
5807    return FALSE;
5808  }
5809  else
5810  {
5811    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
5812           Tok2Cmdname(iiOp));
5813    return TRUE;
5814  }
5815}
5816static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
5817{
5818  if ((yyInRingConstruction)
5819  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
5820  {
5821    memcpy(res,u,sizeof(sleftv));
5822    memset(u,0,sizeof(sleftv));
5823    return FALSE;
5824  }
5825  leftv v=u->next;
5826  BOOLEAN b;
5827  if(v==NULL)
5828    b=iiExprArith1(res,u,iiOp);
5829  else
5830  {
5831    u->next=NULL;
5832    b=iiExprArith2(res,u,iiOp,v);
5833    u->next=v;
5834  }
5835  return b;
5836}
5837static BOOLEAN jjLIST_PL(leftv res, leftv v)
5838{
5839  int sl=0;
5840  if (v!=NULL) sl = v->listLength();
5841  lists L;
5842  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
5843  {
5844    int add_row_shift = 0;
5845    intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
5846    if (weights!=NULL)  add_row_shift=weights->min_in();
5847    L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
5848  }
5849  else
5850  {
5851    L=(lists)omAllocBin(slists_bin);
5852    leftv h=NULL;
5853    int i;
5854    int rt;
5855
5856    L->Init(sl);
5857    for (i=0;i<sl;i++)
5858    {
5859      if (h!=NULL) { /* e.g. not in the first step:
5860                     * h is the pointer to the old sleftv,
5861                     * v is the pointer to the next sleftv
5862                     * (in this moment) */
5863                     h->next=v;
5864                   }
5865      h=v;
5866      v=v->next;
5867      h->next=NULL;
5868      rt=h->Typ();
5869      if (rt==0)
5870      {
5871        L->Clean();
5872        Werror("`%s` is undefined",h->Fullname());
5873        return TRUE;
5874      }
5875      if ((rt==RING_CMD)||(rt==QRING_CMD))
5876      {
5877        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
5878        ((ring)L->m[i].data)->ref++;
5879      }
5880      else
5881        L->m[i].Copy(h);
5882    }
5883  }
5884  res->data=(char *)L;
5885  return FALSE;
5886}
5887static BOOLEAN jjNAMES0(leftv res, leftv v)
5888{
5889  res->data=(void *)ipNameList(IDROOT);
5890  return FALSE;
5891}
5892static BOOLEAN jjOPTION_PL(leftv res, leftv v)
5893{
5894  if(v==NULL)
5895  {
5896    res->data=(char *)showOption();
5897    return FALSE;
5898  }
5899  res->rtyp=NONE;
5900  return setOption(res,v);
5901}
5902static BOOLEAN jjREDUCE4(leftv res, leftv u)
5903{
5904  leftv u1=u;
5905  leftv u2=u1->next;
5906  leftv u3=u2->next;
5907  leftv u4=u3->next;
5908  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
5909  {
5910    int save_d=Kstd1_deg;
5911    Kstd1_deg=(int)(long)u3->Data();
5912    kModW=(intvec *)u4->Data();
5913    BITSET save=verbose;
5914    verbose|=Sy_bit(V_DEG_STOP);
5915    u2->next=NULL;
5916    BOOLEAN r=jjCALL2ARG(res,u);
5917    kModW=NULL;
5918    Kstd1_deg=save_d;
5919    verbose=save;
5920    u->next->next=u3;
5921    return r;
5922  }
5923  else
5924  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5925     (u4->Typ()==INT_CMD))
5926  {
5927    assumeStdFlag(u3);
5928    if(!mpIsDiagUnit((matrix)u2->Data()))
5929    {
5930      WerrorS("2nd argument must be a diagonal matrix of units");
5931      return TRUE;
5932    }
5933    res->rtyp=IDEAL_CMD;
5934    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5935                           mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
5936    return FALSE;
5937  }
5938  else
5939  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5940     (u4->Typ()==INT_CMD))
5941  {
5942    assumeStdFlag(u3);
5943    if(!pIsUnit((poly)u2->Data()))
5944    {
5945      WerrorS("2nd argument must be a unit");
5946      return TRUE;
5947    }
5948    res->rtyp=POLY_CMD;
5949    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5950                           pCopy((poly)u2->Data()),(int)(long)u4->Data());
5951    return FALSE;
5952  }
5953  else
5954  {
5955    Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
5956    return TRUE;
5957  }
5958}
5959static BOOLEAN jjREDUCE5(leftv res, leftv u)
5960{
5961  leftv u1=u;
5962  leftv u2=u1->next;
5963  leftv u3=u2->next;
5964  leftv u4=u3->next;
5965  leftv u5=u4->next;
5966  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5967     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5968  {
5969    assumeStdFlag(u3);
5970    if(!mpIsDiagUnit((matrix)u2->Data()))
5971    {
5972      WerrorS("2nd argument must be a diagonal matrix of units");
5973      return TRUE;
5974    }
5975    res->rtyp=IDEAL_CMD;
5976    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5977                           mpCopy((matrix)u2->Data()),
5978                           (int)(long)u4->Data(),(intvec*)u5->Data());
5979    return FALSE;
5980  }
5981  else
5982  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5983     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5984  {
5985    assumeStdFlag(u3);
5986    if(!pIsUnit((poly)u2->Data()))
5987    {
5988      WerrorS("2nd argument must be a unit");
5989      return TRUE;
5990    }
5991    res->rtyp=POLY_CMD;
5992    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5993                           pCopy((poly)u2->Data()),
5994                           (int)(long)u4->Data(),(intvec*)u5->Data());
5995    return FALSE;
5996  }
5997  else
5998  {
5999    Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
6000           Tok2Cmdname(iiOp));
6001    return TRUE;
6002  }
6003}
6004static BOOLEAN jjRESERVED0(leftv res, leftv v)
6005{
6006  int i=1;
6007  loop
6008  {
6009    Print("%-20s",cmds[i].name);
6010    i++;
6011    if(cmds[i].name==NULL)
6012      break;
6013    if ((i%3)==1) PrintLn();
6014  }
6015  PrintLn();
6016  return FALSE;
6017}
6018static BOOLEAN jjSTRING_PL(leftv res, leftv v)
6019{
6020  if (v == NULL)
6021  {
6022    res->data = omStrDup("");
6023    return FALSE;
6024  }
6025  int n = v->listLength();
6026  if (n == 1)
6027  {
6028    res->data = v->String();
6029    return FALSE;
6030  }
6031
6032  char** slist = (char**) omAlloc(n*sizeof(char*));
6033  int i, j;
6034
6035  for (i=0, j=0; i<n; i++, v = v ->next)
6036  {
6037    slist[i] = v->String();
6038    assume(slist[i] != NULL);
6039    j+=strlen(slist[i]);
6040  }
6041  char* s = (char*) omAlloc((j+1)*sizeof(char));
6042  *s='\0';
6043  for (i=0;i<n;i++)
6044  {
6045    strcat(s, slist[i]);
6046    omFree(slist[i]);
6047  }
6048  omFreeSize(slist, n*sizeof(char*));
6049  res->data = s;
6050  return FALSE;
6051}
6052static BOOLEAN jjTEST(leftv res, leftv v)
6053{
6054  do
6055  {
6056    if (v->Typ()!=INT_CMD)
6057      return TRUE;
6058    test_cmd((int)(long)v->Data());
6059    v=v->next;
6060  }
6061  while (v!=NULL);
6062  return FALSE;
6063}
6064
6065#if defined(__alpha) && !defined(linux)
6066extern "C"
6067{
6068  void usleep(unsigned long usec);
6069};
6070#endif
6071
6072static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6073{
6074  if ((v->Typ() != LINK_CMD) ||
6075      (v->next->Typ() != STRING_CMD) ||
6076      (v->next->next->Typ() != STRING_CMD) ||
6077      (v->next->next->next->Typ() != INT_CMD))
6078    return TRUE;
6079  jjSTATUS3(res, v, v->next, v->next->next);
6080#if defined(HAVE_USLEEP)
6081  if (((long) res->data) == 0L)
6082  {
6083    int i_s = (int)(long) v->next->next->next->Data();
6084    if (i_s > 0)
6085    {
6086      usleep((int)(long) v->next->next->next->Data());
6087      jjSTATUS3(res, v, v->next, v->next->next);
6088    }
6089  }
6090#elif defined(HAVE_SLEEP)
6091  if (((int) res->data) == 0)
6092  {
6093    int i_s = (int) v->next->next->next->Data();
6094    if (i_s > 0)
6095    {
6096      sleep((is - 1)/1000000 + 1);
6097      jjSTATUS3(res, v, v->next, v->next->next);
6098    }
6099  }
6100#endif
6101  return FALSE;
6102}
6103static BOOLEAN jjSUBST_M(leftv res, leftv u)
6104{
6105  leftv v = u->next; // number of args > 0
6106  if (v==NULL) return TRUE;
6107  leftv w = v->next;
6108  if (w==NULL) return TRUE;
6109  leftv rest = w->next;;
6110
6111  u->next = NULL;
6112  v->next = NULL;
6113  w->next = NULL;
6114  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6115  if ((rest!=NULL) && (!b))
6116  {
6117    sleftv tmp_res;
6118    leftv tmp_next=res->next;
6119    res->next=rest;
6120    memset(&tmp_res,0,sizeof(tmp_res));
6121    b = iiExprArithM(&tmp_res,res,iiOp);
6122    memcpy(res,&tmp_res,sizeof(tmp_res));
6123    res->next=tmp_next;
6124  }
6125  u->next = v;
6126  v->next = w;
6127  // rest was w->next, but is already cleaned
6128  return b;
6129}
6130
6131/*=================== operations with many arg.: table =================*/
6132/* number_of_args:  -1: any, -2: any >0, .. */
6133struct sValCmdM dArithM[]=
6134{
6135// operations:
6136// proc         cmd               res            number_of_args plural
6137 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2       ALLOW_PLURAL}
6138,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0        ALLOW_PLURAL}
6139,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2       ALLOW_PLURAL}
6140,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2        ALLOW_PLURAL}
6141,{jjCOEF_M,    COEF_CMD,        NONE,               4        ALLOW_PLURAL}
6142,{jjCALL2ARG,  DIVISION_CMD,    ANY_TYPE/*or set by p*/,2    ALLOW_PLURAL}
6143,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,3    NO_PLURAL}
6144,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,4    NO_PLURAL}
6145,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2       ALLOW_PLURAL}
6146//,{jjEXPORTTO_M,  EXPORTTO_CMD,    NONE,             -2       ALLOW_PLURAL}
6147,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1        ALLOW_PLURAL}
6148,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1       ALLOW_PLURAL}
6149,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2        ALLOW_PLURAL}
6150,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2       ALLOW_PLURAL}
6151,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1        ALLOW_PLURAL}
6152,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2       ALLOW_PLURAL}
6153,{jjCALL2ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 2   ALLOW_PLURAL}
6154,{jjCALL3ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 3   ALLOW_PLURAL}
6155,{jjJET4,      JET_CMD,         POLY_CMD,/*or set by p*/ 4   ALLOW_PLURAL}
6156,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1       ALLOW_PLURAL}
6157,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1        ALLOW_PLURAL}
6158,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1       ALLOW_PLURAL}
6159,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1       ALLOW_PLURAL}
6160,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0       ALLOW_PLURAL}
6161,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 ALLOW_PLURAL}
6162,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  2 ALLOW_PLURAL}
6163,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  3 ALLOW_PLURAL}
6164,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  4 ALLOW_PLURAL}
6165,{jjREDUCE5,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  5 ALLOW_PLURAL}
6166,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1       ALLOW_PLURAL}
6167,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0       ALLOW_PLURAL}
6168,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1       ALLOW_PLURAL}
6169,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3        ALLOW_PLURAL}
6170,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2       ALLOW_PLURAL}
6171,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2       ALLOW_PLURAL}
6172,{jjTEST,      TEST_CMD,        NONE,               -2       ALLOW_PLURAL}
6173,{iiWRITE,     WRITE_CMD,       NONE,               -2       ALLOW_PLURAL}
6174,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2       ALLOW_PLURAL}
6175,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3       ALLOW_PLURAL}
6176,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4       ALLOW_PLURAL}
6177,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6       NO_PLURAL}
6178,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4       NO_PLURAL}
6179,{NULL,        0,               0,                   0       NO_PLURAL}
6180};
6181#ifdef MDEBUG
6182static Subexpr jjDBMakeSub(leftv e,char *f, int l)
6183#else
6184static Subexpr jjMakeSub(leftv e)
6185#endif
6186{
6187  assume( e->Typ()==INT_CMD );
6188  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
6189  r->start =(int)(long)e->Data();
6190  return r;
6191}
6192
6193/*================ generating tables ============================*/
6194#ifdef GENTABLE
6195extern struct sValAssign dAssign[];
6196struct sValCmdTab dArithTab1[]={ {0,0}};
6197#define JJTAB1LEN 0
6198struct sValCmdTab dArithTab2[]={ {0,0}};
6199#define JJTAB2LEN 0
6200void ttGen1()
6201{
6202  FILE *outfile = myfopen("iparith.inc","w");
6203  int i,j,l1=0,l2=0;
6204  currRing=(ring)omAllocBin(sip_sring_bin);
6205  fprintf(outfile,
6206  "/****************************************\n"
6207  "*  Computer Algebra System SINGULAR     *\n"
6208  "****************************************/\n\n");
6209/*-------------------------------------------------------------------*/
6210  fprintf(outfile,"// syntax table for Singular\n//\n");
6211  fprintf(outfile,"// - search for an exact match of the argument types\n");
6212  fprintf(outfile,"// - otherwise search for the first possibility\n");
6213  fprintf(outfile,"//   with converted types of the arguments\n");
6214  fprintf(outfile,"// - otherwise report an error\n//\n");
6215
6216  int op;
6217  i=0;
6218  while ((op=dArith1[i].cmd)!=0)
6219  {
6220    if (dArith1[i].p==jjWRONG)
6221      fprintf(outfile,"// DUMMY ");
6222    char *s = iiTwoOps(op);
6223    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
6224          s,
6225          Tok2Cmdname(dArith1[i].arg),
6226          Tok2Cmdname(ABS(dArith1[i].res)));
6227    i++;
6228  }
6229  fprintf(outfile,"/*---------------------------------------------*/\n");
6230  i=0;
6231  while ((op=dArith2[i].cmd)!=0)
6232  {
6233    if (dArith2[i].p==jjWRONG2)
6234      fprintf(outfile,"// DUMMY ");
6235    char *s = iiTwoOps(op);
6236    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
6237          s,
6238          Tok2Cmdname(dArith2[i].arg1),
6239          Tok2Cmdname(dArith2[i].arg2),
6240          Tok2Cmdname(dArith2[i].res));
6241    i++;
6242  }
6243  fprintf(outfile,"/*---------------------------------------------*/\n");
6244  i=0;
6245  while ((op=dArith3[i].cmd)!=0)
6246  {
6247    char *s = iiTwoOps(op);
6248    if (dArith3[i].p==jjWRONG3)
6249      fprintf(outfile,"// DUMMY ");
6250    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
6251          s,
6252          Tok2Cmdname(dArith3[i].arg1),
6253          Tok2Cmdname(dArith3[i].arg2),
6254          Tok2Cmdname(dArith3[i].arg3),
6255          Tok2Cmdname(dArith3[i].res));
6256    i++;
6257  }
6258  fprintf(outfile,"/*---------------------------------------------*/\n");
6259  i=0;
6260  while ((op=dArithM[i].cmd)!=0)
6261  {
6262    char *s = iiTwoOps(op);
6263    fprintf(outfile,"// operation: %s (...)  ->  %s",
6264          s,
6265          Tok2Cmdname(dArithM[i].res));
6266    switch(dArithM[i].number_of_args)
6267    {
6268      case -2:
6269         fprintf(outfile," ( number of arguments >0 )\n");
6270         break;
6271      case -1:
6272         fprintf(outfile," ( any number of arguments )\n");
6273         break;
6274      default:
6275         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
6276         break;
6277    }
6278    i++;
6279  }
6280  fprintf(outfile,"/*---------------------------------------------*/\n");
6281  i=0;
6282  while ((op=dAssign[i].res)!=0)
6283  {
6284    fprintf(outfile,"// assign: %s =  %s\n",
6285          Tok2Cmdname(op/*dAssign[i].res*/),
6286          Tok2Cmdname(dAssign[i].arg));
6287    i++;
6288  }
6289/*-------------------------------------------------------------------*/
6290  fprintf(outfile,"/*---------------------------------------------*/\n");
6291  for (j=257;j<=MAX_TOK+1;j++)
6292  {
6293    for(i=257;i<=MAX_TOK+1;i++)
6294    {
6295      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
6296      && iiTestConvert(i,j))
6297      {
6298        fprintf(outfile,"// convert %s -> %s\n",
6299          Tok2Cmdname(i), Tok2Cmdname(j));
6300        if (j==ANY_TYPE) break;
6301      }
6302    }
6303  }
6304  fprintf(outfile,"/*---------------------------------------------*/\n");
6305  char ops[]="=><+*/[.^,%(;";
6306  for(i=0;ops[i]!='\0';i++)
6307    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
6308  for (i=257;i<=MAX_TOK;i++)
6309  {
6310    char *s=iiTwoOps(i);
6311    if (s[0]!='$')
6312    {
6313      fprintf(outfile,"// token %d : %s\n", i, s);
6314    }
6315  }
6316/*-------------------------------------------------------------------*/
6317  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
6318/*-------------------------------------------------------------------*/
6319  fprintf(outfile,"/*---------------------------------------------*/\n");
6320  fprintf(outfile,
6321  "struct sValCmdTab dArithTab1[]=\n"
6322  "{\n");
6323  for (j=1;j<=MAX_TOK+1;j++)
6324  {
6325    for(i=0;dArith1[i].cmd!=0;i++)
6326    {
6327      if (dArith1[i].cmd==j)
6328      {
6329        fprintf(outfile," { %d,%d },\n",j,i);
6330        l1++;
6331        break;
6332      }
6333    }
6334  }
6335  fprintf(outfile," { 10000,0 }\n};\n");
6336  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
6337/*-------------------------------------------------------------------*/
6338  fprintf(outfile,
6339  "struct sValCmdTab dArithTab2[]=\n"
6340  "{\n");
6341  for (j=1;j<=MAX_TOK+1;j++)
6342  {
6343    for(i=0;dArith2[i].cmd!=0;i++)
6344    {
6345      if (dArith2[i].cmd==j)
6346      {
6347        fprintf(outfile," { %d,%d },\n",j,i);
6348        l2++;
6349        break;
6350      }
6351    }
6352  }
6353  fprintf(outfile," { 10000,0 }\n};\n");
6354  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
6355  fclose(outfile);
6356}
6357/*-------------------------------------------------------------------*/
6358void ttGen2()
6359{
6360  FILE *outfile = myfopen("iparith.inc","a");
6361  fprintf(outfile,
6362  "/****************************************\n"
6363  "*  Computer Algebra System SINGULAR     *\n"
6364  "****************************************/\n\n");
6365/*-------------------------------------------------------------------*/
6366  fprintf(outfile,"// identifier table for Singular\n//\n");
6367
6368  fprintf(outfile,
6369  "cmdnames cmds[] =\n"
6370  "{  // name-string     alias  tokval toktype\n"
6371  "{ \"$INVALID$\",            0,  -1, 0},\n");
6372  int i=1;
6373  int m=-1;
6374  int id_nr=0;
6375  BOOLEAN f=FALSE;
6376  loop
6377  {
6378    while (cmds[i].tokval!=0)
6379    {
6380      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
6381      {
6382        if(m==-1)
6383        {
6384          m=i;
6385          f=TRUE;
6386        }
6387        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6388        {
6389          m=i;
6390          f=TRUE;
6391        }
6392      }
6393      i++;
6394    }
6395    if(f)
6396    {
6397      id_nr++;
6398      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
6399      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
6400                                             20-strlen(cmds[m].name),
6401                                             cmds[m].alias,
6402                                             cmds[m].tokval);
6403      switch(cmds[m].toktype)
6404      {
6405        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
6406        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
6407        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
6408        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
6409        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
6410        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
6411        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
6412        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
6413        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
6414        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
6415        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
6416        case NONE:             fprintf(outfile,"NONE },\n"); break;
6417        default:               if((cmds[m].toktype>' ')
6418                               &&(cmds[m].toktype<127))
6419                               {
6420                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
6421                               }
6422                               else
6423                               {
6424                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
6425                               }
6426                               break;
6427      }
6428      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
6429      cmds[m].name=NULL;
6430      m=-1;
6431      i=1;
6432      f=FALSE;
6433    }
6434    else break;
6435  }
6436  fprintf(outfile,
6437"/* list of scanner identifiers/only for feread/reservedName */\n");
6438  f=FALSE;
6439  i=1;m=-1;
6440  loop
6441  {
6442    while (cmds[i].tokval!=0)
6443    {
6444      if (cmds[i].name!=NULL)
6445      {
6446        if(m==-1)
6447        {
6448          m=i;
6449          f=TRUE;
6450        }
6451        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6452        {
6453          m=i;
6454          f=TRUE;
6455        }
6456      }
6457      i++;
6458    }
6459    if(f)
6460    {
6461      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
6462                                             20-strlen(cmds[m].name),
6463                                             0/*cmds[m].alias*/
6464                                             /*-1 cmds[m].tokval*/
6465                                             /*0 cmds[m].toktype*/);
6466      cmds[m].name=NULL;
6467      m=-1;
6468      i=1;
6469      f=FALSE;
6470    }
6471    else break;
6472  }
6473  fprintf(outfile,
6474"/* end of list marker */\n"
6475"  { NULL, 0, 0, 0}\n"
6476"};\n"
6477"#ifdef HAVE_RTIMER\n"
6478"#define LAST_IDENTIFIER %d\n"
6479"#else\n"
6480"#define LAST_IDENTIFIER %d\n"
6481"#endif\n",id_nr,id_nr-1);
6482  fclose(outfile);
6483}
6484/*-------------------------------------------------------------------*/
6485#if 0
6486void ttGen3()
6487{
6488  FILE *outfile = myfopen("mpsr_tok.inc","w");
6489  fprintf(outfile,
6490  "/****************************************\n"
6491  "*  Computer Algebra System SINGULAR     *\n"
6492  "****************************************/\n\n");
6493/*-------------------------------------------------------------------*/
6494  fprintf(outfile,"// token table for Singular\n//\n");
6495
6496  fprintf(outfile,
6497  "short vtok[] =\n"
6498  "{\n");
6499  // operations with 1 arg: ===========================================
6500  int i=0;
6501  while (dArith1[i].cmd!=0)
6502  {
6503    if ((dArith1[i].p!=jjWRONG)
6504    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
6505    {
6506      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
6507    }
6508    i++;
6509  }
6510  // operations with 2 args: ===========================================
6511  i=0;
6512  while (dArith2[i].cmd!=0)
6513  {
6514    if ((dArith2[i].p!=jjWRONG2)
6515    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
6516    {
6517      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
6518    }
6519    i++;
6520  }
6521  // operations with 3 args: ===========================================
6522  i=0;
6523  while (dArith3[i].cmd!=0)
6524  {
6525    if (
6526    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
6527    {
6528      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
6529    }
6530    i++;
6531  }
6532  // operations with many args: ===========================================
6533  i=0;
6534  while (dArithM[i].cmd!=0)
6535  {
6536    if (
6537    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
6538    {
6539      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
6540    }
6541    i++;
6542  }
6543  // ====================================================================
6544  fprintf(outfile,
6545  "/* end of list marker */\n"
6546  " %d };\n",MAX_TOK);
6547  fclose(outfile);
6548}
6549#endif
6550void ttGen4()
6551{
6552  FILE *outfile = myfopen("plural_cmd.inc","w");
6553  int i;
6554  char *old_s="";
6555  fprintf(outfile,
6556  "@c *****************************************\n"
6557  "@c *  Computer Algebra System SINGULAR     *\n"
6558  "@c *****************************************\n\n");
6559/*-------------------------------------------------------------------*/
6560  fprintf(outfile,"@multicolumn .45 .45\n");
6561  int op;
6562  i=0;
6563  while ((op=dArith1[i].cmd)!=0)
6564  {
6565    if (dArith1[i].p!=jjWRONG)
6566    {
6567      char *s = iiTwoOps(op);
6568      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6569      {
6570        old_s=s;
6571        switch (dArith1[i].valid_for_plural)
6572        {
6573          case NO_PLURAL_N:
6574            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6575            break;
6576          case ALLOW_PLURAL_N:
6577            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6578            break;
6579          case COMM_PLURAL_N:
6580            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6581            break;
6582        }
6583      }
6584    }
6585    i++;
6586  }
6587  fprintf(outfile,"@c ---------------------------------------------\n");
6588  i=0;
6589  while ((op=dArith2[i].cmd)!=0)
6590  {
6591    if (dArith2[i].p!=jjWRONG2)
6592    {
6593      char *s = iiTwoOps(op);
6594      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6595      {
6596        old_s=s;
6597        switch (dArith2[i].valid_for_plural)
6598        {
6599          case NO_PLURAL_N:
6600            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6601            break;
6602          case ALLOW_PLURAL_N:
6603            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6604            break;
6605          case COMM_PLURAL_N:
6606            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6607            break;
6608        }
6609      }
6610    }
6611    i++;
6612  }
6613  fprintf(outfile,"@c ---------------------------------------------\n");
6614  i=0;
6615  while ((op=dArith3[i].cmd)!=0)
6616  {
6617    char *s = iiTwoOps(op);
6618    if (dArith3[i].p!=jjWRONG3)
6619    {
6620      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6621      {
6622        old_s=s;
6623        switch (dArith3[i].valid_for_plural)
6624        {
6625          case NO_PLURAL_N:
6626            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6627            break;
6628          case ALLOW_PLURAL_N:
6629            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6630            break;
6631          case COMM_PLURAL_N:
6632            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6633            break;
6634        }
6635      }
6636    }
6637    i++;
6638  }
6639  fprintf(outfile,"@c ---------------------------------------------\n");
6640  i=0;
6641  while ((op=dArithM[i].cmd)!=0)
6642  {
6643    char *s = iiTwoOps(op);
6644    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6645    {
6646        old_s=s;
6647        switch (dArithM[i].valid_for_plural)
6648        {
6649          case NO_PLURAL_N:
6650            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6651            break;
6652          case ALLOW_PLURAL_N:
6653            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6654            break;
6655          case COMM_PLURAL_N:
6656            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6657            break;
6658        }
6659    }
6660    i++;
6661  }
6662  fprintf(outfile,"@c ---------------------------------------------\n");
6663  fprintf(outfile,"@end table\n");
6664  fclose(outfile);
6665}
6666/*-------------------------------------------------------------------*/
6667#else
6668#include "iparith.inc"
6669#endif
6670
6671/*=================== operations with 2 args. ============================*/
6672
6673BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
6674{
6675#ifndef GENTABLE
6676  memset(res,0,sizeof(sleftv));
6677
6678  if (!errorreported)
6679  {
6680#ifdef SIQ
6681    if (siq>0)
6682    {
6683      //Print("siq:%d\n",siq);
6684      command d=(command)omAlloc0Bin(ip_command_bin);
6685      memcpy(&d->arg1,a,sizeof(sleftv));
6686      memcpy(&d->arg2,b,sizeof(sleftv));
6687      d->argc=2;
6688      d->op=op;
6689      res->data=(char *)d;
6690      res->rtyp=COMMAND;
6691      return FALSE;
6692    }
6693#endif
6694    int at=a->Typ();
6695    int bt=b->Typ();
6696    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
6697    int index=i;
6698
6699    iiOp=op;
6700    while (dArith2[i].cmd==op)
6701    {
6702      if ((at==dArith2[i].arg1)
6703      && (bt==dArith2[i].arg2))
6704      {
6705        res->rtyp=dArith2[i].res;
6706        #ifdef HAVE_PLURAL
6707        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6708        {
6709          if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6710          {
6711            WerrorS(ii_not_for_plural);
6712            break;
6713          }
6714          else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6715          {
6716            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6717          }
6718          /* else ALLOW_PLURAL */
6719        }
6720        #endif
6721        if (dArith2[i].p(res,a,b))
6722        {
6723          break;// leave loop, goto error handling
6724        }
6725        a->CleanUp();
6726        b->CleanUp();
6727        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6728        return FALSE;
6729      }
6730      i++;
6731    }
6732    // implicite type conversion ----------------------------------------------
6733    if (dArith2[i].cmd!=op)
6734    {
6735      int ai,bi;
6736      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6737      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
6738      BOOLEAN failed=FALSE;
6739      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6740      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
6741      while (dArith2[i].cmd==op)
6742      {
6743        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6744        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
6745        {
6746          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
6747          {
6748            res->rtyp=dArith2[i].res;
6749            #ifdef HAVE_PLURAL
6750            if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6751            {
6752              if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6753              {
6754                WerrorS(ii_not_for_plural);
6755                break;
6756              }
6757              else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6758              {
6759                Warn("assume commutative subalgebra for cmd `%s`",
6760                      Tok2Cmdname(i));
6761              }
6762              /* else ALLOW_PLURAL */
6763            }
6764            #endif
6765            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
6766            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
6767            || (dArith2[i].p(res,an,bn)));
6768            // everything done, clean up temp. variables
6769            if (failed)
6770            {
6771              // leave loop, goto error handling
6772              break;
6773            }
6774            else
6775            {
6776              // everything ok, clean up and return
6777              an->CleanUp();
6778              bn->CleanUp();
6779              omFreeBin((ADDRESS)an, sleftv_bin);
6780              omFreeBin((ADDRESS)bn, sleftv_bin);
6781              a->CleanUp();
6782              b->CleanUp();
6783              return FALSE;
6784            }
6785          }
6786        }
6787        i++;
6788      }
6789      an->CleanUp();
6790      bn->CleanUp();
6791      omFreeBin((ADDRESS)an, sleftv_bin);
6792      omFreeBin((ADDRESS)bn, sleftv_bin);
6793    }
6794    // error handling ---------------------------------------------------
6795    const char *s=NULL;
6796    if (!errorreported)
6797    {
6798      if ((at==0) && (a->Fullname()!=sNoName))
6799      {
6800        s=a->Fullname();
6801      }
6802      else if ((bt==0) && (b->Fullname()!=sNoName))
6803      {
6804        s=b->Fullname();
6805      }
6806      if (s!=NULL)
6807        Werror("`%s` is not defined",s);
6808      else
6809      {
6810        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6811        s = iiTwoOps(op);
6812        if (proccall)
6813        {
6814          Werror("%s(`%s`,`%s`) is not supported"
6815                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
6816        }
6817        else
6818        {
6819          Werror("`%s` %s `%s` is not supported"
6820                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
6821        }
6822        if (BVERBOSE(V_SHOW_USE))
6823        {
6824          while (dArith2[i].cmd==op)
6825          {
6826            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
6827            && (dArith2[i].res!=0)
6828            && (dArith2[i].p!=jjWRONG2))
6829            {
6830              if (proccall)
6831                Werror("expected %s(`%s`,`%s`)"
6832                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6833              else
6834                Werror("expected `%s` %s `%s`"
6835                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
6836            }
6837            i++;
6838          }
6839        }
6840      }
6841    }
6842    res->rtyp = UNKNOWN;
6843  }
6844  a->CleanUp();
6845  b->CleanUp();
6846#endif
6847  return TRUE;
6848}
6849
6850/*==================== operations with 1 arg. ===============================*/
6851
6852BOOLEAN iiExprArith1(leftv res, leftv a, int op)
6853{
6854#ifndef GENTABLE
6855  memset(res,0,sizeof(sleftv));
6856
6857  if (!errorreported)
6858  {
6859#ifdef SIQ
6860    if (siq>0)
6861    {
6862      //Print("siq:%d\n",siq);
6863      command d=(command)omAlloc0Bin(ip_command_bin);
6864      memcpy(&d->arg1,a,sizeof(sleftv));
6865      d->op=op;
6866      d->argc=1;
6867      res->data=(char *)d;
6868      res->rtyp=COMMAND;
6869      return FALSE;
6870    }
6871#endif
6872    int at=a->Typ();
6873    BOOLEAN failed=FALSE;
6874
6875    iiOp=op;
6876    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
6877    int ti = i;
6878    while (dArith1[i].cmd==op)
6879    {
6880      if (at==dArith1[i].arg)
6881      {
6882        int r=res->rtyp=dArith1[i].res;
6883        #ifdef HAVE_PLURAL
6884        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6885        {
6886          if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
6887          {
6888            WerrorS(ii_not_for_plural);
6889            break;
6890          }
6891          else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
6892          {
6893            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6894          }
6895          /* else ALLOW_PLURAL */
6896        }
6897        #endif
6898        if (r<0)
6899        {
6900          res->rtyp=-r;
6901          #ifdef PROC_BUG
6902          dArith1[i].p(res,a);
6903          #else
6904          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
6905          #endif
6906        }
6907        else if (dArith1[i].p(res,a))
6908        {
6909          break;// leave loop, goto error handling
6910        }
6911        if (a->Next()!=NULL)
6912        {
6913          res->next=(leftv)omAllocBin(sleftv_bin);
6914          failed=iiExprArith1(res->next,a->next,op);
6915        }
6916        a->CleanUp();
6917        return failed;
6918      }
6919      i++;
6920    }
6921    // implicite type conversion --------------------------------------------
6922    if (dArith1[i].cmd!=op)
6923    {
6924      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6925      i=ti;
6926      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
6927      while (dArith1[i].cmd==op)
6928      {
6929        int ai;
6930        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
6931        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
6932        {
6933          int r=res->rtyp=dArith1[i].res;
6934          #ifdef HAVE_PLURAL
6935          if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6936          {
6937            if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
6938            {
6939              WerrorS(ii_not_for_plural);
6940              break;
6941            }
6942            else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
6943            {
6944              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6945            }
6946            /* else ALLOW_PLURAL */
6947          }
6948          #endif
6949          if (r<0)
6950          {
6951            res->rtyp=-r;
6952            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
6953            if (!failed)
6954            {
6955              #ifdef PROC_BUG
6956              dArith1[i].p(res,a);
6957              #else
6958              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
6959              #endif
6960            }
6961          }
6962          else
6963          {
6964            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
6965            || (dArith1[i].p(res,an)));
6966          }
6967          // everything done, clean up temp. variables
6968          if (failed)
6969          {
6970            // leave loop, goto error handling
6971            break;
6972          }
6973          else
6974          {
6975            if (an->Next() != NULL)
6976            {
6977              res->next = (leftv)omAllocBin(sleftv_bin);
6978              failed=iiExprArith1(res->next,an->next,op);
6979            }
6980            // everything ok, clean up and return
6981            an->CleanUp();
6982            omFreeBin((ADDRESS)an, sleftv_bin);
6983            a->CleanUp();
6984            return failed;
6985          }
6986        }
6987        i++;
6988      }
6989      an->CleanUp();
6990      omFreeBin((ADDRESS)an, sleftv_bin);
6991    }
6992    // error handling
6993    if (!errorreported)
6994    {
6995      if ((at==0) && (a->Fullname()!=sNoName))
6996      {
6997        Werror("`%s` is not defined",a->Fullname());
6998      }
6999      else
7000      {
7001        i=ti;
7002        char *s = iiTwoOps(op);
7003        Werror("%s(`%s`) is not supported"
7004                ,s,Tok2Cmdname(at));
7005        if (BVERBOSE(V_SHOW_USE))
7006        {
7007          while (dArith1[i].cmd==op)
7008          {
7009            if ((dArith1[i].res!=0)
7010            && (dArith1[i].p!=jjWRONG))
7011              Werror("expected %s(`%s`)"
7012                ,s,Tok2Cmdname(dArith1[i].arg));
7013            i++;
7014          }
7015        }
7016      }
7017    }
7018    res->rtyp = UNKNOWN;
7019  }
7020  a->CleanUp();
7021#endif
7022  return TRUE;
7023}
7024
7025/*=================== operations with 3 args. ============================*/
7026
7027BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
7028{
7029#ifndef GENTABLE
7030  memset(res,0,sizeof(sleftv));
7031
7032  if (!errorreported)
7033  {
7034#ifdef SIQ
7035    if (siq>0)
7036    {
7037      //Print("siq:%d\n",siq);
7038      command d=(command)omAlloc0Bin(ip_command_bin);
7039      memcpy(&d->arg1,a,sizeof(sleftv));
7040      memcpy(&d->arg2,b,sizeof(sleftv));
7041      memcpy(&d->arg3,c,sizeof(sleftv));
7042      d->op=op;
7043      d->argc=3;
7044      res->data=(char *)d;
7045      res->rtyp=COMMAND;
7046      return FALSE;
7047    }
7048#endif
7049    int at=a->Typ();
7050    int bt=b->Typ();
7051    int ct=c->Typ();
7052
7053    iiOp=op;
7054    int i=0;
7055    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7056    while (dArith3[i].cmd==op)
7057    {
7058      if ((at==dArith3[i].arg1)
7059      && (bt==dArith3[i].arg2)
7060      && (ct==dArith3[i].arg3))
7061      {
7062        res->rtyp=dArith3[i].res;
7063        #ifdef HAVE_PLURAL
7064        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7065        {
7066            if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7067            {
7068              WerrorS(ii_not_for_plural);
7069              break;
7070            }
7071            else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7072            {
7073              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7074            }
7075            /* else ALLOW_PLURAL */
7076        }
7077        #endif
7078        if (dArith3[i].p(res,a,b,c))
7079        {
7080          break;// leave loop, goto error handling
7081        }
7082        a->CleanUp();
7083        b->CleanUp();
7084        c->CleanUp();
7085        return FALSE;
7086      }
7087      i++;
7088    }
7089    // implicite type conversion ----------------------------------------------
7090    if (dArith3[i].cmd!=op)
7091    {
7092      int ai,bi,ci;
7093      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7094      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7095      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
7096      BOOLEAN failed=FALSE;
7097      i=0;
7098      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7099      while (dArith3[i].cmd==op)
7100      {
7101        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
7102        {
7103          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
7104          {
7105            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
7106            {
7107              res->rtyp=dArith3[i].res;
7108              #ifdef HAVE_PLURAL
7109              if ((currRing!=NULL)
7110              && (rIsPluralRing(currRing)))
7111              {
7112                if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7113                {
7114                   WerrorS(ii_not_for_plural);
7115                   break;
7116                 }
7117                 else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7118                 {
7119                   Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7120                 }
7121                 /* else ALLOW_PLURAL */
7122              }
7123              #endif
7124              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
7125                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
7126                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
7127                || (dArith3[i].p(res,an,bn,cn)));
7128              // everything done, clean up temp. variables
7129              if (failed)
7130              {
7131                // leave loop, goto error handling
7132                break;
7133              }
7134              else
7135              {
7136                // everything ok, clean up and return
7137                an->CleanUp();
7138                bn->CleanUp();
7139                cn->CleanUp();
7140                omFreeBin((ADDRESS)an, sleftv_bin);
7141                omFreeBin((ADDRESS)bn, sleftv_bin);
7142                omFreeBin((ADDRESS)cn, sleftv_bin);
7143                a->CleanUp();
7144                b->CleanUp();
7145                c->CleanUp();
7146        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7147                return FALSE;
7148              }
7149            }
7150          }
7151        }
7152        i++;
7153      }
7154      an->CleanUp();
7155      bn->CleanUp();
7156      cn->CleanUp();
7157      omFreeBin((ADDRESS)an, sleftv_bin);
7158      omFreeBin((ADDRESS)bn, sleftv_bin);
7159      omFreeBin((ADDRESS)cn, sleftv_bin);
7160    }
7161    // error handling ---------------------------------------------------
7162    if (!errorreported)
7163    {
7164      const char *s=NULL;
7165      if ((at==0) && (a->Fullname()!=sNoName))
7166      {
7167        s=a->Fullname();
7168      }
7169      else if ((bt==0) && (b->Fullname()!=sNoName))
7170      {
7171        s=b->Fullname();
7172      }
7173      else if ((ct==0) && (c->Fullname()!=sNoName))
7174      {
7175        s=c->Fullname();
7176      }
7177      if (s!=NULL)
7178        Werror("`%s` is not defined",s);
7179      else
7180      {
7181        i=0;
7182        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7183        char *s = iiTwoOps(op);
7184        Werror("%s(`%s`,`%s`,`%s`) is not supported"
7185                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
7186        if (BVERBOSE(V_SHOW_USE))
7187        {
7188          while (dArith3[i].cmd==op)
7189          {
7190            if(((at==dArith3[i].arg1)
7191            ||(bt==dArith3[i].arg2)
7192            ||(ct==dArith3[i].arg3))
7193            && (dArith3[i].res!=0))
7194            {
7195              Werror("expected %s(`%s`,`%s`,`%s`)"
7196                  ,s,Tok2Cmdname(dArith3[i].arg1)
7197                  ,Tok2Cmdname(dArith3[i].arg2)
7198                  ,Tok2Cmdname(dArith3[i].arg3));
7199            }
7200            i++;
7201          }
7202        }
7203      }
7204    }
7205    res->rtyp = UNKNOWN;
7206  }
7207  a->CleanUp();
7208  b->CleanUp();
7209  c->CleanUp();
7210        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7211#endif
7212  return TRUE;
7213}
7214/*==================== operations with many arg. ===============================*/
7215
7216BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
7217{
7218  // cnt = 0: all
7219  // cnt = 1: only first one
7220  leftv next;
7221  BOOLEAN failed = TRUE;
7222  if(v==NULL) return failed;
7223  res->rtyp = LIST_CMD;
7224  if(cnt) v->next = NULL;
7225  next = v->next;             // saving next-pointer
7226  failed = jjLIST_PL(res, v);
7227  v->next = next;             // writeback next-pointer
7228  return failed;
7229}
7230
7231BOOLEAN iiExprArithM(leftv res, leftv a, int op)
7232{
7233#ifndef GENTABLE
7234  memset(res,0,sizeof(sleftv));
7235
7236  if (!errorreported)
7237  {
7238#ifdef SIQ
7239    if (siq>0)
7240    {
7241      //Print("siq:%d\n",siq);
7242      command d=(command)omAlloc0Bin(ip_command_bin);
7243      d->op=op;
7244      res->data=(char *)d;
7245      if (a!=NULL)
7246      {
7247        d->argc=a->listLength();
7248        // else : d->argc=0;
7249        memcpy(&d->arg1,a,sizeof(sleftv));
7250        switch(d->argc)
7251        {
7252          case 3:
7253            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
7254            a->next->next->rtyp=0;
7255            a->next->next->data=NULL;
7256            a->next->next->name=NULL;
7257            a->next->next->attribute=NULL;
7258            /* no break */
7259          case 2:
7260            memcpy(&d->arg2,a->next,sizeof(sleftv));
7261            a->next->rtyp=0;
7262            a->next->name=NULL;
7263            a->next->data=NULL;
7264            a->next->attribute=NULL;
7265            d->arg2.next=NULL;
7266            /* no break */
7267          case 1:
7268            d->arg1.next=NULL;
7269        }
7270        if (d->argc>3) a->next=NULL;
7271        a->rtyp=0;
7272        a->data=NULL;
7273        a->name=NULL;
7274        a->CleanUp();
7275      }
7276      res->rtyp=COMMAND;
7277      return FALSE;
7278    }
7279#endif
7280    BOOLEAN failed=FALSE;
7281    int args=0;
7282    if (a!=NULL) args=a->listLength();
7283
7284    iiOp=op;
7285    int i=0;
7286    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
7287    while (dArithM[i].cmd==op)
7288    {
7289      if ((args==dArithM[i].number_of_args)
7290      || (dArithM[i].number_of_args==-1)
7291      || ((dArithM[i].number_of_args==-2)&&(args>0)))
7292      {
7293        res->rtyp=dArithM[i].res;
7294        #ifdef HAVE_PLURAL
7295        if ((currRing!=NULL)
7296        && (rIsPluralRing(currRing)))
7297        {
7298          if (dArithM[i].valid_for_plural==0 /*NO_PLURAL*/)
7299          {
7300            WerrorS(ii_not_for_plural);
7301            break;
7302          }
7303          else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
7304          {
7305            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7306          }
7307          /* else ALLOW_PLURAL */
7308        }
7309        #endif
7310        if (dArithM[i].p(res,a))
7311        {
7312          break;// leave loop, goto error handling
7313        }
7314        if (a!=NULL) a->CleanUp();
7315        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7316        return failed;
7317      }
7318      i++;
7319    }
7320    // error handling
7321    if (!errorreported)
7322    {
7323      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
7324      {
7325        Werror("`%s` is not defined",a->Fullname());
7326      }
7327      else
7328      {
7329        char *s = iiTwoOps(op);
7330        Werror("%s(...) is not supported",s);
7331      }
7332    }
7333    res->rtyp = UNKNOWN;
7334  }
7335  if (a!=NULL) a->CleanUp();
7336        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7337#endif
7338  return TRUE;
7339}
7340
7341/*=================== general utilities ============================*/
7342int IsCmd(const char *n, int & tok)
7343{
7344  int an=1;
7345  int i,v;
7346#ifndef GENTABLE
7347  int en=LAST_IDENTIFIER;
7348
7349  loop
7350  {
7351    if(an>=en-1)
7352    {
7353      if (strcmp(n, cmds[an].name) == 0)
7354      {
7355        i=an;
7356        break;
7357      }
7358      else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
7359      {
7360        i=en;
7361        break;
7362      }
7363      else
7364      {
7365        return 0;
7366      }
7367    }
7368    i=(an+en)/2;
7369    if (*n < *(cmds[i].name))
7370    {
7371      en=i-1;
7372    }
7373    else if (*n > *(cmds[i].name))
7374    {
7375      an=i+1;
7376    }
7377    else
7378    {
7379      v=strcmp(n,cmds[i].name);
7380      if(v<0)
7381      {
7382        en=i-1;
7383      }
7384      else if(v>0)
7385      {
7386        an=i+1;
7387      }
7388      else /*v==0*/
7389      {
7390        break;
7391      }
7392    }
7393  }
7394  lastreserved=cmds[i].name;
7395  tok=cmds[i].tokval;
7396  if(cmds[i].alias==2)
7397  {
7398    Warn("outdated identifier `%s` used - please change your code",
7399    cmds[i].name);
7400    cmds[i].alias=1;
7401  }
7402  if (currRingHdl==NULL)
7403  {
7404    #ifdef SIQ
7405    if (siq<=0)
7406    {
7407    #endif
7408      if ((tok>=BEGIN_RING) && (tok<=END_RING))
7409      {
7410        WerrorS("no ring active");
7411        return 0;
7412      }
7413    #ifdef SIQ
7414    }
7415    #endif
7416  }
7417  if (!expected_parms)
7418  {
7419    switch (tok)
7420    {
7421      case IDEAL_CMD:
7422      case INT_CMD:
7423      case INTVEC_CMD:
7424      case MAP_CMD:
7425      case MATRIX_CMD:
7426      case MODUL_CMD:
7427      case POLY_CMD:
7428      case PROC_CMD:
7429      case RING_CMD:
7430      case STRING_CMD:
7431        cmdtok = tok;
7432        break;
7433    }
7434  }
7435  return cmds[i].toktype;
7436#else
7437  return 0;
7438#endif
7439}
7440static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
7441{
7442#ifndef GENTABLE
7443  int a=0;
7444  int e=len;
7445  int p=len/2;
7446  do
7447  {
7448     if (op==dArithTab[p].cmd) return dArithTab[p].start;
7449     if (op<dArithTab[p].cmd) e=p-1;
7450     else   a = p+1;
7451     p=a+(e-a)/2;
7452  }
7453  while ( a <= e);
7454
7455#endif
7456  assume(0);
7457  return 0;
7458}
7459
Note: See TracBrowser for help on using the repository browser.