source: git/Singular/iparith.cc @ 16ffb5

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