source: git/Singular/iparith.cc @ b5e57e2

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