source: git/Singular/iparith.cc @ a96818

spielwiese
Last change on this file since a96818 was a96818, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes: code simplified git-svn-id: file:///usr/local/Singular/svn/trunk@8750 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 215.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.383 2005-10-26 10:42:40 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 *)((long)u->Data() >= (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 *)((long)u->Data()>(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 *)((long)u->Data() <= (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 jjMINOR(leftv res, leftv u, leftv v)
2021{
2022  res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2023  return (res->data==NULL);
2024}
2025static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2026{
2027  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2028  tHomog hom=testHomog;
2029  if (w_u!=NULL)
2030  {
2031    w_u=ivCopy(w_u);
2032    hom=isHomog;
2033  }
2034  intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2035  if (w_v!=NULL)
2036  {
2037    w_v=ivCopy(w_v);
2038    hom=isHomog;
2039  }
2040  if ((w_u!=NULL) && (w_v==NULL))
2041    w_v=ivCopy(w_u);
2042  if ((w_v!=NULL) && (w_u==NULL))
2043    w_u=ivCopy(w_v);
2044  ideal u_id=(ideal)u->Data();
2045  ideal v_id=(ideal)v->Data();
2046  if (w_u!=NULL)
2047  {
2048     if ((*w_u).compare((w_v))!=0)
2049     {
2050       WarnS("incompatible weights");
2051       delete w_u; w_u=NULL;
2052       hom=testHomog;
2053     }
2054     else
2055     {
2056       if ((!idHomModule(u_id,currQuotient,&w_v))
2057       || (!idHomModule(v_id,currQuotient,&w_v)))
2058       {
2059         WarnS("wrong weights");
2060         delete w_u; w_u=NULL;
2061         hom=testHomog;
2062       }
2063     }
2064  }
2065  res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2066  if (w_u!=NULL)
2067  {
2068    atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2069  }
2070  delete w_v;
2071  return FALSE;
2072}
2073static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2074{
2075  number q=(number)v->Data();
2076  if (nIsZero(q))
2077  {
2078    WerrorS(ii_div_by_0);
2079    return TRUE;
2080  }
2081  res->data =(char *) nIntMod((number)u->Data(),q);
2082  return FALSE;
2083}
2084static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2085{
2086  char *opt=(char *)v->Data();
2087  int mode=0;
2088  while(*opt!='\0')
2089  {
2090    if (*opt=='i') mode |= PROT_I;
2091    else if (*opt=='o') mode |= PROT_O;
2092    opt++;
2093  }
2094  monitor((char *)(u->Data()),mode);
2095  return FALSE;
2096}
2097static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2098{
2099  idhdl h=(idhdl)u->data;
2100  int i=(int)(long)v->Data();
2101  int p=0;
2102  if ((0<i)
2103  && (IDRING(h)->parameter!=NULL)
2104  && (i<=(p=rPar(IDRING(h)))))
2105    res->data=omStrDup(IDRING(h)->parameter[i-1]);
2106  else
2107  {
2108    Werror("par number %d out of range 1..%d",i,p);
2109    return TRUE;
2110  }
2111  return FALSE;
2112}
2113
2114#ifdef HAVE_PLURAL
2115static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2116{
2117  return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2118}
2119
2120static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2121{
2122  return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2123}
2124
2125static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2126{
2127  return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2128}
2129
2130static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2131{
2132  return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2133}
2134
2135static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2136{
2137  if (rIsPluralRing(currRing))
2138  {
2139    poly p = (poly)a->CopyD(POLY_CMD);
2140    poly q = (poly)b->Data();
2141    res->data = nc_p_Bracket_qq(p,q);
2142  }
2143  else res->data=NULL;
2144  return FALSE;
2145}
2146
2147static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2148{
2149  /* number, poly, vector, ideal, module, matrix */
2150  ring  r = (ring)a->Data();
2151  if (r == currRing)
2152  {
2153    res->data = b->Data();
2154    res->rtyp = b->rtyp;
2155    return FALSE;
2156  }
2157  if (!rIsLikeOpposite(currRing, r))
2158  {
2159    Werror("%s is not an opposite ring to current ring",a->Fullname());
2160    return TRUE;
2161  }
2162  idhdl w;
2163  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2164  {
2165    int argtype = IDTYP(w);
2166    switch (argtype)
2167    {
2168    case NUMBER_CMD:
2169      {
2170        /* since basefields are equal, we can apply nCopy */
2171        res->data = nCopy((number)IDDATA(w));
2172        res->rtyp = argtype;
2173        break;
2174      }
2175    case POLY_CMD:
2176    case VECTOR_CMD:
2177      {
2178        poly    q = (poly)IDDATA(w);
2179        res->data = pOppose(r,q);
2180        res->rtyp = argtype;
2181        break;
2182      }
2183    case IDEAL_CMD:
2184    case MODUL_CMD:
2185      {
2186        ideal   Q = (ideal)IDDATA(w);
2187        res->data = idOppose(r,Q);
2188        res->rtyp = argtype;
2189        break;
2190      }
2191    case MATRIX_CMD:
2192      {
2193        ring save = currRing;
2194        rChangeCurrRing(r);
2195        matrix  m = (matrix)IDDATA(w);
2196        ideal   Q = idMatrix2Module(mpCopy(m));
2197        rChangeCurrRing(save);
2198        ideal   S = idOppose(r,Q);
2199        id_Delete(&Q, r);
2200        res->data = idModule2Matrix(S);
2201        res->rtyp = argtype;
2202        break;
2203      }
2204    default:
2205      {
2206        WerrorS("unsupported type in oppose");
2207        return TRUE;
2208      }
2209    }
2210  }
2211  else
2212  {
2213    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2214    return TRUE;
2215  }
2216  return FALSE;
2217}
2218#endif /* HAVE_PLURAL */
2219
2220static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2221{
2222  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2223    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2224  idDelMultiples((ideal)(res->data));
2225  return FALSE;
2226}
2227static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2228{
2229  int i=(int)(long)u->Data();
2230  int j=(int)(long)v->Data();
2231#ifdef buildin_rand
2232  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
2233#else
2234  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
2235#endif
2236  return FALSE;
2237}
2238static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2239{
2240  si_link l=(si_link)u->Data();
2241  leftv r=slRead(l,v);
2242  if (r==NULL)
2243  {
2244    const char *s;
2245    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2246    else                            s=sNoName;
2247    Werror("cannot read from `%s`",s);
2248    return TRUE;
2249  }
2250  memcpy(res,r,sizeof(sleftv));
2251  omFreeBin((ADDRESS)r, sleftv_bin);
2252  return FALSE;
2253}
2254static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2255{
2256  assumeStdFlag(v);
2257  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2258  return FALSE;
2259}
2260static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2261{
2262  assumeStdFlag(v);
2263  ideal ui=(ideal)u->Data();
2264  idTest(ui);
2265  ideal vi=(ideal)v->Data();
2266  idTest(vi);
2267  res->data = (char *)kNF(vi,currQuotient,ui);
2268  return FALSE;
2269}
2270#if 0
2271static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2272{
2273  int maxl=(int)(long)v->Data();
2274  if (maxl<0)
2275  {
2276    WerrorS("length for res must not be negative");
2277    return TRUE;
2278  }
2279  int l=0;
2280  //resolvente r;
2281  syStrategy r;
2282  intvec *weights=NULL;
2283  int wmaxl=maxl;
2284  ideal u_id=(ideal)u->Data();
2285
2286  maxl--;
2287  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2288  {
2289    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2290    if (currQuotient!=NULL)
2291    {
2292      Warn(
2293      "full resolution in a qring may be infinite, setting max length to %d",
2294      maxl+1);
2295    }
2296  }
2297  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2298  if (weights!=NULL)
2299  {
2300    if (!idTestHomModule(u_id,currQuotient,weights))
2301    {
2302      WarnS("wrong weights given:");weights->show();PrintLn();
2303      weights=NULL;
2304    }
2305  }
2306
2307  intvec *ww=NULL;
2308  int add_row_shift=0;
2309  if (weights!=NULL)
2310  {
2311     ww=ivCopy(weights);
2312     add_row_shift = ww->min_in();
2313     (*ww) -= add_row_shift;
2314  }
2315  else
2316    idHomModule(u_id,currQuotient,&ww);
2317  weights=ww;
2318
2319  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2320  {
2321    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2322  }
2323  else if (iiOp==SRES_CMD)
2324  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2325    r=sySchreyer(u_id,maxl+1);
2326  else if (iiOp == LRES_CMD)
2327  {
2328    int dummy;
2329    if((currQuotient!=NULL)||
2330    (!idHomIdeal (u_id,NULL)))
2331    {
2332       WerrorS
2333       ("`lres` not implemented for inhomogeneous input or qring");
2334       return TRUE;
2335    }
2336    r=syLaScala3(u_id,&dummy);
2337  }
2338  else if (iiOp == KRES_CMD)
2339  {
2340    int dummy;
2341    if((currQuotient!=NULL)||
2342    (!idHomIdeal (u_id,NULL)))
2343    {
2344       WerrorS
2345       ("`kres` not implemented for inhomogeneous input or qring");
2346       return TRUE;
2347    }
2348    r=syKosz(u_id,&dummy);
2349  }
2350  else
2351  {
2352    int dummy;
2353    if((currQuotient!=NULL)||
2354    (!idHomIdeal (u_id,NULL)))
2355    {
2356       WerrorS
2357       ("`hres` not implemented for inhomogeneous input or qring");
2358       return TRUE;
2359    }
2360    r=syHilb(u_id,&dummy);
2361  }
2362  if (r==NULL) return TRUE;
2363  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2364  r->list_length=wmaxl;
2365  res->data=(void *)r;
2366  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2367  {
2368    intvec *w=ivCopy(r->weights[0]);
2369    if (weights!=NULL) (*w) += add_row_shift;
2370    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2371    delete w;
2372  }
2373  else
2374  {
2375//#if 0
2376// need to set weights for ALL components (sres)
2377    if (weights!=NULL)
2378    {
2379      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2380      r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2381      (r->weights)[0] = ivCopy(weights);
2382    }
2383//#endif
2384  }
2385  if (ww!=NULL) { delete ww; ww=NULL; }
2386  return FALSE;
2387}
2388#else
2389static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2390{
2391  int maxl=(int)(long)v->Data();
2392  if (maxl<0)
2393  {
2394    WerrorS("length for res must not be negative");
2395    return TRUE;
2396  }
2397  int l=0;
2398  //resolvente r;
2399  syStrategy r;
2400  intvec *weights=NULL;
2401  int wmaxl=maxl;
2402  ideal u_id=(ideal)u->Data();
2403
2404  maxl--;
2405  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2406  {
2407    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2408    if (currQuotient!=NULL)
2409    {
2410      Warn(
2411      "full resolution in a qring may be infinite, setting max length to %d",
2412      maxl+1);
2413    }
2414  }
2415  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2416  if (weights!=NULL)
2417  {
2418    if (!idTestHomModule(u_id,currQuotient,weights))
2419    {
2420      WarnS("wrong weights given:");weights->show();PrintLn();
2421      weights=NULL;
2422    }
2423  }
2424  intvec *ww=NULL;
2425  int add_row_shift=0;
2426  if (weights!=NULL)
2427  {
2428     ww=ivCopy(weights);
2429     add_row_shift = ww->min_in();
2430     (*ww) -= add_row_shift;
2431  }
2432
2433  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2434  {
2435    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2436  }
2437  else if (iiOp==SRES_CMD)
2438  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2439    r=sySchreyer(u_id,maxl+1);
2440  else if (iiOp == LRES_CMD)
2441  {
2442    int dummy;
2443    if((currQuotient!=NULL)||
2444    (!idHomIdeal (u_id,NULL)))
2445    {
2446       WerrorS
2447       ("`lres` not implemented for inhomogeneous input or qring");
2448       return TRUE;
2449    }
2450    r=syLaScala3(u_id,&dummy);
2451  }
2452  else if (iiOp == KRES_CMD)
2453  {
2454    int dummy;
2455    if((currQuotient!=NULL)||
2456    (!idHomIdeal (u_id,NULL)))
2457    {
2458       WerrorS
2459       ("`kres` not implemented for inhomogeneous input or qring");
2460       return TRUE;
2461    }
2462    r=syKosz(u_id,&dummy);
2463  }
2464  else
2465  {
2466    int dummy;
2467    if((currQuotient!=NULL)||
2468    (!idHomIdeal (u_id,NULL)))
2469    {
2470       WerrorS
2471       ("`hres` not implemented for inhomogeneous input or qring");
2472       return TRUE;
2473    }
2474    r=syHilb(u_id,&dummy);
2475  }
2476  if (r==NULL) return TRUE;
2477  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2478  r->list_length=wmaxl;
2479  res->data=(void *)r;
2480  if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2481  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2482  {
2483    ww=ivCopy(r->weights[0]);
2484    if (weights!=NULL) (*ww) += add_row_shift;
2485    atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2486  }
2487  else
2488  {
2489    if (weights!=NULL)
2490    {
2491      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2492    }
2493  }
2494  return FALSE;
2495}
2496#endif
2497static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2498{
2499  ring r;
2500  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2501  res->data = (char *)r;
2502  return (i==-1);
2503}
2504#define SIMPL_LMDIV 32
2505#define SIMPL_LMEQ  16
2506#define SIMPL_MULT 8
2507#define SIMPL_EQU  4
2508#define SIMPL_NULL 2
2509#define SIMPL_NORM 1
2510static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2511{
2512  int sw = (int)(long)v->Data();
2513  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2514  ideal id = (ideal)u->CopyD(IDEAL_CMD);
2515  if (sw & SIMPL_LMDIV)
2516  {
2517    idDelDiv(id);
2518  }
2519  if (sw & SIMPL_LMEQ)
2520  {
2521    idDelLmEquals(id);
2522  }
2523  if (sw & SIMPL_NULL)
2524  {
2525    idSkipZeroes(id);
2526  }
2527  if (sw & SIMPL_NORM)
2528  {
2529    idNorm(id);
2530  }
2531  if (sw & SIMPL_MULT)
2532  {
2533    idDelMultiples(id);
2534  }
2535  else if(sw & SIMPL_EQU)
2536  {
2537    idDelEquals(id);
2538  }
2539  res->data = (char * )id;
2540  return FALSE;
2541}
2542#ifdef HAVE_FACTORY
2543extern int singclap_factorize_retry;
2544static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2545{
2546  intvec *v=NULL;
2547  int sw=(int)(long)dummy->Data();
2548  int fac_sw=sw;
2549  if ((sw<0)||(sw>2)) fac_sw=1;
2550  singclap_factorize_retry=0;
2551  ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2552  if (f==NULL)
2553    return TRUE;
2554  switch(sw)
2555  {
2556    case 0:
2557    case 2:
2558    {
2559      lists l=(lists)omAllocBin(slists_bin);
2560      l->Init(2);
2561      l->m[0].rtyp=IDEAL_CMD;
2562      l->m[0].data=(void *)f;
2563      l->m[1].rtyp=INTVEC_CMD;
2564      l->m[1].data=(void *)v;
2565      res->data=(void *)l;
2566      res->rtyp=LIST_CMD;
2567      return FALSE;
2568    }
2569    case 1:
2570      res->data=(void *)f;
2571      return FALSE;
2572    case 3:
2573      {
2574        poly p=f->m[0];
2575        int i=IDELEMS(f);
2576        f->m[0]=NULL;
2577        while(i>1)
2578        {
2579          i--;
2580          p=pMult(p,f->m[i]);
2581          f->m[i]=NULL;
2582        }
2583        res->data=(void *)p;
2584        res->rtyp=POLY_CMD;
2585      }
2586      return FALSE;
2587  }
2588  WerrorS("invalid switch");
2589  return TRUE;
2590}
2591#endif
2592static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2593{
2594  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2595  return FALSE;
2596}
2597static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2598{
2599  int sw = (int)(long)v->Data();
2600  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2601  poly p = (poly)u->CopyD(POLY_CMD);
2602  if (sw & SIMPL_NORM)
2603  {
2604    pNorm(p);
2605  }
2606  res->data = (char * )p;
2607  return FALSE;
2608}
2609static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2610{
2611  ideal result;
2612  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2613  tHomog hom=testHomog;
2614  if (w!=NULL)
2615  {
2616    w=ivCopy(w);
2617    hom=isHomog;
2618  }
2619  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
2620  idSkipZeroes(result);
2621  res->data = (char *)result;
2622  setFlag(res,FLAG_STD);
2623  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2624  return FALSE;
2625}
2626static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2627{
2628  assumeStdFlag(u);
2629  ideal result;
2630  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2631  tHomog hom=testHomog;
2632  if (w!=NULL)
2633  {
2634    w=ivCopy(w);
2635    hom=isHomog;
2636  }
2637  ideal i1=(ideal)u->Data();
2638  ideal i0=idInit(1,i1->rank);
2639  i0->m[0]=(poly)v->Data();
2640  i1=idSimpleAdd(i1,i0);
2641  i0->m[0]=NULL;
2642  idDelete(&i0);
2643  BITSET save_test=test;
2644  test|=Sy_bit(OPT_SB_1);
2645  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2646  test=save_test;
2647  idDelete(&i1);
2648  idSkipZeroes(result);
2649  res->data = (char *)result;
2650  setFlag(res,FLAG_STD);
2651  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2652  return FALSE;
2653}
2654static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2655{
2656  idhdl h=(idhdl)u->data;
2657  int i=(int)(long)v->Data();
2658  if ((0<i) && (i<=IDRING(h)->N))
2659    res->data=omStrDup(IDRING(h)->names[i-1]);
2660  else
2661  {
2662    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2663    return TRUE;
2664  }
2665  return FALSE;
2666}
2667static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2668{
2669  res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2670  return FALSE;
2671}
2672#define jjWRONG2 (proc2)jjWRONG
2673#define jjWRONG3 (proc3)jjWRONG
2674static BOOLEAN jjWRONG(leftv res, leftv u)
2675{
2676  return TRUE;
2677}
2678
2679static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2680{
2681  char * s=(char *)u->Data();
2682  if(strcmp(s, "with")==0)
2683    return jjLOAD(res, v, TRUE);
2684  WerrorS("invalid second argument");
2685  WerrorS("load(\"libname\" [,\"with\"]);");
2686  return TRUE;
2687}
2688
2689/*=================== operations with 2 args.: table =================*/
2690
2691struct sValCmd2 dArith2[]=
2692{
2693// operations:
2694// proc        cmd              res             arg1        arg2   plural
2695 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2696,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2697,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2698,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2699,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2700,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2701,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2702,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
2703,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2704,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2705,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
2706,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2707,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2708,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2709,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2710,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2711,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2712,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
2713,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
2714,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  RING_CMD ALLOW_PLURAL}
2715,{jjRSUM,      '+',            QRING_CMD,      RING_CMD,   QRING_CMD ALLOW_PLURAL}
2716,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  QRING_CMD ALLOW_PLURAL}
2717,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2718,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2719,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2720,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2721,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2722,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2723,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2724,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2725,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2726,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2727,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2728,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2729,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2730,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
2731,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2732,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2733,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2734,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2735,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2736,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2737,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2738,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2739,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2740,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
2741,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2742,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2743,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2744,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD ALLOW_PLURAL}
2745,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2746,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2747,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2748,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2749,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2750,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2751,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2752,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2753,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2754,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2755,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2756,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2757,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2758,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2759,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2760,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2761,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2762,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2763,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2764,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2765,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2766,{jjMOD_N,     '%',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2767,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2768,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2769,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2770,{jjMOD_N,     INTMOD_CMD,     NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2771,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2772,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2773,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2774,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2775,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2776,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2777,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2778,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2779,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2780,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2781,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2782,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2783,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2784,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2785,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2786,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2787,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2788,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2789,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2790,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2791,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2792,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2793,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2794,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2795,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2796,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2797,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2798,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2799,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2800,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2801,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2802,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2803,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2804,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2805,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2806,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2807,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2808,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2809,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2810,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2811,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2812,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2813,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2814,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2815,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2816,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2817,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2818,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2819,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2820,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2821,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2822,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2823,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2824,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2825,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2826,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2827,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2828,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2829,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2830,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
2831,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2832,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2833,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2834,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
2835,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2836,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2837,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2838,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
2839,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2840,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2841,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2842,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2843,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2844,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2845,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2846,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2847,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
2848,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2849,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2850// and the procedures with 2 arguments:
2851,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
2852,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2853,{jjBETTI2,    BETTI_CMD,      INTMAT_CMD,     LIST_CMD,   INT_CMD ALLOW_PLURAL}
2854,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2855,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2856,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2857#ifdef HAVE_PLURAL
2858,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2859#endif
2860,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2861,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2862,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2863,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2864,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2865,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2866,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2867,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2868,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2869,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
2870,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2871,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2872,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2873,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2874,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2875,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2876,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2877,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2878,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2879,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
2880,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2881,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2882,{jjEXPORTTO,  EXPORTTO_CMD,   NONE,           PACKAGE_CMD, IDHDL ALLOW_PLURAL}
2883,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
2884#ifdef HAVE_FACTORY
2885,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2886,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2887,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2888#else
2889,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2890,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2891,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2892#endif
2893,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2894,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2895#ifdef HAVE_FGLM
2896,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2897,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2898,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
2899#else
2900,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2901,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2902,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2903#endif
2904,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2905,{jjFWALK,     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2906
2907,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2908,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2909#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
2910,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2911#else
2912,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2913#endif
2914,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
2915,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
2916,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2917,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2918,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2919,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2920,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2921,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2922,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2923,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2924,{jjIMPORTFROM,IMPORTFROM_CMD, NONE,           PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
2925,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2926,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
2927,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2928,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2929,{jjJanetBasis2, JANET_CMD,    IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2930,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2931,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2932,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2933,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2934,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
2935,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2936,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2937,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
2938,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
2939,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
2940,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2941,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2942,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2943,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2944,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2945,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2946,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2947,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
2948,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2949,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2950,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2951,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2952//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2953//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2954,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2955,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2956#ifdef HAVE_PLURAL
2957,{jjPlural_num_poly, NCALGEBRA_CMD,  NONE,  POLY_CMD,   POLY_CMD   NO_PLURAL}
2958,{jjPlural_num_mat,  NCALGEBRA_CMD,  NONE,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
2959,{jjPlural_mat_poly, NCALGEBRA_CMD,  NONE,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
2960,{jjPlural_mat_mat,  NCALGEBRA_CMD,  NONE,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
2961#endif
2962#ifdef HAVE_PLURAL
2963,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
2964,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, QRING_CMD,   DEF_CMD ALLOW_PLURAL}
2965#endif
2966,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2967,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2968,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
2969,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2970,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2971,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2972,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2973,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2974,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2975,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2976,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
2977,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2978,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2979,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2980//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2981//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2982,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2983,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2984,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2985,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2986,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2987,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2988,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2989//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2990//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2991,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2992,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
2993,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
2994,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2995,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2996,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
2997,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
2998,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2999,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3000,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
3001,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
3002,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
3003,{NULL,        0,              0,              0,          0 NO_PLURAL}
3004};
3005/*=================== operations with 1 arg.: static proc =================*/
3006static BOOLEAN jjDUMMY(leftv res, leftv u)
3007{
3008  res->data = (char *)u->CopyD();
3009  return FALSE;
3010}
3011static BOOLEAN jjNULL(leftv res, leftv u)
3012{
3013  return FALSE;
3014}
3015//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3016//{
3017//  res->data = (char *)((int)(long)u->Data()+1);
3018//  return FALSE;
3019//}
3020//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3021//{
3022//  res->data = (char *)((int)(long)u->Data()-1);
3023//  return FALSE;
3024//}
3025static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3026{
3027  if (IDTYP((idhdl)u->data)==INT_CMD)
3028  {
3029    if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
3030    else                IDINT((idhdl)u->data)--;
3031    return FALSE;
3032  }
3033  return TRUE;
3034}
3035static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3036{
3037  res->data = (char *)(-(int)(long)u->Data());
3038  return FALSE;
3039}
3040static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3041{
3042  number n=(number)u->CopyD(NUMBER_CMD);
3043  n=nNeg(n);
3044  res->data = (char *)n;
3045  return FALSE;
3046}
3047static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3048{
3049  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3050  return FALSE;
3051}
3052static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3053{
3054  poly m1=pISet(-1);
3055  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3056  return FALSE;
3057}
3058static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3059{
3060  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3061  (*iv)*=(-1);
3062  res->data = (char *)iv;
3063  return FALSE;
3064}
3065static BOOLEAN jjPROC1(leftv res, leftv u)
3066{
3067  return jjPROC(res,u,NULL);
3068}
3069static BOOLEAN jjBAREISS(leftv res, leftv v)
3070{
3071  //matrix m=(matrix)v->Data();
3072  //lists l=mpBareiss(m,FALSE);
3073  intvec *iv;
3074  ideal m;
3075  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3076  lists l=(lists)omAllocBin(slists_bin);
3077  l->Init(2);
3078  l->m[0].rtyp=MODUL_CMD;
3079  l->m[1].rtyp=INTVEC_CMD;
3080  l->m[0].data=(void *)m;
3081  l->m[1].data=(void *)iv;
3082  res->data = (char *)l;
3083  return FALSE;
3084}
3085//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3086//{
3087//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3088//  ivTriangMat(m);
3089//  res->data = (char *)m;
3090//  return FALSE;
3091//}
3092static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3093{
3094  return iiExprArithM(res,u,iiOp);
3095}
3096static BOOLEAN jjCHAR(leftv res, leftv v)
3097{
3098  res->data = (char *)rChar((ring)v->Data());
3099  return FALSE;
3100}
3101static BOOLEAN jjCOLS(leftv res, leftv v)
3102{
3103  res->data = (char *)MATCOLS((matrix)(v->Data()));
3104  return FALSE;
3105}
3106static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3107{
3108  res->data = (char *)((intvec*)(v->Data()))->cols();
3109  return FALSE;
3110}
3111static BOOLEAN jjCONTENT(leftv res, leftv v)
3112{
3113  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3114  poly p=(poly)v->CopyD(POLY_CMD);
3115  if (p!=NULL) pCleardenom(p);
3116  res->data = (char *)p;
3117  return FALSE;
3118}
3119static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3120{
3121  res->data = (char *)nSize((number)v->Data());
3122  return FALSE;
3123}
3124static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3125{
3126  lists l=(lists)v->Data();
3127  res->data = (char *)(l->nr+1);
3128  return FALSE;
3129}
3130static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3131{
3132  matrix m=(matrix)v->Data();
3133  res->data = (char *)(MATROWS(m)*MATCOLS(m));
3134  return FALSE;
3135}
3136static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3137{
3138  res->data = (char *)((intvec*)(v->Data()))->length();
3139  return FALSE;
3140}
3141static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3142{
3143  ring r=(ring)v->Data();
3144  int elems=-1;
3145  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
3146  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3147  {
3148#ifdef HAVE_FACTORY
3149    extern int ipower ( int b, int n ); /* factory/cf_util */
3150    elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3151#else
3152    elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3153#endif
3154  }
3155  res->data = (char *)elems;
3156  return FALSE;
3157}
3158static BOOLEAN jjDEG(leftv res, leftv v)
3159{
3160  int dummy;
3161  poly p=(poly)v->Data();
3162  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3163  else res->data=(char *)-1;
3164  return FALSE;
3165}
3166static BOOLEAN jjDEG_M(leftv res, leftv u)
3167{
3168  ideal I=(ideal)u->Data();
3169  int d=-1;
3170  int dummy;
3171  int i;
3172  for(i=IDELEMS(I);i>=0;i--)
3173    if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3174  res->data = (char *)d;
3175  return FALSE;
3176}
3177static BOOLEAN jjDEGREE(leftv res, leftv v)
3178{
3179  assumeStdFlag(v);
3180  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3181  scDegree((ideal)v->Data(),module_w,currQuotient);
3182  return FALSE;
3183}
3184static BOOLEAN jjDEFINED(leftv res, leftv v)
3185{
3186  if ((v->rtyp==IDHDL)
3187  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3188  {
3189    res->data=(void *)(IDLEV((idhdl)v->data)+1);
3190  }
3191  else if (v->rtyp!=0) res->data=(void *)(-1);
3192  return FALSE;
3193}
3194#ifdef HAVE_FACTORY
3195static BOOLEAN jjDET(leftv res, leftv v)
3196{
3197  matrix m=(matrix)v->Data();
3198  poly p;
3199  if (smCheckDet((ideal)m,m->cols(),TRUE))
3200  {
3201    ideal I=idMatrix2Module(mpCopy(m));
3202    p=smCallDet(I);
3203    idDelete(&I);
3204  }
3205  else
3206    p=singclap_det(m);
3207  res ->data = (char *)p;
3208  return FALSE;
3209}
3210static BOOLEAN jjDET_I(leftv res, leftv v)
3211{
3212  intvec * m=(intvec*)v->Data();
3213  int i,j;
3214  i=m->rows();j=m->cols();
3215  if(i==j)
3216    res->data = (char *)singclap_det_i(m);
3217  else
3218  {
3219    Werror("det of %d x %d intmat",i,j);
3220    return TRUE;
3221  }
3222  return FALSE;
3223}
3224static BOOLEAN jjDET_S(leftv res, leftv v)
3225{
3226  ideal I=(ideal)v->Data();
3227  poly p;
3228  if (smCheckDet(I,IDELEMS(I),FALSE))
3229  {
3230    matrix m=idModule2Matrix(idCopy(I));
3231    p=singclap_det(m);
3232    idDelete((ideal *)&m);
3233  }
3234  else
3235    p=smCallDet(I);
3236  res->data = (char *)p;
3237  return FALSE;
3238}
3239#endif
3240static BOOLEAN jjDIM(leftv res, leftv v)
3241{
3242  assumeStdFlag(v);
3243  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
3244  return FALSE;
3245}
3246static BOOLEAN jjDUMP(leftv res, leftv v)
3247{
3248  si_link l = (si_link)v->Data();
3249  if (slDump(l))
3250  {
3251    const char *s;
3252    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3253    else                            s=sNoName;
3254    Werror("cannot dump to `%s`",s);
3255    return TRUE;
3256  }
3257  else
3258    return FALSE;
3259}
3260static BOOLEAN jjE(leftv res, leftv v)
3261{
3262  res->data = (char *)pOne();
3263  pSetComp((poly)res->data,(int)(long)v->Data());
3264  pSetm((poly)res->data);
3265  return FALSE;
3266}
3267static BOOLEAN jjEXECUTE(leftv res, leftv v)
3268{
3269  char * d = (char *)v->Data();
3270  char * s = (char *)omAlloc(strlen(d) + 13);
3271  strcpy( s, (char *)d);
3272  strcat( s, "\n;RETURN();\n");
3273  newBuffer(s,BT_execute);
3274  return yyparse();
3275}
3276#ifdef HAVE_FACTORY
3277static BOOLEAN jjFACSTD(leftv res, leftv v)
3278{
3279  ideal_list p,h;
3280  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3281  p=h;
3282  int l=0;
3283  while (p!=NULL) { p=p->next;l++; }
3284  lists L=(lists)omAllocBin(slists_bin);
3285  L->Init(l);
3286  l=0;
3287  while(h!=NULL)
3288  {
3289    L->m[l].data=(char *)h->d;
3290    L->m[l].rtyp=IDEAL_CMD;
3291    p=h->next;
3292    omFreeSize(h,sizeof(*h));
3293    h=p;
3294    l++;
3295  }
3296  res->data=(void *)L;
3297  return FALSE;
3298}
3299static BOOLEAN jjFAC_P(leftv res, leftv u)
3300{
3301  intvec *v=NULL;
3302  singclap_factorize_retry=0;
3303  ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3304  if (f==NULL) return TRUE;
3305  ivTest(v);
3306  lists l=(lists)omAllocBin(slists_bin);
3307  l->Init(2);
3308  l->m[0].rtyp=IDEAL_CMD;
3309  l->m[0].data=(void *)f;
3310  l->m[1].rtyp=INTVEC_CMD;
3311  l->m[1].data=(void *)v;
3312  res->data=(void *)l;
3313  return FALSE;
3314}
3315#endif
3316static BOOLEAN jjGETDUMP(leftv res, leftv v)
3317{
3318  si_link l = (si_link)v->Data();
3319  if (slGetDump(l))
3320  {
3321    const char *s;
3322    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3323    else                            s=sNoName;
3324    Werror("cannot get dump from `%s`",s);
3325    return TRUE;
3326  }
3327  else
3328    return FALSE;
3329}
3330static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3331{
3332  assumeStdFlag(v);
3333  ideal I=(ideal)v->Data();
3334  res->data=(void *)iiHighCorner(I,0);
3335  return FALSE;
3336}
3337static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3338{
3339  assumeStdFlag(v);
3340  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3341  BOOLEAN delete_w=FALSE;
3342  ideal I=(ideal)v->Data();
3343  int i;
3344  poly p=NULL,po=NULL;
3345  int rk=idRankFreeModule(I);
3346  if (w==NULL)
3347  {
3348    w = new intvec(rk);
3349    delete_w=TRUE;
3350  }
3351  for(i=rk;i>0;i--)
3352  {
3353    p=iiHighCorner(I,i);
3354    if (p==NULL)
3355    {
3356      WerrorS("module must be zero-dimensional");
3357      if (delete_w) delete w;
3358      return TRUE;
3359    }
3360    if (po==NULL)
3361    {
3362      po=p;
3363    }
3364    else
3365    {
3366      // now po!=NULL, p!=NULL
3367      int d=(pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - pFDeg(p,currRing)+(*w)[i-1]);
3368      if (d==0)
3369        d=pLmCmp(po,p);
3370      if (d > 0)
3371      {
3372        pDelete(&p);
3373      }
3374      else // (d < 0)
3375      {
3376        pDelete(&po); po=p;
3377      }
3378    }
3379  }
3380  if (delete_w) delete w;
3381  res->data=(void *)po;
3382  return FALSE;
3383}
3384static BOOLEAN jjHILBERT(leftv res, leftv v)
3385{
3386  assumeStdFlag(v);
3387  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3388  //scHilbertPoly((ideal)v->Data(),currQuotient);
3389  hLookSeries((ideal)v->Data(),module_w,currQuotient);
3390  return FALSE;
3391}
3392static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3393{
3394  res->data=(void *)hSecondSeries((intvec *)v->Data());
3395  return FALSE;
3396}
3397static BOOLEAN jjHOMOG1(leftv res, leftv v)
3398{
3399  intvec *w;
3400  res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
3401  if ((res->data!=NULL) && (v->rtyp==IDHDL))
3402  {
3403    atSet((idhdl)v->data,omStrDup("isHomog"),w,INTVEC_CMD);
3404  }
3405  else if (w!=NULL) delete w;
3406  return FALSE;
3407}
3408static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3409{
3410  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3411  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3412  if (IDELEMS((ideal)mat)==0)
3413  {
3414    idDelete((ideal *)&mat);
3415    mat=(matrix)idInit(1,1);
3416  }
3417  else
3418  {
3419    MATROWS(mat)=1;
3420    mat->rank=1;
3421    idTest((ideal)mat);
3422  }
3423  res->data=(char *)mat;
3424  return FALSE;
3425}
3426static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3427{
3428  map m=(map)v->CopyD(MAP_CMD);
3429  omFree((ADDRESS)m->preimage);
3430  m->preimage=NULL;
3431  ideal I=(ideal)m;
3432  I->rank=1;
3433  res->data=(char *)I;
3434  return FALSE;
3435}
3436static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3437{
3438  if (currRing!=NULL)
3439  {
3440    ring q=(ring)v->Data();
3441    if (rEqual(currRing, q, 0))
3442    {
3443      if (q->qideal==NULL)
3444        res->data=(char *)idInit(1,1);
3445      else
3446        res->data=(char *)idCopy(q->qideal);
3447      return FALSE;
3448    }
3449  }
3450  WerrorS("can only get ideal from identical qring");
3451  return TRUE;
3452}
3453static BOOLEAN jjIm2Iv(leftv res, leftv v)
3454{
3455  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3456  iv->makeVector();
3457  res->data = iv;
3458  return FALSE;
3459}
3460static BOOLEAN jjIMPART(leftv res, leftv v)
3461{
3462  res->data = (char *)nImPart((number)v->Data());
3463  return FALSE;
3464}
3465static BOOLEAN jjINDEPSET(leftv res, leftv v)
3466{
3467  assumeStdFlag(v);
3468  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3469  return FALSE;
3470}
3471static BOOLEAN jjINTERRED(leftv res, leftv v)
3472{
3473  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3474  //if (result==NULL) return TRUE;
3475  res->data = result;
3476  return FALSE;
3477}
3478static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3479{
3480  res->data = (char *)pVar((poly)v->Data());
3481  return FALSE;
3482}
3483static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3484{
3485  res->data = (char *)(r_IsRingVar((char *)v->Data(), currRing)+1);
3486  return FALSE;
3487}
3488static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3489{
3490  res->data = (char *)0;
3491  return FALSE;
3492}
3493static BOOLEAN jjJACOB_P(leftv res, leftv v)
3494{
3495  ideal i=idInit(pVariables,1);
3496  int k;
3497  poly p=(poly)(v->Data());
3498  for (k=pVariables;k>0;k--)
3499  {
3500    i->m[k-1]=pDiff(p,k);
3501  }
3502  res->data = (char *)i;
3503  return FALSE;
3504}
3505static BOOLEAN jjKBASE(leftv res, leftv v)
3506{
3507  assumeStdFlag(v);
3508  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3509  return FALSE;
3510}
3511#ifdef MDEBUG
3512static BOOLEAN jjpHead(leftv res, leftv v)
3513{
3514  res->data=(char *)pHead((poly)v->Data());
3515  return FALSE;
3516}
3517#endif
3518static BOOLEAN jjL2R(leftv res, leftv v)
3519{
3520  res->data=(char *)syConvList((lists)v->Data());
3521  if (res->data != NULL)
3522    return FALSE;
3523  else
3524    return TRUE;
3525}
3526static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3527{
3528  poly p=(poly)v->Data();
3529  if (p==NULL)
3530  {
3531    res->data=(char *)nInit(0);
3532  }
3533  else
3534  {
3535    res->data=(char *)nCopy(pGetCoeff(p));
3536  }
3537  return FALSE;
3538}
3539static BOOLEAN jjLEADEXP(leftv res, leftv v)
3540{
3541  poly p=(poly)v->Data();
3542  int s=pVariables;
3543  if (v->Typ()==VECTOR_CMD) s++;
3544  intvec *iv=new intvec(s);
3545  if (p!=NULL)
3546  {
3547    for(int i = pVariables;i;i--)
3548    {
3549      (*iv)[i-1]=pGetExp(p,i);
3550    }
3551    if (s!=pVariables)
3552      (*iv)[pVariables]=pGetComp(p);
3553  }
3554  res->data=(char *)iv;
3555  return FALSE;
3556}
3557static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3558{
3559  poly p=(poly)v->Data();
3560  if (p == NULL)
3561  {
3562    res->data = (char*) NULL;
3563  }
3564  else
3565  {
3566    poly lm = pLmInit(p);
3567    pSetCoeff(lm, nInit(1));
3568    res->data = (char*) lm;
3569  }
3570  return FALSE;
3571}
3572static BOOLEAN jjLISTRING(leftv res, leftv v)
3573{
3574  ring r=rCompose((lists)v->Data());
3575  if (r==NULL) return TRUE;
3576  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3577  res->data=(char *)r;
3578  return FALSE;
3579}
3580static BOOLEAN jjMEMORY(leftv res, leftv v)
3581{
3582  omUpdateInfo();
3583  switch(((int)(long)v->Data()))
3584  {
3585  case 0:
3586    res->data = (char *)om_Info.UsedBytes;
3587    break;
3588  case 1:
3589    res->data = (char *)om_Info.CurrentBytesSystem;
3590    break;
3591  case 2:
3592    res->data = (char *)om_Info.MaxBytesSystem;
3593    break;
3594
3595  default:
3596    omPrintStats(stdout);
3597    omPrintInfo(stdout);
3598    omPrintBinStats(stdout);
3599    res->data = (char *)0;
3600  }
3601  return FALSE;
3602  res->data = (char *)0;
3603  return FALSE;
3604}
3605static BOOLEAN jjMONITOR1(leftv res, leftv v)
3606{
3607  monitor((char *)(v->Data()),PROT_I);
3608  return FALSE;
3609}
3610static BOOLEAN jjMSTD(leftv res, leftv v)
3611{
3612  int t=v->Typ();
3613  ideal r,m;
3614  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3615  lists l=(lists)omAllocBin(slists_bin);
3616  l->Init(2);
3617  l->m[0].rtyp=t;
3618  l->m[0].data=(char *)r;
3619  setFlag(&(l->m[0]),FLAG_STD);
3620  l->m[1].rtyp=t;
3621  l->m[1].data=(char *)m;
3622  res->data=(char *)l;
3623  return FALSE;
3624}
3625static BOOLEAN jjMULT(leftv res, leftv v)
3626{
3627  assumeStdFlag(v);
3628  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3629  return FALSE;
3630}
3631static BOOLEAN jjMINRES_R(leftv res, leftv v)
3632{
3633  intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3634  res->data=(char *)syMinimize((syStrategy)v->Data());
3635  if (weights!=NULL) 
3636    atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3637  return FALSE;
3638}
3639static BOOLEAN jjNAMEOF(leftv res, leftv v)
3640{
3641  res->data = (char *)v->name;
3642  if (res->data==NULL) res->data=omStrDup("");
3643  v->name=NULL;
3644  return FALSE;
3645}
3646static BOOLEAN jjNAMES(leftv res, leftv v)
3647{
3648  res->data=ipNameList(((ring)v->Data())->idroot);
3649  return FALSE;
3650}
3651static BOOLEAN jjNVARS(leftv res, leftv v)
3652{
3653  res->data = (char *)(((ring)(v->Data()))->N);
3654  return FALSE;
3655}
3656static BOOLEAN jjOpenClose(leftv res, leftv v)
3657{
3658  si_link l=(si_link)v->Data();
3659  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3660  else                return slClose(l);
3661}
3662static BOOLEAN jjORD(leftv res, leftv v)
3663{
3664  poly p=(poly)v->Data();
3665  res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3666  return FALSE;
3667}
3668static BOOLEAN jjPAR1(leftv res, leftv v)
3669{
3670  int i=(int)(long)v->Data();
3671  int p=0;
3672  p=rPar(currRing);
3673  if ((0<i) && (i<=p))
3674  {
3675    res->data=(char *)nPar(i);
3676  }
3677  else
3678  {
3679    Werror("par number %d out of range 1..%d",i,p);
3680    return TRUE;
3681  }
3682  return FALSE;
3683}
3684static BOOLEAN jjPARDEG(leftv res, leftv v)
3685{
3686  res->data = (char *)nParDeg((number)v->Data());
3687  return FALSE;
3688}
3689static BOOLEAN jjPARSTR1(leftv res, leftv v)
3690{
3691  if (currRing==NULL)
3692  {
3693    WerrorS("no ring active");
3694    return TRUE;
3695  }
3696  int i=(int)(long)v->Data();
3697  int p=0;
3698  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3699    res->data=omStrDup(currRing->parameter[i-1]);
3700  else
3701  {
3702    Werror("par number %d out of range 1..%d",i,p);
3703    return TRUE;
3704  }
3705  return FALSE;
3706}
3707static BOOLEAN jjP2I(leftv res, leftv v)
3708{
3709  poly p=(poly)v->Data();
3710  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3711  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3712  {
3713    WerrorS("poly must be constant");
3714    return TRUE;
3715  }
3716  res->data = (char *)nInt(pGetCoeff(p));
3717  return FALSE;
3718}
3719static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3720{
3721  map mapping=(map)v->Data();
3722  syMake(res,omStrDup(mapping->preimage));
3723  return FALSE;
3724}
3725static BOOLEAN jjPRIME(leftv res, leftv v)
3726{
3727  int i = IsPrime((int)(long)(v->Data()));
3728  res->data = (char *)(i > 1 ? i : 2);
3729  return FALSE;
3730}
3731static BOOLEAN jjPRUNE(leftv res, leftv v)
3732{
3733  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3734  ideal v_id=(ideal)v->Data();
3735  if (w!=NULL)
3736  {
3737    w=ivCopy(w);
3738    intvec **ww=&w;
3739    res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3740    atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3741  }
3742  else
3743    res->data = (char *)idMinEmbedding(v_id);
3744  return FALSE;
3745}
3746static BOOLEAN jjP2N(leftv res, leftv v)
3747{
3748  number n;
3749  poly p;
3750  if (((p=(poly)v->Data())!=NULL)
3751  && (pIsConstant(p)))
3752  {
3753    n=nCopy(pGetCoeff(p));
3754  }
3755  else
3756  {
3757    n=nInit(0);
3758  }
3759  res->data = (char *)n;
3760  return FALSE;
3761}
3762static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3763{
3764  char *s= (char *)v->Data();
3765  int i = 1;
3766  int l = strlen(s);
3767  while (cmds[i].tokval!=0)
3768  {
3769    if (strcmp(s, cmds[i].name) == 0)
3770    {
3771      res->data = (char *)1;
3772      return FALSE;
3773    }
3774    i++;
3775  }
3776  //res->data = (char *)0;
3777  return FALSE;
3778}
3779static BOOLEAN jjREAD(leftv res, leftv v)
3780{
3781  return jjREAD2(res,v,NULL);
3782}
3783static BOOLEAN jjREGULARITY(leftv res, leftv v)
3784{
3785  res->data = (char *)iiRegularity((lists)v->Data());
3786  return FALSE;
3787}
3788static BOOLEAN jjREPART(leftv res, leftv v)
3789{
3790  res->data = (char *)nRePart((number)v->Data());
3791  return FALSE;
3792}
3793static BOOLEAN jjRINGLIST(leftv res, leftv v)
3794{
3795  ring r=(ring)v->Data();
3796  if (r!=NULL)
3797    res->data = (char *)rDecompose((ring)v->Data());
3798  return (r==NULL);
3799}
3800static BOOLEAN jjROWS(leftv res, leftv v)
3801{
3802  ideal i = (ideal)v->Data();
3803  res->data = (char *)i->rank;
3804  return FALSE;
3805}
3806static BOOLEAN jjROWS_IV(leftv res, leftv v)
3807{
3808  res->data = (char *)((intvec*)(v->Data()))->rows();
3809  return FALSE;
3810}
3811static BOOLEAN jjRPAR(leftv res, leftv v)
3812{
3813  res->data = (char *)rPar(((ring)v->Data()));
3814  return FALSE;
3815}
3816static BOOLEAN jjSLIM_GB(leftv res, leftv u)
3817{
3818  if (currQuotient!=NULL)
3819  {
3820    Werror("qring not supported by slimgb at the moment");
3821    return TRUE;
3822  }
3823  if (pOrdSgn!=1)
3824  {
3825    Werror("ordering must be global for slimgb");
3826    return TRUE;
3827  }
3828  res->data=(char *)t_rep_gb(currRing, (ideal)u->Data());
3829  setFlag(res,FLAG_STD);
3830  return FALSE;
3831}
3832static BOOLEAN jjSTD(leftv res, leftv v)
3833{
3834  ideal result;
3835  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3836  tHomog hom=testHomog;
3837  if (w!=NULL)
3838  {
3839    w=ivCopy(w);
3840    hom=isHomog;
3841  }
3842  result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3843  idSkipZeroes(result);
3844  res->data = (char *)result;
3845  setFlag(res,FLAG_STD);
3846  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3847  return FALSE;
3848}
3849static BOOLEAN jjSort_Id(leftv res, leftv v)
3850{
3851  res->data = (char *)idSort((ideal)v->Data());
3852  return FALSE;
3853}
3854#if 1
3855static BOOLEAN jjSYZYGY(leftv res, leftv v)
3856{
3857  intvec *w=NULL;
3858  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3859  if (w!=NULL) delete w;
3860  return FALSE;
3861}
3862#else
3863// activate, if idSyz hadle moduke weights correctly !
3864static BOOLEAN jjSYZYGY(leftv res, leftv v)
3865{
3866  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3867  ideal v_id=(ideal)v->Data();
3868  tHomog hom=testHomog;
3869  int add_row_shift=0;
3870  if (w!=NULL)
3871  {
3872    w=ivCopy(w);
3873    add_row_shift=w->min_in();
3874    (*w)-=add_row_shift;
3875    if (idHomModule(v_id,currQuotient,&w))
3876      hom=isHomog;
3877    else
3878    {
3879      //WarnS("wrong weights");
3880      delete w; w=NULL;
3881      hom=testHomog;
3882    }
3883  }
3884  res->data = (char *)idSyzygies(v_id,hom,&w);
3885  if (w!=NULL)
3886  {
3887    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3888  }
3889  return FALSE;
3890}
3891#endif
3892static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3893{
3894  res->data = (char *)ivTrace((intvec*)(v->Data()));
3895  return FALSE;
3896}
3897static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3898{
3899  res->data = (char *)ivTranp((intvec*)(v->Data()));
3900  return FALSE;
3901}
3902
3903#ifdef HAVE_PLURAL
3904
3905static BOOLEAN jjOPPOSITE(leftv res, leftv a)
3906{
3907  ring    r = (ring)a->Data();
3908  if (rIsPluralRing(r))
3909  {
3910    res->data = rOpposite(r);
3911  }
3912  else res->data = rCopy(r);
3913  return FALSE;
3914}
3915
3916static BOOLEAN jjENVELOPE(leftv res, leftv a)
3917{
3918  ring    r = (ring)a->Data();
3919  if (rIsPluralRing(r))
3920  {
3921    //    ideal   i;
3922//     if (a->rtyp == QRING_CMD)
3923//     {
3924//       i = r->qideal;
3925//       r->qideal = NULL;
3926//     }
3927    ring s = rEnvelope(r);
3928//     if (a->rtyp == QRING_CMD)
3929//     {
3930//       ideal is  = idOppose(r,i); /* twostd? */
3931//       is        = idAdd(is,i);
3932//       s->qideal = i;
3933//     }
3934    res->data = s;
3935  }
3936  else  res->data = rCopy(r);
3937  return FALSE;
3938}
3939
3940static BOOLEAN jjTWOSTD(leftv res, leftv a)
3941{
3942  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
3943  else  res->data=(ideal)a->Data();
3944  setFlag(res,FLAG_STD);
3945  setFlag(res,FLAG_TWOSTD);
3946  return FALSE;
3947}
3948#endif
3949
3950static BOOLEAN jjTYPEOF(leftv res, leftv v)
3951{
3952  switch ((int)(long)v->data)
3953  {
3954    case INT_CMD:     res->data=omStrDup("int"); break;
3955    case POLY_CMD:   res->data=omStrDup("poly"); break;
3956    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3957    case STRING_CMD:  res->data=omStrDup("string"); break;
3958    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3959    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3960    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3961    case MODUL_CMD:   res->data=omStrDup("module"); break;
3962    case MAP_CMD:     res->data=omStrDup("map"); break;
3963    case PROC_CMD:    res->data=omStrDup("proc"); break;
3964    case RING_CMD:    res->data=omStrDup("ring"); break;
3965    case QRING_CMD:   res->data=omStrDup("qring"); break;
3966    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3967    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3968    case LIST_CMD:   res->data=omStrDup("list"); break;
3969    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3970    case LINK_CMD:   res->data=omStrDup("link"); break;
3971    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3972    case DEF_CMD:
3973    case NONE:    res->data=omStrDup("none"); break;
3974    default:       res->data=omStrDup("?unknown type?");
3975  }
3976  return FALSE;
3977}
3978static BOOLEAN jjVAR1(leftv res, leftv v)
3979{
3980  int i=(int)(long)v->Data();
3981  if ((0<i) && (i<=currRing->N))
3982  {
3983    poly p=pOne();
3984    pSetExp(p,i,1);
3985    pSetm(p);
3986    res->data=(char *)p;
3987  }
3988  else
3989  {
3990    Werror("var number %d out of range 1..%d",i,currRing->N);
3991    return TRUE;
3992  }
3993  return FALSE;
3994}
3995static BOOLEAN jjVARSTR1(leftv res, leftv v)
3996{
3997  if (currRing==NULL)
3998  {
3999    WerrorS("no ring active");
4000    return TRUE;
4001  }
4002  int i=(int)(long)v->Data();
4003  if ((0<i) && (i<=currRing->N))
4004    res->data=omStrDup(currRing->names[i-1]);
4005  else
4006  {
4007    Werror("var number %d out of range 1..%d",i,currRing->N);
4008    return TRUE;
4009  }
4010  return FALSE;
4011}
4012static BOOLEAN jjVDIM(leftv res, leftv v)
4013{
4014  assumeStdFlag(v);
4015  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
4016  return FALSE;
4017}
4018
4019static BOOLEAN jjLOAD1(leftv res, leftv v)
4020{
4021  return jjLOAD(res, v,iiOp==LIB_CMD);
4022}
4023static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4024{
4025#ifdef HAVE_NS
4026  char * s=(char *)v->CopyD();
4027  char libnamebuf[256];
4028  lib_types LT = type_of_LIB(s, libnamebuf);
4029#ifdef HAVE_DYNAMIC_LOADING
4030  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN autoexport);
4031#endif /* HAVE_DYNAMIC_LOADING */
4032  switch(LT)
4033  {
4034      default:
4035      case LT_NONE:
4036        Werror("%s: unknown type", s);
4037        break;
4038      case LT_NOTFOUND:
4039        Werror("cannot open %s", s);
4040        break;
4041
4042      case LT_SINGULAR:
4043      {
4044        char *plib = iiConvName(s);
4045        idhdl pl = IDROOT->get(plib,0);
4046        if (pl==NULL)
4047        {
4048          pl = enterid( plib,0, PACKAGE_CMD, &IDROOT, TRUE );
4049          IDPACKAGE(pl)->language = LANG_SINGULAR;
4050          IDPACKAGE(pl)->libname=omStrDup(plib);
4051        }
4052        else if (IDTYP(pl)!=PACKAGE_CMD)
4053        {
4054          Werror("can not create package `%s`",plib);
4055          omFree(plib);
4056          return TRUE;
4057        }
4058        package savepack=currPack;
4059        currPack=IDPACKAGE(pl);
4060        IDPACKAGE(pl)->loaded=TRUE;
4061        char libnamebuf[256];
4062        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4063        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, FALSE, TRUE);
4064        currPack=savepack;
4065        IDPACKAGE(pl)->loaded=(!bo);
4066        return bo;
4067      }
4068      case LT_MACH_O:
4069      case LT_ELF:
4070      case LT_HPUX:
4071#ifdef HAVE_DYNAMIC_LOADING
4072        return load_modules(s, libnamebuf, autoexport);
4073#else /* HAVE_DYNAMIC_LOADING */
4074        WerrorS("Dynamic modules are not supported by this version of Singular");
4075        break;
4076#endif /* HAVE_DYNAMIC_LOADING */
4077  }
4078#endif
4079  return TRUE;
4080}
4081
4082/*=================== operations with 1 arg.: table =================*/
4083
4084#ifdef INIT_BUG
4085#define XS(A) -((short)A)
4086#define jjstrlen       (proc1)1
4087#define jjpLength      (proc1)2
4088#define jjidElem       (proc1)3
4089#define jjmpDetBareiss (proc1)4
4090#define jjidFreeModule (proc1)5
4091#define jjidVec2Ideal  (proc1)6
4092#define jjrCharStr     (proc1)7
4093#ifndef MDEBUG
4094#define jjpHead        (proc1)8
4095#endif
4096#define jjidHead       (proc1)9
4097#define jjidMaxIdeal   (proc1)10
4098#define jjidMinBase    (proc1)11
4099#define jjsyMinBase    (proc1)12
4100#define jjpMaxComp     (proc1)13
4101#define jjmpTrace      (proc1)14
4102#define jjmpTransp     (proc1)15
4103#define jjrOrdStr      (proc1)16
4104#define jjrVarStr      (proc1)18
4105#define jjrParStr      (proc1)19
4106#define jjCOUNT_RES    (proc1)22
4107#define jjDIM_R        (proc1)23
4108#define jjidTransp     (proc1)24
4109
4110extern struct sValCmd1 dArith1[];
4111void jjInitTab1()
4112{
4113  int i=0;
4114  for (;dArith1[i].cmd!=0;i++)
4115  {
4116    if (dArith1[i].res<0)
4117    {
4118      switch ((int)dArith1[i].p)
4119      {
4120        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
4121        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
4122        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
4123        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
4124#ifndef HAVE_FACTORY
4125        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4126#endif
4127        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4128        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
4129#ifndef MDEBUG
4130        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
4131#endif
4132        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
4133        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
4134        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
4135        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
4136        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
4137        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
4138        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
4139        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
4140        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
4141        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
4142        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
4143        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
4144        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
4145#ifdef GENTABLE
4146        default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4147#endif
4148      }
4149    }
4150  }
4151}
4152#else
4153#if defined(PROC_BUG)
4154#define XS(A) A
4155static BOOLEAN jjstrlen(leftv res, leftv v)
4156{
4157  res->data = (char *)strlen((char *)v->Data());
4158  return FALSE;
4159}
4160static BOOLEAN jjpLength(leftv res, leftv v)
4161{
4162  res->data = (char *)pLength((poly)v->Data());
4163  return FALSE;
4164}
4165static BOOLEAN jjidElem(leftv res, leftv v)
4166{
4167  res->data = (char *)idElem((ideal)v->Data());
4168  return FALSE;
4169}
4170static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4171{
4172  res->data = (char *)mpDetBareiss((matrix)v->Data());
4173  return FALSE;
4174}
4175static BOOLEAN jjidFreeModule(leftv res, leftv v)
4176{
4177  res->data = (char *)idFreeModule((int)(long)v->Data());
4178  return FALSE;
4179}
4180static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4181{
4182  res->data = (char *)idVec2Ideal((poly)v->Data());
4183  return FALSE;
4184}
4185static BOOLEAN jjrCharStr(leftv res, leftv v)
4186{
4187  res->data = rCharStr((ring)v->Data());
4188  return FALSE;
4189}
4190#ifndef MDEBUG
4191static BOOLEAN jjpHead(leftv res, leftv v)
4192{
4193  res->data = (char *)pHead((poly)v->Data());
4194  return FALSE;
4195}
4196#endif
4197static BOOLEAN jjidHead(leftv res, leftv v)
4198{
4199  res->data = (char *)idHead((ideal)v->Data());
4200  return FALSE;
4201}
4202static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4203{
4204  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4205  return FALSE;
4206}
4207static BOOLEAN jjidMinBase(leftv res, leftv v)
4208{
4209  res->data = (char *)idMinBase((ideal)v->Data());
4210  return FALSE;
4211}
4212static BOOLEAN jjsyMinBase(leftv res, leftv v)
4213{
4214  res->data = (char *)syMinBase((ideal)v->Data());
4215  return FALSE;
4216}
4217static BOOLEAN jjpMaxComp(leftv res, leftv v)
4218{
4219  res->data = (char *)pMaxComp((poly)v->Data());
4220  return FALSE;
4221}
4222static BOOLEAN jjmpTrace(leftv res, leftv v)
4223{
4224  res->data = (char *)mpTrace((matrix)v->Data());
4225  return FALSE;
4226}
4227static BOOLEAN jjmpTransp(leftv res, leftv v)
4228{
4229  res->data = (char *)mpTransp((matrix)v->Data());
4230  return FALSE;
4231}
4232static BOOLEAN jjrOrdStr(leftv res, leftv v)
4233{
4234  res->data = rOrdStr((ring)v->Data());
4235  return FALSE;
4236}
4237static BOOLEAN jjrVarStr(leftv res, leftv v)
4238{
4239  res->data = rVarStr((ring)v->Data());
4240  return FALSE;
4241}
4242static BOOLEAN jjrParStr(leftv res, leftv v)
4243{
4244  res->data = rParStr((ring)v->Data());
4245  return FALSE;
4246}
4247static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4248{
4249  res->data=(char *)syLength((syStrategy)v->Data());
4250  return FALSE;
4251}
4252static BOOLEAN jjDIM_R(leftv res, leftv v)
4253{
4254  res->data = (char *)syDim((syStrategy)v->Data());
4255  return FALSE;
4256}
4257static BOOLEAN jjidTransp(leftv res, leftv v)
4258{
4259  res->data = (char *)idTransp((ideal)v->Data());
4260  return FALSE;
4261}
4262#else
4263#define XS(A)          -((short)A)
4264#define jjstrlen       (proc1)strlen
4265#define jjpLength      (proc1)pLength
4266#define jjidElem       (proc1)idElem
4267#define jjmpDetBareiss (proc1)mpDetBareiss
4268#define jjidFreeModule (proc1)idFreeModule
4269#define jjidVec2Ideal  (proc1)idVec2Ideal
4270#define jjrCharStr     (proc1)rCharStr
4271#ifndef MDEBUG
4272#define jjpHead        (proc1)pHeadProc
4273#endif
4274#define jjidHead       (proc1)idHead
4275#define jjidMaxIdeal   (proc1)idMaxIdeal
4276#define jjidMinBase    (proc1)idMinBase
4277#define jjsyMinBase    (proc1)syMinBase
4278#define jjpMaxComp     (proc1)pMaxCompProc
4279#define jjmpTrace      (proc1)mpTrace
4280#define jjmpTransp     (proc1)mpTransp
4281#define jjrOrdStr      (proc1)rOrdStr
4282#define jjrVarStr      (proc1)rVarStr
4283#define jjrParStr      (proc1)rParStr
4284#define jjCOUNT_RES    (proc1)syLength
4285#define jjDIM_R        (proc1)syDim
4286#define jjidTransp     (proc1)idTransp
4287#endif
4288#endif
4289static BOOLEAN jjnInt(leftv res, leftv u)
4290{
4291  number n=(number)u->CopyD(NUMBER_CMD);
4292  res->data=(char *)nInt(n);
4293  nDelete(&n);
4294  return FALSE;
4295}
4296#define s short
4297struct sValCmd1 dArith1[]=
4298{
4299// operations:
4300// proc         cmd               res             arg           plural
4301// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4302//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4303 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4304,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4305,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4306,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4307,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4308,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4309,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4310,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4311,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4312,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4313,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4314// and the procedures with 1 argument:
4315,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4316//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4317,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4318,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4319,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4320,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4321,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4322,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4323,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4324#ifdef HAVE_FACTORY
4325,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4326#else
4327,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4328#endif
4329,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4330,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4331,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4332//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4333,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4334,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4335,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4336,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4337,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4338,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4339,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4340,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4341,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4342,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
4343,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
4344,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4345,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
4346,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
4347,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4348,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4349,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4350,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
4351,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4352,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
4353,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4354,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4355,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4356,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4357,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
4358,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
4359,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
4360#ifdef HAVE_FACTORY
4361,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4362,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
4363,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
4364#else
4365,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4366,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
4367#endif
4368,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
4369,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
4370,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4371,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4372,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
4373,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4374,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
4375#ifdef HAVE_FACTORY
4376,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4377#else
4378,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4379#endif
4380#ifdef HAVE_FGLM
4381,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4382#else
4383,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4384#endif
4385,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
4386#ifdef HAVE_FACTORY
4387,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4388#else
4389,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4390#endif
4391,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
4392,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
4393,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
4394,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
4395,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
4396,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
4397,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4398,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4399,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
4400,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
4401,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
4402,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
4403,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
4404,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4405,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4406,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
4407,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
4408,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4409,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4410,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4411,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
4412,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4413,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4414,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4415,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4416,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
4417,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
4418,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
4419,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4420,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4421,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4422,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4423,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
4424#ifdef MDEBUG
4425,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4426#else
4427,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
4428#endif
4429,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
4430#ifdef MDEBUG
4431,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4432#else
4433,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
4434#endif
4435,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4436,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4437,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4438,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
4439,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4440,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4441,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4442,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
4443,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
4444,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
4445,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4446,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4447,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
4448,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
4449,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
4450,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
4451,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
4452,{jjMINRES_R,   MINRES_CMD,      RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4453,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4454,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4455,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
4456,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
4457,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4458,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
4459,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4460,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
4461,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4462,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4463,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4464,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4465,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4466,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4467,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4468,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4469,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4470,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4471,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4472,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4473,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4474,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
4475,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4476,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4477,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4478,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4479,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4480,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
4481,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
4482,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
4483,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
4484,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4485,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4486,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4487,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
4488,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
4489,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
4490,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4491,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
4492,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
4493,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4494,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4495,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4496,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
4497,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
4498//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
4499,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4500,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4501,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4502,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4503,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4504,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4505,{jjSLIM_GB,    SLIM_GB_CMD,     MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4506,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4507,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4508,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4509,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4510,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
4511,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
4512,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4513,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4514#ifdef HAVE_PLURAL
4515,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4516,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4517,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4518,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4519,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4520#endif
4521,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
4522,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
4523,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4524,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
4525,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4526,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4527,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
4528,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4529,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4530,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4531,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4532,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4533,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
4534,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4535,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4536,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4537,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4538,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4539,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4540,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4541,{NULL,         0,               0,              0              NO_PLURAL}
4542};
4543#undef s
4544/*=================== operations with 3 args.: static proc =================*/
4545static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4546{
4547  char *s= (char *)u->Data();
4548  int   r = (int)(long)v->Data();
4549  int   c = (int)(long)w->Data();
4550  int l = strlen(s);
4551
4552  if ( (r<1) || (r>l) || (c<0) )
4553  {
4554    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4555    return TRUE;
4556  }
4557  res->data = (char *)omAlloc(c+1);
4558  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4559  return FALSE;
4560}
4561static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4562{
4563  intvec *iv = (intvec *)u->Data();
4564  int   r = (int)(long)v->Data();
4565  int   c = (int)(long)w->Data();
4566  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4567  {
4568    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4569           r,c,u->Fullname(),iv->rows(),iv->cols());
4570    return TRUE;
4571  }
4572  res->data=u->data;
4573  u->data=NULL;
4574  res->rtyp=u->rtyp;
4575  u->rtyp=0;
4576  res->name=u->name;
4577  u->name=NULL;
4578  Subexpr e=jjMakeSub(v);
4579          e->next=jjMakeSub(w);
4580  if (u->e==NULL) res->e=e;
4581  else
4582  {
4583    Subexpr h=u->e;
4584    while (h->next!=NULL) h=h->next;
4585    h->next=e;
4586    res->e=u->e;
4587    u->e=NULL;
4588  }
4589  return FALSE;
4590}
4591static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4592{
4593  matrix m= (matrix)u->Data();
4594  int   r = (int)(long)v->Data();
4595  int   c = (int)(long)w->Data();
4596  //Print("gen. elem %d, %d\n",r,c);
4597  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4598  {
4599    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4600      MATROWS(m),MATCOLS(m));
4601    return TRUE;
4602  }
4603  res->data=u->data;
4604  u->data=NULL;
4605  res->rtyp=u->rtyp;
4606  u->rtyp=0;
4607  res->name=u->name;
4608  u->name=NULL;
4609  Subexpr e=jjMakeSub(v);
4610          e->next=jjMakeSub(w);
4611  if (u->e==NULL)
4612    res->e=e;
4613  else
4614  {
4615    Subexpr h=u->e;
4616    while (h->next!=NULL) h=h->next;
4617    h->next=e;
4618    res->e=u->e;
4619    u->e=NULL;
4620  }
4621  return FALSE;
4622}
4623static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4624{
4625  sleftv t;
4626  sleftv ut;
4627  leftv p=NULL;
4628  intvec *iv=(intvec *)w->Data();
4629  int l;
4630  BOOLEAN nok;
4631
4632  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4633  {
4634    WerrorS("cannot build expression lists from unnamed objects");
4635    return TRUE;
4636  }
4637  memcpy(&ut,u,sizeof(ut));
4638  memset(&t,0,sizeof(t));
4639  t.rtyp=INT_CMD;
4640  for (l=0;l< iv->length(); l++)
4641  {
4642    t.data=(char *)(*iv)[l];
4643    if (p==NULL)
4644    {
4645      p=res;
4646    }
4647    else
4648    {
4649      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4650      p=p->next;
4651    }
4652    memcpy(u,&ut,sizeof(ut));
4653    if (u->Typ() == MATRIX_CMD)
4654      nok=jjBRACK_Ma(p,u,v,&t);
4655    else /* INTMAT_CMD */
4656      nok=jjBRACK_Im(p,u,v,&t);
4657    if (nok)
4658    {
4659      while (res->next!=NULL)
4660      {
4661        p=res->next->next;
4662        omFreeBin((ADDRESS)res->next, sleftv_bin);
4663        // res->e aufraeumen !!!!
4664        res->next=p;
4665      }
4666      return TRUE;
4667    }
4668  }
4669  return FALSE;
4670}
4671static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4672{
4673  sleftv t;
4674  sleftv ut;
4675  leftv p=NULL;
4676  intvec *iv=(intvec *)v->Data();
4677  int l;
4678  BOOLEAN nok;
4679
4680  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4681  {
4682    WerrorS("cannot build expression lists from unnamed objects");
4683    return TRUE;
4684  }
4685  memcpy(&ut,u,sizeof(ut));
4686  memset(&t,0,sizeof(t));
4687  t.rtyp=INT_CMD;
4688  for (l=0;l< iv->length(); l++)
4689  {
4690    t.data=(char *)((*iv)[l]);
4691    if (p==NULL)
4692    {
4693      p=res;
4694    }
4695    else
4696    {
4697      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4698      p=p->next;
4699    }
4700    memcpy(u,&ut,sizeof(ut));
4701    if (u->Typ() == MATRIX_CMD)
4702      nok=jjBRACK_Ma(p,u,&t,w);
4703    else /* INTMAT_CMD */
4704      nok=jjBRACK_Im(p,u,&t,w);
4705    if (nok)
4706    {
4707      while (res->next!=NULL)
4708      {
4709        p=res->next->next;
4710        omFreeBin((ADDRESS)res->next, sleftv_bin);
4711        // res->e aufraeumen !!
4712        res->next=p;
4713      }
4714      return TRUE;
4715    }
4716  }
4717  return FALSE;
4718}
4719static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4720{
4721  sleftv t1,t2,ut;
4722  leftv p=NULL;
4723  intvec *vv=(intvec *)v->Data();
4724  intvec *wv=(intvec *)w->Data();
4725  int vl;
4726  int wl;
4727  BOOLEAN nok;
4728
4729  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4730  {
4731    WerrorS("cannot build expression lists from unnamed objects");
4732    return TRUE;
4733  }
4734  memcpy(&ut,u,sizeof(ut));
4735  memset(&t1,0,sizeof(sleftv));
4736  memset(&t2,0,sizeof(sleftv));
4737  t1.rtyp=INT_CMD;
4738  t2.rtyp=INT_CMD;
4739  for (vl=0;vl< vv->length(); vl++)
4740  {
4741    t1.data=(char *)((*vv)[vl]);
4742    for (wl=0;wl< wv->length(); wl++)
4743    {
4744      t2.data=(char *)((*wv)[wl]);
4745      if (p==NULL)
4746      {
4747        p=res;
4748      }
4749      else
4750      {
4751        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4752        p=p->next;
4753      }
4754      memcpy(u,&ut,sizeof(ut));
4755      if (u->Typ() == MATRIX_CMD)
4756        nok=jjBRACK_Ma(p,u,&t1,&t2);
4757      else /* INTMAT_CMD */
4758        nok=jjBRACK_Im(p,u,&t1,&t2);
4759      if (nok)
4760      {
4761        res->CleanUp();
4762        return TRUE;
4763      }
4764    }
4765  }
4766  return FALSE;
4767}
4768static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4769{
4770  v->next=(leftv)omAllocBin(sleftv_bin);
4771  memcpy(v->next,w,sizeof(sleftv));
4772  memset(w,0,sizeof(sleftv));
4773  return jjPROC(res,u,v);
4774}
4775static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4776{
4777  u->next=(leftv)omAllocBin(sleftv_bin);
4778  memcpy(u->next,v,sizeof(sleftv));
4779  u->next->next=(leftv)omAllocBin(sleftv_bin);
4780  memcpy(u->next->next,w,sizeof(sleftv));
4781  BOOLEAN r=iiExprArithM(res,u,iiOp);
4782  // iiExprArithM did the CleanUp
4783  w->rtyp=0; w->data=NULL;
4784  return r;
4785}
4786static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4787{
4788  intvec *iv;
4789  ideal m;
4790  lists l=(lists)omAllocBin(slists_bin);
4791  int k=(int)(long)w->Data();
4792  if (k>=0)
4793  {
4794    smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
4795    l->Init(2);
4796    l->m[0].rtyp=MODUL_CMD;
4797    l->m[1].rtyp=INTVEC_CMD;
4798    l->m[0].data=(void *)m;
4799    l->m[1].data=(void *)iv;
4800  }
4801  else
4802  {
4803    m=smCallSolv((ideal)u->Data());
4804    l->Init(1);
4805    l->m[0].rtyp=IDEAL_CMD;
4806    l->m[0].data=(void *)m;
4807  }
4808  res->data = (char *)l;
4809  return FALSE;
4810}
4811static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4812{
4813  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4814  {
4815    WerrorS("3rd argument must be a name of a matrix");
4816    return TRUE;
4817  }
4818  ideal i=(ideal)u->Data();
4819  int rank=(int)i->rank;
4820  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4821  if (r) return TRUE;
4822  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4823  return FALSE;
4824}
4825static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4826{
4827  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4828           (ideal)(v->Data()),(poly)(w->Data()));
4829  return FALSE;
4830}
4831static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4832{
4833  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4834  {
4835    WerrorS("3rd argument must be a name of a matrix");
4836    return TRUE;
4837  }
4838  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4839  poly p=(poly)u->CopyD(POLY_CMD);
4840  ideal i=idInit(1,1);
4841  i->m[0]=p;
4842  sleftv t;
4843  memset(&t,0,sizeof(t));
4844  t.data=(char *)i;
4845  t.rtyp=IDEAL_CMD;
4846  int rank=1;
4847  if (u->Typ()==VECTOR_CMD)
4848  {
4849    i->rank=rank=pMaxComp(p);
4850    t.rtyp=MODUL_CMD;
4851  }
4852  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4853  t.CleanUp();
4854  if (r) return TRUE;
4855  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4856  return FALSE;
4857}
4858static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4859{
4860  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4861    (intvec *)w->Data());
4862  setFlag(res,FLAG_STD);
4863  return FALSE;
4864}
4865static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4866{
4867  /*4
4868  * look for the substring what in the string where
4869  * starting at position n
4870  * return the position of the first char of what in where
4871  * or 0
4872  */
4873  int n=(int)(long)w->Data();
4874  char *where=(char *)u->Data();
4875  char *what=(char *)v->Data();
4876  char *found;
4877  if ((1>n)||(n>(int)strlen(where)))
4878  {
4879    Werror("start position %d out of range",n);
4880    return TRUE;
4881  }
4882  found = strchr(where+n-1,*what);
4883  if (*(what+1)!='\0')
4884  {
4885    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4886    {
4887      found=strchr(found+1,*what);
4888    }
4889  }
4890  if (found != NULL)
4891  {
4892    res->data=(char *)((found-where)+1);
4893  }
4894  return FALSE;
4895}
4896static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
4897{
4898  if ((int)(long)w->Data()==0)
4899    res->data=(char *)walkProc(u,v);
4900  else
4901    res->data=(char *)fractalWalkProc(u,v);
4902  setFlag( res, FLAG_STD );
4903  return FALSE;
4904}
4905static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4906{
4907  assumeStdFlag(u);
4908  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4909  intvec *wdegree=(intvec*)w->Data();
4910  if (wdegree->length()!=pVariables)
4911  {
4912    Werror("weight vector must have size %d, not %d",
4913           pVariables,wdegree->length());
4914    return TRUE;
4915  }
4916  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4917  switch((int)(long)v->Data())
4918  {
4919    case 1:
4920      res->data=(void *)iv;
4921      return FALSE;
4922    case 2:
4923      res->data=(void *)hSecondSeries(iv);
4924      delete iv;
4925      return FALSE;
4926  }
4927  WerrorS(feNotImplemented);
4928  delete iv;
4929  return TRUE;
4930}
4931static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4932{
4933  intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
4934  intvec* arg = (intvec*) u->Data();
4935  int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
4936
4937  for (i=0; i<n; i++)
4938  {
4939    (*im)[i] = (*arg)[i];
4940  }
4941
4942  res->data = (char *)im;
4943  return FALSE;
4944}
4945static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4946{
4947  short *iw=iv2array((intvec *)w->Data());
4948  res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
4949  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4950  return FALSE;
4951}
4952static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
4953{
4954  if (!pIsUnit((poly)v->Data()))
4955  {
4956    WerrorS("2nd argument must be a unit");
4957    return TRUE;
4958  }
4959  res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4960  return FALSE;
4961}
4962static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4963{
4964  res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
4965                             (intvec *)w->Data());
4966  return FALSE;
4967}
4968static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4969{
4970  if (!mpIsDiagUnit((matrix)v->Data()))
4971  {
4972    WerrorS("2nd argument must be a diagonal matrix of units");
4973    return TRUE;
4974  }
4975  res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
4976                               (matrix)v->CopyD());
4977  return FALSE;
4978}
4979static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4980{
4981  assumeStdFlag(w);
4982  res->data = (char *)idMinors(
4983                        (matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
4984  return FALSE;
4985}
4986static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4987{
4988  idhdl h;
4989  ring rr;
4990  map mapping;
4991
4992  if ((v->name==NULL) || (w->name==NULL))
4993  {
4994    WerrorS("2nd/3rd arguments must have names");
4995    return TRUE;
4996  }
4997  rr=(ring)u->Data();
4998  const char *ring_name=u->Name();
4999  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5000  {
5001    if (h->typ==MAP_CMD)
5002    {
5003      mapping=IDMAP(h);
5004      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5005      if ((preim_ring==NULL)
5006      || (IDRING(preim_ring)!=currRing))
5007      {
5008        Werror("preimage ring `%s` is not the basering",mapping->preimage);
5009        return TRUE;
5010      }
5011    }
5012    else if (h->typ==IDEAL_CMD)
5013    {
5014      mapping=IDMAP(h);
5015    }
5016    else
5017    {
5018      Werror("`%s` is no map nor ideal",IDID(h));
5019      return TRUE;
5020    }
5021  }
5022  else
5023  {
5024    Werror("`%s` is not defined in `%s`",v->name,ring_name);
5025    return TRUE;
5026  }
5027  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5028  {
5029    if (h->typ==IDEAL_CMD)
5030    {
5031      if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5032      || ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5033      {
5034        WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5035      }
5036      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5037      if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5038    }
5039    else
5040    {
5041      Werror("`%s` is no ideal",IDID(h));
5042      return TRUE;
5043    }
5044  }
5045  else
5046  {
5047    Werror("`%s` is not defined in `%s`",w->name,ring_name);
5048    return TRUE;
5049  }
5050  return FALSE;
5051}
5052static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5053{
5054  int di, k;
5055  int i=(int)(long)u->Data();
5056  int r=(int)(long)v->Data();
5057  int c=(int)(long)w->Data();
5058  if ((r<=0) || (c<=0)) return TRUE;
5059  intvec *iv = new intvec(r, c, 0);
5060  if (iv->rows()==0)
5061  {
5062    delete iv;
5063    return TRUE;
5064  }
5065  if (i!=0)
5066  {
5067    if (i<0) i = -i;
5068    di = 2 * i + 1;
5069    for (k=0; k<iv->length(); k++)
5070    {
5071#ifdef buildin_rand
5072      (*iv)[k] = ((siRand() % di) - i);
5073#else
5074      (*iv)[k] = ((rand() % di) - i);
5075#endif
5076    }
5077  }
5078  res->data = (char *)iv;
5079  return FALSE;
5080}
5081static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5082  int &ringvar, poly &monomexpr)
5083{
5084  monomexpr=(poly)w->Data();
5085  poly p=(poly)v->Data();
5086  #if 0
5087  if (pLength(monomexpr)>1)
5088  {
5089    Werror("`%s` substitutes a ringvar only by a term",
5090      Tok2Cmdname(SUBST_CMD));
5091    return TRUE;
5092  }
5093  #endif
5094  if (!(ringvar=pVar(p)))
5095  {
5096    if (rField_is_Extension(currRing))
5097    {
5098      assume(currRing->algring!=NULL);
5099      lnumber n=(lnumber)pGetCoeff(p);
5100      ringvar=-p_Var(n->z,currRing->algring);
5101    }
5102    if(ringvar==0)
5103    {
5104      WerrorS("ringvar/par expected");
5105      return TRUE;
5106    }
5107  }
5108  return FALSE;
5109}
5110static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5111{
5112  int ringvar;
5113  poly monomexpr;
5114  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5115  if (nok) return TRUE;
5116  if (ringvar>0)
5117  {
5118    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5119      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5120    else
5121      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5122  }
5123  else
5124  {
5125    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5126  }
5127  return FALSE;
5128}
5129static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5130{
5131  int ringvar;
5132  poly monomexpr;
5133  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5134  if (nok) return TRUE;
5135  if (ringvar>0)
5136  {
5137    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5138      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5139    else
5140      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5141  }
5142  else
5143  {
5144    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5145  }
5146  return FALSE;
5147}
5148// we do not want to have jjSUBST_Id_X inlined:
5149static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5150                            int input_type);
5151static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5152{
5153  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5154}
5155static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5156{
5157  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5158}
5159static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5160{
5161  sleftv tmp;
5162  memset(&tmp,0,sizeof(tmp));
5163  // do not check the result, conversion from int/number to poly works always
5164  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5165  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5166  tmp.CleanUp();
5167  return b;
5168}
5169static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5170{
5171  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5172  ideal I=(ideal)u->CopyD(IDEAL_CMD);
5173  int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5174  //for(i=i-1;i>=0;i--)
5175  //{
5176  //  m->m[i]=I->m[i];
5177  //  I->m[i]=NULL;
5178  //}
5179  memcpy4(m->m,I->m,i*sizeof(poly));
5180  memset(I->m,0,i*sizeof(poly));
5181  idDelete(&I);
5182  res->data = (char *)m;
5183  return FALSE;
5184}
5185static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5186{
5187  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5188           (int)(long)v->Data(),(int)(long)w->Data());
5189  return FALSE;
5190}
5191static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5192{
5193  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5194  matrix I=(matrix)u->CopyD(MATRIX_CMD);
5195  int r=si_min(MATROWS(I),(int)(long)v->Data());
5196  int c=si_min(MATCOLS(I),(int)(long)w->Data());
5197  int i,j;
5198  for(i=r;i>0;i--)
5199  {
5200    for(j=c;j>0;j--)
5201    {
5202      MATELEM(m,i,j)=MATELEM(I,i,j);
5203      MATELEM(I,i,j)=NULL;
5204    }
5205  }
5206  idDelete((ideal *)&I);
5207  res->data = (char *)m;
5208  return FALSE;
5209}
5210static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5211{
5212  if (w->rtyp!=IDHDL) return TRUE;
5213  BITSET save_test=test;
5214  int ul= IDELEMS((ideal)u->Data());
5215  int vl= IDELEMS((ideal)v->Data());
5216  ideal m
5217    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5218             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5219  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5220  test=save_test;
5221  return FALSE;
5222}
5223static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5224{
5225  assumeStdFlag(v);
5226  if (!idIsZeroDim((ideal)v->Data()))
5227  {
5228    Werror("`%s` must be 0-dimensional",v->Name());
5229    return TRUE;
5230  }
5231  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5232    (poly)w->CopyD());
5233  return FALSE;
5234}
5235static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5236{
5237  assumeStdFlag(v);
5238  if (!idIsZeroDim((ideal)v->Data()))
5239  {
5240    Werror("`%s` must be 0-dimensional",v->Name());
5241    return TRUE;
5242  }
5243  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5244    (matrix)w->CopyD());
5245  return FALSE;
5246}
5247static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5248{
5249  assumeStdFlag(v);
5250  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5251    0,(int)(long)w->Data());
5252  return FALSE;
5253}
5254static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5255{
5256  assumeStdFlag(v);
5257  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5258    0,(int)(long)w->Data());
5259  return FALSE;
5260}
5261#ifdef OLD_RES
5262static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5263{
5264  int maxl=(int)v->Data();
5265  int l=0;
5266  resolvente r;
5267  intvec **weights=NULL;
5268  int wmaxl=maxl;
5269  maxl--;
5270  if ((maxl==-1) && (iiOp!=MRES_CMD))
5271    maxl = pVariables-1;
5272  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5273  {
5274    intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5275    if (iv!=NULL)
5276    {
5277      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5278      weights[0] = ivCopy(iv);
5279      l=1;
5280    }
5281    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
5282  }
5283  else
5284    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5285  if (r==NULL) return TRUE;
5286  int t3=u->Typ();
5287  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5288  return FALSE;
5289  return TRUE;
5290}
5291#endif
5292static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5293{
5294  res->data=(void *)rInit(u,v,w);
5295  return (res->data==NULL);
5296}
5297static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5298{
5299  int yes;
5300  jjSTATUS2(res, u, v);
5301  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5302  omFree((ADDRESS) res->data);
5303  res->data = (void *) yes;
5304  return FALSE;
5305}
5306static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5307{
5308  ideal result;
5309  intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5310  tHomog hom=testHomog;
5311  if (ww!=NULL)
5312  {
5313    ww=ivCopy(ww);
5314    hom=isHomog;
5315  }
5316  result=kStd((ideal)(u->Data()),
5317              currQuotient,
5318              hom,
5319              &ww,                  // module weights
5320              (intvec *)v->Data(),  // hilbert series
5321              0,0,                  // syzComp, newIdeal
5322              (intvec *)w->Data()); // weights of vars
5323  idSkipZeroes(result);
5324  res->data = (char *)result;
5325  setFlag(res,FLAG_STD);
5326  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5327  return FALSE;
5328}
5329
5330/*=================== operations with 3 args.: table =================*/
5331struct sValCmd3 dArith3[]=
5332{
5333// operations:
5334// proc             cmd          res         arg1        arg2        arg3   plural
5335 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5336,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5337,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5338,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5339,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5340,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5341,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5342,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5343,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5344,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5345,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
5346,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
5347,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5348,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5349,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5350,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5351,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
5352,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
5353,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5354,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5355,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
5356,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5357,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5358,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5359,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
5360//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5361,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5362,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5363,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5364,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5365,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5366,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5367,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
5368,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
5369,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5370,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5371,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
5372,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
5373,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5374,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5375,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5376,{jjMATRIX_Ma,