source: git/Singular/iparith.cc @ 610069

spielwiese
Last change on this file since 610069 was 610069, checked in by Hans Schönemann <hannes@…>, 15 years ago
*hannes: kbase with module weights git-svn-id: file:///usr/local/Singular/svn/trunk@11318 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 249.9 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.489 2009-01-15 17:04:47 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_12},
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_123},
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 jjINDEPSET2(leftv res, leftv u, leftv v)
2308{
2309  assumeStdFlag(u);
2310  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2311                    currQuotient);
2312  return FALSE;
2313}
2314static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
2315{
2316  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2317  setFlag(res,FLAG_STD);
2318  return FALSE;
2319}
2320static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2321{
2322  return jjStdJanetBasis(res,u,(int)(long)v->Data());
2323}
2324static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2325{
2326  res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2327  return FALSE;
2328}
2329static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2330{
2331  res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
2332  return FALSE;
2333}
2334static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2335{
2336  assumeStdFlag(u);
2337  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2338  res->data = (char *)scKBase((int)(long)v->Data(),
2339                              (ideal)(u->Data()),currQuotient, w_u);
2340  return FALSE;
2341}
2342static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w);
2343static BOOLEAN jjKERNEL(leftv res, leftv u, leftv v)
2344{
2345  return jjPREIMAGE(res,u,v,NULL);
2346}
2347static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2348{
2349  return mpKoszul(res, u,v);
2350}
2351static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2352{
2353  sleftv h;
2354  memset(&h,0,sizeof(sleftv));
2355  h.rtyp=INT_CMD;
2356  h.data=(void *)(long)IDELEMS((ideal)v->Data());
2357  return mpKoszul(res, u, &h, v);
2358}
2359static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2360{
2361  ideal m;
2362  BITSET save_test=test;
2363  int ul= IDELEMS((ideal)u->Data());
2364  int vl= IDELEMS((ideal)v->Data());
2365  m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
2366  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
2367  test=save_test;
2368  return FALSE;
2369}
2370static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2371{
2372  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
2373  idhdl h=(idhdl)v->data;
2374  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2375  res->data = (char *)idLiftStd((ideal)u->Data(),
2376                                &(h->data.umatrix),testHomog);
2377  setFlag(res,FLAG_STD);
2378  return FALSE;
2379}
2380static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2381{
2382  char * s=(char *)u->Data();
2383  if(strcmp(s, "with")==0)
2384    return jjLOAD(res, v, TRUE);
2385  WerrorS("invalid second argument");
2386  WerrorS("load(\"libname\" [,\"with\"]);");
2387  return TRUE;
2388}
2389static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2390{
2391  res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2392  return (res->data==NULL);
2393}
2394static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2395{
2396  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2397  tHomog hom=testHomog;
2398  if (w_u!=NULL)
2399  {
2400    w_u=ivCopy(w_u);
2401    hom=isHomog;
2402  }
2403  intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2404  if (w_v!=NULL)
2405  {
2406    w_v=ivCopy(w_v);
2407    hom=isHomog;
2408  }
2409  if ((w_u!=NULL) && (w_v==NULL))
2410    w_v=ivCopy(w_u);
2411  if ((w_v!=NULL) && (w_u==NULL))
2412    w_u=ivCopy(w_v);
2413  ideal u_id=(ideal)u->Data();
2414  ideal v_id=(ideal)v->Data();
2415  if (w_u!=NULL)
2416  {
2417     if ((*w_u).compare((w_v))!=0)
2418     {
2419       WarnS("incompatible weights");
2420       delete w_u; w_u=NULL;
2421       hom=testHomog;
2422     }
2423     else
2424     {
2425       if ((!idTestHomModule(u_id,currQuotient,w_v))
2426       || (!idTestHomModule(v_id,currQuotient,w_v)))
2427       {
2428         WarnS("wrong weights");
2429         delete w_u; w_u=NULL;
2430         hom=testHomog;
2431       }
2432     }
2433  }
2434  res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2435  if (w_u!=NULL)
2436  {
2437    atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2438  }
2439  delete w_v;
2440  return FALSE;
2441}
2442static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2443{
2444  number q=(number)v->Data();
2445  if (nlIsZero(q))
2446  {
2447    WerrorS(ii_div_by_0);
2448    return TRUE;
2449  }
2450  res->data =(char *) nlIntMod((number)u->Data(),q);
2451  return FALSE;
2452}
2453static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2454{
2455  number q=(number)v->Data();
2456  if (nIsZero(q))
2457  {
2458    WerrorS(ii_div_by_0);
2459    return TRUE;
2460  }
2461  res->data =(char *) nIntMod((number)u->Data(),q);
2462  return FALSE;
2463}
2464static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v);
2465static BOOLEAN jjMONITOR1(leftv res, leftv v)
2466{
2467  return jjMONITOR2(res,v,NULL);
2468}
2469static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2470{
2471#if 0
2472  char *opt=(char *)v->Data();
2473  int mode=0;
2474  while(*opt!='\0')
2475  {
2476    if (*opt=='i') mode |= PROT_I;
2477    else if (*opt=='o') mode |= PROT_O;
2478    opt++;
2479  }
2480  monitor((char *)(u->Data()),mode);
2481#else
2482  si_link l=(si_link)u->Data();
2483  if (slOpen(l,SI_LINK_WRITE)) return TRUE;
2484  if(strcmp(l->m->type,"ASCII")!=0)
2485  {
2486    Werror("ASCII link required, not `%s`",l->m->type);
2487    slClose(l);
2488    return TRUE;
2489  }
2490  SI_LINK_SET_CLOSE_P(l); // febase handles the FILE*
2491  char *opt;
2492  if (v==NULL) opt="i";
2493  else         opt=(char *)v->Data();
2494  int mode=0;
2495  while(*opt!='\0')
2496  {
2497    if (*opt=='i') mode |= PROT_I;
2498    else if (*opt=='o') mode |= PROT_O;
2499    opt++;
2500  }
2501  if (((FILE*)l->data) == stdin) monitor(NULL,0);
2502  else monitor((FILE *)l->data,mode);
2503  return FALSE;
2504#endif
2505}
2506static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2507{
2508  idhdl h=(idhdl)u->data;
2509  int i=(int)(long)v->Data();
2510  int p=0;
2511  if ((0<i)
2512  && (IDRING(h)->parameter!=NULL)
2513  && (i<=(p=rPar(IDRING(h)))))
2514    res->data=omStrDup(IDRING(h)->parameter[i-1]);
2515  else
2516  {
2517    Werror("par number %d out of range 1..%d",i,p);
2518    return TRUE;
2519  }
2520  return FALSE;
2521}
2522#ifdef HAVE_PLURAL
2523static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2524{
2525  if (iiOp==NCALGEBRA_CMD)
2526  {
2527    return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2528  }
2529  else
2530  {
2531    ring r=rCopy(currRing);
2532    BOOLEAN result=nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),r);
2533    res->data=r;
2534    if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2535    return result;
2536  }
2537}
2538static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2539{
2540  if (iiOp==NCALGEBRA_CMD)
2541  {
2542    return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2543  }
2544  else
2545  {
2546    ring r=rCopy(currRing);
2547    BOOLEAN result=nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,r);
2548    res->data=r;
2549    if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2550    return result;
2551  }
2552}
2553static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2554{
2555  if (iiOp==NCALGEBRA_CMD)
2556  {
2557    return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2558  }
2559  else
2560  {
2561    ring r=rCopy(currRing);
2562    BOOLEAN result=nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),r);
2563    res->data=r;
2564    if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2565    return result;
2566  }
2567}
2568static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2569{
2570  if (iiOp==NCALGEBRA_CMD)
2571  {
2572    return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2573  }
2574  else
2575  {
2576    ring r=rCopy(currRing);
2577    BOOLEAN result=nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,r);
2578    res->data=r;
2579    if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2580    return result;
2581  }
2582}
2583static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2584{
2585  if (rIsPluralRing(currRing))
2586  {
2587    poly p = (poly)a->CopyD(POLY_CMD);
2588    poly q = (poly)b->Data();
2589    res->data = nc_p_Bracket_qq(p,q);
2590  }
2591  else res->data=NULL;
2592  return FALSE;
2593}
2594static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2595{
2596  /* number, poly, vector, ideal, module, matrix */
2597  ring  r = (ring)a->Data();
2598  if (r == currRing)
2599  {
2600    res->data = b->Data();
2601    res->rtyp = b->rtyp;
2602    return FALSE;
2603  }
2604  if (!rIsLikeOpposite(currRing, r))
2605  {
2606    Werror("%s is not an opposite ring to current ring",a->Fullname());
2607    return TRUE;
2608  }
2609  idhdl w;
2610  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2611  {
2612    int argtype = IDTYP(w);
2613    switch (argtype)
2614    {
2615    case NUMBER_CMD:
2616      {
2617        /* since basefields are equal, we can apply nCopy */
2618        res->data = nCopy((number)IDDATA(w));
2619        res->rtyp = argtype;
2620        break;
2621      }
2622    case POLY_CMD:
2623    case VECTOR_CMD:
2624      {
2625        poly    q = (poly)IDDATA(w);
2626        res->data = pOppose(r,q);
2627        res->rtyp = argtype;
2628        break;
2629      }
2630    case IDEAL_CMD:
2631    case MODUL_CMD:
2632      {
2633        ideal   Q = (ideal)IDDATA(w);
2634        res->data = idOppose(r,Q);
2635        res->rtyp = argtype;
2636        break;
2637      }
2638    case MATRIX_CMD:
2639      {
2640        ring save = currRing;
2641        rChangeCurrRing(r);
2642        matrix  m = (matrix)IDDATA(w);
2643        ideal   Q = idMatrix2Module(mpCopy(m));
2644        rChangeCurrRing(save);
2645        ideal   S = idOppose(r,Q);
2646        id_Delete(&Q, r);
2647        res->data = idModule2Matrix(S);
2648        res->rtyp = argtype;
2649        break;
2650      }
2651    default:
2652      {
2653        WerrorS("unsupported type in oppose");
2654        return TRUE;
2655      }
2656    }
2657  }
2658  else
2659  {
2660    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2661    return TRUE;
2662  }
2663  return FALSE;
2664}
2665#endif /* HAVE_PLURAL */
2666
2667static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2668{
2669  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2670    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2671  idDelMultiples((ideal)(res->data));
2672  return FALSE;
2673}
2674static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2675{
2676  int i=(int)(long)u->Data();
2677  int j=(int)(long)v->Data();
2678#ifdef buildin_rand
2679  res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
2680#else /* buildin_rand */
2681  res->data =(char *)(long)((i > j) ? i : (rand() % (j-i+1)) + i);
2682#endif /* buildin_rand */
2683  return FALSE;
2684}
2685static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2686{
2687  si_link l=(si_link)u->Data();
2688  leftv r=slRead(l,v);
2689  if (r==NULL)
2690  {
2691    const char *s;
2692    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2693    else                            s=sNoName;
2694    Werror("cannot read from `%s`",s);
2695    return TRUE;
2696  }
2697  memcpy(res,r,sizeof(sleftv));
2698  omFreeBin((ADDRESS)r, sleftv_bin);
2699  return FALSE;
2700}
2701static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2702{
2703  assumeStdFlag(v);
2704  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2705  return FALSE;
2706}
2707static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2708{
2709  assumeStdFlag(v);
2710  ideal ui=(ideal)u->Data();
2711  idTest(ui);
2712  ideal vi=(ideal)v->Data();
2713  idTest(vi);
2714  res->data = (char *)kNF(vi,currQuotient,ui);
2715  return FALSE;
2716}
2717#if 0
2718static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2719{
2720  int maxl=(int)(long)v->Data();
2721  if (maxl<0)
2722  {
2723    WerrorS("length for res must not be negative");
2724    return TRUE;
2725  }
2726  int l=0;
2727  //resolvente r;
2728  syStrategy r;
2729  intvec *weights=NULL;
2730  int wmaxl=maxl;
2731  ideal u_id=(ideal)u->Data();
2732
2733  maxl--;
2734  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2735  {
2736    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2737    if (currQuotient!=NULL)
2738    {
2739      Warn(
2740      "full resolution in a qring may be infinite, setting max length to %d",
2741      maxl+1);
2742    }
2743  }
2744  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2745  if (weights!=NULL)
2746  {
2747    if (!idTestHomModule(u_id,currQuotient,weights))
2748    {
2749      WarnS("wrong weights given:");weights->show();PrintLn();
2750      weights=NULL;
2751    }
2752  }
2753  intvec *ww=NULL;
2754  int add_row_shift=0;
2755  if (weights!=NULL)
2756  {
2757     ww=ivCopy(weights);
2758     add_row_shift = ww->min_in();
2759     (*ww) -= add_row_shift;
2760  }
2761  else
2762    idHomModule(u_id,currQuotient,&ww);
2763  weights=ww;
2764
2765  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2766  {
2767    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2768  }
2769  else if (iiOp==SRES_CMD)
2770  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2771    r=sySchreyer(u_id,maxl+1);
2772  else if (iiOp == LRES_CMD)
2773  {
2774    int dummy;
2775    if((currQuotient!=NULL)||
2776    (!idHomIdeal (u_id,NULL)))
2777    {
2778       WerrorS
2779       ("`lres` not implemented for inhomogeneous input or qring");
2780       return TRUE;
2781    }
2782    r=syLaScala3(u_id,&dummy);
2783  }
2784  else if (iiOp == KRES_CMD)
2785  {
2786    int dummy;
2787    if((currQuotient!=NULL)||
2788    (!idHomIdeal (u_id,NULL)))
2789    {
2790       WerrorS
2791       ("`kres` not implemented for inhomogeneous input or qring");
2792       return TRUE;
2793    }
2794    r=syKosz(u_id,&dummy);
2795  }
2796  else
2797  {
2798    int dummy;
2799    if((currQuotient!=NULL)||
2800    (!idHomIdeal (u_id,NULL)))
2801    {
2802       WerrorS
2803       ("`hres` not implemented for inhomogeneous input or qring");
2804       return TRUE;
2805    }
2806    r=syHilb(u_id,&dummy);
2807  }
2808  if (r==NULL) return TRUE;
2809  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2810  r->list_length=wmaxl;
2811  res->data=(void *)r;
2812  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2813  {
2814    intvec *w=ivCopy(r->weights[0]);
2815    if (weights!=NULL) (*w) += add_row_shift;
2816    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2817    delete w;
2818  }
2819  else
2820  {
2821//#if 0
2822// need to set weights for ALL components (sres)
2823    if (weights!=NULL)
2824    {
2825      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2826      r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2827      (r->weights)[0] = ivCopy(weights);
2828    }
2829//#endif
2830  }
2831  if (ww!=NULL) { delete ww; ww=NULL; }
2832  return FALSE;
2833}
2834#else
2835static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2836{
2837  int maxl=(int)(long)v->Data();
2838  if (maxl<0)
2839  {
2840    WerrorS("length for res must not be negative");
2841    return TRUE;
2842  }
2843  int l=0;
2844  //resolvente r;
2845  syStrategy r;
2846  intvec *weights=NULL;
2847  int wmaxl=maxl;
2848  ideal u_id=(ideal)u->Data();
2849
2850  maxl--;
2851  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2852  {
2853    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2854    if (currQuotient!=NULL)
2855    {
2856      Warn(
2857      "full resolution in a qring may be infinite, setting max length to %d",
2858      maxl+1);
2859    }
2860  }
2861  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2862  if (weights!=NULL)
2863  {
2864    if (!idTestHomModule(u_id,currQuotient,weights))
2865    {
2866      WarnS("wrong weights given:");weights->show();PrintLn();
2867      weights=NULL;
2868    }
2869  }
2870  intvec *ww=NULL;
2871  int add_row_shift=0;
2872  if (weights!=NULL)
2873  {
2874     ww=ivCopy(weights);
2875     add_row_shift = ww->min_in();
2876     (*ww) -= add_row_shift;
2877  }
2878  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2879  {
2880    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2881  }
2882  else if (iiOp==SRES_CMD)
2883  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2884    r=sySchreyer(u_id,maxl+1);
2885  else if (iiOp == LRES_CMD)
2886  {
2887    int dummy;
2888    if((currQuotient!=NULL)||
2889    (!idHomIdeal (u_id,NULL)))
2890    {
2891       WerrorS
2892       ("`lres` not implemented for inhomogeneous input or qring");
2893       return TRUE;
2894    }
2895    r=syLaScala3(u_id,&dummy);
2896  }
2897  else if (iiOp == KRES_CMD)
2898  {
2899    int dummy;
2900    if((currQuotient!=NULL)||
2901    (!idHomIdeal (u_id,NULL)))
2902    {
2903       WerrorS
2904       ("`kres` not implemented for inhomogeneous input or qring");
2905       return TRUE;
2906    }
2907    r=syKosz(u_id,&dummy);
2908  }
2909  else
2910  {
2911    int dummy;
2912    if((currQuotient!=NULL)||
2913    (!idHomIdeal (u_id,NULL)))
2914    {
2915       WerrorS
2916       ("`hres` not implemented for inhomogeneous input or qring");
2917       return TRUE;
2918    }
2919    r=syHilb(u_id,&dummy);
2920  }
2921  if (r==NULL) return TRUE;
2922  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2923  r->list_length=wmaxl;
2924  res->data=(void *)r;
2925  if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2926  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2927  {
2928    ww=ivCopy(r->weights[0]);
2929    if (weights!=NULL) (*ww) += add_row_shift;
2930    atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2931  }
2932  else
2933  {
2934    if (weights!=NULL)
2935    {
2936      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2937    }
2938  }
2939  return FALSE;
2940}
2941#endif
2942static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2943{
2944  ring r;
2945  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2946  res->data = (char *)r;
2947  return (i==-1);
2948}
2949#define SIMPL_LMDIV 32
2950#define SIMPL_LMEQ  16
2951#define SIMPL_MULT 8
2952#define SIMPL_EQU  4
2953#define SIMPL_NULL 2
2954#define SIMPL_NORM 1
2955static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2956{
2957  int sw = (int)(long)v->Data();
2958  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2959  ideal id = (ideal)u->CopyD(IDEAL_CMD);
2960  if (sw & SIMPL_LMDIV)
2961  {
2962    idDelDiv(id);
2963  }
2964  if (sw & SIMPL_LMEQ)
2965  {
2966    idDelLmEquals(id);
2967  }
2968  if (sw & SIMPL_MULT)
2969  {
2970    idDelMultiples(id);
2971  }
2972  else if(sw & SIMPL_EQU)
2973  {
2974    idDelEquals(id);
2975  }
2976  if (sw & SIMPL_NULL)
2977  {
2978    idSkipZeroes(id);
2979  }
2980  if (sw & SIMPL_NORM)
2981  {
2982    idNorm(id);
2983  }
2984  res->data = (char * )id;
2985  return FALSE;
2986}
2987static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2988{
2989  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2990  return FALSE;
2991}
2992static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2993{
2994  int sw = (int)(long)v->Data();
2995  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2996  poly p = (poly)u->CopyD(POLY_CMD);
2997  if (sw & SIMPL_NORM)
2998  {
2999    pNorm(p);
3000  }
3001  res->data = (char * )p;
3002  return FALSE;
3003}
3004static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
3005{
3006  ideal result;
3007  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3008  tHomog hom=testHomog;
3009  ideal u_id=(ideal)(u->Data());
3010  if (w!=NULL)
3011  {
3012    if (!idTestHomModule(u_id,currQuotient,w))
3013    {
3014      WarnS("wrong weights");
3015      w=NULL;
3016    }
3017    else
3018    {
3019      w=ivCopy(w);
3020      hom=isHomog;
3021    }
3022  }
3023  result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
3024  idSkipZeroes(result);
3025  res->data = (char *)result;
3026  setFlag(res,FLAG_STD);
3027  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3028  return FALSE;
3029}
3030static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
3031{
3032  ideal result;
3033  assumeStdFlag(u);
3034  ideal i1=(ideal)(u->Data());
3035  ideal i0;
3036  int r=v->Typ();
3037  if ((/*v->Typ()*/r==POLY_CMD) ||(r==VECTOR_CMD))
3038  {
3039    i0=idInit(1,i1->rank);
3040    i0->m[0]=(poly)v->Data();
3041  }
3042  else /*IDEAL*/
3043  {
3044    i0=(ideal)v->CopyD();
3045  }
3046  int ii0=idElem(i0);
3047  i1=idSimpleAdd(i1,i0);
3048  memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3049  idDelete(&i0);
3050  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3051  tHomog hom=testHomog;
3052
3053  if (w!=NULL)
3054  {
3055    if (!idTestHomModule(i1,currQuotient,w))
3056    {
3057      // no warnung: this is legal, if i in std(i,p)
3058      // is homogeneous, but p not
3059      w=NULL;
3060    }
3061    else
3062    {
3063      w=ivCopy(w);
3064      hom=isHomog;
3065    }
3066  }
3067  BITSET save_test=test;
3068  test|=Sy_bit(OPT_SB_1);
3069  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-ii0);
3070  test=save_test;
3071  idDelete(&i1);
3072  idSkipZeroes(result);
3073  res->data = (char *)result;
3074  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
3075  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3076  return FALSE;
3077}
3078static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
3079{
3080  idhdl h=(idhdl)u->data;
3081  int i=(int)(long)v->Data();
3082  if ((0<i) && (i<=IDRING(h)->N))
3083    res->data=omStrDup(IDRING(h)->names[i-1]);
3084  else
3085  {
3086    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
3087    return TRUE;
3088  }
3089  return FALSE;
3090}
3091static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
3092{
3093  res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
3094  return FALSE;
3095}
3096#define jjWRONG2 (proc2)jjWRONG
3097#define jjWRONG3 (proc3)jjWRONG
3098static BOOLEAN jjWRONG(leftv res, leftv u)
3099{
3100  return TRUE;
3101}
3102
3103/*=================== operations with 2 args.: table =================*/
3104
3105struct sValCmd2 dArith2[]=
3106{
3107// operations:
3108// proc        cmd              res             arg1        arg2   plural
3109 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3110,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3111,{jjPLUS_BI,   '+',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3112,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3113,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3114,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3115,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3116,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3117,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
3118,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3119,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3120,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
3121,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3122,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
3123,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3124,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
3125,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3126,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3127,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
3128,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
3129,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  RING_CMD ALLOW_PLURAL}
3130,{jjRSUM,      '+',            QRING_CMD,      RING_CMD,   QRING_CMD ALLOW_PLURAL}
3131,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  QRING_CMD ALLOW_PLURAL}
3132,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3133,{jjMINUS_BI,  '-',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3134,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3135,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3136,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3137,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3138,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3139,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3140,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3141,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3142,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3143,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3144,{jjTIMES_BI,  '*',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3145,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3146,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3147,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
3148,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3149,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3150,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
3151,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3152,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
3153,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD NO_PLURAL}
3154,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
3155,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3156,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3157,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
3158,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
3159,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
3160,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3161,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD ALLOW_PLURAL}
3162,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3163,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3164,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
3165,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3166,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
3167,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
3168,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3169,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
3170,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3171,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3172,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3173,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3174,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3175,{jjDIV_BI,    '/',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3176,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3177,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3178,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3179,{jjDIV_BI,    INTDIV_CMD,     BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3180,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3181,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3182,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3183,{jjMOD_BI,    '%',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3184,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3185,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3186,{jjMOD_N,     '%',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3187,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3188,{jjMOD_BI,    INTMOD_CMD,     BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3189,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3190,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3191,{jjMOD_N,     INTMOD_CMD,     NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3192,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3193,{jjPOWER_BI,   '^',           BIGINT_CMD,     BIGINT_CMD, INT_CMD ALLOW_PLURAL}
3194,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
3195,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
3196,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3197,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3198,{jjLE_BI,     LE,             INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3199,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3200,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3201,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3202,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3203,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3204,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3205,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3206,{jjLT_BI,     '<',            INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3207,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3208,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3209,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3210,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3211,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3212,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3213,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3214,{jjGE_BI,     GE,             INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3215,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3216,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3217,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3218,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3219,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3220,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3221,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3222,{jjGT_BI,     '>',            INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3223,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3224,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3225,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3226,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3227,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3228,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3229,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3230,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3231,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3232,{jjEQUAL_BI,  EQUAL_EQUAL,    INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3233,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3234,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3235,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3236,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3237,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3238,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3239,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3240,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3241,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3242,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3243,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
3244,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3245,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3246,{jjEQUAL_BI,  NOTEQUAL,       INT_CMD,        BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3247,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3248,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3249,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3250,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3251,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3252,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3253,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3254,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3255,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3256,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
3257,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3258,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
3259,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3260,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3261,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3262,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
3263,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
3264,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3265,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
3266,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
3267,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
3268,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
3269,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
3270,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
3271,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
3272,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3273,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3274,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
3275,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
3276,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
3277,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
3278,{jjCOLON,     ':',            INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
3279// and the procedures with 2 arguments:
3280,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
3281,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3282,{jjBETTI2,    BETTI_CMD,      INTMAT_CMD,     LIST_CMD,   INT_CMD ALLOW_PLURAL}
3283,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
3284,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3285,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3286#ifdef HAVE_PLURAL
3287,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3288#endif
3289,{jjCHINREM_BI,CHINREM_CMD,    BIGINT_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3290//,{jjCHINREM_P, CHINREM_CMD,    POLY_CMD,       LIST_CMD,   INTVEC_CMD ALLOW_PLURAL}
3291,{jjCHINREM_ID,CHINREM_CMD,    IDEAL_CMD,      LIST_CMD,   INTVEC_CMD ALLOW_PLURAL}
3292,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3293,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3294,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
3295,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3296,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3297,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3298,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
3299,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3300,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
3301,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
3302,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3303,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3304,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3305,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3306,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
3307,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3308,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
3309,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
3310,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
3311,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
3312,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3313,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
3314,{jjELIMIN_IV, ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
3315,{jjELIMIN_IV, ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
3316,{jjEXPORTTO,  EXPORTTO_CMD,   NONE,           PACKAGE_CMD, IDHDL ALLOW_PLURAL}
3317,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
3318#ifdef HAVE_FACTORY
3319,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
3320,{jjFAC_P2,     FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
3321,{jjFACSTD2,   FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
3322#else
3323,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
3324,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
3325,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
3326#endif
3327,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
3328,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3329#ifdef HAVE_FGLM
3330,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
3331,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
3332,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
3333#else
3334,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
3335,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
3336,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
3337#endif
3338,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
3339,{jjFWALK,     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
3340,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3341,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3342,{jjGCD_BI,    GCD_CMD,        BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3343#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
3344,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
3345#else
3346,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
3347#endif
3348,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
3349,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
3350,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
3351,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3352,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3353,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
3354,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3355,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3356,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
3357,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3358,{jjIMPORTFROM,IMPORTFROM_CMD, NONE,           PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
3359,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3360,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
3361#ifdef HAVE_INTERPOLATION
3362,{jjINTERPOLATION,INTERPOLATE_CMD,IDEAL_CMD,   LIST_CMD,   INTVEC_CMD NO_PLURAL}
3363#endif
3364,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3365,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3366,{jjJanetBasis2, JANET_CMD,    IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3367,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
3368,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3369,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3370,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3371,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
3372,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3373,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3374,{jjKERNEL,    KERNEL_CMD,     IDEAL_CMD, RING_CMD,        ANY_TYPE ALLOW_PLURAL}
3375,{jjKERNEL,    KERNEL_CMD,     IDEAL_CMD, QRING_CMD,       ANY_TYPE ALLOW_PLURAL}
3376,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
3377,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
3378,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
3379,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3380,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3381,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3382,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
3383,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
3384,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3385,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
3386,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3387,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
3388,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
3389,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3390,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3391,{jjMONITOR2,  MONITOR_CMD,    NONE,           LINK_CMD, STRING_CMD ALLOW_PLURAL}
3392//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3393//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3394,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
3395,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3396,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3397//,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
3398#ifdef HAVE_PLURAL
3399,{jjPlural_num_poly, NCALGEBRA_CMD,NONE,       POLY_CMD,   POLY_CMD   NO_PLURAL}
3400,{jjPlural_num_mat,  NCALGEBRA_CMD,NONE,       POLY_CMD,   MATRIX_CMD NO_PLURAL}
3401,{jjPlural_mat_poly, NCALGEBRA_CMD,NONE,       MATRIX_CMD, POLY_CMD   NO_PLURAL}
3402,{jjPlural_mat_mat,  NCALGEBRA_CMD,NONE,       MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3403,{jjPlural_num_poly, NC_ALGEBRA_CMD,RING_CMD,  POLY_CMD,   POLY_CMD   NO_PLURAL}
3404,{jjPlural_num_mat,  NC_ALGEBRA_CMD,RING_CMD,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
3405,{jjPlural_mat_poly, NC_ALGEBRA_CMD,RING_CMD,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
3406,{jjPlural_mat_mat,  NC_ALGEBRA_CMD,RING_CMD,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3407#endif
3408#ifdef HAVE_PLURAL
3409,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
3410,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, QRING_CMD,   DEF_CMD ALLOW_PLURAL}
3411#endif
3412,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
3413,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3414,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
3415,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3416,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3417,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3418,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
3419,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
3420,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
3421,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3422,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3423,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3424,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3425,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3426//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3427//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3428,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3429,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3430,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
3431,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
3432,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3433,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
3434,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
3435//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
3436//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
3437,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
3438,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
3439,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3440,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
3441,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
3442,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
3443,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
3444,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
3445,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
3446,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
3447,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
3448,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
3449,{NULL,        0,              0,              0,          0 NO_PLURAL}
3450};
3451/*=================== operations with 1 arg.: static proc =================*/
3452static BOOLEAN jjDUMMY(leftv res, leftv u)
3453{
3454  res->data = (char *)u->CopyD();
3455  return FALSE;
3456}
3457static BOOLEAN jjNULL(leftv res, leftv u)
3458{
3459  return FALSE;
3460}
3461//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3462//{
3463//  res->data = (char *)((int)(long)u->Data()+1);
3464//  return FALSE;
3465//}
3466//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3467//{
3468//  res->data = (char *)((int)(long)u->Data()-1);
3469//  return FALSE;
3470//}
3471static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3472{
3473  if (IDTYP((idhdl)u->data)==INT_CMD)
3474  {
3475    int i=IDINT((idhdl)u->data);
3476    if (iiOp==PLUSPLUS) i++;
3477    else                i--;
3478    IDDATA((idhdl)u->data)=(char *)(long)i;
3479    return FALSE;
3480  }
3481  return TRUE;
3482}
3483static BOOLEAN jjUMINUS_BI(leftv res, leftv u)
3484{
3485  number n=(number)u->CopyD(BIGINT_CMD);
3486  n=nlNeg(n);
3487  res->data = (char *)n;
3488  return FALSE;
3489}
3490static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3491{
3492  res->data = (char *)(-(long)u->Data());
3493  return FALSE;
3494}
3495static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3496{
3497  number n=(number)u->CopyD(NUMBER_CMD);
3498  n=nNeg(n);
3499  res->data = (char *)n;
3500  return FALSE;
3501}
3502static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3503{
3504  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3505  return FALSE;
3506}
3507static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3508{
3509  poly m1=pISet(-1);
3510  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3511  return FALSE;
3512}
3513static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3514{
3515  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3516  (*iv)*=(-1);
3517  res->data = (char *)iv;
3518  return FALSE;
3519}
3520static BOOLEAN jjPROC1(leftv res, leftv u)
3521{
3522  return jjPROC(res,u,NULL);
3523}
3524static BOOLEAN jjBAREISS(leftv res, leftv v)
3525{
3526  //matrix m=(matrix)v->Data();
3527  //lists l=mpBareiss(m,FALSE);
3528  intvec *iv;
3529  ideal m;
3530  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3531  lists l=(lists)omAllocBin(slists_bin);
3532  l->Init(2);
3533  l->m[0].rtyp=MODUL_CMD;
3534  l->m[1].rtyp=INTVEC_CMD;
3535  l->m[0].data=(void *)m;
3536  l->m[1].data=(void *)iv;
3537  res->data = (char *)l;
3538  return FALSE;
3539}
3540//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3541//{
3542//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3543//  ivTriangMat(m);
3544//  res->data = (char *)m;
3545//  return FALSE;
3546//}
3547static BOOLEAN jjBI2N(leftv res, leftv u)
3548{
3549  if (rField_is_Q())
3550  {
3551    res->data=u->CopyD();
3552    return FALSE;
3553  }
3554  else
3555  {
3556    BOOLEAN bo=FALSE;
3557    number n=(number)u->CopyD();
3558    if (rField_is_Zp())
3559    {
3560      res->data=(void *)npMap0(n);
3561    }
3562    else if (rField_is_Q_a())
3563    {
3564      res->data=(void *)naMap00(n);
3565    }
3566    else if (rField_is_Zp_a())
3567    {
3568      res->data=(void *)naMap0P(n);
3569    }
3570#ifdef HAVE_RINGS
3571    else if (rField_is_Ring_Z())
3572    {
3573      res->data=(void *)nrzMapQ(n);
3574    }
3575    else if (rField_is_Ring_ModN())
3576    {
3577      res->data=(void *)nrnMapQ(n);
3578    }
3579    else if (rField_is_Ring_PtoM())
3580    {
3581      res->data=(void *)nrnMapQ(n);
3582    }
3583    else if (rField_is_Ring_2toM())
3584    {
3585      res->data=(void *)nr2mMapQ(n);
3586    }
3587#endif
3588    else
3589    {
3590      WerrorS("cannot convert bigint to this field");
3591      bo=TRUE;
3592    }
3593    nlDelete(&n,NULL);
3594    return bo;
3595  }
3596}
3597static BOOLEAN jjBI2P(leftv res, leftv u)
3598{
3599  sleftv tmp;
3600  BOOLEAN bo=jjBI2N(&tmp,u);
3601  if (!bo)
3602  {
3603    number n=(number) tmp.data;
3604    if (nIsZero(n)) { res->data=NULL;nDelete(&n); }
3605    else
3606    {
3607      poly p=pOne();
3608      pSetCoeff(p,n);
3609      res->data=(void *)p;
3610    }
3611  }
3612  return bo;
3613}
3614static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3615{
3616  return iiExprArithM(res,u,iiOp);
3617}
3618static BOOLEAN jjCHAR(leftv res, leftv v)
3619{
3620  res->data = (char *)(long)rChar((ring)v->Data());
3621  return FALSE;
3622}
3623static BOOLEAN jjCOLS(leftv res, leftv v)
3624{
3625  res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3626  return FALSE;
3627}
3628static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3629{
3630  res->data = (char *)(long)((intvec*)(v->Data()))->cols();
3631  return FALSE;
3632}
3633static BOOLEAN jjCONTENT(leftv res, leftv v)
3634{
3635  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3636  poly p=(poly)v->CopyD(POLY_CMD);
3637  if (p!=NULL) pCleardenom(p);
3638  res->data = (char *)p;
3639  return FALSE;
3640}
3641static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3642{
3643  res->data = (char *)(long)nSize((number)v->Data());
3644  return FALSE;
3645}
3646static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3647{
3648  lists l=(lists)v->Data();
3649  res->data = (char *)(long)(l->nr+1);
3650  return FALSE;
3651}
3652static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3653{
3654  matrix m=(matrix)v->Data();
3655  res->data = (char *)(long)(MATROWS(m)*MATCOLS(m));
3656  return FALSE;
3657}
3658static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3659{
3660  res->data = (char *)(long)((intvec*)(v->Data()))->length();
3661  return FALSE;
3662}
3663static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3664{
3665  ring r=(ring)v->Data();
3666  int elems=-1;
3667  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
3668  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3669  {
3670#ifdef HAVE_FACTORY
3671    extern int ipower ( int b, int n ); /* factory/cf_util */
3672    elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3673#else
3674    elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3675#endif
3676  }
3677  res->data = (char *)(long)elems;
3678  return FALSE;
3679}
3680static BOOLEAN jjDEG(leftv res, leftv v)
3681{
3682  int dummy;
3683  poly p=(poly)v->Data();
3684  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3685  else res->data=(char *)-1;
3686  return FALSE;
3687}
3688static BOOLEAN jjDEG_M(leftv res, leftv u)
3689{
3690  ideal I=(ideal)u->Data();
3691  int d=-1;
3692  int dummy;
3693  int i;
3694  for(i=IDELEMS(I)-1;i>=0;i--)
3695    if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3696  res->data = (char *)(long)d;
3697  return FALSE;
3698}
3699static BOOLEAN jjDEGREE(leftv res, leftv v)
3700{
3701  assumeStdFlag(v);
3702  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3703  scDegree((ideal)v->Data(),module_w,currQuotient);
3704  return FALSE;
3705}
3706static BOOLEAN jjDEFINED(leftv res, leftv v)
3707{
3708  if ((v->rtyp==IDHDL)
3709  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3710  {
3711    res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3712  }
3713  else if (v->rtyp!=0) res->data=(void *)(-1);
3714  return FALSE;
3715}
3716#ifdef HAVE_FACTORY
3717static BOOLEAN jjDET(leftv res, leftv v)
3718{
3719  matrix m=(matrix)v->Data();
3720  poly p;
3721  if (smCheckDet((ideal)m,m->cols(),TRUE))
3722  {
3723    ideal I=idMatrix2Module(mpCopy(m));
3724    p=smCallDet(I);
3725    idDelete(&I);
3726  }
3727  else
3728    p=singclap_det(m);
3729  res ->data = (char *)p;
3730  return FALSE;
3731}
3732static BOOLEAN jjDET_I(leftv res, leftv v)
3733{
3734  intvec * m=(intvec*)v->Data();
3735  int i,j;
3736  i=m->rows();j=m->cols();
3737  if(i==j)
3738    res->data = (char *)(long)singclap_det_i(m);
3739  else
3740  {
3741    Werror("det of %d x %d intmat",i,j);
3742    return TRUE;
3743  }
3744  return FALSE;
3745}
3746static BOOLEAN jjDET_S(leftv res, leftv v)
3747{
3748  ideal I=(ideal)v->Data();
3749  poly p;
3750  if (IDELEMS(I)<1) return TRUE;
3751  if (smCheckDet(I,IDELEMS(I),FALSE))
3752  {
3753    matrix m=idModule2Matrix(idCopy(I));
3754    p=singclap_det(m);
3755    idDelete((ideal *)&m);
3756  }
3757  else
3758    p=smCallDet(I);
3759  res->data = (char *)p;
3760  return FALSE;
3761}
3762#endif
3763static BOOLEAN jjDIM(leftv res, leftv v)
3764{
3765  assumeStdFlag(v);
3766  res->data = (char *)(long)scDimInt((ideal)(v->Data()),currQuotient);
3767  return FALSE;
3768}
3769static BOOLEAN jjDUMP(leftv res, leftv v)
3770{
3771  si_link l = (si_link)v->Data();
3772  if (slDump(l))
3773  {
3774    const char *s;
3775    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3776    else                            s=sNoName;
3777    Werror("cannot dump to `%s`",s);
3778    return TRUE;
3779  }
3780  else
3781    return FALSE;
3782}
3783static BOOLEAN jjE(leftv res, leftv v)
3784{
3785  res->data = (char *)pOne();
3786  int co=(int)(long)v->Data();
3787  if (co>0)
3788  {
3789    pSetComp((poly)res->data,co);
3790    pSetm((poly)res->data);
3791  }
3792  else WerrorS("argument of gen must be positive");
3793  return (co<=0);
3794}
3795static BOOLEAN jjEXECUTE(leftv res, leftv v)
3796{
3797  char * d = (char *)v->Data();
3798  char * s = (char *)omAlloc(strlen(d) + 13);
3799  strcpy( s, (char *)d);
3800  strcat( s, "\n;RETURN();\n");
3801  newBuffer(s,BT_execute);
3802  return yyparse();
3803}
3804#ifdef HAVE_FACTORY
3805static BOOLEAN jjFACSTD(leftv res, leftv v)
3806{
3807  ideal_list p,h;
3808  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3809  p=h;
3810  int l=0;
3811  while (p!=NULL) { p=p->next;l++; }
3812  lists L=(lists)omAllocBin(slists_bin);
3813  L->Init(l);
3814  l=0;
3815  while(h!=NULL)
3816  {
3817    L->m[l].data=(char *)h->d;
3818    L->m[l].rtyp=IDEAL_CMD;
3819    p=h->next;
3820    omFreeSize(h,sizeof(*h));
3821    h=p;
3822    l++;
3823  }
3824  res->data=(void *)L;
3825  return FALSE;
3826}
3827static BOOLEAN jjFAC_P(leftv res, leftv u)
3828{
3829  intvec *v=NULL;
3830  singclap_factorize_retry=0;
3831  ideal f=singclap_factorize((poly)(u->CopyD()), &v, 0);
3832  if (f==NULL) return TRUE;
3833  ivTest(v);
3834  lists l=(lists)omAllocBin(slists_bin);
3835  l->Init(2);
3836  l->m[0].rtyp=IDEAL_CMD;
3837  l->m[0].data=(void *)f;
3838  l->m[1].rtyp=INTVEC_CMD;
3839  l->m[1].data=(void *)v;
3840  res->data=(void *)l;
3841  return FALSE;
3842}
3843#endif
3844static BOOLEAN jjGETDUMP(leftv res, leftv v)
3845{
3846  si_link l = (si_link)v->Data();
3847  if (slGetDump(l))
3848  {
3849    const char *s;
3850    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3851    else                            s=sNoName;
3852    Werror("cannot get dump from `%s`",s);
3853    return TRUE;
3854  }
3855  else
3856    return FALSE;
3857}
3858static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3859{
3860  assumeStdFlag(v);
3861  ideal I=(ideal)v->Data();
3862  res->data=(void *)iiHighCorner(I,0);
3863  return FALSE;
3864}
3865static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3866{
3867  assumeStdFlag(v);
3868  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3869  BOOLEAN delete_w=FALSE;
3870  ideal I=(ideal)v->Data();
3871  int i;
3872  poly p=NULL,po=NULL;
3873  int rk=idRankFreeModule(I);
3874  if (w==NULL)
3875  {
3876    w = new intvec(rk);
3877    delete_w=TRUE;
3878  }
3879  for(i=rk;i>0;i--)
3880  {
3881    p=iiHighCorner(I,i);
3882    if (p==NULL)
3883    {
3884      WerrorS("module must be zero-dimensional");
3885      if (delete_w) delete w;
3886      return TRUE;
3887    }
3888    if (po==NULL)
3889    {
3890      po=p;
3891    }
3892    else
3893    {
3894      // now po!=NULL, p!=NULL
3895      int d=(pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - pFDeg(p,currRing)+(*w)[i-1]);
3896      if (d==0)
3897        d=pLmCmp(po,p);
3898      if (d > 0)
3899      {
3900        pDelete(&p);
3901      }
3902      else // (d < 0)
3903      {
3904        pDelete(&po); po=p;
3905      }
3906    }
3907  }
3908  if (delete_w) delete w;
3909  res->data=(void *)po;
3910  return FALSE;
3911}
3912static BOOLEAN jjHILBERT(leftv res, leftv v)
3913{
3914  assumeStdFlag(v);
3915  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3916  //scHilbertPoly((ideal)v->Data(),currQuotient);
3917  hLookSeries((ideal)v->Data(),module_w,currQuotient);
3918  return FALSE;
3919}
3920static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3921{
3922  res->data=(void *)hSecondSeries((intvec *)v->Data());
3923  return FALSE;
3924}
3925static BOOLEAN jjHOMOG1(leftv res, leftv v)
3926{
3927  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3928  ideal v_id=(ideal)v->Data();
3929  if (w==NULL)
3930  {
3931    res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
3932    if ((res->data!=NULL) && (v->rtyp==IDHDL))
3933    {
3934      char *isHomog=omStrDup("isHomog");
3935      if (v->e==NULL)
3936        atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3937      else
3938        atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3939    }
3940    else if (w!=NULL) delete w;
3941  }
3942  else
3943    res->data=(void *)(long)idTestHomModule(v_id,currQuotient,w);
3944  return FALSE;
3945}
3946static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3947{
3948  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3949  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3950  if (IDELEMS((ideal)mat)==0)
3951  {
3952    idDelete((ideal *)&mat);
3953    mat=(matrix)idInit(1,1);
3954  }
3955  else
3956  {
3957    MATROWS(mat)=1;
3958    mat->rank=1;
3959    idTest((ideal)mat);
3960  }
3961  res->data=(char *)mat;
3962  return FALSE;
3963}
3964static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3965{
3966  map m=(map)v->CopyD(MAP_CMD);
3967  omFree((ADDRESS)m->preimage);
3968  m->preimage=NULL;
3969  ideal I=(ideal)m;
3970  I->rank=1;
3971  res->data=(char *)I;
3972  return FALSE;
3973}
3974static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3975{
3976  if (currRing!=NULL)
3977  {
3978    ring q=(ring)v->Data();
3979    if (rSamePolyRep(currRing, q))
3980    {
3981      if (q->qideal==NULL)
3982        res->data=(char *)idInit(1,1);
3983      else
3984        res->data=(char *)idCopy(q->qideal);
3985      return FALSE;
3986    }
3987  }
3988  WerrorS("can only get ideal from identical qring");
3989  return TRUE;
3990}
3991static BOOLEAN jjIm2Iv(leftv res, leftv v)
3992{
3993  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3994  iv->makeVector();
3995  res->data = iv;
3996  return FALSE;
3997}
3998static BOOLEAN jjIMPART(leftv res, leftv v)
3999{
4000  res->data = (char *)nImPart((number)v->Data());
4001  return FALSE;
4002}
4003static BOOLEAN jjINDEPSET(leftv res, leftv v)
4004{
4005  assumeStdFlag(v);
4006  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
4007  return FALSE;
4008}
4009static BOOLEAN jjINTERRED(leftv res, leftv v)
4010{
4011  ideal result=kInterRed((ideal)(v->Data()), currQuotient);
4012  if (TEST_OPT_PROT) { PrintLn(); mflush(); }
4013  res->data = result;
4014  return FALSE;
4015}
4016static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
4017{
4018  res->data = (char *)(long)pVar((poly)v->Data());
4019  return FALSE;
4020}
4021static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
4022{
4023  res->data = (char *)(long)(r_IsRingVar((char *)v->Data(), currRing)+1);
4024  return FALSE;
4025}
4026static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
4027{
4028  res->data = (char *)0;
4029  return FALSE;
4030}
4031static BOOLEAN jjJACOB_P(leftv res, leftv v)
4032{
4033  ideal i=idInit(pVariables,1);
4034  int k;
4035  poly p=(poly)(v->Data());
4036  for (k=pVariables;k>0;k--)
4037  {
4038    i->m[k-1]=pDiff(p,k);
4039  }
4040  res->data = (char *)i;
4041  return FALSE;
4042}
4043static BOOLEAN jjKBASE(leftv res, leftv v)
4044{
4045  assumeStdFlag(v);
4046  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
4047  return FALSE;
4048}
4049#ifdef MDEBUG
4050static BOOLEAN jjpHead(leftv res, leftv v)
4051{
4052  res->data=(char *)pHead((poly)v->Data());
4053  return FALSE;
4054}
4055#endif
4056static BOOLEAN jjL2R(leftv res, leftv v)
4057{
4058  res->data=(char *)syConvList((lists)v->Data());
4059  if (res->data != NULL)
4060    return FALSE;
4061  else
4062    return TRUE;
4063}
4064static BOOLEAN jjLEADCOEF(leftv res, leftv v)
4065{
4066  poly p=(poly)v->Data();
4067  if (p==NULL)
4068  {
4069    res->data=(char *)nInit(0);
4070  }
4071  else
4072  {
4073    res->data=(char *)nCopy(pGetCoeff(p));
4074  }
4075  return FALSE;
4076}
4077static BOOLEAN jjLEADEXP(leftv res, leftv v)
4078{
4079  poly p=(poly)v->Data();
4080  int s=pVariables;
4081  if (v->Typ()==VECTOR_CMD) s++;
4082  intvec *iv=new intvec(s);
4083  if (p!=NULL)
4084  {
4085    for(int i = pVariables;i;i--)
4086    {
4087      (*iv)[i-1]=pGetExp(p,i);
4088    }
4089    if (s!=pVariables)
4090      (*iv)[pVariables]=pGetComp(p);
4091  }
4092  res->data=(char *)iv;
4093  return FALSE;
4094}
4095static BOOLEAN jjLEADMONOM(leftv res, leftv v)
4096{
4097  poly p=(poly)v->Data();
4098  if (p == NULL)
4099  {
4100    res->data = (char*) NULL;
4101  }
4102  else
4103  {
4104    poly lm = pLmInit(p);
4105    pSetCoeff(lm, nInit(1));
4106    res->data = (char*) lm;
4107  }
4108  return FALSE;
4109}
4110static BOOLEAN jjLISTRING(leftv res, leftv v)
4111{
4112  ring r=rCompose((lists)v->Data());
4113  if (r==NULL) return TRUE;
4114  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
4115  res->data=(char *)r;
4116  return FALSE;
4117}
4118#if SIZEOF_LONG == 8
4119static number jjLONG2N(long d)
4120{
4121  int i=(int)d;
4122  if ((long)i == d)
4123  {
4124    return nlInit(i);
4125  }
4126  else
4127  {
4128    number z=(number)omAllocBin(rnumber_bin);
4129    #if defined(LDEBUG)
4130    z->debug=123456;
4131    #endif
4132    mpz_init_set_si(&z->z,d);
4133    return z;
4134  }
4135}
4136#else
4137#define jjLONG2N(D) nlInit((int)D)
4138#endif
4139static BOOLEAN jjMEMORY(leftv res, leftv v)
4140{
4141  omUpdateInfo();
4142  long d;
4143  switch(((int)(long)v->Data()))
4144  {
4145  case 0:
4146    res->data=(char *)jjLONG2N(om_Info.UsedBytes);
4147    break;
4148  case 1:
4149    res->data = (char *)jjLONG2N(om_Info.CurrentBytesSystem);
4150    break;
4151  case 2:
4152    res->data = (char *)jjLONG2N(om_Info.MaxBytesSystem);
4153    break;
4154  default:
4155    omPrintStats(stdout);
4156    omPrintInfo(stdout);
4157    omPrintBinStats(stdout);
4158    res->data = (char *)0;
4159    res->rtyp = NONE;
4160  }
4161  return FALSE;
4162  res->data = (char *)0;
4163  return FALSE;
4164}
4165#if SIZEOF_LONG == 8
4166static number jjBI2N(long d)
4167{
4168  if (d<((long)INT_MAX)) return nlInit((int)d);
4169  else
4170  {
4171    number n=nlRInit(0);
4172    mpz_set_si(&n->z,d);
4173    return n;
4174  }
4175}
4176#endif
4177//static BOOLEAN jjMONITOR1(leftv res, leftv v)
4178//{
4179//  return jjMONITOR2(res,v,NULL);
4180//}
4181static BOOLEAN jjMSTD(leftv res, leftv v)
4182{
4183  int t=v->Typ();
4184  ideal r,m;
4185  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
4186  lists l=(lists)omAllocBin(slists_bin);
4187  l->Init(2);
4188  l->m[0].rtyp=t;
4189  l->m[0].data=(char *)r;
4190  setFlag(&(l->m[0]),FLAG_STD);
4191  l->m[1].rtyp=t;
4192  l->m[1].data=(char *)m;
4193  res->data=(char *)l;
4194  return FALSE;
4195}
4196static BOOLEAN jjMULT(leftv res, leftv v)
4197{
4198  assumeStdFlag(v);
4199  res->data = (char *)(long)scMultInt((ideal)(v->Data()),currQuotient);
4200  return FALSE;
4201}
4202static BOOLEAN jjMINRES_R(leftv res, leftv v)
4203{
4204  intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4205  res->data=(char *)syMinimize((syStrategy)v->Data());
4206  if (weights!=NULL)
4207    atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
4208  return FALSE;
4209}
4210static BOOLEAN jjN2BI(leftv res, leftv v)
4211{
4212  number n,i; i=(number)v->Data();
4213  if (rField_is_Zp())
4214  {
4215     if (((long)i)>(npPrimeM>>1))
4216       n=nlInit((int)(((long)i)-npPrimeM));
4217     else
4218       n=nlInit((int)(long)i);
4219  }
4220  else if (rField_is_Q()) n=nlBigInt(i);
4221#ifdef HAVE_RINGS
4222  else if (rField_is_Ring_Z() || rField_is_Ring_ModN() || rField_is_Ring_PtoM()) n=nlMapGMP(i);
4223  else if (rField_is_Ring_2toM()) n=nlInit((unsigned long) i);
4224#endif
4225  else goto err;
4226  res->data=(void *)n;
4227  return FALSE;
4228err:
4229  WerrorS("cannot convert to bigint"); return TRUE;
4230}
4231static BOOLEAN jjNAMEOF(leftv res, leftv v)
4232{
4233  res->data = (char *)v->name;
4234  if (res->data==NULL) res->data=omStrDup("");
4235  v->name=NULL;
4236  return FALSE;
4237}
4238static BOOLEAN jjNAMES(leftv res, leftv v)
4239{
4240  res->data=ipNameList(((ring)v->Data())->idroot);
4241  return FALSE;
4242}
4243static BOOLEAN jjNVARS(leftv res, leftv v)
4244{
4245  res->data = (char *)(long)(((ring)(v->Data()))->N);
4246  return FALSE;
4247}
4248static BOOLEAN jjOpenClose(leftv res, leftv v)
4249{
4250  si_link l=(si_link)v->Data();
4251  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
4252  else                return slClose(l);
4253}
4254static BOOLEAN jjORD(leftv res, leftv v)
4255{
4256  poly p=(poly)v->Data();
4257  res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
4258  return FALSE;
4259}
4260static BOOLEAN jjPAR1(leftv res, leftv v)
4261{
4262  int i=(int)(long)v->Data();
4263  int p=0;
4264  p=rPar(currRing);
4265  if ((0<i) && (i<=p))
4266  {
4267    res->data=(char *)nPar(i);
4268  }
4269  else
4270  {
4271    Werror("par number %d out of range 1..%d",i,p);
4272    return TRUE;
4273  }
4274  return FALSE;
4275}
4276static BOOLEAN jjPARDEG(leftv res, leftv v)
4277{
4278  res->data = (char *)(long)nParDeg((number)v->Data());
4279  return FALSE;
4280}
4281static BOOLEAN jjPARSTR1(leftv res, leftv v)
4282{
4283  if (currRing==NULL)
4284  {
4285    WerrorS("no ring active");
4286    return TRUE;
4287  }
4288  int i=(int)(long)v->Data();
4289  int p=0;
4290  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
4291    res->data=omStrDup(currRing->parameter[i-1]);
4292  else
4293  {
4294    Werror("par number %d out of range 1..%d",i,p);
4295    return TRUE;
4296  }
4297  return FALSE;
4298}
4299static BOOLEAN jjP2I(leftv res, leftv v)
4300{
4301  poly p=(poly)v->Data();
4302  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
4303  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
4304  {
4305    WerrorS("poly must be constant");
4306    return TRUE;
4307  }
4308  res->data = (char *)(long)nInt(pGetCoeff(p));
4309  return FALSE;
4310}
4311static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
4312{
4313  map mapping=(map)v->Data();
4314  syMake(res,omStrDup(mapping->preimage));
4315  return FALSE;
4316}
4317static BOOLEAN jjPRIME(leftv res, leftv v)
4318{
4319  int i = IsPrime((int)(long)(v->Data()));
4320  res->data = (char *)(long)(i > 1 ? i : 2);
4321  return FALSE;
4322}
4323static BOOLEAN jjPRUNE(leftv res, leftv v)
4324{
4325  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4326  ideal v_id=(ideal)v->Data();
4327  if (w!=NULL)
4328  {
4329    if (!idTestHomModule(v_id,currQuotient,w))
4330    {
4331      WarnS("wrong weights");
4332      w=NULL;
4333      // and continue at the non-homog case below
4334    }
4335    else
4336    {
4337      w=ivCopy(w);
4338      intvec **ww=&w;
4339      res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
4340      atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
4341      return FALSE;
4342    }
4343  }
4344  res->data = (char *)idMinEmbedding(v_id);
4345  return FALSE;
4346}
4347static BOOLEAN jjP2N(leftv res, leftv v)
4348{
4349  number n;
4350  poly p;
4351  if (((p=(poly)v->Data())!=NULL)
4352  && (pIsConstant(p)))
4353  {
4354    n=nCopy(pGetCoeff(p));
4355  }
4356  else
4357  {
4358    n=nInit(0);
4359  }
4360  res->data = (char *)n;
4361  return FALSE;
4362}
4363static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
4364{
4365  char *s= (char *)v->Data();
4366  int i = 1;
4367  int l = strlen(s);
4368  for(i=0; i<sArithBase.nCmdUsed; i++)
4369  {
4370    //Print("test %d, >>%s<<, tab:>>%s<<\n",i,s,sArithBase.sCmds[i].name);
4371    if (strcmp(s, sArithBase.sCmds[i].name) == 0)
4372    {
4373      res->data = (char *)1;
4374      return FALSE;
4375    }
4376  }
4377  //res->data = (char *)0;
4378  return FALSE;
4379}
4380static BOOLEAN jjREAD(leftv res, leftv v)
4381{
4382  return jjREAD2(res,v,NULL);
4383}
4384static BOOLEAN jjREGULARITY(leftv res, leftv v)
4385{
4386  res->data = (char *)(long)iiRegularity((lists)v->Data());
4387  return FALSE;
4388}
4389static BOOLEAN jjREPART(leftv res, leftv v)
4390{
4391  res->data = (char *)nRePart((number)v->Data());
4392  return FALSE;
4393}
4394static BOOLEAN jjRINGLIST(leftv res, leftv v)
4395{
4396  ring r=(ring)v->Data();
4397  if (r!=NULL)
4398    res->data = (char *)rDecompose((ring)v->Data());
4399  return (r==NULL)||(res->data==NULL);
4400}
4401static BOOLEAN jjROWS(leftv res, leftv v)
4402{
4403  ideal i = (ideal)v->Data();
4404  res->data = (char *)i->rank;
4405  return FALSE;
4406}
4407static BOOLEAN jjROWS_IV(leftv res, leftv v)
4408{
4409  res->data = (char *)(long)((intvec*)(v->Data()))->rows();
4410  return FALSE;
4411}
4412static BOOLEAN jjRPAR(leftv res, leftv v)
4413{
4414  res->data = (char *)(long)rPar(((ring)v->Data()));
4415  return FALSE;
4416}
4417static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4418{
4419#ifdef HAVE_PLURAL
4420  const bool bIsSCA = rIsSCA(currRing);
4421#else
4422  const bool bIsSCA = false;
4423#endif
4424
4425  if ((currQuotient!=NULL) && !bIsSCA)
4426  {
4427    WerrorS("qring not supported by slimgb at the moment");
4428    return TRUE;
4429  }
4430  if (rHasLocalOrMixedOrdering_currRing())
4431  {
4432    WerrorS("ordering must be global for slimgb");
4433    return TRUE;
4434  }
4435  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4436  tHomog hom=testHomog;
4437  ideal u_id=(ideal)u->Data();
4438  if (w!=NULL)
4439  {
4440    if (!idTestHomModule(u_id,currQuotient,w))
4441    {
4442      WarnS("wrong weights");
4443      w=NULL;
4444    }
4445    else
4446    {
4447      w=ivCopy(w);
4448      hom=isHomog;
4449    }
4450  }
4451
4452  assume(u_id->rank>=idRankFreeModule(u_id));
4453  res->data=(char *)t_rep_gb(currRing,
4454    u_id,u_id->rank);
4455  //res->data=(char *)t_rep_gb(currRing, u_id);
4456
4457  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4458  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4459  return FALSE;
4460}
4461static BOOLEAN jjSTD(leftv res, leftv v)
4462{
4463  ideal result;
4464  ideal v_id=(ideal)v->Data();
4465  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4466  tHomog hom=testHomog;
4467  if (w!=NULL)
4468  {
4469    if (!idTestHomModule(v_id,currQuotient,w))
4470    {
4471      WarnS("wrong weights");
4472      w=NULL;
4473    }
4474    else
4475    {
4476      hom=isHomog;
4477      w=ivCopy(w);
4478    }
4479  }
4480  result=kStd(v_id,currQuotient,hom,&w);
4481  idSkipZeroes(result);
4482  res->data = (char *)result;
4483  if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4484  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4485  return FALSE;
4486}
4487static BOOLEAN jjSort_Id(leftv res, leftv v)
4488{
4489  res->data = (char *)idSort((ideal)v->Data());
4490  return FALSE;
4491}
4492#ifdef HAVE_FACTORY
4493extern int singclap_factorize_retry;
4494static BOOLEAN jjSQR_FREE(leftv res, leftv u)
4495{
4496  intvec *v=NULL;
4497  singclap_factorize_retry=0;
4498  ideal f=singclap_sqrfree((poly)(u->CopyD()));
4499  if (f==NULL)
4500    return TRUE;
4501  res->data=(void *)f;
4502  return FALSE;
4503}
4504#endif
4505#if 1
4506static BOOLEAN jjSYZYGY(leftv res, leftv v)
4507{
4508  intvec *w=NULL;
4509  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4510  if (w!=NULL) delete w;
4511  return FALSE;
4512}
4513#else
4514// activate, if idSyz handle module weights correctly !
4515static BOOLEAN jjSYZYGY(leftv res, leftv v)
4516{
4517  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4518  ideal v_id=(ideal)v->Data();
4519  tHomog hom=testHomog;
4520  int add_row_shift=0;
4521  if (w!=NULL)
4522  {
4523    w=ivCopy(w);
4524    add_row_shift=w->min_in();
4525    (*w)-=add_row_shift;
4526    if (idTestHomModule(v_id,currQuotient,w))
4527      hom=isHomog;
4528    else
4529    {
4530      //WarnS("wrong weights");
4531      delete w; w=NULL;
4532      hom=testHomog;
4533    }
4534  }
4535  res->data = (char *)idSyzygies(v_id,hom,&w);
4536  if (w!=NULL)
4537  {
4538    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4539  }
4540  return FALSE;
4541}
4542#endif
4543static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4544{
4545  res->data = (char *)(long)ivTrace((intvec*)(v->Data()));
4546  return FALSE;
4547}
4548static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4549{
4550  res->data = (char *)ivTranp((intvec*)(v->Data()));
4551  return FALSE;
4552}
4553#ifdef HAVE_PLURAL
4554static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4555{
4556  ring    r = (ring)a->Data();
4557  if (rIsPluralRing(r))
4558  {
4559    res->data = rOpposite(r);
4560  }
4561  else res->data = rCopy(r);
4562  return FALSE;
4563}
4564static BOOLEAN jjENVELOPE(leftv res, leftv a)
4565{
4566  ring    r = (ring)a->Data();
4567  if (rIsPluralRing(r))
4568  {
4569    //    ideal   i;
4570//     if (a->rtyp == QRING_CMD)
4571//     {
4572//       i = r->qideal;
4573//       r->qideal = NULL;
4574//     }
4575    ring s = rEnvelope(r);
4576//     if (a->rtyp == QRING_CMD)
4577//     {
4578//       ideal is  = idOppose(r,i); /* twostd? */
4579//       is        = idAdd(is,i);
4580//       s->qideal = i;
4581//     }
4582    res->data = s;
4583  }
4584  else  res->data = rCopy(r);
4585  return FALSE;
4586}
4587static BOOLEAN jjTWOSTD(leftv res, leftv a)
4588{
4589  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
4590  else  res->data=(ideal)a->CopyD();
4591  setFlag(res,FLAG_STD);
4592  setFlag(res,FLAG_TWOSTD);
4593  return FALSE;
4594}
4595#endif
4596
4597static BOOLEAN jjTYPEOF(leftv res, leftv v)
4598{
4599  switch ((int)(long)v->data)
4600  {
4601    case INT_CMD:     res->data=omStrDup("int"); break;
4602    case POLY_CMD:   res->data=omStrDup("poly"); break;
4603    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
4604    case STRING_CMD:  res->data=omStrDup("string"); break;
4605    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
4606    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
4607    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4608    case MODUL_CMD:   res->data=omStrDup("module"); break;
4609    case MAP_CMD:     res->data=omStrDup("map"); break;
4610    case PROC_CMD:    res->data=omStrDup("proc"); break;
4611    case RING_CMD:    res->data=omStrDup("ring"); break;
4612    case QRING_CMD:   res->data=omStrDup("qring"); break;
4613    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
4614    case NUMBER_CMD:  res->data=omStrDup("number"); break;
4615    case BIGINT_CMD:  res->data=omStrDup("bigint"); break;
4616    case LIST_CMD:   res->data=omStrDup("list"); break;
4617    case PACKAGE_CMD: res->data=omStrDup("package"); break;
4618    case LINK_CMD:   res->data=omStrDup("link"); break;
4619    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4620    case DEF_CMD:
4621    case NONE:    res->data=omStrDup("none"); break;
4622    default:       res->data=omStrDup("?unknown type?");
4623  }
4624  return FALSE;
4625}
4626static BOOLEAN jjUNIVARIATE(leftv res, leftv v)
4627{
4628  res->data=(char *)pIsUnivariate((poly)v->Data());
4629  return FALSE;
4630}
4631static BOOLEAN jjVAR1(leftv res, leftv v)
4632{
4633  int i=(int)(long)v->Data();
4634  if ((0<i) && (i<=currRing->N))
4635  {
4636    poly p=pOne();
4637    pSetExp(p,i,1);
4638    pSetm(p);
4639    res->data=(char *)p;
4640  }
4641  else
4642  {
4643    Werror("var number %d out of range 1..%d",i,currRing->N);
4644    return TRUE;
4645  }
4646  return FALSE;
4647}
4648static BOOLEAN jjVARSTR1(leftv res, leftv v)
4649{
4650  if (currRing==NULL)
4651  {
4652    WerrorS("no ring active");
4653    return TRUE;
4654  }
4655  int i=(int)(long)v->Data();
4656  if ((0<i) && (i<=currRing->N))
4657    res->data=omStrDup(currRing->names[i-1]);
4658  else
4659  {
4660    Werror("var number %d out of range 1..%d",i,currRing->N);
4661    return TRUE;
4662  }
4663  return FALSE;
4664}
4665static BOOLEAN jjVDIM(leftv res, leftv v)
4666{
4667  assumeStdFlag(v);
4668  res->data = (char *)(long)scMult0Int((ideal)v->Data(),currQuotient);
4669  return FALSE;
4670}
4671
4672static BOOLEAN jjLOAD1(leftv res, leftv v)
4673{
4674  return jjLOAD(res, v,iiOp==LIB_CMD);
4675}
4676static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4677{
4678#ifdef HAVE_NS
4679  char * s=(char *)v->CopyD();
4680  char libnamebuf[256];
4681  lib_types LT = type_of_LIB(s, libnamebuf);
4682#ifdef HAVE_DYNAMIC_LOADING
4683  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN autoexport);
4684#endif /* HAVE_DYNAMIC_LOADING */
4685  switch(LT)
4686  {
4687      default:
4688      case LT_NONE:
4689        Werror("%s: unknown type", s);
4690        break;
4691      case LT_NOTFOUND:
4692        Werror("cannot open %s", s);
4693        break;
4694
4695      case LT_SINGULAR:
4696      {
4697        char *plib = iiConvName(s);
4698        idhdl pl = IDROOT->get(plib,0);
4699        if (pl==NULL)
4700        {
4701          pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4702          IDPACKAGE(pl)->language = LANG_SINGULAR;
4703          IDPACKAGE(pl)->libname=omStrDup(plib);
4704        }
4705        else if (IDTYP(pl)!=PACKAGE_CMD)
4706        {
4707          Werror("can not create package `%s`",plib);
4708          omFree(plib);
4709          return TRUE;
4710        }
4711        package savepack=currPack;
4712        currPack=IDPACKAGE(pl);
4713        IDPACKAGE(pl)->loaded=TRUE;
4714        char libnamebuf[256];
4715        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4716        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4717        currPack=savepack;
4718        IDPACKAGE(pl)->loaded=(!bo);
4719        return bo;
4720      }
4721      case LT_MACH_O:
4722      case LT_ELF:
4723      case LT_HPUX:
4724#ifdef HAVE_DYNAMIC_LOADING
4725        return load_modules(s, libnamebuf, autoexport);
4726#else /* HAVE_DYNAMIC_LOADING */
4727        WerrorS("Dynamic modules are not supported by this version of Singular");
4728        break;
4729#endif /* HAVE_DYNAMIC_LOADING */
4730  }
4731#endif
4732  return TRUE;
4733}
4734
4735/*=================== operations with 1 arg.: table =================*/
4736
4737#ifdef INIT_BUG
4738#define XS(A) -((short)A)
4739#define jjstrlen       (proc1)1
4740#define jjpLength      (proc1)2
4741#define jjidElem       (proc1)3
4742#define jjmpDetBareiss (proc1)4
4743#define jjidFreeModule (proc1)5
4744#define jjidVec2Ideal  (proc1)6
4745#define jjrCharStr     (proc1)7
4746#ifndef MDEBUG
4747#define jjpHead        (proc1)8
4748#endif
4749#define jjidHead       (proc1)9
4750#define jjidMaxIdeal   (proc1)10
4751#define jjidMinBase    (proc1)11
4752#define jjsyMinBase    (proc1)12
4753#define jjpMaxComp     (proc1)13
4754#define jjmpTrace      (proc1)14
4755#define jjmpTransp     (proc1)15
4756#define jjrOrdStr      (proc1)16
4757#define jjrVarStr      (proc1)18
4758#define jjrParStr      (proc1)19
4759#define jjCOUNT_RES    (proc1)22
4760#define jjDIM_R        (proc1)23
4761#define jjidTransp     (proc1)24
4762
4763extern struct sValCmd1 dArith1[];
4764void jjInitTab1()
4765{
4766  int i=0;
4767  for (;dArith1[i].cmd!=0;i++)
4768  {
4769    if (dArith1[i].res<0)
4770    {
4771      switch ((int)dArith1[i].p)
4772      {
4773        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
4774        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
4775        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
4776        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
4777#ifndef HAVE_FACTORY
4778        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4779#endif
4780        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4781        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
4782#ifndef MDEBUG
4783        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
4784#endif
4785        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
4786        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
4787        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
4788        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
4789        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
4790        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
4791        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
4792        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
4793        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
4794        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
4795        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
4796        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
4797        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
4798#ifdef GENTABLE
4799        default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4800#endif
4801      }
4802    }
4803  }
4804}
4805#else
4806#if defined(PROC_BUG)
4807#define XS(A) A
4808static BOOLEAN jjstrlen(leftv res, leftv v)
4809{
4810  res->data = (char *)strlen((char *)v->Data());
4811  return FALSE;
4812}
4813static BOOLEAN jjpLength(leftv res, leftv v)
4814{
4815  res->data = (char *)pLength((poly)v->Data());
4816  return FALSE;
4817}
4818static BOOLEAN jjidElem(leftv res, leftv v)
4819{
4820  res->data = (char *)idElem((ideal)v->Data());
4821  return FALSE;
4822}
4823static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4824{
4825  res->data = (char *)mpDetBareiss((matrix)v->Data());
4826  return FALSE;
4827}
4828static BOOLEAN jjidFreeModule(leftv res, leftv v)
4829{
4830  res->data = (char *)idFreeModule((int)(long)v->Data());
4831  return FALSE;
4832}
4833static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4834{
4835  res->data = (char *)idVec2Ideal((poly)v->Data());
4836  return FALSE;
4837}
4838static BOOLEAN jjrCharStr(leftv res, leftv v)
4839{
4840  res->data = rCharStr((ring)v->Data());
4841  return FALSE;
4842}
4843#ifndef MDEBUG
4844static BOOLEAN jjpHead(leftv res, leftv v)
4845{
4846  res->data = (char *)pHead((poly)v->Data());
4847  return FALSE;
4848}
4849#endif
4850static BOOLEAN jjidHead(leftv res, leftv v)
4851{
4852  res->data = (char *)idHead((ideal)v->Data());
4853  return FALSE;
4854}
4855static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4856{
4857  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4858  return FALSE;
4859}
4860static BOOLEAN jjidMinBase(leftv res, leftv v)
4861{
4862  res->data = (char *)idMinBase((ideal)v->Data());
4863  return FALSE;
4864}
4865static BOOLEAN jjsyMinBase(leftv res, leftv v)
4866{
4867  res->data = (char *)syMinBase((ideal)v->Data());
4868  return FALSE;
4869}
4870static BOOLEAN jjpMaxComp(leftv res, leftv v)
4871{
4872  res->data = (char *)pMaxComp((poly)v->Data());
4873  return FALSE;
4874}
4875static BOOLEAN jjmpTrace(leftv res, leftv v)
4876{
4877  res->data = (char *)mpTrace((matrix)v->Data());
4878  return FALSE;
4879}
4880static BOOLEAN jjmpTransp(leftv res, leftv v)
4881{
4882  res->data = (char *)mpTransp((matrix)v->Data());
4883  return FALSE;
4884}
4885static BOOLEAN jjrOrdStr(leftv res, leftv v)
4886{
4887  res->data = rOrdStr((ring)v->Data());
4888  return FALSE;
4889}
4890static BOOLEAN jjrVarStr(leftv res, leftv v)
4891{
4892  res->data = rVarStr((ring)v->Data());
4893  return FALSE;
4894}
4895static BOOLEAN jjrParStr(leftv res, leftv v)
4896{
4897  res->data = rParStr((ring)v->Data());
4898  return FALSE;
4899}
4900static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4901{
4902  res->data=(char *)syLength((syStrategy)v->Data());
4903  return FALSE;
4904}
4905static BOOLEAN jjDIM_R(leftv res, leftv v)
4906{
4907  res->data = (char *)syDim((syStrategy)v->Data());
4908  return FALSE;
4909}
4910static BOOLEAN jjidTransp(leftv res, leftv v)
4911{
4912  res->data = (char *)idTransp((ideal)v->Data());
4913  return FALSE;
4914}
4915#else
4916#define XS(A)          -((short)A)
4917#define jjstrlen       (proc1)strlen
4918#define jjpLength      (proc1)pLength
4919#define jjidElem       (proc1)idElem
4920#define jjmpDetBareiss (proc1)mpDetBareiss
4921#define jjidFreeModule (proc1)idFreeModule
4922#define jjidVec2Ideal  (proc1)idVec2Ideal
4923#define jjrCharStr     (proc1)rCharStr
4924#ifndef MDEBUG
4925#define jjpHead        (proc1)pHeadProc
4926#endif
4927#define jjidHead       (proc1)idHead
4928#define jjidMaxIdeal   (proc1)idMaxIdeal
4929#define jjidMinBase    (proc1)idMinBase
4930#define jjsyMinBase    (proc1)syMinBase
4931#define jjpMaxComp     (proc1)pMaxCompProc
4932#define jjmpTrace      (proc1)mpTrace
4933#define jjmpTransp     (proc1)mpTransp
4934#define jjrOrdStr      (proc1)rOrdStr
4935#define jjrVarStr      (proc1)rVarStr
4936#define jjrParStr      (proc1)rParStr
4937#define jjCOUNT_RES    (proc1)syLength
4938#define jjDIM_R        (proc1)syDim
4939#define jjidTransp     (proc1)idTransp
4940#endif
4941#endif
4942static BOOLEAN jjnInt(leftv res, leftv u)
4943{
4944  number n=(number)u->Data();
4945  res->data=(char *)(long)nInt(n);
4946  return FALSE;
4947}
4948static BOOLEAN jjnlInt(leftv res, leftv u)
4949{
4950  number n=(number)u->Data();
4951  res->data=(char *)(long)nlInt(n);
4952  return FALSE;
4953}
4954#define s short
4955struct sValCmd1 dArith1[]=
4956{
4957// operations:
4958// proc         cmd               res             arg           plural
4959// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4960//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4961 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4962,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4963,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4964,{jjUMINUS_BI,   '-',            BIGINT_CMD,     BIGINT_CMD     ALLOW_PLURAL}
4965,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4966,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4967,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4968,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4969,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4970,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4971,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4972,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4973// and the procedures with 1 argument:
4974,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4975//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4976,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4977,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4978,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4979,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4980,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4981,{jjDUMMY,      BIGINT_CMD,      BIGINT_CMD,     BIGINT_CMD     ALLOW_PLURAL}
4982,{jjN2BI,       BIGINT_CMD,      BIGINT_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4983,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4984,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4985#ifdef HAVE_FACTORY
4986,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4987#else
4988,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4989#endif
4990,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4991,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4992,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4993//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4994,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4995,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4996,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4997,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4998,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4999,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
5000,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5001,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
5002,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD ALLOW_PLURAL}
5003,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
5004,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
5005,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
5006,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
5007,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
5008,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
5009,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
5010,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
5011,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
5012,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
5013,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
5014,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
5015,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
5016,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
5017,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
5018,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
5019,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
5020,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
5021#ifdef HAVE_FACTORY
5022,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
5023,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
5024,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
5025#else
5026,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
5027,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
5028#endif
5029,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
5030,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
5031,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
5032,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
5033,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
5034,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
5035,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
5036#ifdef HAVE_FACTORY
5037,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
5038#else
5039,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
5040#endif
5041#ifdef HAVE_FGLM
5042,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
5043#else
5044,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
5045#endif
5046,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
5047#ifdef HAVE_FACTORY
5048,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
5049#else
5050,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
5051#endif
5052,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
5053,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
5054,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
5055,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
5056,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
5057,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
5058,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
5059,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
5060,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5061,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
5062,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
5063,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
5064,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
5065,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
5066,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
5067,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
5068,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
5069,{jjnlInt,      INT_CMD,         INT_CMD,        BIGINT_CMD     ALLOW_PLURAL}
5070,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
5071,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
5072,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5073,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5074,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
5075,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
5076,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
5077,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
5078,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
5079,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
5080,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
5081,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
5082,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5083,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5084,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5085,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
5086#ifdef MDEBUG
5087,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
5088#else
5089,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
5090#endif
5091,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
5092#ifdef MDEBUG
5093,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5094#else
5095,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
5096#endif
5097,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
5098,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
5099,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5100,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
5101,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5102,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
5103,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5104,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
5105,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
5106,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
5107,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
5108,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
5109,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
5110,{jjMEMORY,     MEMORY_CMD,      BIGINT_CMD,     INT_CMD        ALLOW_PLURAL}
5111,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
5112,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
5113,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
5114,{jjMINRES_R,   MINRES_CMD,      RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
5115,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5116,{jjMONITOR1,   MONITOR_CMD,     NONE,           LINK_CMD     ALLOW_PLURAL}
5117,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
5118,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
5119,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
5120,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
5121,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
5122,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
5123,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
5124,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
5125,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
5126,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
5127,{jjBI2N,       NUMBER_CMD,      NUMBER_CMD,     BIGINT_CMD     ALLOW_PLURAL}
5128,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
5129,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
5130,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
5131,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
5132,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
5133,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
5134,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
5135,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
5136,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
5137,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
5138,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
5139,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
5140,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
5141,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
5142,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
5143,{jjBI2P,       POLY_CMD,        POLY_CMD,       BIGINT_CMD     ALLOW_PLURAL}
5144,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
5145,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
5146,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
5147,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
5148,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5149,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
5150,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
5151,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
5152,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
5153,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
5154,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
5155,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
5156,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
5157,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
5158,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
5159,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
5160,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
5161,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
5162//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
5163,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
5164,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
5165,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
5166,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
5167,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
5168,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5169,{jjSLIM_GB,    SLIM_GB_CMD,     MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5170,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
5171,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
5172,{jjSQR_FREE,   SQR_FREE_CMD,    IDEAL_CMD,      POLY_CMD       NO_PLURAL}
5173,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5174,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5175,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
5176,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
5177,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5178,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
5179#ifdef HAVE_PLURAL
5180,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
5181,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
5182,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
5183,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
5184,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5185#endif
5186,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
5187,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
5188,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
5189,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
5190,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
5191,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
5192,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
5193,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
5194,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
5195,{jjUNIVARIATE, UNIVARIATE_CMD,  INT_CMD,        POLY_CMD       ALLOW_PLURAL}
5196,{jjVARIABLES_P,VARIABLES_CMD,   LIST_CMD,       POLY_CMD       ALLOW_PLURAL}
5197,{jjVARIABLES_ID,VARIABLES_CMD,  LIST_CMD,       IDEAL_CMD       ALLOW_PLURAL}
5198,{jjVARIABLES_ID,VARIABLES_CMD,  LIST_CMD,       MATRIX_CMD       ALLOW_PLURAL}
5199,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
5200,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
5201,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
5202,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
5203,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
5204,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
5205,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
5206,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
5207,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
5208,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
5209,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
5210,{NULL,         0,               0,              0              NO_PLURAL}
5211};
5212#undef s
5213/*=================== operations with 3 args.: static proc =================*/
5214static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
5215{
5216  char *s= (char *)u->Data();
5217  int   r = (int)(long)v->Data();
5218  int   c = (int)(long)w->Data();
5219  int l = strlen(s);
5220
5221  if ( (r<1) || (r>l) || (c<0) )
5222  {
5223    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
5224    return TRUE;
5225  }
5226  res->data = (char *)omAlloc((long)(c+1));
5227  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
5228  return FALSE;
5229}
5230static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
5231{
5232  intvec *iv = (intvec *)u->Data();
5233  int   r = (int)(long)v->Data();
5234  int   c = (int)(long)w->Data();
5235  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
5236  {
5237    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
5238           r,c,u->Fullname(),iv->rows(),iv->cols());
5239    return TRUE;
5240  }
5241  res->data=u->data; u->data=NULL;
5242  res->rtyp=u->rtyp; u->rtyp=0;
5243  res->name=u->name; u->name=NULL;
5244  res->attribute=u->attribute; u->attribute=NULL;
5245  Subexpr e=jjMakeSub(v);
5246          e->next=jjMakeSub(w);
5247  if (u->e==NULL) res->e=e;
5248  else
5249  {
5250    Subexpr h=u->e;
5251    while (h->next!=NULL) h=h->next;
5252    h->next=e;
5253    res->e=u->e;
5254    u->e=NULL;
5255  }
5256  return FALSE;
5257}
5258static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
5259{
5260  matrix m= (matrix)u->Data();
5261  int   r = (int)(long)v->Data();
5262  int   c = (int)(long)w->Data();
5263  //Print("gen. elem %d, %d\n",r,c);
5264  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
5265  {
5266    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
5267      MATROWS(m),MATCOLS(m));
5268    return TRUE;
5269  }
5270  res->data=u->data; u->data=NULL;
5271  res->rtyp=u->rtyp; u->rtyp=0;
5272  res->name=u->name; u->name=NULL;
5273  res->attribute=u->attribute; u->attribute=NULL;
5274  Subexpr e=jjMakeSub(v);
5275          e->next=jjMakeSub(w);
5276  if (u->e==NULL)
5277    res->e=e;
5278  else
5279  {
5280    Subexpr h=u->e;
5281    while (h->next!=NULL) h=h->next;
5282    h->next=e;
5283    res->e=u->e;
5284    u->e=NULL;
5285  }
5286  return FALSE;
5287}
5288static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
5289{
5290  sleftv t;
5291  sleftv ut;
5292  leftv p=NULL;
5293  intvec *iv=(intvec *)w->Data();
5294  int l;
5295  BOOLEAN nok;
5296
5297  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5298  {
5299    WerrorS("cannot build expression lists from unnamed objects");
5300    return TRUE;
5301  }
5302  memcpy(&ut,u,sizeof(ut));
5303  memset(&t,0,sizeof(t));
5304  t.rtyp=INT_CMD;
5305  for (l=0;l< iv->length(); l++)
5306  {
5307    t.data=(char *)(long)((*iv)[l]);
5308    if (p==NULL)
5309    {
5310      p=res;
5311    }
5312    else
5313    {
5314      p->next=(leftv)omAlloc0Bin(sleftv_bin);
5315      p=p->next;
5316    }
5317    memcpy(u,&ut,sizeof(ut));
5318    if (u->Typ() == MATRIX_CMD)
5319      nok=jjBRACK_Ma(p,u,v,&t);
5320    else /* INTMAT_CMD */
5321      nok=jjBRACK_Im(p,u,v,&t);
5322    if (nok)
5323    {
5324      while (res->next!=NULL)
5325      {
5326        p=res->next->next;
5327        omFreeBin((ADDRESS)res->next, sleftv_bin);
5328        // res->e aufraeumen !!!!
5329        res->next=p;
5330      }
5331      return TRUE;
5332    }
5333  }
5334  return FALSE;
5335}
5336static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
5337{
5338  sleftv t;
5339  sleftv ut;
5340  leftv p=NULL;
5341  intvec *iv=(intvec *)v->Data();
5342  int l;
5343  BOOLEAN nok;
5344
5345  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5346  {
5347    WerrorS("cannot build expression lists from unnamed objects");
5348    return TRUE;
5349  }
5350  memcpy(&ut,u,sizeof(ut));
5351  memset(&t,0,sizeof(t));
5352  t.rtyp=INT_CMD;
5353  for (l=0;l< iv->length(); l++)
5354  {
5355    t.data=(char *)(long)((*iv)[l]);
5356    if (p==NULL)
5357    {
5358      p=res;
5359    }
5360    else
5361    {
5362      p->next=(leftv)omAlloc0Bin(sleftv_bin);
5363      p=p->next;
5364    }
5365    memcpy(u,&ut,sizeof(ut));
5366    if (u->Typ() == MATRIX_CMD)
5367      nok=jjBRACK_Ma(p,u,&t,w);
5368    else /* INTMAT_CMD */
5369      nok=jjBRACK_Im(p,u,&t,w);
5370    if (nok)
5371    {
5372      while (res->next!=NULL)
5373      {
5374        p=res->next->next;
5375        omFreeBin((ADDRESS)res->next, sleftv_bin);
5376        // res->e aufraeumen !!
5377        res->next=p;
5378      }
5379      return TRUE;
5380    }
5381  }
5382  return FALSE;
5383}
5384static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
5385{
5386  sleftv t1,t2,ut;
5387  leftv p=NULL;
5388  intvec *vv=(intvec *)v->Data();
5389  intvec *wv=(intvec *)w->Data();
5390  int vl;
5391  int wl;
5392  BOOLEAN nok;
5393
5394  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5395  {
5396    WerrorS("cannot build expression lists from unnamed objects");
5397    return TRUE;
5398  }
5399  memcpy(&ut,u,sizeof(ut));
5400  memset(&t1,0,sizeof(sleftv));
5401  memset(&t2,0,sizeof(sleftv));
5402  t1.rtyp=INT_CMD;
5403  t2.rtyp=INT_CMD;
5404  for (vl=0;vl< vv->length(); vl++)
5405  {
5406    t1.data=(char *)(long)((*vv)[vl]);
5407    for (wl=0;wl< wv->length(); wl++)
5408    {
5409      t2.data=(char *)(long)((*wv)[wl]);
5410      if (p==NULL)
5411      {
5412        p=res;
5413      }
5414      else
5415      {
5416        p->next=(leftv)omAlloc0Bin(sleftv_bin);
5417        p=p->next;
5418      }
5419      memcpy(u,&ut,sizeof(ut));
5420      if (u->Typ() == MATRIX_CMD)
5421        nok=jjBRACK_Ma(p,u,&t1,&t2);
5422      else /* INTMAT_CMD */
5423        nok=jjBRACK_Im(p,u,&t1,&t2);
5424      if (nok)
5425      {
5426        res->CleanUp();
5427        return TRUE;
5428      }
5429    }
5430  }
5431  return FALSE;
5432}
5433static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
5434{
5435  v->next=(leftv)omAllocBin(sleftv_bin);
5436  memcpy(v->next,w,sizeof(sleftv));
5437  memset(w,0,sizeof(sleftv));
5438  return jjPROC(res,u,v);
5439}
5440static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
5441{
5442  u->next=(leftv)omAllocBin(sleftv_bin);
5443  memcpy(u->next,v,sizeof(sleftv));
5444  u->next->next=(leftv)omAllocBin(sleftv_bin);
5445  memcpy(u->next->next,w,sizeof(sleftv));
5446  BOOLEAN r=iiExprArithM(res,u,iiOp);
5447  v->Init();
5448  w->Init();
5449  //w->rtyp=0; w->data=NULL;
5450  // iiExprArithM did the CleanUp
5451  return r;
5452}
5453static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5454{
5455  intvec *iv;
5456  ideal m;
5457  lists l=(lists)omAllocBin(slists_bin);
5458  int k=(int)(long)w->Data();
5459  if (k>=0)
5460  {
5461    smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
5462    l->Init(2);
5463    l->m[0].rtyp=MODUL_CMD;
5464    l->m[1].rtyp=INTVEC_CMD;
5465    l->m[0].data=(void *)m;
5466    l->m[1].data=(void *)iv;
5467  }
5468  else
5469  {
5470    m=smCallSolv((ideal)u->Data());
5471    l->Init(1);
5472    l->m[0].rtyp=IDEAL_CMD;
5473    l->m[0].data=(void *)m;
5474  }
5475  res->data = (char *)l;
5476  return FALSE;
5477}
5478static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5479{
5480  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
5481  {
5482    WerrorS("3rd argument must be a name of a matrix");
5483    return TRUE;
5484  }
5485  ideal i=(ideal)u->Data();
5486  int rank=(int)i->rank;
5487  BOOLEAN r=jjCOEFFS_Id(res,u,v);
5488  if (r) return TRUE;
5489  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5490  return FALSE;
5491}
5492static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5493{
5494  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5495           (ideal)(v->Data()),(poly)(w->Data()));
5496  return FALSE;
5497}
5498static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5499{
5500  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
5501  {
5502    WerrorS("3rd argument must be a name of a matrix");
5503    return TRUE;
5504  }
5505  // CopyD for POLY_CMD and VECTOR_CMD are identical:
5506  poly p=(poly)u->CopyD(POLY_CMD);
5507  ideal i=idInit(1,1);
5508  i->m[0]=p;
5509  sleftv t;
5510  memset(&t,0,sizeof(t));
5511  t.data=(char *)i;
5512  t.rtyp=IDEAL_CMD;
5513  int rank=1;
5514  if (u->Typ()==VECTOR_CMD)
5515  {
5516    i->rank=rank=pMaxComp(p);
5517    t.rtyp=MODUL_CMD;
5518  }
5519  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5520  t.CleanUp();
5521  if (r) return TRUE;
5522  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5523  return FALSE;
5524}
5525static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5526{
5527  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5528    (intvec *)w->Data());
5529  //setFlag(res,FLAG_STD);
5530  return FALSE;
5531}
5532static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5533{
5534  /*4
5535  * look for the substring what in the string where
5536  * starting at position n
5537  * return the position of the first char of what in where
5538  * or 0
5539  */
5540  int n=(int)(long)w->Data();
5541  char *where=(char *)u->Data();
5542  char *what=(char *)v->Data();
5543  char *found;
5544  if ((1>n)||(n>(int)strlen(where)))
5545  {
5546    Werror("start position %d out of range",n);
5547    return TRUE;
5548  }
5549  found = strchr(where+n-1,*what);
5550  if (*(what+1)!='\0')
5551  {
5552    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5553    {
5554      found=strchr(found+1,*what);
5555    }
5556  }
5557  if (found != NULL)
5558  {
5559    res->data=(char *)((found-where)+1);
5560  }
5561  return FALSE;
5562}
5563static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5564{
5565  if ((int)(long)w->Data()==0)
5566    res->data=(char *)walkProc(u,v);
5567  else
5568    res->data=(char *)fractalWalkProc(u,v);
5569  setFlag( res, FLAG_STD );
5570  return FALSE;
5571}
5572static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5573{
5574  assumeStdFlag(u);
5575  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5576  intvec *wdegree=(intvec*)w->Data();
5577  if (wdegree->length()!=pVariables)
5578  {
5579    Werror("weight vector must have size %d, not %d",
5580           pVariables,wdegree->length());
5581    return TRUE;
5582  }
5583  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5584  switch((int)(long)v->Data())
5585  {
5586    case 1:
5587      res->data=(void *)iv;
5588      return FALSE;
5589    case 2:
5590      res->data=(void *)hSecondSeries(iv);
5591      delete iv;
5592      return FALSE;
5593  }
5594  WerrorS(feNotImplemented);
5595  delete iv;
5596  return TRUE;
5597}
5598static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5599{
5600  intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5601  intvec* arg = (intvec*) u->Data();
5602  int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
5603
5604  for (i=0; i<n; i++)
5605  {
5606    (*im)[i] = (*arg)[i];
5607  }
5608
5609  res->data = (char *)im;
5610  return FALSE;
5611}
5612static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5613{
5614  short *iw=iv2array((intvec *)w->Data());
5615  res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5616  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5617  return FALSE;
5618}
5619static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5620{
5621  if (!pIsUnit((poly)v->Data()))
5622  {
5623    WerrorS("2nd argument must be a unit");
5624    return TRUE;
5625  }
5626  res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5627  return FALSE;
5628}
5629static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5630{
5631  res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5632                             (intvec *)w->Data());
5633  return FALSE;
5634}
5635static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5636{
5637  if (!mpIsDiagUnit((matrix)v->Data()))
5638  {
5639    WerrorS("2nd argument must be a diagonal matrix of units");
5640    return TRUE;
5641  }
5642  res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5643                               (matrix)v->CopyD());
5644  return FALSE;
5645}
5646static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5647{
5648  assumeStdFlag(w);
5649  res->data = (char *)idMinors(
5650                        (matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5651  return FALSE;
5652}
5653static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5654{
5655  // handles preimage(r,phi,i) and kernel(r,phi)
5656  idhdl h;
5657  ring rr;
5658  map mapping;
5659  BOOLEAN kernel_cmd= (iiOp==KERNEL_CMD);
5660
5661  if ((v->name==NULL) || (!kernel_cmd && (w->name==NULL)))
5662  {
5663    WerrorS("2nd/3rd arguments must have names");
5664    return TRUE;
5665  }
5666  rr=(ring)u->Data();
5667  const char *ring_name=u->Name();
5668  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5669  {
5670    if (h->typ==MAP_CMD)
5671    {
5672      mapping=IDMAP(h);
5673      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5674      if ((preim_ring==NULL)
5675      || (IDRING(preim_ring)!=currRing))
5676      {
5677        Werror("preimage ring `%s` is not the basering",mapping->preimage);
5678        return TRUE;
5679      }
5680    }
5681    else if (h->typ==IDEAL_CMD)
5682    {
5683      mapping=IDMAP(h);
5684    }
5685    else
5686    {
5687      Werror("`%s` is no map nor ideal",IDID(h));
5688      return TRUE;
5689    }
5690  }
5691  else
5692  {
5693    Werror("`%s` is not defined in `%s`",v->name,ring_name);
5694    return TRUE;
5695  }
5696  ideal image;
5697  if (kernel_cmd) image=idInit(1,1);
5698  else
5699  {
5700    if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5701    {
5702      if (h->typ==IDEAL_CMD)
5703      {
5704        image=IDIDEAL(h);
5705      }
5706      else
5707      {
5708        Werror("`%s` is no ideal",IDID(h));
5709        return TRUE;
5710      }
5711    }
5712    else
5713    {
5714      Werror("`%s` is not defined in `%s`",w->name,ring_name);
5715      return TRUE;
5716    }
5717  }
5718  if (((currRing->qideal!=NULL) && (rHasLocalOrMixedOrdering_currRing()))
5719  || ((rr->qideal!=NULL) && (rHasLocalOrMixedOrdering(rr))))
5720  {
5721    WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5722  }
5723  res->data=(char *)maGetPreimage(rr,mapping,image);
5724  if (kernel_cmd) idDelete(&image);
5725  return (res->data==NULL/* is of type ideal, should not be NULL*/);
5726}
5727static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5728{
5729  int di, k;
5730  int i=(int)(long)u->Data();
5731  int r=(int)(long)v->Data();
5732  int c=(int)(long)w->Data();
5733  if ((r<=0) || (c<=0)) return TRUE;
5734  intvec *iv = new intvec(r, c, 0);
5735  if (iv->rows()==0)
5736  {
5737    delete iv;
5738    return TRUE;
5739  }
5740  if (i!=0)
5741  {
5742    if (i<0) i = -i;
5743    di = 2 * i + 1;
5744    for (k=0; k<iv->length(); k++)
5745    {
5746#ifdef buildin_rand
5747      (*iv)[k] = ((siRand() % di) - i);
5748#else
5749      (*iv)[k] = ((rand() % di) - i);
5750#endif
5751    }
5752  }
5753  res->data = (char *)iv;
5754  return FALSE;
5755}
5756static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5757  int &ringvar, poly &monomexpr)
5758{
5759  monomexpr=(poly)w->Data();
5760  poly p=(poly)v->Data();
5761  #if 0
5762  if (pLength(monomexpr)>1)
5763  {
5764    Werror("`%s` substitutes a ringvar only by a term",
5765      Tok2Cmdname(SUBST_CMD));
5766    return TRUE;
5767  }
5768  #endif
5769  if (!(ringvar=pVar(p)))
5770  {
5771    if (rField_is_Extension(currRing))
5772    {
5773      assume(currRing->algring!=NULL);
5774      lnumber n=(lnumber)pGetCoeff(p);
5775      ringvar=-p_Var(n->z,currRing->algring);
5776    }
5777    if(ringvar==0)
5778    {
5779      WerrorS("ringvar/par expected");
5780      return TRUE;
5781    }
5782  }
5783  return FALSE;
5784}
5785static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5786{
5787  int ringvar;
5788  poly monomexpr;
5789  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5790  if (nok) return TRUE;
5791  if (ringvar>0)
5792  {
5793    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5794      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5795    else
5796      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5797  }
5798  else
5799  {
5800    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5801  }
5802  return FALSE;
5803}
5804static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5805{
5806  int ringvar;
5807  poly monomexpr;
5808  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5809  if (nok) return TRUE;
5810  if (ringvar>0)
5811  {
5812    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5813      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5814    else
5815      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5816  }
5817  else
5818  {
5819    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5820  }
5821  return FALSE;
5822}
5823// we do not want to have jjSUBST_Id_X inlined:
5824static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5825                            int input_type);
5826static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5827{
5828  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5829}
5830static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5831{
5832  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5833}
5834static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5835{
5836  sleftv tmp;
5837  memset(&tmp,0,sizeof(tmp));
5838  // do not check the result, conversion from int/number to poly works always
5839  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5840  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5841  tmp.CleanUp();
5842  return b;
5843}
5844static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5845{
5846  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5847  ideal I=(ideal)u->CopyD(IDEAL_CMD);
5848  int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5849  //for(i=i-1;i>=0;i--)
5850  //{
5851  //  m->m[i]=I->m[i];
5852  //  I->m[i]=NULL;
5853  //}
5854  memcpy4(m->m,I->m,i*sizeof(poly));
5855  memset(I->m,0,i*sizeof(poly));
5856  idDelete(&I);
5857  res->data = (char *)m;
5858  return FALSE;
5859}
5860static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5861{
5862  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5863           (int)(long)v->Data(),(int)(long)w->Data());
5864  return FALSE;
5865}
5866static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5867{
5868  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5869  matrix I=(matrix)u->CopyD(MATRIX_CMD);
5870  int r=si_min(MATROWS(I),(int)(long)v->Data());
5871  int c=si_min(MATCOLS(I),(int)(long)w->Data());
5872  int i,j;
5873  for(i=r;i>0;i--)
5874  {
5875    for(j=c;j>0;j--)
5876    {
5877      MATELEM(m,i,j)=MATELEM(I,i,j);
5878      MATELEM(I,i,j)=NULL;
5879    }
5880  }
5881  idDelete((ideal *)&I);
5882  res->data = (char *)m;
5883  return FALSE;
5884}
5885static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5886{
5887  if (w->rtyp!=IDHDL) return TRUE;
5888  BITSET save_test=test;
5889  int ul= IDELEMS((ideal)u->Data());
5890  int vl= IDELEMS((ideal)v->Data());
5891  ideal m
5892    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5893             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5894  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5895  test=save_test;
5896  return FALSE;
5897}
5898static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5899{
5900  assumeStdFlag(v);
5901  if (!idIsZeroDim((ideal)v->Data()))
5902  {
5903    Werror("`%s` must be 0-dimensional",v->Name());
5904    return TRUE;
5905  }
5906  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5907    (poly)w->CopyD());
5908  return FALSE;
5909}
5910static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5911{
5912  assumeStdFlag(v);
5913  if (!idIsZeroDim((ideal)v->Data()))
5914  {
5915    Werror("`%s` must be 0-dimensional",v->Name());
5916    return TRUE;
5917  }
5918  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5919    (matrix)w->CopyD());
5920  return FALSE;
5921}
5922static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5923{
5924  assumeStdFlag(v);
5925  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5926    0,(int)(long)w->Data());
5927  return FALSE;
5928}
5929static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5930{
5931  assumeStdFlag(v);
5932  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5933    0,(int)(long)w->Data());
5934  return FALSE;
5935}
5936#ifdef OLD_RES
5937static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5938{
5939  int maxl=(int)v->Data();
5940  ideal u_id=(ideal)u->Data();
5941  int l=0;
5942  resolvente r;
5943  intvec **weights=NULL;
5944  int wmaxl=maxl;
5945  maxl--;
5946  if ((maxl==-1) && (iiOp!=MRES_CMD))
5947    maxl = pVariables-1;
5948  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5949  {
5950    intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5951    if (iv!=NULL)
5952    {
5953      l=1;
5954      if (!idTestHomModule(u_id,currQuotient,iv))
5955      {
5956        WarnS("wrong weights");
5957        iv=NULL;
5958      }
5959      else
5960      {
5961        weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5962        weights[0] = ivCopy(iv);
5963      }
5964    }
5965    r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
5966  }
5967  else
5968    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5969  if (r==NULL) return TRUE;
5970  int t3=u->Typ();
5971  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5972  return FALSE;
5973}
5974#endif
5975static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5976{
5977  res->data=(void *)rInit(u,v,w);
5978  return (res->data==NULL);
5979}
5980static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5981{
5982  int yes;
5983  jjSTATUS2(res, u, v);
5984  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5985  omFree((ADDRESS) res->data);
5986  res->data = (void *)(long)yes;
5987  return FALSE;
5988}
5989static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5990{
5991  intvec *vw=(intvec *)w->Data(); // weights of vars
5992  if (vw->length()!=currRing->N)
5993  {
5994    Werror("%d weights for %d variables",vw->length(),currRing->N);
5995    return TRUE;
5996  }
5997  ideal result;
5998  intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5999  tHomog hom=testHomog;
6000  ideal u_id=(ideal)(u->Data());
6001  if (ww!=NULL)
6002  {
6003    if (!idTestHomModule(u_id,currQuotient,ww))
6004    {
6005      WarnS("wrong weights");
6006      ww=NULL;
6007    }
6008    else
6009    {
6010      ww=ivCopy(ww);
6011      hom=isHomog;
6012    }
6013  }
6014  result=kStd(u_id,
6015              currQuotient,
6016              hom,
6017              &ww,                  // module weights
6018              (intvec *)v->Data(),  // hilbert series
6019              0,0,                  // syzComp, newIdeal
6020              vw);                  // weights of vars
6021  idSkipZeroes(result);
6022  res->data = (char *)result;
6023  setFlag(res,FLAG_STD);
6024  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
6025  return FALSE;
6026}
6027
6028/*=================== operations with 3 args.: table =================*/
6029struct sValCmd3 dArith3[]=
6030{
6031// operations:
6032// proc             cmd          res         arg1        arg2        arg3   plural
6033 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
6034,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
6035,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6036,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
6037,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
6038,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
6039,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6040,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
6041,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
6042,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6043,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
6044,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
6045,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
6046,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
6047,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
6048,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
6049,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
6050,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
6051,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
6052,{jjELIMIN_HILB,    ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
6053,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
6054,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
6055,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
6056,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
6057,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6058,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
6059//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6060,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
6061,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6062,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6063,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6064,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6065,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
6066,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
6067,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
6068,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
6069,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
6070,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
6071,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
6072,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6073,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
6074,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
6075,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
6076,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
6077,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6078#ifdef OLD_RES
6079,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
6080,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
6081#endif
6082,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
6083,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
6084,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
6085,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
6086,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
6087,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
6088,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
6089,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
6090,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
6091,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
6092,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
6093,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
6094,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
6095,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
6096,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
6097#ifdef OLD_RES
6098,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
6099,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
6100#endif
6101#ifdef HAVE_FACTORY
6102,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
6103#else
6104,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
6105#endif
6106,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
6107#ifdef OLD_RES
6108,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
6109,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
6110#endif
6111,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
6112,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
6113,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
6114,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6115,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6116,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6117,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6118,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6119,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
6120,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
6121,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
6122,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
6123,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
6124,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
6125,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
6126};
6127/*=================== operations with many arg.: static proc =================*/
6128static BOOLEAN jjBREAK0(leftv res, leftv v)
6129{
6130#ifdef HAVE_SDB
6131  sdb_show_bp();
6132#endif
6133  return FALSE;
6134}
6135static BOOLEAN jjBREAK1(leftv res, leftv v)
6136{
6137#ifdef HAVE_SDB
6138  if(v->Typ()==PROC_CMD)
6139  {
6140    int lineno=0;
6141    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
6142    {
6143      lineno=(int)(long)v->next->Data();
6144    }
6145    return sdb_set_breakpoint(v->Name(),lineno);
6146  }
6147  return TRUE;
6148#else
6149 return FALSE;
6150#endif
6151}
6152static BOOLEAN jjCALL1ARG(leftv res, leftv v)
6153{
6154  return iiExprArith1(res,v,iiOp);
6155}
6156static BOOLEAN jjCALL2ARG(leftv res, leftv u)
6157{
6158  leftv v=u->next;
6159  u->next=NULL;
6160  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
6161  u->next=v;
6162  return b;
6163}
6164static BOOLEAN jjCALL3ARG(leftv res, leftv u)
6165{
6166  leftv v = u->next;
6167  leftv w = v->next;
6168  u->next = NULL;
6169  v->next = NULL;
6170  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6171  u->next = v;
6172  v->next = w;
6173  return b;
6174}
6175
6176static BOOLEAN jjCOEF_M(leftv res, leftv v)
6177{
6178  if((v->Typ() != VECTOR_CMD)
6179  || (v->next->Typ() != POLY_CMD)
6180  || (v->next->next->Typ() != MATRIX_CMD)
6181  || (v->next->next->next->Typ() != MATRIX_CMD))
6182     return TRUE;
6183  if (v->next->next->rtyp!=IDHDL) return TRUE;
6184  idhdl c=(idhdl)v->next->next->data;
6185  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
6186  idhdl m=(idhdl)v->next->next->next->data;
6187  idDelete((ideal *)&(c->data.uideal));
6188  idDelete((ideal *)&(m->data.uideal));
6189  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
6190    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
6191  return FALSE;
6192}
6193
6194static BOOLEAN jjDIVISION4(leftv res, leftv v)
6195{ // may have 3 or 4 arguments
6196  leftv v1=v;
6197  leftv v2=v1->next;
6198  leftv v3=v2->next;
6199  leftv v4=v3->next;
6200  assumeStdFlag(v2);
6201
6202  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
6203  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
6204
6205  if((i1==0)||(i2==0)
6206  ||(v3->Typ()!=INT_CMD)||((v4!=NULL)&&(v4->Typ()!=INTVEC_CMD)))
6207  {
6208    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
6209    return TRUE;
6210  }
6211
6212  sleftv w1,w2;
6213  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
6214  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
6215  ideal P=(ideal)w1.Data();
6216  ideal Q=(ideal)w2.Data();
6217
6218  int n=(int)(long)v3->Data();
6219  short *w=NULL;
6220  if(v4!=NULL)
6221  {
6222    w=iv2array((intvec *)v4->Data());
6223    short *w0=w+1;
6224    int i=pVariables;
6225    while(i>0&&*w0>0)
6226    {
6227      w0++;
6228      i--;
6229    }
6230    if(i>0)
6231      WarnS("not all weights are positive!");
6232  }
6233
6234  matrix T;
6235  ideal R;
6236  idLiftW(P,Q,n,T,R,w);
6237
6238  w1.CleanUp();
6239  w2.CleanUp();
6240  if(w!=NULL)
6241    omFree(w);
6242
6243  lists L=(lists) omAllocBin(slists_bin);
6244  L->Init(2);
6245  L->m[1].rtyp=v1->Typ();
6246  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
6247  {
6248    if(v1->Typ()==POLY_CMD)
6249      pShift(&R->m[0],-1);
6250    L->m[1].data=(void *)R->m[0];
6251    R->m[0]=NULL;
6252    idDelete(&R);
6253  }
6254  else if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
6255    L->m[1].data=(void *)idModule2Matrix(R);
6256  else
6257  {
6258    L->m[1].rtyp=MODUL_CMD;
6259    L->m[1].data=(void *)R;
6260  }
6261  L->m[0].rtyp=MATRIX_CMD;
6262  L->m[0].data=(char *)T;
6263
6264  res->data=L;
6265  res->rtyp=LIST_CMD;
6266
6267  return FALSE;
6268}
6269
6270//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
6271//{
6272//  int l=u->listLength();
6273//  if (l<2) return TRUE;
6274//  BOOLEAN b;
6275//  leftv v=u->next;
6276//  leftv zz=v;
6277//  leftv z=zz;
6278//  u->next=NULL;
6279//  do
6280//  {
6281//    leftv z=z->next;
6282//    b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
6283//    if (b) break;
6284//  } while (z!=NULL);
6285//  u->next=zz;
6286//  return b;
6287//}
6288static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
6289{
6290  int s=1;
6291  leftv h=v;
6292  if (h!=NULL) s=exprlist_length(h);
6293  ideal id=idInit(s,1);
6294  int rank=1;
6295  int i=0;
6296  poly p;
6297  while (h!=NULL)
6298  {
6299    switch(h->Typ())
6300    {
6301      case POLY_CMD:
6302      {
6303        p=(poly)h->CopyD(POLY_CMD);
6304        break;
6305      }
6306      case INT_CMD:
6307      {
6308        number n=nInit((int)(long)h->Data());
6309        if (!nIsZero(n))
6310        {
6311          p=pOne();
6312          pSetCoeff(p,n);
6313        }
6314        else
6315        {
6316          p=NULL;
6317          nDelete(&n);
6318        }
6319        break;
6320      }
6321      case BIGINT_CMD:
6322      {
6323        number b=(number)h->Data();
6324        number n=nInit_bigint(b);
6325        if (!nIsZero(n))
6326        {
6327          p=pOne();
6328          pSetCoeff(p,n);
6329        }
6330        else
6331        {
6332          p=NULL;
6333          nDelete(&n);
6334        }
6335        break;
6336      }
6337      case NUMBER_CMD:
6338      {
6339        number n=(number)h->CopyD(NUMBER_CMD);
6340        if (!nIsZero(n))
6341        {
6342          p=pOne();
6343          pSetCoeff(p,n);
6344        }
6345        else
6346        {
6347          p=NULL;
6348          nDelete(&n);
6349        }
6350        break;
6351      }
6352      case VECTOR_CMD:
6353      {
6354        p=(poly)h->CopyD(VECTOR_CMD);
6355        if (iiOp!=MODUL_CMD)
6356        {
6357          idDelete(&id);
6358          pDelete(&p);
6359          return TRUE;
6360        }
6361        rank=si_max(rank,(int)pMaxComp(p));
6362        break;
6363      }
6364      default:
6365      {
6366        idDelete(&id);
6367        return TRUE;
6368      }
6369    }
6370    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
6371    {
6372      pSetCompP(p,1);
6373    }
6374    id->m[i]=p;
6375    i++;
6376    h=h->next;
6377  }
6378  id->rank=rank;
6379  res->data=(char *)id;
6380  return FALSE;
6381}
6382static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
6383{
6384  leftv h=v;
6385  int l=v->listLength();
6386  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
6387  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
6388  int t=0;
6389  // try to convert to IDEAL_CMD
6390  while (h!=NULL)
6391  {
6392    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
6393    {
6394      t=IDEAL_CMD;
6395    }
6396    else break;
6397    h=h->next;
6398  }
6399  // if failure, try MODUL_CMD
6400  if (t==0)
6401  {
6402    h=v;
6403    while (h!=NULL)
6404    {
6405      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
6406      {
6407        t=MODUL_CMD;
6408      }
6409      else break;
6410      h=h->next;
6411    }
6412  }
6413  // check for success  in converting
6414  if (t==0)
6415  {
6416    WerrorS("cannot convert to ideal or module");
6417    return TRUE;
6418  }
6419  // call idMultSect
6420  h=v;
6421  int i=0;
6422  sleftv tmp;
6423  while (h!=NULL)
6424  {
6425    if (h->Typ()==t)
6426    {
6427      r[i]=(ideal)h->Data(); /*no copy*/
6428      h=h->next;
6429    }
6430    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
6431    {
6432      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
6433      omFreeSize((ADDRESS)r,l*sizeof(ideal));
6434      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
6435      return TRUE;
6436    }
6437    else
6438    {
6439      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
6440      copied[i]=TRUE;
6441      h=tmp.next;
6442    }
6443    i++;
6444  }
6445  res->rtyp=t;
6446  res->data=(char *)idMultSect(r,i);
6447  while(i>0)
6448  {
6449    i--;
6450    if (copied[i]) idDelete(&(r[i]));
6451  }
6452  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
6453  omFreeSize((ADDRESS)r,l*sizeof(ideal));
6454  return FALSE;
6455}
6456static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
6457{
6458  int i=0;
6459  leftv h=v;
6460  if (h!=NULL) i=exprlist_length(h);
6461  intvec *iv=new intvec(i);
6462  i=0;
6463  while (h!=NULL)
6464  {
6465    if(h->Typ()==INT_CMD)
6466    {
6467      (*iv)[i]=(int)(long)h->Data();
6468    }
6469    else
6470    {
6471      delete iv;
6472      return TRUE;
6473    }
6474    i++;
6475    h=h->next;
6476  }
6477  res->data=(char *)iv;
6478  return FALSE;
6479}
6480static BOOLEAN jjJET4(leftv res, leftv u)
6481{
6482  leftv u1=u;
6483  leftv u2=u1->next;
6484  leftv u3=u2->next;
6485  leftv u4=u3->next;
6486  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6487     (u4->Typ()==INTVEC_CMD)||
6488     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6489     (u4->Typ()==INTVEC_CMD))
6490  {
6491    if(!pIsUnit((poly)u2->Data()))
6492    {
6493      WerrorS("2nd argument must be a unit");
6494      return TRUE;
6495    }
6496    res->rtyp=u1->Typ();
6497    res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
6498                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
6499    return FALSE;
6500  }
6501  else
6502  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6503     (u4->Typ()==INTVEC_CMD)||
6504     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6505     (u4->Typ()==INTVEC_CMD))
6506  {
6507    if(!mpIsDiagUnit((matrix)u2->Data()))
6508    {
6509      WerrorS("2nd argument must be a diagonal matrix of units");
6510      return TRUE;
6511    }
6512    res->rtyp=u1->Typ();
6513    res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
6514                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
6515    return FALSE;
6516  }
6517  else
6518  {
6519    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
6520           Tok2Cmdname(iiOp));
6521    return TRUE;
6522  }
6523}
6524static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
6525{
6526  if ((yyInRingConstruction)
6527  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
6528  {
6529    memcpy(res,u,sizeof(sleftv));
6530    memset(u,0,sizeof(sleftv));
6531    return FALSE;
6532  }
6533  leftv v=u->next;
6534  BOOLEAN b;
6535  if(v==NULL)
6536    b=iiExprArith1(res,u,iiOp);
6537  else
6538  {
6539    u->next=NULL;
6540    b=iiExprArith2(res,u,iiOp,v);
6541    u->next=v;
6542  }
6543  return b;
6544}
6545static BOOLEAN jjLIST_PL(leftv res, leftv v)
6546{
6547  int sl=0;
6548  if (v!=NULL) sl = v->listLength();
6549  lists L;
6550  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
6551  {
6552    int add_row_shift = 0;
6553    intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
6554    if (weights!=NULL)  add_row_shift=weights->min_in();
6555    L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
6556  }
6557  else
6558  {
6559    L=(lists)omAllocBin(slists_bin);
6560    leftv h=NULL;
6561    int i;
6562    int rt;
6563
6564    L->Init(sl);
6565    for (i=0;i<sl;i++)
6566    {
6567      if (h!=NULL)
6568      { /* e.g. not in the first step:
6569         * h is the pointer to the old sleftv,
6570         * v is the pointer to the next sleftv
6571         * (in this moment) */
6572         h->next=v;
6573      }
6574      h=v;
6575      v=v->next;
6576      h->next=NULL;
6577      rt=h->Typ();
6578      if (rt==0)
6579      {
6580        L->Clean();
6581        Werror("`%s` is undefined",h->Fullname());
6582        return TRUE;
6583      }
6584      if ((rt==RING_CMD)||(rt==QRING_CMD))
6585      {
6586        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
6587        ((ring)L->m[i].data)->ref++;
6588      }
6589      else
6590        L->m[i].Copy(h);
6591    }
6592  }
6593  res->data=(char *)L;
6594  return FALSE;
6595}
6596static BOOLEAN jjNAMES0(leftv res, leftv v)
6597{
6598  res->data=(void *)ipNameList(IDROOT);
6599  return FALSE;
6600}
6601static BOOLEAN jjOPTION_PL(leftv res, leftv v)
6602{
6603  if(v==NULL)
6604  {
6605    res->data=(char *)showOption();
6606    return FALSE;
6607  }
6608  res->rtyp=NONE;
6609  return setOption(res,v);
6610}
6611static BOOLEAN jjREDUCE4(leftv res, leftv u)
6612{
6613  leftv u1=u;
6614  leftv u2=u1->next;
6615  leftv u3=u2->next;
6616  leftv u4=u3->next;
6617  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
6618  {
6619    int save_d=Kstd1_deg;
6620    Kstd1_deg=(int)(long)u3->Data();
6621    kModW=(intvec *)u4->Data();
6622    BITSET save=verbose;
6623    verbose|=Sy_bit(V_DEG_STOP);
6624    u2->next=NULL;
6625    BOOLEAN r=jjCALL2ARG(res,u);
6626    kModW=NULL;
6627    Kstd1_deg=save_d;
6628    verbose=save;
6629    u->next->next=u3;
6630    return r;
6631  }
6632  else
6633  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6634     (u4->Typ()==INT_CMD))
6635  {
6636    assumeStdFlag(u3);
6637    if(!mpIsDiagUnit((matrix)u2->Data()))
6638    {
6639      WerrorS("2nd argument must be a diagonal matrix of units");
6640      return TRUE;
6641    }
6642    res->rtyp=IDEAL_CMD;
6643    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6644                           mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
6645    return FALSE;
6646  }
6647  else
6648  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6649     (u4->Typ()==INT_CMD))
6650  {
6651    assumeStdFlag(u3);
6652    if(!pIsUnit((poly)u2->Data()))
6653    {
6654      WerrorS("2nd argument must be a unit");
6655      return TRUE;
6656    }
6657    res->rtyp=POLY_CMD;
6658    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6659                           pCopy((poly)u2->Data()),(int)(long)u4->Data());
6660    return FALSE;
6661  }
6662  else
6663  {
6664    Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
6665    return TRUE;
6666  }
6667}
6668static BOOLEAN jjREDUCE5(leftv res, leftv u)
6669{
6670  leftv u1=u;
6671  leftv u2=u1->next;
6672  leftv u3=u2->next;
6673  leftv u4=u3->next;
6674  leftv u5=u4->next;
6675  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6676     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6677  {
6678    assumeStdFlag(u3);
6679    if(!mpIsDiagUnit((matrix)u2->Data()))
6680    {
6681      WerrorS("2nd argument must be a diagonal matrix of units");
6682      return TRUE;
6683    }
6684    res->rtyp=IDEAL_CMD;
6685    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6686                           mpCopy((matrix)u2->Data()),
6687                           (int)(long)u4->Data(),(intvec*)u5->Data());
6688    return FALSE;
6689  }
6690  else
6691  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6692     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6693  {
6694    assumeStdFlag(u3);
6695    if(!pIsUnit((poly)u2->Data()))
6696    {
6697      WerrorS("2nd argument must be a unit");
6698      return TRUE;
6699    }
6700    res->rtyp=POLY_CMD;
6701    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6702                           pCopy((poly)u2->Data()),
6703                           (int)(long)u4->Data(),(intvec*)u5->Data());
6704    return FALSE;
6705  }
6706  else
6707  {
6708    Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
6709           Tok2Cmdname(iiOp));
6710    return TRUE;
6711  }
6712}
6713static BOOLEAN jjRESERVED0(leftv res, leftv v)
6714{
6715  int i=1;
6716  int nCount = (sArithBase.nCmdUsed-1)/3;
6717  if((3*nCount)<sArithBase.nCmdUsed) nCount++;
6718  //Print("CMDS: %d/%d\n", sArithBase.nCmdUsed,
6719  //      sArithBase.nCmdAllocated);
6720  for(i=0; i<nCount; i++)
6721  {
6722    Print("%-20s",sArithBase.sCmds[i+1].name);
6723    if(i+1+nCount<sArithBase.nCmdUsed)
6724      Print("%-20s",sArithBase.sCmds[i+1+nCount].name);
6725    if(i+1+2*nCount<sArithBase.nCmdUsed)
6726      Print("%-20s",sArithBase.sCmds[i+1+2*nCount].name);
6727    //if ((i%3)==1) PrintLn();
6728    PrintLn();
6729  }
6730  PrintLn();
6731  return FALSE;
6732}
6733static BOOLEAN jjSTRING_PL(leftv res, leftv v)
6734{
6735  if (v == NULL)
6736  {
6737    res->data = omStrDup("");
6738    return FALSE;
6739  }
6740  int n = v->listLength();
6741  if (n == 1)
6742  {
6743    res->data = v->String();
6744    return FALSE;
6745  }
6746
6747  char** slist = (char**) omAlloc(n*sizeof(char*));
6748  int i, j;
6749
6750  for (i=0, j=0; i<n; i++, v = v ->next)
6751  {
6752    slist[i] = v->String();
6753    assume(slist[i] != NULL);
6754    j+=strlen(slist[i]);
6755  }
6756  char* s = (char*) omAlloc((j+1)*sizeof(char));
6757  *s='\0';
6758  for (i=0;i<n;i++)
6759  {
6760    strcat(s, slist[i]);
6761    omFree(slist[i]);
6762  }
6763  omFreeSize(slist, n*sizeof(char*));
6764  res->data = s;
6765  return FALSE;
6766}
6767static BOOLEAN jjTEST(leftv res, leftv v)
6768{
6769  do
6770  {
6771    if (v->Typ()!=INT_CMD)
6772      return TRUE;
6773    test_cmd((int)(long)v->Data());
6774    v=v->next;
6775  }
6776  while (v!=NULL);
6777  return FALSE;
6778}
6779
6780#if defined(__alpha) && !defined(linux)
6781extern "C"
6782{
6783  void usleep(unsigned long usec);
6784};
6785#endif
6786
6787static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6788{
6789  if ((v->Typ() != LINK_CMD) ||
6790      (v->next->Typ() != STRING_CMD) ||
6791      (v->next->next->Typ() != STRING_CMD) ||
6792      (v->next->next->next->Typ() != INT_CMD))
6793    return TRUE;
6794  jjSTATUS3(res, v, v->next, v->next->next);
6795#if defined(HAVE_USLEEP)
6796  if (((long) res->data) == 0L)
6797  {
6798    int i_s = (int)(long) v->next->next->next->Data();
6799    if (i_s > 0)
6800    {
6801      usleep((int)(long) v->next->next->next->Data());
6802      jjSTATUS3(res, v, v->next, v->next->next);
6803    }
6804  }
6805#elif defined(HAVE_SLEEP)
6806  if (((int) res->data) == 0)
6807  {
6808    int i_s = (int) v->next->next->next->Data();
6809    if (i_s > 0)
6810    {
6811      sleep((is - 1)/1000000 + 1);
6812      jjSTATUS3(res, v, v->next, v->next->next);
6813    }
6814  }
6815#endif
6816  return FALSE;
6817}
6818static BOOLEAN jjSUBST_M(leftv res, leftv u)
6819{
6820  leftv v = u->next; // number of args > 0
6821  if (v==NULL) return TRUE;
6822  leftv w = v->next;
6823  if (w==NULL) return TRUE;
6824  leftv rest = w->next;;
6825
6826  u->next = NULL;
6827  v->next = NULL;
6828  w->next = NULL;
6829  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6830  if ((rest!=NULL) && (!b))
6831  {
6832    sleftv tmp_res;
6833    leftv tmp_next=res->next;
6834    res->next=rest;
6835    memset(&tmp_res,0,sizeof(tmp_res));
6836    b = iiExprArithM(&tmp_res,res,iiOp);
6837    memcpy(res,&tmp_res,sizeof(tmp_res));
6838    res->next=tmp_next;
6839  }
6840  u->next = v;
6841  v->next = w;
6842  // rest was w->next, but is already cleaned
6843  return b;
6844}
6845
6846/*=================== operations with many arg.: table =================*/
6847/* number_of_args:  -1: any, -2: any >0, .. */
6848struct sValCmdM dArithM[]=
6849{
6850// operations:
6851// proc         cmd               res            number_of_args plural
6852 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2       ALLOW_PLURAL}
6853,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0        ALLOW_PLURAL}
6854,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2       ALLOW_PLURAL}
6855,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2        ALLOW_PLURAL}
6856,{jjCOEF_M,    COEF_CMD,        NONE,               4        ALLOW_PLURAL}
6857,{jjCALL2ARG,  DIVISION_CMD,    ANY_TYPE/*or set by p*/,2    ALLOW_PLURAL}
6858,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,3    NO_PLURAL}
6859,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,4    NO_PLURAL}
6860,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2       ALLOW_PLURAL}
6861//,{jjEXPORTTO_M,  EXPORTTO_CMD,    NONE,             -2       ALLOW_PLURAL}
6862,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1        ALLOW_PLURAL}
6863,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1       ALLOW_PLURAL}
6864,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2        ALLOW_PLURAL}
6865,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2       ALLOW_PLURAL}
6866,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1        ALLOW_PLURAL}
6867,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2       ALLOW_PLURAL}
6868,{jjCALL2ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 2   ALLOW_PLURAL}
6869,{jjCALL3ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 3   ALLOW_PLURAL}
6870,{jjJET4,      JET_CMD,         POLY_CMD,/*or set by p*/ 4   ALLOW_PLURAL}
6871,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1       ALLOW_PLURAL}
6872,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1        ALLOW_PLURAL}
6873,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1       ALLOW_PLURAL}
6874,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1       ALLOW_PLURAL}
6875,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0       ALLOW_PLURAL}
6876,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 ALLOW_PLURAL}
6877,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  2 ALLOW_PLURAL}
6878,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  3 ALLOW_PLURAL}
6879,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  4 ALLOW_PLURAL}
6880,{jjREDUCE5,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  5 ALLOW_PLURAL}
6881,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1       ALLOW_PLURAL}
6882,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0       ALLOW_PLURAL}
6883,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1       ALLOW_PLURAL}
6884,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3        ALLOW_PLURAL}
6885,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2       ALLOW_PLURAL}
6886,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2       ALLOW_PLURAL}
6887,{jjTEST,      TEST_CMD,        NONE,               -2       ALLOW_PLURAL}
6888,{iiWRITE,     WRITE_CMD,       NONE,               -2       ALLOW_PLURAL}
6889,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2       ALLOW_PLURAL}
6890,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3       ALLOW_PLURAL}
6891,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4       ALLOW_PLURAL}
6892,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6       NO_PLURAL}
6893,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4       NO_PLURAL}
6894,{NULL,        0,               0,                   0       NO_PLURAL}
6895};
6896#ifdef MDEBUG
6897static Subexpr jjDBMakeSub(leftv e,const char *f,const int l)
6898#else
6899static Subexpr jjMakeSub(leftv e)
6900#endif
6901{
6902  assume( e->Typ()==INT_CMD );
6903  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
6904  r->start =(int)(long)e->Data();
6905  return r;
6906}
6907
6908/*================ generating tables ============================*/
6909#ifdef GENTABLE
6910extern struct sValAssign dAssign[];
6911struct sValCmdTab dArithTab1[]={ {0,0}};
6912#define JJTAB1LEN 0
6913struct sValCmdTab dArithTab2[]={ {0,0}};
6914#define JJTAB2LEN 0
6915void ttGen1()
6916{
6917  FILE *outfile = myfopen("iparith.inc","w");
6918  int i,j,l1=0,l2=0;
6919  currRing=(ring)omAllocBin(sip_sring_bin);
6920  fprintf(outfile,
6921  "/****************************************\n"
6922  "*  Computer Algebra System SINGULAR     *\n"
6923  "****************************************/\n\n");
6924/*-------------------------------------------------------------------*/
6925  fprintf(outfile,"// syntax table for Singular\n//\n");
6926  fprintf(outfile,"// - search for an exact match of the argument types\n");
6927  fprintf(outfile,"// - otherwise search for the first possibility\n");
6928  fprintf(outfile,"//   with converted types of the arguments\n");
6929  fprintf(outfile,"// - otherwise report an error\n//\n");
6930
6931  int op;
6932  i=0;
6933  while ((op=dArith1[i].cmd)!=0)
6934  {
6935    if (dArith1[i].p==jjWRONG)
6936      fprintf(outfile,"// DUMMY ");
6937    const char *s = iiTwoOps(op);
6938    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
6939          s,
6940          Tok2Cmdname(dArith1[i].arg),
6941          Tok2Cmdname(ABS(dArith1[i].res)));
6942    i++;
6943  }
6944  fprintf(outfile,"/*---------------------------------------------*/\n");
6945  i=0;
6946  while ((op=dArith2[i].cmd)!=0)
6947  {
6948    if (dArith2[i].p==jjWRONG2)
6949      fprintf(outfile,"// DUMMY ");
6950    const char *s = iiTwoOps(op);
6951    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
6952          s,
6953          Tok2Cmdname(dArith2[i].arg1),
6954          Tok2Cmdname(dArith2[i].arg2),
6955          Tok2Cmdname(dArith2[i].res));
6956    i++;
6957  }
6958  fprintf(outfile,"/*---------------------------------------------*/\n");
6959  i=0;
6960  while ((op=dArith3[i].cmd)!=0)
6961  {
6962    const char *s = iiTwoOps(op);
6963    if (dArith3[i].p==jjWRONG3)
6964      fprintf(outfile,"// DUMMY ");
6965    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
6966          s,
6967          Tok2Cmdname(dArith3[i].arg1),
6968          Tok2Cmdname(dArith3[i].arg2),
6969          Tok2Cmdname(dArith3[i].arg3),
6970          Tok2Cmdname(dArith3[i].res));
6971    i++;
6972  }
6973  fprintf(outfile,"/*---------------------------------------------*/\n");
6974  i=0;
6975  while ((op=dArithM[i].cmd)!=0)
6976  {
6977    const char *s = iiTwoOps(op);
6978    fprintf(outfile,"// operation: %s (...)  ->  %s",
6979          s,
6980          Tok2Cmdname(dArithM[i].res));
6981    switch(dArithM[i].number_of_args)
6982    {
6983      case -2:
6984         fprintf(outfile," ( number of arguments >0 )\n");
6985         break;
6986      case -1:
6987         fprintf(outfile," ( any number of arguments )\n");
6988         break;
6989      default:
6990         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
6991         break;
6992    }
6993    i++;
6994  }
6995  fprintf(outfile,"/*---------------------------------------------*/\n");
6996  i=0;
6997  while ((op=dAssign[i].res)!=0)
6998  {
6999    fprintf(outfile,"// assign: %s =  %s\n",
7000          Tok2Cmdname(op/*dAssign[i].res*/),
7001          Tok2Cmdname(dAssign[i].arg));
7002    i++;
7003  }
7004/*-------------------------------------------------------------------*/
7005  fprintf(outfile,"/*---------------------------------------------*/\n");
7006  for (j=257;j<=MAX_TOK+1;j++)
7007  {
7008    for(i=257;i<=MAX_TOK+1;i++)
7009    {
7010      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
7011      && iiTestConvert(i,j))
7012      {
7013        fprintf(outfile,"// convert %s -> %s\n",
7014          Tok2Cmdname(i), Tok2Cmdname(j));
7015        if (j==ANY_TYPE) break;
7016      }
7017    }
7018  }
7019  fprintf(outfile,"/*---------------------------------------------*/\n");
7020  char ops[]="=><+*/[.^,%(;";
7021  for(i=0;ops[i]!='\0';i++)
7022    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
7023  for (i=257;i<=MAX_TOK;i++)
7024  {
7025    const char *s=iiTwoOps(i);
7026    if (s[0]!='$')
7027    {
7028      fprintf(outfile,"// token %d : %s\n", i, s);
7029    }
7030  }
7031/*-------------------------------------------------------------------*/
7032  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
7033/*-------------------------------------------------------------------*/
7034  fprintf(outfile,"/*---------------------------------------------*/\n");
7035  fprintf(outfile,
7036  "struct sValCmdTab dArithTab1[]=\n"
7037  "{\n");
7038  for (j=1;j<=MAX_TOK+1;j++)
7039  {
7040    for(i=0;dArith1[i].cmd!=0;i++)
7041    {
7042      if (dArith1[i].cmd==j)
7043      {
7044        fprintf(outfile," { %d,%d },\n",j,i);
7045        l1++;
7046        break;
7047      }
7048    }
7049  }
7050  fprintf(outfile," { 10000,0 }\n};\n");
7051  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
7052/*-------------------------------------------------------------------*/
7053  fprintf(outfile,
7054  "struct sValCmdTab dArithTab2[]=\n"
7055  "{\n");
7056  for (j=1;j<=MAX_TOK+1;j++)
7057  {
7058    for(i=0;dArith2[i].cmd!=0;i++)
7059    {
7060      if (dArith2[i].cmd==j)
7061      {
7062        fprintf(outfile," { %d,%d },\n",j,i);
7063        l2++;
7064        break;
7065      }
7066    }
7067  }
7068  fprintf(outfile," { 10000,0 }\n};\n");
7069  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
7070  fclose(outfile);
7071}
7072/*-------------------------------------------------------------------*/
7073#if 0
7074void ttGen2()
7075{
7076  FILE *outfile = myfopen("iparith.inc","a");
7077  fprintf(outfile,
7078  "/****************************************\n"
7079  "*  Computer Algebra System SINGULAR     *\n"
7080  "****************************************/\n\n");
7081/*-------------------------------------------------------------------*/
7082  fprintf(outfile,"// identifier table for Singular\n//\n");
7083
7084  fprintf(outfile,
7085  "cmdnames OLDcmds[] =\n"
7086  "{  // name-string     alias  tokval toktype\n"
7087  "{ \"$INVALID$\",            0,  -1, 0},\n");
7088  int i=1;
7089  int m=-1;
7090  int id_nr=0;
7091  BOOLEAN f=FALSE;
7092  loop
7093  {
7094    while (cmds[i].tokval!=0)
7095    {
7096      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
7097      {
7098        if(m==-1)
7099        {
7100          m=i;
7101          f=TRUE;
7102        }
7103        else if(strcmp(cmds[m].name,cmds[i].name)>0)
7104        {
7105          m=i;
7106          f=TRUE;
7107        }
7108      }
7109      i++;
7110    }
7111    if(f)
7112    {
7113      id_nr++;
7114      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
7115      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
7116                                             20-strlen(cmds[m].name),
7117                                             cmds[m].alias,
7118                                             cmds[m].tokval);
7119      switch(cmds[m].toktype)
7120      {
7121        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
7122        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
7123        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
7124        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
7125        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
7126        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
7127        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
7128        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
7129        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
7130        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
7131        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
7132        case NONE:             fprintf(outfile,"NONE },\n"); break;
7133        default:               if((cmds[m].toktype>' ')
7134                               &&(cmds[m].toktype<127))
7135                               {
7136                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
7137                               }
7138                               else
7139                               {
7140                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
7141                               }
7142                               break;
7143      }
7144      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
7145      cmds[m].name=NULL;
7146      m=-1;
7147      i=1;
7148      f=FALSE;
7149    }
7150    else break;
7151  }
7152  fprintf(outfile,
7153"/* list of scanner identifiers/only for feread/reservedName */\n");
7154  f=FALSE;
7155  i=1;m=-1;
7156  loop
7157  {
7158    while (cmds[i].tokval!=0)
7159    {
7160      if (cmds[i].name!=NULL)
7161      {
7162        if(m==-1)
7163        {
7164          m=i;
7165          f=TRUE;
7166        }
7167        else if(strcmp(cmds[m].name,cmds[i].name)>0)
7168        {
7169          m=i;
7170          f=TRUE;
7171        }
7172      }
7173      i++;
7174    }
7175    if(f)
7176    {
7177      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
7178                                             20-strlen(cmds[m].name),
7179                                             0/*cmds[m].alias*/
7180                                             /*-1 cmds[m].tokval*/
7181                                             /*0 cmds[m].toktype*/);
7182      cmds[m].name=NULL;
7183      m=-1;
7184      i=1;
7185      f=FALSE;
7186    }
7187    else break;
7188  }
7189  fprintf(outfile,
7190"/* end of list marker */\n"
7191"  { NULL, 0, 0, 0}\n"
7192"};\n"
7193"#ifdef HAVE_RTIMER\n"
7194"#define LAST_IDENTIFIER %d\n"
7195"#else\n"
7196"#define LAST_IDENTIFIER %d\n"
7197"#endif\n",id_nr,id_nr-1);
7198  fclose(outfile);
7199}
7200#endif
7201/*---------------------------------------------------------------------*/
7202/**
7203 * @brief generate cmds initialisation
7204**/
7205/*---------------------------------------------------------------------*/
7206
7207void ttGen2b()
7208{
7209  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
7210
7211  FILE *outfile = myfopen("iparith.inc","a");
7212  fprintf(outfile,
7213  "/****************************************\n"
7214  "*  Computer Algebra System SINGULAR     *\n"
7215  "****************************************/\n\n");
7216/*-------------------------------------------------------------------*/
7217  fprintf(outfile,"// identifier table for Singular\n//\n");
7218
7219  fprintf(
7220    outfile,
7221    "#ifdef MODULE_GENERATOR\n"
7222    "#define omAlloc0(A) malloc(A)\n"
7223    "#endif\n"
7224    "void iiInitCmdName()\n{\n"
7225    "  sArithBase.nCmdUsed      = 0;\n"
7226    "  sArithBase.nCmdAllocated = %d;\n"
7227    "  sArithBase.sCmds = (cmdnames*)omAlloc0(sArithBase.nCmdAllocated*sizeof(cmdnames));\n"
7228    "\n"
7229    "  // name-string                   alias  tokval toktype index\n",
7230    cmd_size);
7231  int m=0;
7232  int id_nr=0;
7233
7234  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
7235
7236  for(m=0; m<cmd_size; m++)
7237  {
7238    if(cmds[m].tokval>0) id_nr++;
7239    if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
7240    fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
7241            20-strlen(cmds[m].name),
7242            cmds[m].alias,
7243            cmds[m].tokval);
7244    switch(cmds[m].toktype)
7245    {
7246        case CMD_1:            fprintf(outfile,"CMD_1"); break;
7247        case CMD_2:            fprintf(outfile,"CMD_2"); break;
7248        case CMD_3:            fprintf(outfile,"CMD_3"); break;
7249        case CMD_12:           fprintf(outfile,"CMD_12"); break;
7250        case CMD_123 :         fprintf(outfile,"CMD_123"); break;
7251        case CMD_23:           fprintf(outfile,"CMD_23"); break;
7252        case CMD_M:            fprintf(outfile,"CMD_M"); break;
7253        case SYSVAR:           fprintf(outfile,"SYSVAR"); break;
7254        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL"); break;
7255        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST"); break;
7256        case RING_DECL:        fprintf(outfile,"RING_DECL"); break;
7257        case NONE:             fprintf(outfile,"NONE"); break;
7258        default:
7259          if((cmds[m].toktype>' ') &&(cmds[m].toktype<127))
7260          {
7261            fprintf(outfile,"'%c'",cmds[m].toktype);
7262          }
7263          else
7264          {
7265            fprintf(outfile,"%d",cmds[m].toktype);
7266          }
7267          break;
7268#if 0
7269          fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d,  -1, 0 );\n",
7270              cmds[m].name, 20-strlen(cmds[m].name),
7271              0/*cmds[m].alias*/
7272              /*-1 cmds[m].tokval*/
7273              /*0 cmds[m].toktype*/);
7274#endif
7275    }
7276    fprintf(outfile,", %d);\n", m);
7277    if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
7278  }
7279  fprintf(outfile, "/* end of list marker */\n");
7280  fprintf(outfile,
7281          "#ifdef HAVE_RTIMER\n"
7282          "  sArithBase.nLastIdentifier = %d;\n"
7283          "#else /* HAVE_RTIMER */\n"
7284          "  sArithBase.nLastIdentifier = %d;\n"
7285          "#endif /* HAVE_RTIMER */\n",
7286          id_nr,id_nr-1);
7287
7288
7289  fprintf(outfile,
7290"}\n"
7291"#ifdef HAVE_RTIMER\n"
7292"#define LAST_IDENTIFIER %d\n"
7293"#else\n"
7294"#define LAST_IDENTIFIER %d\n"
7295"#endif\n",id_nr,id_nr-1);
7296  fclose(outfile);
7297}
7298/*-------------------------------------------------------------------*/
7299#if 0
7300void ttGen3()
7301{
7302  FILE *outfile = myfopen("mpsr_tok.inc","w");
7303  fprintf(outfile,
7304  "/****************************************\n"
7305  "*  Computer Algebra System SINGULAR     *\n"
7306  "****************************************/\n\n");
7307/*-------------------------------------------------------------------*/
7308  fprintf(outfile,"// token table for Singular\n//\n");
7309
7310  fprintf(outfile,
7311  "short vtok[] =\n"
7312  "{\n");
7313  // operations with 1 arg: ===========================================
7314  int i=0;
7315  while (dArith1[i].cmd!=0)
7316  {
7317    if ((dArith1[i].p!=jjWRONG)
7318    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
7319    {
7320      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
7321    }
7322    i++;
7323  }
7324  // operations with 2 args: ===========================================
7325  i=0;
7326  while (dArith2[i].cmd!=0)
7327  {
7328    if ((dArith2[i].p!=jjWRONG2)
7329    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
7330    {
7331      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
7332    }
7333    i++;
7334  }
7335  // operations with 3 args: ===========================================
7336  i=0;
7337  while (dArith3[i].cmd!=0)
7338  {
7339    if (
7340    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
7341    {
7342      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
7343    }
7344    i++;
7345  }
7346  // operations with many args: ===========================================
7347  i=0;
7348  while (dArithM[i].cmd!=0)
7349  {
7350    if (
7351    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
7352    {
7353      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
7354    }
7355    i++;
7356  }
7357  // ====================================================================
7358  fprintf(outfile,
7359  "/* end of list marker */\n"
7360  " %d };\n",MAX_TOK);
7361  fclose(outfile);
7362}
7363#endif
7364void ttGen4()
7365{
7366  FILE *outfile = myfopen("plural_cmd.inc","w");
7367  int i;
7368  const char *old_s="";
7369  fprintf(outfile,
7370  "@c *****************************************\n"
7371  "@c *  Computer Algebra System SINGULAR     *\n"
7372  "@c *****************************************\n\n");
7373/*-------------------------------------------------------------------*/
7374  fprintf(outfile,"@multicolumn .45 .45\n");
7375  int op;
7376  i=0;
7377  while ((op=dArith1[i].cmd)!=0)
7378  {
7379    if (dArith1[i].p!=jjWRONG)
7380    {
7381      const char *s = iiTwoOps(op);
7382      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7383      {
7384        old_s=s;
7385        #ifdef HAVE_PLURAL
7386        switch (dArith1[i].valid_for_plural)
7387        {
7388          case NO_PLURAL_N:
7389            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7390            break;
7391          case ALLOW_PLURAL_N:
7392            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7393            break;
7394          case COMM_PLURAL_N:
7395            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7396            break;
7397        }
7398        #endif
7399      }
7400    }
7401    i++;
7402  }
7403  fprintf(outfile,"@c ---------------------------------------------\n");
7404  i=0;
7405  while ((op=dArith2[i].cmd)!=0)
7406  {
7407    if (dArith2[i].p!=jjWRONG2)
7408    {
7409      const char *s = iiTwoOps(op);
7410      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7411      {
7412        old_s=s;
7413        #ifdef HAVE_PLURAL
7414        switch (dArith2[i].valid_for_plural)
7415        {
7416          case NO_PLURAL_N:
7417            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7418            break;
7419          case ALLOW_PLURAL_N:
7420            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7421            break;
7422          case COMM_PLURAL_N:
7423            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7424            break;
7425        }
7426        #endif
7427      }
7428    }
7429    i++;
7430  }
7431  fprintf(outfile,"@c ---------------------------------------------\n");
7432  i=0;
7433  while ((op=dArith3[i].cmd)!=0)
7434  {
7435    const char *s = iiTwoOps(op);
7436    if (dArith3[i].p!=jjWRONG3)
7437    {
7438      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7439      {
7440        old_s=s;
7441        #ifdef HAVE_PLURAL
7442        switch (dArith3[i].valid_for_plural)
7443        {
7444          case NO_PLURAL_N:
7445            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7446            break;
7447          case ALLOW_PLURAL_N:
7448            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7449            break;
7450          case COMM_PLURAL_N:
7451            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7452            break;
7453        }
7454        #endif
7455      }
7456    }
7457    i++;
7458  }
7459  fprintf(outfile,"@c ---------------------------------------------\n");
7460  i=0;
7461  while ((op=dArithM[i].cmd)!=0)
7462  {
7463    const char *s = iiTwoOps(op);
7464    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7465    {
7466        old_s=s;
7467        #ifdef HAVE_PLURAL
7468        switch (dArithM[i].valid_for_plural)
7469        {
7470          case NO_PLURAL_N:
7471            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7472            break;
7473          case ALLOW_PLURAL_N:
7474            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7475            break;
7476          case COMM_PLURAL_N:
7477            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7478            break;
7479        }
7480        #endif
7481    }
7482    i++;
7483  }
7484  fprintf(outfile,"@c ---------------------------------------------\n");
7485  fprintf(outfile,"@end table\n");
7486  fclose(outfile);
7487}
7488/*-------------------------------------------------------------------*/
7489#else
7490#include "iparith.inc"
7491#endif
7492
7493/*=================== operations with 2 args. ============================*/
7494
7495BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
7496{
7497#ifndef GENTABLE
7498  memset(res,0,sizeof(sleftv));
7499  BOOLEAN call_failed=FALSE;
7500
7501  if (!errorreported)
7502  {
7503#ifdef SIQ
7504    if (siq>0)
7505    {
7506      //Print("siq:%d\n",siq);
7507      command d=(command)omAlloc0Bin(ip_command_bin);
7508      memcpy(&d->arg1,a,sizeof(sleftv));
7509      //a->Init();
7510      memcpy(&d->arg2,b,sizeof(sleftv));
7511      //b->Init();
7512      d->argc=2;
7513      d->op=op;
7514      res->data=(char *)d;
7515      res->rtyp=COMMAND;
7516      return FALSE;
7517    }
7518#endif
7519    int at=a->Typ();
7520    int bt=b->Typ();
7521    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
7522    int index=i;
7523
7524    iiOp=op;
7525    while (dArith2[i].cmd==op)
7526    {
7527      if ((at==dArith2[i].arg1)
7528      && (bt==dArith2[i].arg2))
7529      {
7530        res->rtyp=dArith2[i].res;
7531        #ifdef HAVE_PLURAL
7532        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7533        {
7534          if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
7535          {
7536            WerrorS(ii_not_for_plural);
7537            break;
7538          }
7539          else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7540          {
7541            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7542          }
7543          /* else ALLOW_PLURAL */
7544        }
7545        #endif
7546        if ((call_failed=dArith2[i].p(res,a,b)))
7547        {
7548          break;// leave loop, goto error handling
7549        }
7550        a->CleanUp();
7551        b->CleanUp();
7552        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7553        return FALSE;
7554      }
7555      i++;
7556    }
7557    // implicite type conversion ----------------------------------------------
7558    if (dArith2[i].cmd!=op)
7559    {
7560      int ai,bi;
7561      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7562      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7563      BOOLEAN failed=FALSE;
7564      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
7565      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
7566      while (dArith2[i].cmd==op)
7567      {
7568        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7569        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
7570        {
7571          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
7572          {
7573            res->rtyp=dArith2[i].res;
7574            #ifdef HAVE_PLURAL
7575            if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7576            {
7577              if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
7578              {
7579                WerrorS(ii_not_for_plural);
7580                break;
7581              }
7582              else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7583              {
7584                Warn("assume commutative subalgebra for cmd `%s`",
7585                      Tok2Cmdname(i));
7586              }
7587              /* else ALLOW_PLURAL */
7588            }
7589            #endif
7590            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
7591            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
7592            || (call_failed=dArith2[i].p(res,an,bn)));
7593            // everything done, clean up temp. variables
7594            if (failed)
7595            {
7596              // leave loop, goto error handling
7597              break;
7598            }
7599            else
7600            {
7601              // everything ok, clean up and return
7602              an->CleanUp();
7603              bn->CleanUp();
7604              omFreeBin((ADDRESS)an, sleftv_bin);
7605              omFreeBin((ADDRESS)bn, sleftv_bin);
7606              a->CleanUp();
7607              b->CleanUp();
7608              return FALSE;
7609            }
7610          }
7611        }
7612        i++;
7613      }
7614      an->CleanUp();
7615      bn->CleanUp();
7616      omFreeBin((ADDRESS)an, sleftv_bin);
7617      omFreeBin((ADDRESS)bn, sleftv_bin);
7618    }
7619    // error handling ---------------------------------------------------
7620    const char *s=NULL;
7621    if (!errorreported)
7622    {
7623      if ((at==0) && (a->Fullname()!=sNoName))
7624      {
7625        s=a->Fullname();
7626      }
7627      else if ((bt==0) && (b->Fullname()!=sNoName))
7628      {
7629        s=b->Fullname();
7630      }
7631      if (s!=NULL)
7632        Werror("`%s` is not defined",s);
7633      else
7634      {
7635        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
7636        s = iiTwoOps(op);
7637        if (proccall)
7638        {
7639          Werror("%s(`%s`,`%s`) failed"
7640                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
7641        }
7642        else
7643        {
7644          Werror("`%s` %s `%s` failed"
7645                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
7646        }
7647        if ((!call_failed) && BVERBOSE(V_SHOW_USE))
7648        {
7649          while (dArith2[i].cmd==op)
7650          {
7651            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
7652            && (dArith2[i].res!=0)
7653            && (dArith2[i].p!=jjWRONG2))
7654            {
7655              if (proccall)
7656                Werror("expected %s(`%s`,`%s`)"
7657                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7658              else
7659                Werror("expected `%s` %s `%s`"
7660                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
7661            }
7662            i++;
7663          }
7664        }
7665      }
7666    }
7667    res->rtyp = UNKNOWN;
7668  }
7669  a->CleanUp();
7670  b->CleanUp();
7671#endif
7672  return TRUE;
7673}
7674
7675/*==================== operations with 1 arg. ===============================*/
7676
7677BOOLEAN iiExprArith1(leftv res, leftv a, int op)
7678{
7679#ifndef GENTABLE
7680  memset(res,0,sizeof(sleftv));
7681  BOOLEAN call_failed=FALSE;
7682
7683  if (!errorreported)
7684  {
7685#ifdef SIQ
7686    if (siq>0)
7687    {
7688      //Print("siq:%d\n",siq);
7689      command d=(command)omAlloc0Bin(ip_command_bin);
7690      memcpy(&d->arg1,a,sizeof(sleftv));
7691      //a->Init();
7692      d->op=op;
7693      d->argc=1;
7694      res->data=(char *)d;
7695      res->rtyp=COMMAND;
7696      return FALSE;
7697    }
7698#endif
7699    int at=a->Typ();
7700    BOOLEAN failed=FALSE;
7701
7702    iiOp=op;
7703    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
7704    int ti = i;
7705    while (dArith1[i].cmd==op)
7706    {
7707      if (at==dArith1[i].arg)
7708      {
7709        int r=res->rtyp=dArith1[i].res;
7710        #ifdef HAVE_PLURAL
7711        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7712        {
7713          if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
7714          {
7715            WerrorS(ii_not_for_plural);
7716            break;
7717          }
7718          else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7719          {
7720            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7721          }
7722          /* else ALLOW_PLURAL */
7723        }
7724        #endif
7725        if (r<0)
7726        {
7727          res->rtyp=-r;
7728          #ifdef PROC_BUG
7729          dArith1[i].p(res,a);
7730          #else
7731          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
7732          #endif
7733        }
7734        else if ((call_failed=dArith1[i].p(res,a)))
7735        {
7736          break;// leave loop, goto error handling
7737        }
7738        if (a->Next()!=NULL)
7739        {
7740          res->next=(leftv)omAllocBin(sleftv_bin);
7741          failed=iiExprArith1(res->next,a->next,op);
7742        }
7743        a->CleanUp();
7744        return failed;
7745      }
7746      i++;
7747    }
7748    // implicite type conversion --------------------------------------------
7749    if (dArith1[i].cmd!=op)
7750    {
7751      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7752      i=ti;
7753      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
7754      while (dArith1[i].cmd==op)
7755      {
7756        int ai;
7757        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
7758        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
7759        {
7760          int r=res->rtyp=dArith1[i].res;
7761          #ifdef HAVE_PLURAL
7762          if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7763          {
7764            if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
7765            {
7766              WerrorS(ii_not_for_plural);
7767              break;
7768            }
7769            else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7770            {
7771              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7772            }
7773            /* else ALLOW_PLURAL */
7774          }
7775          #endif
7776          if (r<0)
7777          {
7778            res->rtyp=-r;
7779            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
7780            if (!failed)
7781            {
7782              #ifdef PROC_BUG
7783              dArith1[i].p(res,a);
7784              #else
7785              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
7786              #endif
7787            }
7788          }
7789          else
7790          {
7791            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
7792            || (call_failed=dArith1[i].p(res,an)));
7793          }
7794          // everything done, clean up temp. variables
7795          if (failed)
7796          {
7797            // leave loop, goto error handling
7798            break;
7799          }
7800          else
7801          {
7802            if (an->Next() != NULL)
7803            {
7804              res->next = (leftv)omAllocBin(sleftv_bin);
7805              failed=iiExprArith1(res->next,an->next,op);
7806            }
7807            // everything ok, clean up and return
7808            an->CleanUp();
7809            omFreeBin((ADDRESS)an, sleftv_bin);
7810            a->CleanUp();
7811            return failed;
7812          }
7813        }
7814        i++;
7815      }
7816      an->CleanUp();
7817      omFreeBin((ADDRESS)an, sleftv_bin);
7818    }
7819    // error handling
7820    if (!errorreported)
7821    {
7822      if ((at==0) && (a->Fullname()!=sNoName))
7823      {
7824        Werror("`%s` is not defined",a->Fullname());
7825      }
7826      else
7827      {
7828        i=ti;
7829        const char *s = iiTwoOps(op);
7830        Werror("%s(`%s`) failed"
7831                ,s,Tok2Cmdname(at));
7832        if ((!call_failed) && BVERBOSE(V_SHOW_USE))
7833        {
7834          while (dArith1[i].cmd==op)
7835          {
7836            if ((dArith1[i].res!=0)
7837            && (dArith1[i].p!=jjWRONG))
7838              Werror("expected %s(`%s`)"
7839                ,s,Tok2Cmdname(dArith1[i].arg));
7840            i++;
7841          }
7842        }
7843      }
7844    }
7845    res->rtyp = UNKNOWN;
7846  }
7847  a->CleanUp();
7848#endif
7849  return TRUE;
7850}
7851
7852/*=================== operations with 3 args. ============================*/
7853
7854BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
7855{
7856#ifndef GENTABLE
7857  memset(res,0,sizeof(sleftv));
7858  BOOLEAN call_failed=FALSE;
7859
7860  if (!errorreported)
7861  {
7862#ifdef SIQ
7863    if (siq>0)
7864    {
7865      //Print("siq:%d\n",siq);
7866      command d=(command)omAlloc0Bin(ip_command_bin);
7867      memcpy(&d->arg1,a,sizeof(sleftv));
7868      //a->Init();
7869      memcpy(&d->arg2,b,sizeof(sleftv));
7870      //b->Init();
7871      memcpy(&d->arg3,c,sizeof(sleftv));
7872      //c->Init();
7873      d->op=op;
7874      d->argc=3;
7875      res->data=(char *)d;
7876      res->rtyp=COMMAND;
7877      return FALSE;
7878    }
7879#endif
7880    int at=a->Typ();
7881    int bt=b->Typ();
7882    int ct=c->Typ();
7883
7884    iiOp=op;
7885    int i=0;
7886    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7887    while (dArith3[i].cmd==op)
7888    {
7889      if ((at==dArith3[i].arg1)
7890      && (bt==dArith3[i].arg2)
7891      && (ct==dArith3[i].arg3))
7892      {
7893        res->rtyp=dArith3[i].res;
7894        #ifdef HAVE_PLURAL
7895        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7896        {
7897            if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7898            {
7899              WerrorS(ii_not_for_plural);
7900              break;
7901            }
7902            else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7903            {
7904              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7905            }
7906            /* else ALLOW_PLURAL */
7907        }
7908        #endif
7909        if ((call_failed=dArith3[i].p(res,a,b,c)))
7910        {
7911          break;// leave loop, goto error handling
7912        }
7913        a->CleanUp();
7914        b->CleanUp();
7915        c->CleanUp();
7916        return FALSE;
7917      }
7918      i++;
7919    }
7920    // implicite type conversion ----------------------------------------------
7921    if (dArith3[i].cmd!=op)
7922    {
7923      int ai,bi,ci;
7924      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7925      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7926      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
7927      BOOLEAN failed=FALSE;
7928      i=0;
7929      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7930      while (dArith3[i].cmd==op)
7931      {
7932        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
7933        {
7934          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
7935          {
7936            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
7937            {
7938              res->rtyp=dArith3[i].res;
7939              #ifdef HAVE_PLURAL
7940              if ((currRing!=NULL)
7941              && (rIsPluralRing(currRing)))
7942              {
7943                if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7944                {
7945                   WerrorS(ii_not_for_plural);
7946                   break;
7947                 }
7948                 else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7949                 {
7950                   Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7951                 }
7952                 /* else ALLOW_PLURAL */
7953              }
7954              #endif
7955              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
7956                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
7957                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
7958                || (call_failed=dArith3[i].p(res,an,bn,cn)));
7959              // everything done, clean up temp. variables
7960              if (failed)
7961              {
7962                // leave loop, goto error handling
7963                break;
7964              }
7965              else
7966              {
7967                // everything ok, clean up and return
7968                an->CleanUp();
7969                bn->CleanUp();
7970                cn->CleanUp();
7971                omFreeBin((ADDRESS)an, sleftv_bin);
7972                omFreeBin((ADDRESS)bn, sleftv_bin);
7973                omFreeBin((ADDRESS)cn, sleftv_bin);
7974                a->CleanUp();
7975                b->CleanUp();
7976                c->CleanUp();
7977        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7978                return FALSE;
7979              }
7980            }
7981          }
7982        }
7983        i++;
7984      }
7985      an->CleanUp();
7986      bn->CleanUp();
7987      cn->CleanUp();
7988      omFreeBin((ADDRESS)an, sleftv_bin);
7989      omFreeBin((ADDRESS)bn, sleftv_bin);
7990      omFreeBin((ADDRESS)cn, sleftv_bin);
7991    }
7992    // error handling ---------------------------------------------------
7993    if (!errorreported)
7994    {
7995      const char *s=NULL;
7996      if ((at==0) && (a->Fullname()!=sNoName))
7997      {
7998        s=a->Fullname();
7999      }
8000      else if ((bt==0) && (b->Fullname()!=sNoName))
8001      {
8002        s=b->Fullname();
8003      }
8004      else if ((ct==0) && (c->Fullname()!=sNoName))
8005      {
8006        s=c->Fullname();
8007      }
8008      if (s!=NULL)
8009        Werror("`%s` is not defined",s);
8010      else
8011      {
8012        i=0;
8013        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
8014        const char *s = iiTwoOps(op);
8015        Werror("%s(`%s`,`%s`,`%s`) failed"
8016                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
8017        if ((!call_failed) && BVERBOSE(V_SHOW_USE))
8018        {
8019          while (dArith3[i].cmd==op)
8020          {
8021            if(((at==dArith3[i].arg1)
8022            ||(bt==dArith3[i].arg2)
8023            ||(ct==dArith3[i].arg3))
8024            && (dArith3[i].res!=0))
8025            {
8026              Werror("expected %s(`%s`,`%s`,`%s`)"
8027                  ,s,Tok2Cmdname(dArith3[i].arg1)
8028                  ,Tok2Cmdname(dArith3[i].arg2)
8029                  ,Tok2Cmdname(dArith3[i].arg3));
8030            }
8031            i++;
8032          }
8033        }
8034      }
8035    }
8036    res->rtyp = UNKNOWN;
8037  }
8038  a->CleanUp();
8039  b->CleanUp();
8040  c->CleanUp();
8041        //Print("op: %d,result typ:%d\n",op,res->rtyp);
8042#endif
8043  return TRUE;
8044}
8045/*==================== operations with many arg. ===============================*/
8046
8047BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
8048{
8049  // cnt = 0: all
8050  // cnt = 1: only first one
8051  leftv next;
8052  BOOLEAN failed = TRUE;
8053  if(v==NULL) return failed;
8054  res->rtyp = LIST_CMD;
8055  if(cnt) v->next = NULL;
8056  next = v->next;             // saving next-pointer
8057  failed = jjLIST_PL(res, v);
8058  v->next = next;             // writeback next-pointer
8059  return failed;
8060}
8061
8062BOOLEAN iiExprArithM(leftv res, leftv a, int op)
8063{
8064#ifndef GENTABLE
8065  memset(res,0,sizeof(sleftv));
8066
8067  if (!errorreported)
8068  {
8069#ifdef SIQ
8070    if (siq>0)
8071    {
8072      //Print("siq:%d\n",siq);
8073      command d=(command)omAlloc0Bin(ip_command_bin);
8074      d->op=op;
8075      res->data=(char *)d;
8076      if (a!=NULL)
8077      {
8078        d->argc=a->listLength();
8079        // else : d->argc=0;
8080        memcpy(&d->arg1,a,sizeof(sleftv));
8081        switch(d->argc)
8082        {
8083          case 3:
8084            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
8085            a->next->next->Init();
8086            /* no break */
8087          case 2:
8088            memcpy(&d->arg2,a->next,sizeof(sleftv));
8089            a->next->Init();
8090            a->next->next=d->arg2.next;
8091            d->arg2.next=NULL;
8092            /* no break */
8093          case 1:
8094            a->Init();
8095            a->next=d->arg1.next;
8096            d->arg1.next=NULL;
8097        }
8098        if (d->argc>3) a->next=NULL;
8099        a->name=NULL;
8100        a->rtyp=0;
8101        a->data=NULL;
8102        a->e=NULL;
8103        a->attribute=NULL;
8104        a->CleanUp();
8105      }
8106      res->rtyp=COMMAND;
8107      return FALSE;
8108    }
8109#endif
8110    BOOLEAN failed=FALSE;
8111    int args=0;
8112    if (a!=NULL) args=a->listLength();
8113
8114    iiOp=op;
8115    int i=0;
8116    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
8117    while (dArithM[i].cmd==op)
8118    {
8119      if ((args==dArithM[i].number_of_args)
8120      || (dArithM[i].number_of_args==-1)
8121      || ((dArithM[i].number_of_args==-2)&&(args>0)))
8122      {
8123        res->rtyp=dArithM[i].res;
8124        #ifdef HAVE_PLURAL
8125        if ((currRing!=NULL)
8126        && (rIsPluralRing(currRing)))
8127        {
8128          if (dArithM[i].valid_for_plural==0 /*NO_PLURAL*/)
8129          {
8130            WerrorS(ii_not_for_plural);
8131            break;
8132          }
8133          else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
8134          {
8135            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
8136          }
8137          /* else ALLOW_PLURAL */
8138        }
8139        #endif
8140        if (dArithM[i].p(res,a))
8141        {
8142          break;// leave loop, goto error handling
8143        }
8144        if (a!=NULL) a->CleanUp();
8145        //Print("op: %d,result typ:%d\n",op,res->rtyp);
8146        return failed;
8147      }
8148      i++;
8149    }
8150    // error handling
8151    if (!errorreported)
8152    {
8153      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
8154      {
8155        Werror("`%s` is not defined",a->Fullname());
8156      }
8157      else
8158      {
8159        const char *s = iiTwoOps(op);
8160        Werror("%s(...) failed",s);
8161      }
8162    }
8163    res->rtyp = UNKNOWN;
8164  }
8165  if (a!=NULL) a->CleanUp();
8166        //Print("op: %d,result typ:%d\n",op,res->rtyp);
8167#endif
8168  return TRUE;
8169}
8170
8171/*=================== general utilities ============================*/
8172int IsCmd(const char *n, int & tok)
8173{
8174#ifndef GENTABLE
8175  int i;
8176  int an=1;
8177  int en=sArithBase.nLastIdentifier;
8178
8179  loop
8180  //for(an=0; an<sArithBase.nCmdUsed; )
8181  {
8182    if(an>=en-1)
8183    {
8184      if (strcmp(n, sArithBase.sCmds[an].name) == 0)
8185      {
8186        i=an;
8187        break;
8188      }
8189      else if ((an!=en) && (strcmp(n, sArithBase.sCmds[en].name) == 0))
8190      {
8191        i=en;
8192        break;
8193      }
8194      else
8195      {
8196        return 0;
8197      }
8198    }
8199    i=(an+en)/2;
8200    if (*n < *(sArithBase.sCmds[i].name))
8201    {
8202      en=i-1;
8203    }
8204    else if (*n > *(sArithBase.sCmds[i].name))
8205    {
8206      an=i+1;
8207    }
8208    else
8209    {
8210      int v=strcmp(n,sArithBase.sCmds[i].name);
8211      if(v<0)
8212      {
8213        en=i-1;
8214      }
8215      else if(v>0)
8216      {
8217        an=i+1;
8218      }
8219      else /*v==0*/
8220      {
8221        break;
8222      }
8223    }
8224  }
8225  lastreserved=sArithBase.sCmds[i].name;
8226  tok=sArithBase.sCmds[i].tokval;
8227  if(sArithBase.sCmds[i].alias==2)
8228  {
8229    Warn("outdated identifier `%s` used - please change your code",
8230    sArithBase.sCmds[i].name);
8231    sArithBase.sCmds[i].alias=1;
8232  }
8233  if (currRingHdl==NULL)
8234  {
8235    #ifdef SIQ
8236    if (siq<=0)
8237    {
8238    #endif
8239      if ((tok>=BEGIN_RING) && (tok<=END_RING))
8240      {
8241        WerrorS("no ring active");
8242        return 0;
8243      }
8244    #ifdef SIQ
8245    }
8246    #endif
8247  }
8248  if (!expected_parms)
8249  {
8250    switch (tok)
8251    {
8252      case IDEAL_CMD:
8253      case INT_CMD:
8254      case INTVEC_CMD:
8255      case MAP_CMD:
8256      case MATRIX_CMD:
8257      case MODUL_CMD:
8258      case POLY_CMD:
8259      case PROC_CMD:
8260      case RING_CMD:
8261      case STRING_CMD:
8262        cmdtok = tok;
8263        break;
8264    }
8265  }
8266  return sArithBase.sCmds[i].toktype;
8267#else
8268  return 0;
8269#endif
8270}
8271static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
8272{
8273#ifndef GENTABLE
8274  int a=0;
8275  int e=len;
8276  int p=len/2;
8277  do
8278  {
8279     if (op==dArithTab[p].cmd) return dArithTab[p].start;
8280     if (op<dArithTab[p].cmd) e=p-1;
8281     else   a = p+1;
8282     p=a+(e-a)/2;
8283  }
8284  while ( a <= e);
8285
8286#endif
8287  assume(0);
8288  return 0;
8289}
8290
8291#ifdef GENTABLE
8292const char * Tok2Cmdname(int tok)
8293{
8294  int i = 0;
8295  if (tok < 0)
8296  {
8297    return cmds[0].name;
8298  }
8299  if (tok==ANY_TYPE) return "any_type";
8300  if (tok==NONE) return "nothing";
8301  //if (tok==IFBREAK) return "if_break";
8302  //if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
8303  //if (tok==ORDER_VECTOR) return "ordering";
8304  //if (tok==REF_VAR) return "ref";
8305  //if (tok==OBJECT) return "object";
8306  //if (tok==PRINT_EXPR) return "print_expr";
8307  if (tok==IDHDL) return "identifier";
8308  while (cmds[i].tokval!=0)
8309  {
8310    if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
8311    {
8312      return cmds[i].name;
8313    }
8314    i++;
8315  }
8316  return cmds[0].name;
8317}
8318#else /* GENTABLE */
8319const char * Tok2Cmdname(int tok)
8320{
8321  int i = 0;
8322  if (tok <= 0)
8323  {
8324    return sArithBase.sCmds[0].name;
8325  }
8326  if (tok==ANY_TYPE) return "any_type";
8327  if (tok==NONE) return "nothing";
8328  //if (tok==IFBREAK) return "if_break";
8329  //if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
8330  //if (tok==ORDER_VECTOR) return "ordering";
8331  //if (tok==REF_VAR) return "ref";
8332  //if (tok==OBJECT) return "object";
8333  //if (tok==PRINT_EXPR) return "print_expr";
8334  if (tok==IDHDL) return "identifier";
8335  for(i=0; i<sArithBase.nCmdUsed; i++)
8336    //while (sArithBase.sCmds[i].tokval!=0)
8337  {
8338    if ((sArithBase.sCmds[i].tokval == tok)&&
8339        (sArithBase.sCmds[i].alias==0))
8340    {
8341      return sArithBase.sCmds[i].name;
8342    }
8343  }
8344  return sArithBase.sCmds[0].name;
8345}
8346#endif /* GENTABLE */
8347
8348
8349/*---------------------------------------------------------------------*/
8350/**
8351 * @brief compares to entry of cmdsname-list
8352
8353 @param[in] a
8354 @param[in] b
8355
8356 @return <ReturnValue>
8357**/
8358/*---------------------------------------------------------------------*/
8359static int _gentable_sort_cmds( const void *a, const void *b )
8360{
8361  cmdnames *pCmdL = (cmdnames*)a;
8362  cmdnames *pCmdR = (cmdnames*)b;
8363
8364  if(a==NULL || b==NULL)             return 0;
8365
8366  /* empty entries goes to the end of the list for later reuse */
8367  if(pCmdL->name==NULL) return 1;
8368  if(pCmdR->name==NULL) return -1;
8369
8370  /* $INVALID$ must come first */
8371  if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
8372  if(strcmp(pCmdR->name, "$INVALID$")==0) return  1;
8373
8374  /* tokval=-1 are reserved names at the end */
8375  if (pCmdL->tokval==-1)
8376  {
8377    if (pCmdR->tokval==-1)
8378       return strcmp(pCmdL->name, pCmdR->name);
8379    /* pCmdL->tokval==-1, pCmdL goes at the end */
8380    return 1;
8381  }
8382  /* pCmdR->tokval==-1, pCmdR goes at the end */
8383  if(pCmdR->tokval==-1) return -1;
8384
8385  return strcmp(pCmdL->name, pCmdR->name);
8386}
8387
8388/*---------------------------------------------------------------------*/
8389/**
8390 * @brief initialisation of arithmetic structured data
8391
8392 @retval 0 on success
8393
8394**/
8395/*---------------------------------------------------------------------*/
8396int iiInitArithmetic()
8397{
8398  int i;
8399  //printf("iiInitArithmetic()\n");
8400#ifndef GENTABLE
8401  memset(&sArithBase, 0, sizeof(sArithBase));
8402  iiInitCmdName();
8403  /* fix last-identifier */
8404#if 0
8405  /* we expect that gentable allready did every thing */
8406  for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8407      sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--) {
8408    if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8409  }
8410#endif
8411  //Print("L=%d\n", sArithBase.nLastIdentifier);
8412
8413  //iiArithAddCmd(szName, nAlias, nTokval, nToktype);
8414  //iiArithAddCmd("mygcd", 1, GCD_CMD, CMD_2);
8415
8416  //iiArithAddCmd("Top", 0,-1,0);
8417
8418
8419  //for(i=0; i<sArithBase.nCmdUsed; i++) {
8420  //  printf("CMD[%03d] %s, %d, %d, %d\n", i,
8421  //         sArithBase.sCmds[i].name,
8422  //         sArithBase.sCmds[i].alias,
8423  //         sArithBase.sCmds[i].tokval,
8424  //         sArithBase.sCmds[i].toktype);
8425  //}
8426  //iiArithRemoveCmd("Top");
8427  //iiArithAddCmd("mygcd", 2, GCD_CMD, CMD_2);
8428  //iiArithRemoveCmd("mygcd");
8429  //iiArithAddCmd("kkk", 1, 1234, CMD_1);
8430#endif   /* !GENTABLE */
8431  return 0;
8432}
8433
8434/*---------------------------------------------------------------------*/
8435/**
8436 * @brief append newitem of size sizeofitem to the list named list.
8437
8438 @param[in,out] list
8439 @param[in,out] item_count
8440 @param[in] sizeofitem
8441 @param[in] newitem
8442
8443 @retval  0 success
8444 @retval -1 failure
8445**/
8446/*---------------------------------------------------------------------*/
8447int iiArithAddItem2list(
8448  void **list,
8449  long  *item_count,
8450  long sizeofitem,
8451  void *newitem
8452  )
8453{
8454  int count = *item_count;
8455
8456  //TRACE(0, "add_item_to_list(%p, %p, %ld, %p)\n", list, item_count,
8457  //       sizeofitem, newitem);
8458
8459  if(count==0)
8460  {
8461    *list = (void *)omAlloc(sizeofitem);
8462  }
8463  else
8464  {
8465    *list = (void *)omRealloc(*list, (count+1) * sizeofitem);
8466  }
8467  if((*list)==NULL) return -1;
8468
8469  //memset((*list)+count*sizeofitem, 0, sizeofitem);
8470  //memcpy((*list)+count*sizeofitem, newitem, sizeofitem);
8471
8472  /* erhoehe counter um 1 */
8473  (count)++;
8474  *item_count = count;
8475  return 0;
8476}
8477
8478int iiArithFindCmd(const char *szName)
8479{
8480#ifndef GENTABLE
8481  int an=0;
8482  int i = 0,v = 0;
8483  int en=sArithBase.nLastIdentifier;
8484
8485  loop
8486  //for(an=0; an<sArithBase.nCmdUsed; )
8487  {
8488    if(an>=en-1)
8489    {
8490      if (strcmp(szName, sArithBase.sCmds[an].name) == 0)
8491      {
8492        //Print("RET-an=%d %s\n", an, sArithBase.sCmds[an].name);
8493        return an;
8494      }
8495      else if (strcmp(szName, sArithBase.sCmds[en].name) == 0)
8496      {
8497        //Print("RET-en=%d %s\n", en, sArithBase.sCmds[en].name);
8498        return en;
8499      }
8500      else
8501      {
8502        //Print("RET- 1\n");
8503        return -1;
8504      }
8505    }
8506    i=(an+en)/2;
8507    if (*szName < *(sArithBase.sCmds[i].name))
8508    {
8509      en=i-1;
8510    }
8511    else if (*szName > *(sArithBase.sCmds[i].name))
8512    {
8513      an=i+1;
8514    }
8515    else
8516    {
8517      v=strcmp(szName,sArithBase.sCmds[i].name);
8518      if(v<0)
8519      {
8520        en=i-1;
8521      }
8522      else if(v>0)
8523      {
8524        an=i+1;
8525      }
8526      else /*v==0*/
8527      {
8528        //Print("RET-i=%d %s\n", i, sArithBase.sCmds[i].name);
8529        return i;
8530      }
8531    }
8532  }
8533  //if(i>=0 && i<sArithBase.nCmdUsed)
8534  //  return i;
8535  //Print("RET-2\n");
8536  return -2;
8537#else
8538  return 0;
8539#endif
8540}
8541
8542char *iiArithGetCmd( int nPos )
8543{
8544  if(nPos<0) return NULL;
8545  if(nPos<sArithBase.nCmdUsed)
8546    return sArithBase.sCmds[nPos].name;
8547  return NULL;
8548}
8549
8550int iiArithRemoveCmd(const char *szName)
8551{
8552  int nIndex;
8553  if(szName==NULL) return -1;
8554
8555  nIndex = iiArithFindCmd(szName);
8556  if(nIndex<0 || nIndex>=sArithBase.nCmdUsed)
8557  {
8558    Print("'%s' not found (%d)\n", szName, nIndex);
8559    return -1;
8560  }
8561  omFree(sArithBase.sCmds[nIndex].name);
8562  sArithBase.sCmds[nIndex].name=NULL;
8563  qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8564        (&_gentable_sort_cmds));
8565  sArithBase.nCmdUsed--;
8566
8567  /* fix last-identifier */
8568  for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8569      sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8570  {
8571    if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8572  }
8573  //Print("L=%d\n", sArithBase.nLastIdentifier);
8574  return 0;
8575}
8576
8577int iiArithAddCmd(
8578  const char *szName,
8579  short nAlias,
8580  short nTokval,
8581  short nToktype,
8582  short nPos
8583  )
8584{
8585  //printf("AddCmd(%s, %d, %d, %d, %d)\n", szName, nAlias,
8586  //       nTokval, nToktype, nPos);
8587  if(nPos>=0)
8588  {
8589    // no checks: we rely on a correct generated code in iparith.inc
8590    assume(nPos < sArithBase.nCmdAllocated);
8591    assume(szName!=NULL);
8592    sArithBase.sCmds[nPos].name    = omStrDup(szName);
8593    sArithBase.sCmds[nPos].alias   = nAlias;
8594    sArithBase.sCmds[nPos].tokval  = nTokval;
8595    sArithBase.sCmds[nPos].toktype = nToktype;
8596    sArithBase.nCmdUsed++;
8597    //if(nTokval>0) sArithBase.nLastIdentifier++;
8598  }
8599  else
8600  {
8601    if(szName==NULL) return -1;
8602    int nIndex = iiArithFindCmd(szName);
8603    if(nIndex>=0)
8604    {
8605      Print("'%s' already exists at %d\n", szName, nIndex);
8606      return -1;
8607    }
8608
8609    if(sArithBase.nCmdUsed>=sArithBase.nCmdAllocated)
8610    {
8611      /* needs to create new slots */
8612      unsigned long nSize = (sArithBase.nCmdAllocated+1)*sizeof(cmdnames);
8613      sArithBase.sCmds = (cmdnames *)omRealloc(sArithBase.sCmds, nSize);
8614      if(sArithBase.sCmds==NULL) return -1;
8615      sArithBase.nCmdAllocated++;
8616    }
8617    /* still free slots available */
8618    sArithBase.sCmds[sArithBase.nCmdUsed].name    = omStrDup(szName);
8619    sArithBase.sCmds[sArithBase.nCmdUsed].alias   = nAlias;
8620    sArithBase.sCmds[sArithBase.nCmdUsed].tokval  = nTokval;
8621    sArithBase.sCmds[sArithBase.nCmdUsed].toktype = nToktype;
8622    sArithBase.nCmdUsed++;
8623
8624    qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8625          (&_gentable_sort_cmds));
8626    for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8627        sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8628    {
8629      if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8630    }
8631    //Print("L=%d\n", sArithBase.nLastIdentifier);
8632  }
8633  return 0;
8634}
8635
8636#ifdef GENTABLE
8637  // some special cmds which do not fit in with the others, and
8638  // nevertheless need to be transmitted
8639short ExtraCmds[] =
8640{
8641  OPTION_CMD,
8642  NAMES_CMD,
8643//  RESERVEDNAME_CMD,
8644  PROC_CMD,
8645  MAP_CMD,
8646  PACKAGE_CMD,
8647  '=',
8648  0
8649};
8650
8651// This returns 1 if tok is a token which can appear in a Singular
8652// (quoted) command, and 0 otherwise
8653short IsCmdToken(short tok)
8654{
8655  int i = 0;
8656  // cmds with one arg
8657  while (dArith1[i].cmd != 0)
8658    if (dArith1[i].cmd == tok) return 1;
8659    else i++;
8660
8661  // cmds with two args
8662  i=0;
8663  while (dArith2[i].cmd != 0)
8664    if (dArith2[i].cmd == tok) return 1;
8665    else i++;
8666
8667  // cmds with three args
8668  i=0;
8669  while (dArith3[i].cmd != 0)
8670    if (dArith3[i].cmd == tok) return 1;
8671    else i++;
8672
8673  // cmds with many args
8674  i=0;
8675  while (dArithM[i].cmd != 0)
8676    if (dArithM[i].cmd == tok) return 1;
8677    else i++;
8678
8679  // cmds which are somewhat special (like those having 0 args)
8680  i=0;
8681  while (ExtraCmds[i] != 0)
8682    if (ExtraCmds[i] == tok) return 1;
8683    else i++;
8684
8685  return 0;
8686}
8687#endif
Note: See TracBrowser for help on using the repository browser.