source: git/Singular/iparith.cc @ 1ceb92

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