source: git/Singular/iparith.cc @ 7447d8

spielwiese
Last change on this file since 7447d8 was 7447d8, checked in by Hans Schönemann <hannes@…>, 19 years ago
*hannes: gcc 4 and 64bit git-svn-id: file:///usr/local/Singular/svn/trunk@8463 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 215.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.372 2005-07-27 15:47:55 Singular Exp $ */
5
6/*
7* ABSTRACT: table driven kernel interface, used by interpreter
8*/
9
10#include <stdlib.h>
11#include <string.h>
12#include <ctype.h>
13#include <stdio.h>
14#include <time.h>
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "omalloc.h"
22#include "polys.h"
23#include "febase.h"
24#include "sdb.h"
25#include "longalg.h"
26#include "ideals.h"
27#include "matpol.h"
28#include "kstd1.h"
29#include "timer.h"
30#include "ring.h"
31#include "subexpr.h"
32#include "lists.h"
33#include "longalg.h"
34#include "numbers.h"
35#include "stairc.h"
36#include "maps.h"
37#include "maps_ip.h"
38#include "syz.h"
39#include "weight.h"
40#include "ipconv.h"
41#include "ipprint.h"
42#include "sing_dld.h"
43#include "attrib.h"
44#include "silink.h"
45#include "sparsmat.h"
46#include "units.h"
47#include "janet.h"
48#include "GMPrat.h"
49#include "tgb.h"
50#include "walkProc.h"
51#include "mod_raw.h"
52#ifdef HAVE_FACTORY
53#include "clapsing.h"
54#include "kstdfac.h"
55#endif
56#ifdef HAVE_FGLM
57#include "fglm.h"
58#endif
59
60#include "ipshell.h"
61
62#include "mpr_inout.h"
63
64#ifdef HAVE_PLURAL
65#include "gring.h"
66#define ALLOW_PLURAL    ,1
67#define ALLOW_PLURAL_N   1
68#define NO_PLURAL       ,0
69#define NO_PLURAL_N      0
70#define COMM_PLURAL     ,2
71#define COMM_PLURAL_N    2
72#else
73#define ALLOW_PLURAL
74#define NO_PLURAL
75#define COMM_PLURAL
76#endif
77
78/*=============== types =====================*/
79struct sValCmdTab
80{
81  short cmd;
82  short start;
83};
84
85typedef sValCmdTab jjValCmdTab[];
86
87/* ifdef GENTABLE: definitions are in ipshell.h */
88#ifndef GENTABLE
89typedef char * (*Proc1)(char *);
90struct sValCmd1
91{
92  proc1 p;
93  short cmd;
94  short res;
95  short arg;
96#ifdef HAVE_PLURAL
97  short valid_for_plural;
98#endif
99};
100
101typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
102struct sValCmd2
103{
104  proc2 p;
105  short cmd;
106  short res;
107  short arg1;
108  short arg2;
109#ifdef HAVE_PLURAL
110  short valid_for_plural;
111#endif
112};
113
114typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
115struct sValCmd3
116{
117  proc3 p;
118  short cmd;
119  short res;
120  short arg1;
121  short arg2;
122  short arg3;
123#ifdef HAVE_PLURAL
124  short valid_for_plural;
125#endif
126};
127struct sValCmdM
128{
129  proc1 p;
130  short cmd;
131  short res;
132  short number_of_args; /* -1: any, -2: any >0, .. */
133#ifdef HAVE_PLURAL
134  short valid_for_plural;
135#endif
136};
137#endif
138
139/*============= proc =======================*/
140static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
141static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
142#ifdef MDEBUG
143#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
144static Subexpr jjDBMakeSub(leftv e,char *f, int l);
145#else
146static Subexpr jjMakeSub(leftv e);
147#endif
148
149/*============= vars ======================*/
150extern int cmdtok;
151extern BOOLEAN expected_parms;
152
153#define ii_div_by_0 "div. by 0"
154#define ii_not_for_plural "not implemented for non-commutative rings"
155
156int iiOp; /* the current operation*/
157
158#ifdef GENTABLE
159cmdnames cmds[] =
160{  // name-string alias tokval          toktype
161  { "$INVALID$",   0, -1,                 0},
162  { "and",         0, '&' ,               LOGIC_OP},
163  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
164  { "bareiss",     0, BAREISS_CMD ,       CMD_123},
165  { "betti",       0, BETTI_CMD ,         CMD_12},
166  #ifdef HAVE_PLURAL
167  { "bracket",     0, BRACKET_CMD ,       CMD_2},
168  #endif
169  { "break",       0, BREAK_CMD ,         BREAK_CMD},
170  { "breakpoint",  0, BREAKPOINT_CMD ,    CMD_M},
171  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
172  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
173  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
174  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
175  { "close",       0, CLOSE_CMD ,         CMD_1},
176  { "coef",        0, COEF_CMD ,          CMD_M},
177  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
178  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
179  { "contract",    0, CONTRACT_CMD ,      CMD_2},
180  { "convhull",    0, NEWTONPOLY_CMD,     CMD_1},
181  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
182  { "def",         0, DEF_CMD ,           ROOT_DECL},
183  { "defined",     0, DEFINED_CMD ,       CMD_1},
184  { "deg",         0, DEG_CMD ,           CMD_12},
185  { "degree",      0, DEGREE_CMD ,        CMD_1},
186  { "delete",      0, DELETE_CMD ,        CMD_2},
187  { "det",         0, DET_CMD ,           CMD_1},
188  { "diff",        0, DIFF_CMD ,          CMD_2},
189  { "dim",         0, DIM_CMD ,           CMD_1},
190  { "div",         0, INTDIV_CMD ,        MULDIV_OP},
191  { "division",    0, DIVISION_CMD ,      CMD_M},
192  { "dump",        0, DUMP_CMD,           CMD_1},
193  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
194  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
195  { "ERROR",       0, ERROR_CMD ,         CMD_1},
196  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
197  { "else",        0, ELSE_CMD ,          ELSE_CMD},
198  #ifdef HAVE_PLURAL
199  { "envelope",    0, ENVELOPE_CMD ,       CMD_1},
200  #endif
201  { "eval",        0, EVAL ,              EVAL},
202  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
203  { "execute",     0, EXECUTE_CMD ,       CMD_1},
204  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
205  { "exportto",    0, EXPORTTO_CMD ,      CMD_2},
206  { "factorize",   0, FAC_CMD ,           CMD_12},
207  { "fetch",       0, FETCH_CMD ,         CMD_2},
208  { "fglm",        0, FGLM_CMD ,          CMD_2},
209  { "fglmquot",    0, FGLMQUOT_CMD,       CMD_2},
210  { "find",        0, FIND_CMD ,          CMD_23},
211  { "finduni",     0, FINDUNI_CMD,        CMD_1},
212  { "forif",       0, IF_CMD ,            IF_CMD},
213  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
214  { "facstd",      0, FACSTD_CMD ,        CMD_12},
215  { "frwalk",      0, FWALK_CMD ,         CMD_23},
216  { "gen",         0, E_CMD ,             CMD_1},
217  { "getdump",     0, GETDUMP_CMD,        CMD_1},
218  { "gcd",         0, GCD_CMD ,           CMD_2},
219  { "GCD",         2, GCD_CMD ,           CMD_2},
220  { "hilb",        0, HILBERT_CMD ,       CMD_123},
221  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
222  { "homog",       0, HOMOG_CMD ,         CMD_12},
223  { "hres",        0, HRES_CMD ,          CMD_2},
224  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
225  { "if",          0, IF_CMD ,            IF_CMD},
226  { "imap",        0, IMAP_CMD ,          CMD_2},
227  { "impart",      0, IMPART_CMD ,        CMD_1},
228  { "importfrom",  0, IMPORTFROM_CMD ,    CMD_2},
229  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
230  { "insert",      0, INSERT_CMD ,        CMD_23},
231  { "int",         0, INT_CMD ,           ROOT_DECL},
232  { "interred",    0, INTERRED_CMD ,      CMD_1},
233  { "intersect",   0, INTERSECT_CMD ,     CMD_M},
234  { "intmat",      0, INTMAT_CMD ,        INTMAT_CMD},
235  { "intvec",      0, INTVEC_CMD ,        ROOT_DECL_LIST},
236  { "jacob",       0, JACOB_CMD ,         CMD_1},
237  { "janet",       0, JANET_CMD ,         CMD_12},
238  { "jet",         0, JET_CMD ,           CMD_M},
239  { "kbase",       0, KBASE_CMD ,         CMD_12},
240  { "keepring",    0, KEEPRING_CMD ,      KEEPRING_CMD},
241  { "kill",        0, KILL_CMD ,          KILL_CMD},
242  { "killattrib",  0, KILLATTR_CMD ,      CMD_12},
243  { "koszul",      0, KOSZUL_CMD ,        CMD_23},
244  { "kres",        0, KRES_CMD ,          CMD_2},
245  { "laguerre",    0, LAGSOLVE_CMD,       CMD_3},
246  { "lead",        0, LEAD_CMD ,          CMD_1},
247  { "leadcoef",    0, LEADCOEF_CMD ,      CMD_1},
248  { "leadexp",     0, LEADEXP_CMD ,       CMD_1},
249  { "leadmonom",   0, LEADMONOM_CMD ,     CMD_1},
250  { "LIB",         0, LIB_CMD ,           SYSVAR},
251  { "lift",        0, LIFT_CMD ,          CMD_23},
252  { "liftstd",     0, LIFTSTD_CMD ,       CMD_2},
253  { "link",        0, LINK_CMD ,          ROOT_DECL},
254  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
255  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
256  { "load",        0, LOAD_CMD ,          CMD_12},
257  { "lres",        0, LRES_CMD ,          CMD_2},
258  { "map",         0, MAP_CMD ,           RING_DECL},
259  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
260  { "maxideal",    0, MAXID_CMD ,         CMD_1},
261  { "memory",      0, MEMORY_CMD ,        CMD_1},
262  { "minbase",     0, MINBASE_CMD ,       CMD_1},
263  { "minor",       0, MINOR_CMD ,         CMD_23},
264  { "minres",      0, MINRES_CMD ,        CMD_1},
265  { "mod",         0, INTMOD_CMD ,        MULDIV_OP},
266  { "module",      0, MODUL_CMD ,         MODUL_CMD},
267  { "modulo",      0, MODULO_CMD ,        CMD_2},
268  { "monitor",     0, MONITOR_CMD ,       CMD_12},
269  { "mpresmat",    0, MPRES_CMD,          CMD_2},
270  { "mult",        0, MULTIPLICITY_CMD ,  CMD_1},
271  #ifdef OLD_RES
272  { "mres",        0, MRES_CMD ,          CMD_23},
273  #else
274  { "mres",        0, MRES_CMD ,          CMD_2},
275  #endif
276  { "mstd",        0, MSTD_CMD ,          CMD_1},
277  { "nameof",      0, NAMEOF_CMD ,        CMD_1},
278  { "names",       0, NAMES_CMD ,         CMD_M},
279  #ifdef HAVE_PLURAL
280  { "ncalgebra",   0, NCALGEBRA_CMD ,     CMD_2},
281  #endif
282  { "ncols",       0, COLS_CMD ,          CMD_1},
283  { "not",         0, NOT ,               NOT},
284  { "npars",       0, NPARS_CMD ,         CMD_1},
285  #ifdef OLD_RES
286  { "nres",        0, RES_CMD ,           CMD_23},
287  #else
288  { "nres",        0, RES_CMD ,           CMD_2},
289  #endif
290  { "nrows",       0, ROWS_CMD ,          CMD_1},
291  { "number",      0, NUMBER_CMD ,        RING_DECL},
292  { "nvars",       0, NVARS_CMD ,         CMD_1},
293  { "open",        0, OPEN_CMD ,          CMD_1},
294  #ifdef HAVE_PLURAL
295  { "oppose",      0, OPPOSE_CMD ,        CMD_2},
296  { "opposite",    0, OPPOSITE_CMD ,      CMD_1},
297  #endif
298  { "option",      0, OPTION_CMD ,        CMD_M},
299  { "or",          0, '|' ,               LOGIC_OP},
300  { "ord",         0, ORD_CMD ,           CMD_1},
301  { "ordstr",      0, ORDSTR_CMD ,        CMD_1},
302  { "package",     0, PACKAGE_CMD ,       ROOT_DECL},
303  { "par",         0, PAR_CMD ,           CMD_1},
304  { "parameter",   0, PARAMETER ,         PARAMETER},
305  { "pardeg",      0, PARDEG_CMD ,        CMD_1},
306  { "parstr",      0, PARSTR_CMD ,        CMD_12},
307  { "poly",        0, POLY_CMD ,          RING_DECL},
308  { "preimage",    0, PREIMAGE_CMD ,      CMD_13},
309  { "prime",       0, PRIME_CMD ,         CMD_1},
310  { "print",       0, PRINT_CMD ,         CMD_12},
311  { "prune",       0, PRUNE_CMD ,         CMD_1},
312  { "proc",        0, PROC_CMD ,          PROC_CMD},
313  { "qhweight",    0, QHWEIGHT_CMD ,      CMD_1},
314  { "qring",       0, QRING_CMD ,         ROOT_DECL},
315  { "quote",       0, QUOTE ,             QUOTE},
316  { "quotient",    0, QUOTIENT_CMD ,      CMD_2},
317  { "random",      0, RANDOM_CMD ,        CMD_23},
318  { "read",        0, READ_CMD ,          CMD_12},
319  { "reduce",      0, REDUCE_CMD ,        CMD_M},
320  { "regularity",  0, REGULARITY_CMD ,    CMD_1},
321  { "repart",      0, REPART_CMD ,        CMD_1},
322  { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
323  { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},
324  { "resultant",   0, RESULTANT_CMD,      CMD_3},
325  { "return",      0, RETURN ,            RETURN},
326  { "RETURN",      0, END_GRAMMAR ,       RETURN},
327  { "ring",        0, RING_CMD ,          RING_CMD},
328  { "ringlist",    0, RINGLIST_CMD ,      CMD_1},
329  { "rvar",        0, IS_RINGVAR ,        CMD_1},
330  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
331  { "simplex",     0, SIMPLEX_CMD,        CMD_M},
332  { "simplify",    0, SIMPLIFY_CMD ,      CMD_2},
333  { "size",        0, COUNT_CMD ,         CMD_1},
334  { "slimgb",      0, SLIM_GB_CMD ,       CMD_1},
335  { "sortvec",     0, SORTVEC_CMD ,       CMD_1},
336  #ifdef OLD_RES
337  { "sres",        0, SRES_CMD ,          CMD_23},
338  #else
339  { "sres",        0, SRES_CMD ,          CMD_2},
340  #endif
341  { "status",      0, STATUS_CMD,         CMD_M},
342  { "std",         0, STD_CMD ,           CMD_123},
343  { "string",      0, STRING_CMD ,        ROOT_DECL_LIST},
344  { "subst",       0, SUBST_CMD ,         CMD_M},
345  { "system",      0, SYSTEM_CMD,         CMD_M},
346  { "syz",         0, SYZYGY_CMD ,        CMD_1},
347  { "test",        0, TEST_CMD ,          CMD_M},
348  { "trace",       0, TRACE_CMD ,         CMD_1},
349  { "transpose",   0, TRANSPOSE_CMD ,     CMD_1},
350  #ifdef HAVE_PLURAL
351  { "twostd",      0, TWOSTD_CMD ,        CMD_1},
352  #endif
353  { "type",        0, TYPE_CMD ,          TYPE_CMD},
354  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
355  { "uressolve",   0, URSOLVE_CMD,        CMD_M},
356  { "vandermonde", 0, VANDER_CMD,         CMD_3},
357  { "var",         0, VAR_CMD ,           CMD_1},
358  { "varstr",      0, VARSTR_CMD ,        CMD_12},
359  { "vdim",        0, VDIM_CMD ,          CMD_1},
360  { "vector",      0, VECTOR_CMD ,        RING_DECL},
361  { "wedge",       0, WEDGE_CMD ,         CMD_2},
362  { "weight",      0, WEIGHT_CMD ,        CMD_1},
363  { "whileif",     0, IF_CMD ,            IF_CMD},
364  { "write",       0, WRITE_CMD ,         CMD_M},
365/* delete for next version:*/
366  { "IN",          1, LEAD_CMD ,          CMD_1},
367  { "NF",          1, REDUCE_CMD ,        CMD_M},
368  { "multiplicity",1, MULTIPLICITY_CMD ,  CMD_1},
369  { "verbose",     2, OPTION_CMD ,        CMD_M},
370//  { "rank",        1, ROWS_CMD ,          CMD_1},
371//  { "Current",     0, -1 ,                SYSVAR},
372//  { "Top",         0, -1 ,                SYSVAR},
373//  { "Up",          0, -1 ,                SYSVAR},
374
375/* set sys vars*/
376  { "degBound",    0, VMAXDEG ,           SYSVAR},
377  { "echo",        0, VECHO ,             SYSVAR},
378  { "minpoly",     0, VMINPOLY ,          SYSVAR},
379  { "multBound",   0, VMAXMULT ,          SYSVAR},
380  { "noether",     0, VNOETHER ,          SYSVAR},
381  { "pagelength",  0, VPAGELENGTH ,       SYSVAR},
382  { "pagewidth",   0, VCOLMAX ,           SYSVAR},
383  { "printlevel",  0, VPRINTLEVEL ,       SYSVAR},
384  { "short",       0, VSHORTOUT ,         SYSVAR},
385  { "timer",       0, VTIMER ,            SYSVAR},
386  { "rtimer",      0, VRTIMER,            SYSVAR},
387  { "TRACE",       0, TRACE ,             SYSVAR},
388  { "voice",       0, VOICE ,             SYSVAR},
389
390/* other reserved words:scanner.l */
391  { "pause",       2, -1 ,             0},
392  { "while",       0, -1 ,             0},
393  { "for",         0, -1 ,             0},
394  { "help",        0, -1 ,             0},
395  { "newline",     0, -1 ,             0},
396  { "exit",        0, -1 ,             0},
397  { "quit",        0, -1 ,             0},
398/* end of list marker */
399  { NULL, 0, 0, 0}
400};
401#endif
402
403/*=================== operations with 2 args.: static proc =================*/
404static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
405{
406  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
407  int bb = (int)(long)(v->Data());
408  if (errorreported) return TRUE;
409  switch (iiOp)
410  {
411    case '+': (*aa) += bb; break;
412    case '-': (*aa) -= bb; break;
413    case '*': (*aa) *= bb; break;
414    case '/':
415    case INTDIV_CMD: (*aa) /= bb; break;
416    case '%':
417    case INTMOD_CMD: (*aa) %= bb; break;
418  }
419  res->data=(char *)aa;
420  return FALSE;
421}
422static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
423{
424  return jjOP_IV_I(res,v,u);
425}
426static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
427{
428  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
429  int bb = (int)(long)(v->Data());
430  int i=si_min(aa->rows(),aa->cols());
431  switch (iiOp)
432  {
433    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
434              break;
435    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
436              break;
437  }
438  res->data=(char *)aa;
439  return FALSE;
440}
441static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
442{
443  return jjOP_IM_I(res,v,u);
444}
445static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
446{
447  res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
448  return FALSE;
449}
450static void jjEQUAL_REST(leftv res,leftv u,leftv v)
451{
452  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
453  {
454    int save_iiOp=iiOp;
455    if (iiOp==NOTEQUAL)
456      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
457    else
458      iiExprArith2(res,u->next,iiOp,v->next);
459    iiOp=save_iiOp;
460  }
461  if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
462}
463static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
464{
465  intvec*    a = (intvec * )(u->Data());
466  intvec*    b = (intvec * )(v->Data());
467  int r=a->compare(b);
468  switch  (iiOp)
469  {
470    case '<':
471      res->data  = (char *) (r<0);
472      break;
473    case '>':
474      res->data  = (char *) (r>0);
475      break;
476    case LE:
477      res->data  = (char *) (r<=0);
478      break;
479    case GE:
480      res->data  = (char *) (r>=0);
481      break;
482    case EQUAL_EQUAL:
483    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
484      res->data  = (char *) (r==0);
485      break;
486  }
487  jjEQUAL_REST(res,u,v);
488  return r==-2;
489}
490static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
491{
492  intvec* a = (intvec * )(u->Data());
493  int     b = (int)(long)(v->Data());
494  int r=a->compare(b);
495  switch  (iiOp)
496  {
497    case '<':
498      res->data  = (char *) (r<0);
499      break;
500    case '>':
501      res->data  = (char *) (r>0);
502      break;
503    case LE:
504      res->data  = (char *) (r<=0);
505      break;
506    case GE:
507      res->data  = (char *) (r>=0);
508      break;
509    case EQUAL_EQUAL:
510    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
511      res->data  = (char *) (r==0);
512      break;
513  }
514  jjEQUAL_REST(res,u,v);
515  return FALSE;
516}
517static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
518{
519  poly p=(poly)u->Data();
520  poly q=(poly)v->Data();
521  int r=pCmp(p,q);
522  if (r==0)
523  {
524    /* compare lead coeffs */
525    number h=nSub(pGetCoeff(p),pGetCoeff(q));
526    r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
527    nDelete(&h);
528  }
529  else if (p==NULL)
530  {
531    if (q==NULL)
532    {
533      /* compare 0, 0 */
534      r=0;
535    }
536    else if(pIsConstant(q))
537    {
538      /* compare 0, const */
539      r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
540    }
541  }
542  else if (q==NULL)
543  {
544    if (pIsConstant(p))
545    {
546      /* compare const, 0 */
547      r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
548    }
549  }
550  switch  (iiOp)
551  {
552    case '<':
553      res->data  = (char *) (r < 0);
554      break;
555    case '>':
556      res->data  = (char *) (r > 0);
557      break;
558    case LE:
559      res->data  = (char *) (r <= 0);
560      break;
561    case GE:
562      res->data  = (char *) (r >= 0);
563      break;
564    //case EQUAL_EQUAL:
565    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
566    //  res->data  = (char *) (r == 0);
567    //  break;
568  }
569  jjEQUAL_REST(res,u,v);
570  return FALSE;
571}
572static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
573{
574  char*    a = (char * )(u->Data());
575  char*    b = (char * )(v->Data());
576  int result = strcmp(a,b);
577  switch  (iiOp)
578  {
579    case '<':
580      res->data  = (char *) (result  < 0);
581      break;
582    case '>':
583      res->data  = (char *) (result  > 0);
584      break;
585    case LE:
586      res->data  = (char *) (result  <= 0);
587      break;
588    case GE:
589      res->data  = (char *) (result  >= 0);
590      break;
591    case EQUAL_EQUAL:
592    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
593      res->data  = (char *) (result  == 0);
594      break;
595  }
596  jjEQUAL_REST(res,u,v);
597  return FALSE;
598}
599static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
600{
601  if (u->Next()!=NULL)
602  {
603    u=u->next;
604    res->next = (leftv)omAllocBin(sleftv_bin);
605    return iiExprArith2(res->next,u,iiOp,v);
606  }
607  else if (v->Next()!=NULL)
608  {
609    v=v->next;
610    res->next = (leftv)omAllocBin(sleftv_bin);
611    return iiExprArith2(res->next,u,iiOp,v);
612  }
613  return FALSE;
614}
615static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
616{
617  int b=(int)(long)u->Data();
618  int e=(int)(long)v->Data();
619  int rc = 1;
620  BOOLEAN overflow=FALSE;
621  if (e >= 0)
622  {
623    if (b==0)
624    {
625      rc=0;
626    }
627    else
628    {
629      int oldrc;
630      while ((e--)!=0)
631      {
632        oldrc=rc;
633        rc *= b;
634        if (!overflow)
635        {
636          if(rc/b!=oldrc) overflow=TRUE;
637        }
638      }
639      if (overflow)
640        WarnS("int overflow(^), result may be wrong");
641    }
642    res->data = (char *)rc;
643    if (u!=NULL) return jjOP_REST(res,u,v);
644    return FALSE;
645  }
646  else
647  {
648    WerrorS("exponent must be non-negative");
649    return TRUE;
650  }
651}
652static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
653{
654  int e=(int)(long)v->Data();
655  number n=(number)u->CopyD(NUMBER_CMD);
656  if (e<0)
657  {
658    number m=nInvers(n);
659    nDelete(&n);
660    n=m;
661    e=-e;
662  }
663  nPower(n,e,(number*)&res->data);
664  nDelete(&n);
665  if (u!=NULL) return jjOP_REST(res,u,v);
666  return FALSE;
667}
668static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
669{
670  res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)(long)v->Data());
671  if (u!=NULL) return jjOP_REST(res,u,v);
672  return FALSE;
673}
674static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
675{
676  res->data = (char *)idPower((ideal)(u->Data()),(int)(long)(v->Data()));
677  if (u!=NULL) return jjOP_REST(res,u,v);
678  return FALSE;
679}
680static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
681{
682  u=u->next;
683  v=v->next;
684  if (u==NULL)
685  {
686    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
687    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
688    {
689      do
690      {
691        if (res->next==NULL)
692          res->next = (leftv)omAlloc0Bin(sleftv_bin);
693        leftv tmp_v=v->next;
694        v->next=NULL;
695        BOOLEAN b=iiExprArith1(res->next,v,'-');
696        v->next=tmp_v;
697        if (b)
698          return TRUE;
699        v=tmp_v;
700        res=res->next;
701      } while (v!=NULL);
702      return FALSE;
703    }
704    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
705    {
706      res->next = (leftv)omAlloc0Bin(sleftv_bin);
707      res=res->next;
708      res->data = v->CopyD();
709      res->rtyp = v->Typ();
710      v=v->next;
711      if (v==NULL) return FALSE;
712    }
713  }
714  if (v!=NULL)                     /* u<>NULL, v<>NULL */
715  {
716    do
717    {
718      res->next = (leftv)omAlloc0Bin(sleftv_bin);
719      leftv tmp_u=u->next; u->next=NULL;
720      leftv tmp_v=v->next; v->next=NULL;
721      BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
722      u->next=tmp_u;
723      v->next=tmp_v;
724      if (b)
725        return TRUE;
726      u=tmp_u;
727      v=tmp_v;
728      res=res->next;
729    } while ((u!=NULL) && (v!=NULL));
730    return FALSE;
731  }
732  loop                             /* u<>NULL, v==NULL */
733  {
734    res->next = (leftv)omAlloc0Bin(sleftv_bin);
735    res=res->next;
736    res->data = u->CopyD();
737    res->rtyp = u->Typ();
738    u=u->next;
739    if (u==NULL) return FALSE;
740  }
741}
742static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
743{
744#ifdef HAVE_NS
745  idhdl packhdl;
746
747  switch(u->Typ())
748  {
749      case 0:
750        Print("%s of type 'ANY'. Trying load.\n", v->name);
751        if(iiTryLoadLib(u, u->name))
752        {
753          Werror("'%s' no such package", u->name);
754          return TRUE;
755        }
756        syMake(u,u->name,NULL);
757        // else: use next case !!! no break !!!
758
759      case PACKAGE_CMD:
760        packhdl = (idhdl)u->data;
761        if((!IDPACKAGE(packhdl)->loaded)
762        && (IDPACKAGE(packhdl)->language > LANG_TOP))
763        {
764          //if(iiReLoadLib(packhdl))
765          //  Werror("unable to reload package '%s'", IDID(packhdl));
766          Werror("'%s' not loaded", u->name);
767          return TRUE;
768        }
769        if(v->rtyp == IDHDL)
770        {
771          v->name = omStrDup(v->name);
772        }
773        v->req_packhdl=IDPACKAGE(packhdl);
774        v->packhdl=IDPACKAGE(packhdl);
775        syMake(v, v->name, packhdl);
776        memcpy(res, v, sizeof(sleftv));
777        memset(v, 0, sizeof(sleftv));
778        break;
779
780      case DEF_CMD:
781        break;
782
783      default:
784        WerrorS("<package>::<id> expected");
785        return TRUE;
786  }
787#else
788  WerrorS("package is not supported in this version");
789#endif /* HAVE_NS */
790  return FALSE;
791}
792static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
793{
794  unsigned int a=(unsigned int)(unsigned long)u->Data();
795  unsigned int b=(unsigned int)(unsigned long)v->Data();
796  unsigned int c=a+b;
797  res->data = (char *)c;
798  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
799  {
800    WarnS("int overflow(+), result may be wrong");
801  }
802  return jjPLUSMINUS_Gen(res,u,v);
803}
804static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
805{
806  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
807  return jjPLUSMINUS_Gen(res,u,v);
808}
809static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
810{
811  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
812  return jjPLUSMINUS_Gen(res,u,v);
813}
814static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
815{
816  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
817  if (res->data==NULL)
818  {
819     WerrorS("intmat size not compatible");
820     return TRUE;
821  }
822  return jjPLUSMINUS_Gen(res,u,v);
823}
824static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
825{
826  res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
827  if (res->data==NULL)
828  {
829     WerrorS("matrix size not compatible");
830     return TRUE;
831  }
832  return jjPLUSMINUS_Gen(res,u,v);
833}
834static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
835{
836  matrix m=(matrix)u->Data();
837  matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
838  if (iiOp=='+')
839    res->data = (char *)mpAdd(m , p);
840  else
841    res->data = (char *)mpSub(m , p);
842  idDelete((ideal *)&p);
843  return jjPLUSMINUS_Gen(res,u,v);
844}
845static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
846{
847  return jjPLUS_MA_P(res,v,u);
848}
849static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
850{
851  char*    a = (char * )(u->Data());
852  char*    b = (char * )(v->Data());
853  char*    r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
854  strcpy(r,a);
855  strcat(r,b);
856  res->data=r;
857  return jjPLUSMINUS_Gen(res,u,v);
858}
859static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
860{
861  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
862  return jjPLUSMINUS_Gen(res,u,v);
863}
864static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
865{
866  unsigned int a=(unsigned int)(unsigned long)u->Data();
867  unsigned int b=(unsigned int)(unsigned long)v->Data();
868  unsigned int c=a-b;
869  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
870  {
871    WarnS("int overflow(-), result may be wrong");
872  }
873  res->data = (char *)c;
874  return jjPLUSMINUS_Gen(res,u,v);
875}
876static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
877{
878  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
879  return jjPLUSMINUS_Gen(res,u,v);
880}
881static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
882{
883  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
884  return jjPLUSMINUS_Gen(res,u,v);
885}
886static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
887{
888  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
889  if (res->data==NULL)
890  {
891     WerrorS("intmat size not compatible");
892     return TRUE;
893  }
894  return jjPLUSMINUS_Gen(res,u,v);
895}
896static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
897{
898  res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
899  if (res->data==NULL)
900  {
901     WerrorS("matrix size not compatible");
902     return TRUE;
903  }
904  return jjPLUSMINUS_Gen(res,u,v);
905}
906static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
907{
908  int a=(int)(long)u->Data();
909  int b=(int)(long)v->Data();
910  int c=a * b;
911  if ((b!=0) && (c/b !=a))
912    WarnS("int overflow(*), result may be wrong");
913  res->data = (char *)c;
914  if ((u->Next()!=NULL) || (v->Next()!=NULL))
915    return jjOP_REST(res,u,v);
916  return FALSE;
917}
918static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
919{
920  res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
921  if ((v->next!=NULL) || (u->next!=NULL))
922    return jjOP_REST(res,u,v);
923  return FALSE;
924}
925static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
926{
927  poly a;
928  poly b;
929
930  if (v->next==NULL)
931  {
932    a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
933    if (u->next==NULL)
934    {
935      b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
936      res->data = (char *)(pMult( a, b));
937      return FALSE;
938    }
939    // u->next exists: copy v
940    b=pCopy((poly)v->Data());
941    res->data = (char *)(pMult( a, b));
942    return jjOP_REST(res,u,v);
943  }
944  // v->next exists: copy u
945  a=pCopy((poly)u->Data());
946  b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
947  res->data = (char *)(pMult( a, b));
948  return jjOP_REST(res,u,v);
949}
950static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
951{
952  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
953  if ((v->next!=NULL) || (u->next!=NULL))
954    return jjOP_REST(res,u,v);
955  return FALSE;
956}
957static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
958{
959  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
960  if (res->data==NULL)
961  {
962     WerrorS("intmat size not compatible");
963     return TRUE;
964  }
965  if ((v->next!=NULL) || (u->next!=NULL))
966    return jjOP_REST(res,u,v);
967  return FALSE;
968}
969static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
970{
971  poly p=(poly)v->CopyD(POLY_CMD);
972  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
973  ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
974  if (r>0) I->rank=r;
975  res->data = (char *)I;
976  return FALSE;
977}
978static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
979{
980  return jjTIMES_MA_P1(res,v,u);
981}
982static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
983{
984  number n=(number)v->CopyD(NUMBER_CMD);
985  poly p=pOne();
986  pSetCoeff(p,n);
987  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
988  return FALSE;
989}
990static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
991{
992  return jjTIMES_MA_N1(res,v,u);
993}
994static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
995{
996  res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data());
997  return FALSE;
998}
999static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1000{
1001  return jjTIMES_MA_I1(res,v,u);
1002}
1003static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1004{
1005  res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
1006  if (res->data==NULL)
1007  {
1008     WerrorS("matrix size not compatible");
1009     return TRUE;
1010  }
1011  if ((v->next!=NULL) || (u->next!=NULL))
1012    return jjOP_REST(res,u,v);
1013  return FALSE;
1014}
1015static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1016{
1017  res->data = (char *)((long)u->Data() >= (long)v->Data());
1018  return FALSE;
1019}
1020static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1021{
1022  number h=nSub((number)u->Data(),(number)v->Data());
1023  res->data = (char *) (nGreaterZero(h)||(nIsZero(h)));
1024  nDelete(&h);
1025  return FALSE;
1026}
1027static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1028{
1029  res->data = (char *)((long)u->Data()>(long)v->Data());
1030  return FALSE;
1031}
1032static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1033{
1034  number h=nSub((number)u->Data(),(number)v->Data());
1035  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1036  nDelete(&h);
1037  return FALSE;
1038}
1039static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1040{
1041  res->data = (char *)((long)u->Data() <= (long)v->Data());
1042  return FALSE;
1043}
1044static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1045{
1046  number h=nSub((number)v->Data(),(number)u->Data());
1047  res->data = (char *) (nGreaterZero(h)||nIsZero(h));
1048  nDelete(&h);
1049  return FALSE;
1050}
1051static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1052{
1053  res->data = (char *)((int)(long)u->Data() < (int)(long)v->Data());
1054  return FALSE;
1055}
1056static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1057{
1058  number h=nSub((number)v->Data(),(number)u->Data());
1059  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1060  nDelete(&h);
1061  return FALSE;
1062}
1063static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1064{
1065  int a= (int)(long)u->Data();
1066  int b= (int)(long)v->Data();
1067  if (b==0)
1068  {
1069    WerrorS(ii_div_by_0);
1070    return TRUE;
1071  }
1072  int bb=ABS(b);
1073  int c=a%bb;
1074  if(c<0) c+=bb;
1075  int r=0;
1076  switch (iiOp)
1077  {
1078    case INTMOD_CMD:
1079        r=c;            break;
1080    case '%':
1081        r= (a % b);     break;
1082    case INTDIV_CMD:
1083        r=((a-c) /b);   break;
1084    case '/':
1085        r= (a / b);     break;
1086  }
1087  res->data=(void *)r;
1088  return FALSE;
1089}
1090static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1091{
1092  number q=(number)v->Data();
1093  if (nIsZero(q))
1094  {
1095    WerrorS(ii_div_by_0);
1096    return TRUE;
1097  }
1098  q = nDiv((number)u->Data(),q);
1099  nNormalize(q);
1100  res->data = (char *)q;
1101  return FALSE;
1102}
1103static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1104{
1105  poly q=(poly)v->Data();
1106  if (q==NULL)
1107  {
1108    WerrorS(ii_div_by_0);
1109    return TRUE;
1110  }
1111  poly p=(poly)(u->Data());
1112  if (p==NULL)
1113  {
1114    res->data=NULL;
1115    return FALSE;
1116  }
1117  if (pNext(q)!=NULL)
1118  {
1119#ifdef HAVE_FACTORY
1120    if(pGetComp(p)==0)
1121    {
1122      res->data=(void*)(singclap_pdivide(p /*(poly)(u->Data())*/ ,
1123                                         q /*(poly)(v->Data())*/ ));
1124    }
1125    else
1126    {
1127      int comps=pMaxComp(p);
1128      ideal I=idInit(comps,1);
1129      p=pCopy(p);
1130      poly h;
1131      int i;
1132      // conversion to a list of polys:
1133      while (p!=NULL)
1134      {
1135        i=pGetComp(p)-1;
1136        h=pNext(p);
1137        pNext(p)=NULL;
1138        pSetComp(p,0);
1139        I->m[i]=pAdd(I->m[i],p);
1140        p=h;
1141      }
1142      // division and conversion to vector:
1143      h=NULL;
1144      p=NULL;
1145      for(i=comps-1;i>=0;i--)
1146      {
1147        if (I->m[i]!=NULL)
1148        {
1149          h=singclap_pdivide(I->m[i],q);
1150          pSetCompP(h,i+1);
1151          p=pAdd(p,h);
1152        }
1153      }
1154      idDelete(&I);
1155      res->data=(void *)p;
1156    }
1157#else
1158    WerrorS("division only by a monomial");
1159    return TRUE;
1160#endif
1161  }
1162  else
1163  {
1164    res->data = (char *)pDivideM(pCopy(p),pHead(q));
1165  }
1166  return FALSE;
1167}
1168static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1169{
1170  poly q=(poly)v->Data();
1171  if (q==NULL)
1172  {
1173    WerrorS(ii_div_by_0);
1174    return TRUE;
1175  }
1176  matrix m=(matrix)(u->Data());
1177  int r=m->rows();
1178  int c=m->cols();
1179  matrix mm=mpNew(r,c);
1180  int i,j;
1181  for(i=r;i>0;i--)
1182  {
1183    for(j=c;j>0;j--)
1184    {
1185      if (pNext(q)!=NULL)
1186      {
1187      #ifdef HAVE_FACTORY
1188        MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1189                                           q /*(poly)(v->Data())*/ );
1190      #else
1191        WerrorS("division only by a monomial");
1192        return TRUE;
1193      #endif
1194      }
1195      else
1196        MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1197    }
1198  }
1199  res->data=(char *)mm;
1200  return FALSE;
1201}
1202static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1203{
1204  res->data = (char *)((int)(long)u->Data() == (int)(long)v->Data());
1205  jjEQUAL_REST(res,u,v);
1206  return FALSE;
1207}
1208static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1209{
1210  res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
1211  jjEQUAL_REST(res,u,v);
1212  return FALSE;
1213}
1214static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1215{
1216  res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
1217  jjEQUAL_REST(res,u,v);
1218  return FALSE;
1219}
1220static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1221{
1222  poly p=(poly)u->Data();
1223  poly q=(poly)v->Data();
1224  if (p==NULL)
1225  {
1226    res->data=(char *)(q==NULL);
1227  }
1228  else
1229  {
1230    if (q==NULL) res->data=(char *)FALSE;
1231    else
1232    {
1233      int r=pCmp(p,q);
1234      if (r==0)
1235      {
1236        p=pSub(pCopy(p),pCopy(q));
1237        res->data = (char *) (p==NULL);
1238        pDelete(&p);
1239      }
1240      else
1241        res->data = (char *) FALSE;
1242    }
1243  }
1244  jjEQUAL_REST(res,u,v);
1245  return FALSE;
1246}
1247static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1248{
1249  res->data = (char *)((long)u->Data() && (long)v->Data());
1250  return FALSE;
1251}
1252static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1253{
1254  res->data = (char *)((long)u->Data() || (long)v->Data());
1255  return FALSE;
1256}
1257static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1258{
1259  res->rtyp=u->rtyp; u->rtyp=0;
1260  res->data=u->data; u->data=NULL;
1261  res->name=u->name; u->name=NULL;
1262  res->e=u->e;       u->e=NULL;
1263  if (res->e==NULL) res->e=jjMakeSub(v);
1264  else
1265  {
1266    Subexpr sh=res->e;
1267    while (sh->next != NULL) sh=sh->next;
1268    sh->next=jjMakeSub(v);
1269  }
1270  return FALSE;
1271}
1272static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1273{
1274  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1275  {
1276    WerrorS("indexed object must have a name");
1277    return TRUE;
1278  }
1279  intvec * iv=(intvec *)v->Data();
1280  leftv p=NULL;
1281  int i;
1282  sleftv t;
1283
1284  memset(&t,0,sizeof(t));
1285  t.rtyp=INT_CMD;
1286  for (i=0;i<iv->length(); i++)
1287  {
1288    t.data=(char *)(*iv)[i];
1289    if (p==NULL)
1290    {
1291      p=res;
1292    }
1293    else
1294    {
1295      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1296      p=p->next;
1297    }
1298    p->rtyp=IDHDL;
1299    p->data=u->data;
1300    p->name=u->name;
1301    p->flag|=u->flag;
1302    p->e=jjMakeSub(&t);
1303  }
1304  u->rtyp=0;
1305  u->data=NULL;
1306  u->name=NULL;
1307  return FALSE;
1308}
1309static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1310{
1311  poly p=(poly)u->Data();
1312  int i=(int)(long)v->Data();
1313  int j=0;
1314  while (p!=NULL)
1315  {
1316    j++;
1317    if (j==i)
1318    {
1319      res->data=(char *)pHead(p);
1320      return FALSE;
1321    }
1322    pIter(p);
1323  }
1324  return FALSE;
1325}
1326static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1327{
1328  poly p=(poly)u->Data();
1329  poly r=NULL;
1330  intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1331  int i;
1332  int sum=0;
1333  for(i=iv->length()-1;i>=0;i--)
1334    sum+=(*iv)[i];
1335  int j=0;
1336  while ((p!=NULL) && (sum>0))
1337  {
1338    j++;
1339    for(i=iv->length()-1;i>=0;i--)
1340    {
1341      if (j==(*iv)[i])
1342      {
1343        r=pAdd(r,pHead(p));
1344        sum-=j;
1345        (*iv)[i]=0;
1346        break;
1347      }
1348    }
1349    pIter(p);
1350  }
1351  delete iv;
1352  res->data=(char *)r;
1353  return FALSE;
1354}
1355static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1356{
1357  poly p=(poly)u->CopyD(VECTOR_CMD);
1358  poly r=p; // pointer to the beginning of component i
1359  poly o=NULL;
1360  int i=(int)(long)v->Data();
1361  while (p!=NULL)
1362  {
1363    if (pGetComp(p)!=i)
1364    {
1365      if (r==p) r=pNext(p);
1366      if (o!=NULL)
1367      {
1368        pDeleteLm(&pNext(o));
1369        p=pNext(o);
1370      }
1371      else
1372        pDeleteLm(&p);
1373    }
1374    else
1375    {
1376      pSetComp(p, 0);
1377      o=p;
1378      p=pNext(o);
1379    }
1380  }
1381  res->data=(char *)r;
1382  return FALSE;
1383}
1384static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1385{
1386  poly p=(poly)u->CopyD(VECTOR_CMD);
1387  if (p!=NULL)
1388  {
1389    poly r=pOne();
1390    poly hp=r;
1391    intvec *iv=(intvec *)v->Data();
1392    int i;
1393    loop
1394    {
1395      for(i=0;i<iv->length();i++)
1396      {
1397        if (pGetComp(p)==(*iv)[i])
1398        {
1399          poly h;
1400          pSplit(p,&h);
1401          pNext(hp)=p;
1402          p=h;
1403          pIter(hp);
1404          break;
1405        }
1406      }
1407      if (p==NULL) break;
1408      if (i==iv->length())
1409      {
1410        pDeleteLm(&p);
1411        if (p==NULL) break;
1412      }
1413    }
1414    pDeleteLm(&r);
1415    res->data=(char *)r;
1416  }
1417  return FALSE;
1418}
1419static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1420{
1421  if(u->name==NULL) return TRUE;
1422  char * nn = (char *)omAlloc(strlen(u->name) + 14);
1423  sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1424  omFree((ADDRESS)u->name);
1425  u->name=NULL;
1426  char *n=omStrDup(nn);
1427  omFree((ADDRESS)nn);
1428  syMake(res,n);
1429  return FALSE;
1430}
1431static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1432{
1433  intvec * iv=(intvec *)v->Data();
1434  leftv p=NULL;
1435  int i;
1436  int slen = strlen(u->name) + 14;
1437  char *n = (char*) omAlloc(slen);
1438
1439  for (i=0;i<iv->length(); i++)
1440  {
1441    if (p==NULL)
1442    {
1443      p=res;
1444    }
1445    else
1446    {
1447      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1448      p=p->next;
1449    }
1450    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1451    syMake(p,omStrDup(n));
1452  }
1453  omFree((ADDRESS)u->name);
1454  u->name = NULL;
1455  omFreeSize(n, slen);
1456  return FALSE;
1457}
1458static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1459{
1460  idrec tmp_proc;
1461  Subexpr e;
1462  void *d;
1463  int typ;
1464  BOOLEAN t=FALSE;
1465  if (u->rtyp!=IDHDL)
1466  {
1467    tmp_proc.id="_auto";
1468    tmp_proc.typ=PROC_CMD;
1469    tmp_proc.data.pinf=(procinfo *)u->Data();
1470    tmp_proc.ref=1;
1471    d=u->data; u->data=(void *)&tmp_proc;
1472    e=u->e; u->e=NULL;
1473    t=TRUE;
1474    typ=u->rtyp; u->rtyp=IDHDL;
1475  }
1476#ifdef HAVE_NS
1477  leftv sl;
1478  if (u->req_packhdl==currPack)
1479    sl = iiMake_proc((idhdl)u->data,NULL,v);
1480  else
1481    sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1482#else /* HAVE_NS */
1483  leftv sl = iiMake_proc((idhdl)u->data,v);
1484#endif /* HAVE_NS */
1485  if (t)
1486  {
1487    u->rtyp=typ;
1488    u->data=d;
1489    u->e=e;
1490  }
1491  if (sl==NULL)
1492  {
1493    return TRUE;
1494  }
1495  else
1496  {
1497    memcpy(res,sl,sizeof(sleftv));
1498  }
1499  return FALSE;
1500}
1501static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1502{
1503  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1504  leftv sl=NULL;
1505  if ((v->e==NULL)&&(v->name!=NULL))
1506  {
1507    map m=(map)u->Data();
1508    sl=iiMap(m,v->name);
1509  }
1510  else
1511  {
1512    Werror("%s(<name>) expected",u->Name());
1513  }
1514  if (sl==NULL) return TRUE;
1515  memcpy(res,sl,sizeof(sleftv));
1516  omFreeBin((ADDRESS)sl, sleftv_bin);
1517  return FALSE;
1518}
1519static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1520{
1521  u->next=(leftv)omAllocBin(sleftv_bin);
1522  memcpy(u->next,v,sizeof(sleftv));
1523  BOOLEAN r=iiExprArithM(res,u,iiOp);
1524  // iiExprArithM did the CleanUp
1525  return r;
1526}
1527static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1528{
1529  poly p=(poly)v->Data();
1530  if ((p==NULL)||(pNext(p)!=NULL)) return TRUE;
1531  res->data=(char *)mpCoeffProc((poly)u->Data(),p /*(poly)v->Data()*/);
1532  return FALSE;
1533}
1534static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1535{
1536  int i=pVar((poly)v->Data());
1537  if (i==0)
1538  {
1539    WerrorS("ringvar expected");
1540    return TRUE;
1541  }
1542  res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1543  return FALSE;
1544}
1545static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1546{
1547  poly p = pInit();
1548  int i;
1549
1550  for (i=1; i<=pVariables; i++)
1551  {
1552    pSetExp(p, i, 1);
1553  }
1554  pSetm(p);
1555  res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1556                                    (ideal)(v->Data()), p);
1557  pDelete(&p);
1558  return FALSE;
1559}
1560static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1561{
1562  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1563  return FALSE;
1564}
1565static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1566{
1567  short *iv=iv2array((intvec *)v->Data());
1568  ideal I=(ideal)u->Data();
1569  int d=-1;
1570  int i;
1571  for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)pDegW(I->m[i],iv));
1572  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1573  res->data = (char *)d;
1574  return FALSE;
1575}
1576static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1577{
1578  short *iv=iv2array((intvec *)v->Data());
1579  res->data = (char *)pDegW((poly)u->Data(),iv);
1580  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1581  return FALSE;
1582}
1583static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1584{
1585  int i=pVar((poly)v->Data());
1586  if (i==0)
1587  {
1588    WerrorS("ringvar expected");
1589    return TRUE;
1590  }
1591  res->data=(char *)pDiff((poly)(u->Data()),i);
1592  return FALSE;
1593}
1594static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1595{
1596  int i=pVar((poly)v->Data());
1597  if (i==0)
1598  {
1599    WerrorS("ringvar expected");
1600    return TRUE;
1601  }
1602  res->data=(char *)idDiff((matrix)(u->Data()),i);
1603  return FALSE;
1604}
1605static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1606{
1607  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1608  return FALSE;
1609}
1610static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1611{
1612  assumeStdFlag(v);
1613  if(currQuotient==NULL)
1614    res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1615  else
1616  {
1617    ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1618    res->data = (char *)scDimInt((ideal)(v->Data()),q);
1619    idDelete(&q);
1620  }
1621  return FALSE;
1622}
1623static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1624{
1625  ideal vi=(ideal)v->Data();
1626  int vl= IDELEMS(vi);
1627  ideal ui=(ideal)u->Data();
1628  int ul= IDELEMS(ui);
1629  ideal R; matrix U;
1630  ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1631  // now make sure that all matices have the corect size:
1632  matrix T = idModule2formatedMatrix(m,vl,ul);
1633  if (MATCOLS(U) != ul)
1634  {
1635    int mul=si_min(ul,MATCOLS(U));
1636    matrix UU=mpNew(ul,ul);
1637    int i,j;
1638    for(i=mul;i>0;i--)
1639    {
1640      for(j=mul;j>0;j--)
1641      {
1642        MATELEM(UU,i,j)=MATELEM(U,i,j);
1643        MATELEM(U,i,j)=NULL;
1644      }
1645    }
1646    idDelete((ideal *)&U);
1647    U=UU;
1648  }
1649  lists L=(lists)omAllocBin(slists_bin);
1650  L->Init(3);
1651  L->m[0].rtyp=MATRIX_CMD;   L->m[0].data=(void *)T;
1652  L->m[1].rtyp=u->Typ();     L->m[1].data=(void *)R;
1653  L->m[2].rtyp=MATRIX_CMD;   L->m[2].data=(void *)U;
1654  res->data=(char *)L;
1655  return FALSE;
1656}
1657static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1658{
1659  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1660  setFlag(res,FLAG_STD);
1661  return FALSE;
1662}
1663static BOOLEAN jjEXPORTTO(leftv res, leftv u, leftv v)
1664{
1665  //Print("exportto %s -> %s\n",v->Name(),u->Name() );
1666  return iiExport(v,0,(idhdl)u->data);
1667}
1668static BOOLEAN jjERROR(leftv res, leftv u)
1669{
1670  WerrorS((char *)u->Data());
1671  return TRUE;
1672}
1673static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1674{
1675  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1676  int p0=ABS(uu),p1=ABS(vv);
1677  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1678
1679  while ( p1!=0 )
1680  {
1681    q=p0 / p1;
1682    r=p0 % p1;
1683    p0 = p1; p1 = r;
1684    r = g0 - g1 * q;
1685    g0 = g1; g1 = r;
1686    r = f0 - f1 * q;
1687    f0 = f1; f1 = r;
1688  }
1689  int a = f0;
1690  int b = g0;
1691  if ( uu /*(int)(long)u->Data()*/ < 0 ) a=-a;
1692  if ( vv /*(int)(long)v->Data()*/ < 0 ) b=-b;
1693  lists L=(lists)omAllocBin(slists_bin);
1694  L->Init(3);
1695  L->m[0].rtyp=INT_CMD;   L->m[0].data=(void *)p0;
1696  L->m[1].rtyp=INT_CMD;   L->m[1].data=(void *)a;
1697  L->m[2].rtyp=INT_CMD;   L->m[2].data=(void *)b;
1698  res->rtyp=LIST_CMD;
1699  res->data=(char *)L;
1700  return FALSE;
1701}
1702#ifdef HAVE_FACTORY
1703static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1704{
1705  poly r,pa,pb;
1706  BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1707  if (ret) return TRUE;
1708  lists L=(lists)omAllocBin(slists_bin);
1709  L->Init(3);
1710  res->data=(char *)L;
1711  L->m[0].data=(void *)r;
1712  L->m[0].rtyp=POLY_CMD;
1713  L->m[1].data=(void *)pa;
1714  L->m[1].rtyp=POLY_CMD;
1715  L->m[2].data=(void *)pb;
1716  L->m[2].rtyp=POLY_CMD;
1717  return FALSE;
1718}
1719static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1720{
1721  ideal_list p,h;
1722  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
1723  p=h;
1724  int l=0;
1725  while (p!=NULL) { p=p->next;l++; }
1726  lists L=(lists)omAllocBin(slists_bin);
1727  L->Init(l);
1728  l=0;
1729  while(h!=NULL)
1730  {
1731    L->m[l].data=(char *)h->d;
1732    L->m[l].rtyp=IDEAL_CMD;
1733    p=h->next;
1734    omFreeSize(h,sizeof(*h));
1735    h=p;
1736    l++;
1737  }
1738  res->data=(void *)L;
1739  return FALSE;
1740}
1741#endif
1742static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1743{
1744  ring r=(ring)u->Data();
1745  idhdl w;
1746  int op=iiOp;
1747  nMapFunc nMap;
1748
1749  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1750  {
1751    int *perm=NULL;
1752    int *par_perm=NULL;
1753    int par_perm_size=0;
1754    BOOLEAN bo;
1755    //if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1756    if ((nMap=nSetMap(r))==NULL)
1757    {
1758      if (rEqual(r,currRing))
1759      {
1760        nMap=nCopy;
1761      }
1762      else
1763      // Allow imap/fetch to be make an exception only for:
1764      if ( (rField_is_Q_a(r) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
1765            (rField_is_Q() || rField_is_Q_a() ||
1766             (rField_is_Zp() || rField_is_Zp_a())))
1767           ||
1768           (rField_is_Zp_a(r) &&  // Zp(a..) -> Zp(a..) || Zp
1769            (rField_is_Zp(currRing, rInternalChar(r)) ||
1770             rField_is_Zp_a(currRing, rInternalChar(r)))) )
1771      {
1772        par_perm_size=rPar(r);
1773        BITSET save_test=test;
1774        naSetChar(rInternalChar(r),r);
1775        nSetChar(currRing);
1776        test=save_test;
1777      }
1778      else
1779      {
1780        goto err_fetch;
1781      }
1782    }
1783    if ((iiOp!=FETCH_CMD) || (r->N!=pVariables) || (rPar(r)!=rPar(currRing)))
1784    {
1785      perm=(int *)omAlloc0((r->N+1)*sizeof(int));
1786      if (par_perm_size!=0)
1787        par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
1788      op=IMAP_CMD;
1789      if (iiOp==IMAP_CMD)
1790      {
1791        maFindPerm(r->names,       r->N,       r->parameter,        r->P,
1792                   currRing->names,currRing->N,currRing->parameter, currRing->P,
1793                   perm,par_perm, currRing->ch);
1794      }
1795      else
1796      {
1797        int i;
1798        if (par_perm_size!=0)
1799          for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
1800        for(i=si_min(r->N,pVariables);i>0;i--) perm[i]=i;
1801      }
1802    }
1803    if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1804    {
1805      int i;
1806      for(i=0;i<si_min(r->N,pVariables);i++)
1807      {
1808        Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
1809      }
1810      for(i=0;i<si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
1811      {
1812        Print("// par nr %d: %s -> %s\n",
1813              i,r->parameter[i],currRing->parameter[i]);
1814      }
1815    }
1816    sleftv tmpW;
1817    memset(&tmpW,0,sizeof(sleftv));
1818    tmpW.rtyp=IDTYP(w);
1819    tmpW.data=IDDATA(w);
1820    if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1821                         perm,par_perm,par_perm_size,nMap)))
1822    {
1823      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1824    }
1825    if (perm!=NULL)
1826      omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
1827    if (par_perm!=NULL)
1828      omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
1829    return bo;
1830  }
1831  else
1832  {
1833    Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1834  }
1835  return TRUE;
1836err_fetch:
1837  Werror("no identity map from %s",u->Fullname());
1838  return TRUE;
1839}
1840static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1841{
1842  /*4
1843  * look for the substring what in the string where
1844  * return the position of the first char of what in where
1845  * or 0
1846  */
1847  char *where=(char *)u->Data();
1848  char *what=(char *)v->Data();
1849  char *found = strstr(where,what);
1850  if (found != NULL)
1851  {
1852    res->data=(char *)((found-where)+1);
1853  }
1854  /*else res->data=NULL;*/
1855  return FALSE;
1856}
1857static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
1858{
1859  res->data=(char *)fractalWalkProc(u,v);
1860  setFlag( res, FLAG_STD );
1861  return FALSE;
1862}
1863static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1864{
1865  int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1866  int p0=ABS(uu),p1=ABS(vv);
1867  int r;
1868
1869  while ( p1!=0 )
1870  {
1871    r=p0 % p1;
1872    p0 = p1; p1 = r;
1873  }
1874  res->rtyp=INT_CMD;
1875  res->data=(char *)p0;
1876  return FALSE;
1877}
1878static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
1879{
1880  number a=(number) u->Data();
1881  number b=(number) v->Data();
1882  if (nIsZero(a))
1883  {
1884    if (nIsZero(b)) res->data=(char *)nInit(1);
1885    else            res->data=(char *)nCopy(b);
1886  }
1887  else
1888  {
1889    if (nIsZero(b))  res->data=(char *)nCopy(a);
1890    else res->data=(char *)nGcd(a, b, currRing);
1891  }
1892  return FALSE;
1893}
1894#ifdef HAVE_FACTORY
1895static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
1896{
1897  res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
1898                                 (poly)(v->CopyD(POLY_CMD)));
1899  return FALSE;
1900}
1901#endif
1902static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1903{
1904  assumeStdFlag(u);
1905  intvec *module_w=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
1906  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1907  switch((int)(long)v->Data())
1908  {
1909    case 1:
1910      res->data=(void *)iv;
1911      return FALSE;
1912    case 2:
1913      res->data=(void *)hSecondSeries(iv);
1914      delete iv;
1915      return FALSE;
1916  }
1917  WerrorS(feNotImplemented);
1918  delete iv;
1919  return TRUE;
1920}
1921static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1922{
1923  int i=pVar((poly)v->Data());
1924  if (i==0)
1925  {
1926    WerrorS("ringvar expected");
1927    return TRUE;
1928  }
1929  res->data = (char *)pHomogen((poly)u->Data(),i);
1930  return FALSE;
1931}
1932static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1933{
1934  int i=pVar((poly)v->Data());
1935  if (i==0)
1936  {
1937    WerrorS("ringvar expected");
1938    return TRUE;
1939  }
1940  res->data = (char *)idHomogen((ideal)u->Data(),i);
1941  return FALSE;
1942}
1943static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1944{
1945  assumeStdFlag(u);
1946  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
1947                    currQuotient);
1948  return FALSE;
1949}
1950static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1951{
1952  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1953  setFlag(res,FLAG_STD);
1954  return FALSE;
1955}
1956static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
1957{
1958  return jjStdJanetBasis(res,u,(int)(long)v->Data());
1959}
1960static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1961{
1962  res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
1963  return FALSE;
1964}
1965static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1966{
1967  res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
1968  return FALSE;
1969}
1970static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1971{
1972  assumeStdFlag(u);
1973  res->data = (char *)scKBase((int)(long)v->Data(),
1974                              (ideal)(u->Data()),currQuotient);
1975  return FALSE;
1976}
1977static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1978{
1979  return mpKoszul(res, u,v);
1980}
1981static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1982{
1983  sleftv h;
1984  memset(&h,0,sizeof(sleftv));
1985  h.rtyp=INT_CMD;
1986  h.data=(void *)IDELEMS((ideal)v->Data());
1987  return mpKoszul(res, u, &h, v);
1988}
1989static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1990{
1991  ideal m;
1992  BITSET save_test=test;
1993  int ul= IDELEMS((ideal)u->Data());
1994  int vl= IDELEMS((ideal)v->Data());
1995  m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
1996  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1997  test=save_test;
1998  return FALSE;
1999}
2000static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2001{
2002  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
2003  idhdl h=(idhdl)v->data;
2004  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2005  res->data = (char *)idLiftStd((ideal)u->Data(),
2006                                &(h->data.umatrix),testHomog);
2007  setFlag(res,FLAG_STD);
2008  return FALSE;
2009}
2010static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2011{
2012  res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2013  return (res->data==NULL);
2014}
2015static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2016{
2017  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2018  tHomog hom=testHomog;
2019  if (w_u!=NULL)
2020  {
2021    w_u=ivCopy(w_u);
2022    hom=isHomog;
2023  }
2024  intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2025  if (w_v!=NULL)
2026  {
2027    w_v=ivCopy(w_v);
2028    hom=isHomog;
2029  }
2030  if ((w_u!=NULL) && (w_v==NULL))
2031    w_v=ivCopy(w_u);
2032  if ((w_v!=NULL) && (w_u==NULL))
2033    w_u=ivCopy(w_v);
2034  ideal u_id=(ideal)u->Data();
2035  ideal v_id=(ideal)v->Data();
2036  if (w_u!=NULL)
2037  {
2038     if ((*w_u).compare((w_v))!=0)
2039     {
2040       WarnS("incompatible weights");
2041       delete w_u; w_u=NULL;
2042       hom=testHomog;
2043     }
2044     else
2045     {
2046       if ((!idHomModule(u_id,currQuotient,&w_v))
2047       || (!idHomModule(v_id,currQuotient,&w_v)))
2048       {
2049         WarnS("wrong weights");
2050         delete w_u; w_u=NULL;
2051         hom=testHomog;
2052       }
2053     }
2054  }
2055  res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2056  if (w_u!=NULL)
2057  {
2058    atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2059  }
2060  delete w_v;
2061  return FALSE;
2062}
2063static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2064{
2065  number q=(number)v->Data();
2066  if (nIsZero(q))
2067  {
2068    WerrorS(ii_div_by_0);
2069    return TRUE;
2070  }
2071  res->data =(char *) nIntMod((number)u->Data(),q);
2072  return FALSE;
2073}
2074static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2075{
2076  char *opt=(char *)v->Data();
2077  int mode=0;
2078  while(*opt!='\0')
2079  {
2080    if (*opt=='i') mode |= PROT_I;
2081    else if (*opt=='o') mode |= PROT_O;
2082    opt++;
2083  }
2084  monitor((char *)(u->Data()),mode);
2085  return FALSE;
2086}
2087static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2088{
2089  idhdl h=(idhdl)u->data;
2090  int i=(int)(long)v->Data();
2091  int p=0;
2092  if ((0<i)
2093  && (IDRING(h)->parameter!=NULL)
2094  && (i<=(p=rPar(IDRING(h)))))
2095    res->data=omStrDup(IDRING(h)->parameter[i-1]);
2096  else
2097  {
2098    Werror("par number %d out of range 1..%d",i,p);
2099    return TRUE;
2100  }
2101  return FALSE;
2102}
2103
2104#ifdef HAVE_PLURAL
2105static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2106{
2107  return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2108}
2109
2110static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2111{
2112  return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2113}
2114
2115static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2116{
2117  return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2118}
2119
2120static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2121{
2122  return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2123}
2124
2125static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2126{
2127  if (rIsPluralRing(currRing))
2128  {
2129    poly p = (poly)a->CopyD(POLY_CMD);
2130    poly q = (poly)b->Data();
2131    res->data = nc_p_Bracket_qq(p,q);
2132  }
2133  else res->data=NULL;
2134  return FALSE;
2135}
2136
2137static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2138{
2139  /* number, poly, vector, ideal, module, matrix */
2140  ring  r = (ring)a->Data();
2141  if (r == currRing)
2142  {
2143    res->data = b->Data();
2144    res->rtyp = b->rtyp;
2145    return FALSE;
2146  }
2147  if (!rIsLikeOpposite(currRing, r))
2148  {
2149    Werror("%s is not an opposite ring to current ring",a->Fullname());
2150    return TRUE;
2151  }
2152  idhdl w;
2153  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2154  {
2155    int argtype = IDTYP(w);
2156    switch (argtype)
2157    {
2158    case NUMBER_CMD:
2159      {
2160        /* since basefields are equal, we can apply nCopy */
2161        res->data = nCopy((number)IDDATA(w));
2162        res->rtyp = argtype;
2163        break;
2164      }
2165    case POLY_CMD:
2166    case VECTOR_CMD:
2167      {
2168        poly    q = (poly)IDDATA(w);
2169        res->data = pOppose(r,q);
2170        res->rtyp = argtype;
2171        break;
2172      }
2173    case IDEAL_CMD:
2174    case MODUL_CMD:
2175      {
2176        ideal   Q = (ideal)IDDATA(w);
2177        res->data = idOppose(r,Q);
2178        res->rtyp = argtype;
2179        break;
2180      }
2181    case MATRIX_CMD:
2182      {
2183        ring save = currRing;
2184        rChangeCurrRing(r);
2185        matrix  m = (matrix)IDDATA(w);
2186        ideal   Q = idMatrix2Module(mpCopy(m));
2187        rChangeCurrRing(save);
2188        ideal   S = idOppose(r,Q);
2189        id_Delete(&Q, r);
2190        res->data = idModule2Matrix(S);
2191        res->rtyp = argtype;
2192        break;
2193      }
2194    default:
2195      {
2196        WerrorS("unsupported type in oppose");
2197        return TRUE;
2198      }
2199    }
2200  }
2201  else
2202  {
2203    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2204    return TRUE;
2205  }
2206  return FALSE;
2207}
2208#endif /* HAVE_PLURAL */
2209
2210static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2211{
2212  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2213    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2214  idDelMultiples((ideal)(res->data));
2215  return FALSE;
2216}
2217static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2218{
2219  int i=(int)(long)u->Data();
2220  int j=(int)(long)v->Data();
2221#ifdef buildin_rand
2222  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
2223#else
2224  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
2225#endif
2226  return FALSE;
2227}
2228static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2229{
2230  si_link l=(si_link)u->Data();
2231  leftv r=slRead(l,v);
2232  if (r==NULL)
2233  {
2234    const char *s;
2235    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2236    else                            s=sNoName;
2237    Werror("cannot read from `%s`",s);
2238    return TRUE;
2239  }
2240  memcpy(res,r,sizeof(sleftv));
2241  omFreeBin((ADDRESS)r, sleftv_bin);
2242  return FALSE;
2243}
2244static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2245{
2246  assumeStdFlag(v);
2247  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2248  return FALSE;
2249}
2250static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2251{
2252  assumeStdFlag(v);
2253  ideal ui=(ideal)u->Data();
2254  idTest(ui);
2255  ideal vi=(ideal)v->Data();
2256  idTest(vi);
2257  res->data = (char *)kNF(vi,currQuotient,ui);
2258  return FALSE;
2259}
2260#if 0
2261static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2262{
2263  int maxl=(int)(long)v->Data();
2264  if (maxl<0)
2265  {
2266    WerrorS("length for res must not be negative");
2267    return TRUE;
2268  }
2269  int l=0;
2270  //resolvente r;
2271  syStrategy r;
2272  intvec *weights=NULL;
2273  int wmaxl=maxl;
2274  ideal u_id=(ideal)u->Data();
2275
2276  maxl--;
2277  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2278  {
2279    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2280    if (currQuotient!=NULL)
2281    {
2282      Warn(
2283      "full resolution in a qring may be infinite, setting max length to %d",
2284      maxl+1);
2285    }
2286  }
2287  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2288  if (weights!=NULL)
2289  {
2290    if (!idTestHomModule(u_id,currQuotient,weights))
2291    {
2292      WarnS("wrong weights given:");weights->show();PrintLn();
2293      weights=NULL;
2294    }
2295  }
2296
2297  intvec *ww=NULL;
2298  int add_row_shift=0;
2299  if (weights!=NULL)
2300  {
2301     ww=ivCopy(weights);
2302     add_row_shift = ww->min_in();
2303     (*ww) -= add_row_shift;
2304  }
2305  else
2306    idHomModule(u_id,currQuotient,&ww);
2307  weights=ww;
2308
2309  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2310  {
2311    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2312  }
2313  else if (iiOp==SRES_CMD)
2314  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2315    r=sySchreyer(u_id,maxl+1);
2316  else if (iiOp == LRES_CMD)
2317  {
2318    int dummy;
2319    if((currQuotient!=NULL)||
2320    (!idHomIdeal (u_id,NULL)))
2321    {
2322       WerrorS
2323       ("`lres` not implemented for inhomogeneous input or qring");
2324       return TRUE;
2325    }
2326    r=syLaScala3(u_id,&dummy);
2327  }
2328  else if (iiOp == KRES_CMD)
2329  {
2330    int dummy;
2331    if((currQuotient!=NULL)||
2332    (!idHomIdeal (u_id,NULL)))
2333    {
2334       WerrorS
2335       ("`kres` not implemented for inhomogeneous input or qring");
2336       return TRUE;
2337    }
2338    r=syKosz(u_id,&dummy);
2339  }
2340  else
2341  {
2342    int dummy;
2343    if((currQuotient!=NULL)||
2344    (!idHomIdeal (u_id,NULL)))
2345    {
2346       WerrorS
2347       ("`hres` not implemented for inhomogeneous input or qring");
2348       return TRUE;
2349    }
2350    r=syHilb(u_id,&dummy);
2351  }
2352  if (r==NULL) return TRUE;
2353  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2354  r->list_length=wmaxl;
2355  res->data=(void *)r;
2356  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2357  {
2358    intvec *w=ivCopy(r->weights[0]);
2359    if (weights!=NULL) (*w) += add_row_shift;
2360    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2361    delete w;
2362  }
2363  else
2364  {
2365//#if 0
2366// need to set weights for ALL components (sres)
2367    if (weights!=NULL)
2368    {
2369      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2370      r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2371      (r->weights)[0] = ivCopy(weights);
2372    }
2373//#endif
2374  }
2375  if (ww!=NULL) { delete ww; ww=NULL; }
2376  return FALSE;
2377}
2378#else
2379static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2380{
2381  int maxl=(int)(long)v->Data();
2382  if (maxl<0)
2383  {
2384    WerrorS("length for res must not be negative");
2385    return TRUE;
2386  }
2387  int l=0;
2388  //resolvente r;
2389  syStrategy r;
2390  intvec *weights=NULL;
2391  int wmaxl=maxl;
2392  ideal u_id=(ideal)u->Data();
2393
2394  maxl--;
2395  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2396  {
2397    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2398    if (currQuotient!=NULL)
2399    {
2400      Warn(
2401      "full resolution in a qring may be infinite, setting max length to %d",
2402      maxl+1);
2403    }
2404  }
2405  weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2406  if (weights!=NULL)
2407  {
2408    if (!idTestHomModule(u_id,currQuotient,weights))
2409    {
2410      WarnS("wrong weights given:");weights->show();PrintLn();
2411      weights=NULL;
2412    }
2413  }
2414  intvec *ww=NULL;
2415  int add_row_shift=0;
2416  if (weights!=NULL)
2417  {
2418     ww=ivCopy(weights);
2419     add_row_shift = ww->min_in();
2420     (*ww) -= add_row_shift;
2421  }
2422
2423  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2424  {
2425    r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2426  }
2427  else if (iiOp==SRES_CMD)
2428  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2429    r=sySchreyer(u_id,maxl+1);
2430  else if (iiOp == LRES_CMD)
2431  {
2432    int dummy;
2433    if((currQuotient!=NULL)||
2434    (!idHomIdeal (u_id,NULL)))
2435    {
2436       WerrorS
2437       ("`lres` not implemented for inhomogeneous input or qring");
2438       return TRUE;
2439    }
2440    r=syLaScala3(u_id,&dummy);
2441  }
2442  else if (iiOp == KRES_CMD)
2443  {
2444    int dummy;
2445    if((currQuotient!=NULL)||
2446    (!idHomIdeal (u_id,NULL)))
2447    {
2448       WerrorS
2449       ("`kres` not implemented for inhomogeneous input or qring");
2450       return TRUE;
2451    }
2452    r=syKosz(u_id,&dummy);
2453  }
2454  else
2455  {
2456    int dummy;
2457    if((currQuotient!=NULL)||
2458    (!idHomIdeal (u_id,NULL)))
2459    {
2460       WerrorS
2461       ("`hres` not implemented for inhomogeneous input or qring");
2462       return TRUE;
2463    }
2464    r=syHilb(u_id,&dummy);
2465  }
2466  if (r==NULL) return TRUE;
2467  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2468  r->list_length=wmaxl;
2469  res->data=(void *)r;
2470  if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2471  if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2472  {
2473    ww=ivCopy(r->weights[0]);
2474    if (weights!=NULL) (*ww) += add_row_shift;
2475    atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2476  }
2477  else
2478  {
2479    if (weights!=NULL)
2480    {
2481      atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2482    }
2483  }
2484  return FALSE;
2485}
2486#endif
2487static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2488{
2489  ring r;
2490  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2491  res->data = (char *)r;
2492  return (i==-1);
2493}
2494#define SIMPL_LMDIV 32
2495#define SIMPL_LMEQ  16
2496#define SIMPL_MULT 8
2497#define SIMPL_EQU  4
2498#define SIMPL_NULL 2
2499#define SIMPL_NORM 1
2500static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2501{
2502  int sw = (int)(long)v->Data();
2503  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2504  ideal id = (ideal)u->CopyD(IDEAL_CMD);
2505  if (sw & SIMPL_LMDIV)
2506  {
2507    idDelDiv(id);
2508  }
2509  if (sw & SIMPL_LMEQ)
2510  {
2511    idDelLmEquals(id);
2512  }
2513  if (sw & SIMPL_NULL)
2514  {
2515    idSkipZeroes(id);
2516  }
2517  if (sw & SIMPL_NORM)
2518  {
2519    idNorm(id);
2520  }
2521  if (sw & SIMPL_MULT)
2522  {
2523    idDelMultiples(id);
2524  }
2525  else if(sw & SIMPL_EQU)
2526  {
2527    idDelEquals(id);
2528  }
2529  res->data = (char * )id;
2530  return FALSE;
2531}
2532#ifdef HAVE_FACTORY
2533extern int singclap_factorize_retry;
2534static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2535{
2536  intvec *v=NULL;
2537  int sw=(int)(long)dummy->Data();
2538  int fac_sw=sw;
2539  if ((sw<0)||(sw>2)) fac_sw=1;
2540  singclap_factorize_retry=0;
2541  ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2542  if (f==NULL)
2543    return TRUE;
2544  switch(sw)
2545  {
2546    case 0:
2547    case 2:
2548    {
2549      lists l=(lists)omAllocBin(slists_bin);
2550      l->Init(2);
2551      l->m[0].rtyp=IDEAL_CMD;
2552      l->m[0].data=(void *)f;
2553      l->m[1].rtyp=INTVEC_CMD;
2554      l->m[1].data=(void *)v;
2555      res->data=(void *)l;
2556      res->rtyp=LIST_CMD;
2557      return FALSE;
2558    }
2559    case 1:
2560      res->data=(void *)f;
2561      return FALSE;
2562    case 3:
2563      {
2564        poly p=f->m[0];
2565        int i=IDELEMS(f);
2566        f->m[0]=NULL;
2567        while(i>1)
2568        {
2569          i--;
2570          p=pMult(p,f->m[i]);
2571          f->m[i]=NULL;
2572        }
2573        res->data=(void *)p;
2574        res->rtyp=POLY_CMD;
2575      }
2576      return FALSE;
2577  }
2578  WerrorS("invalid switch");
2579  return TRUE;
2580}
2581#endif
2582static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2583{
2584  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2585  return FALSE;
2586}
2587static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2588{
2589  int sw = (int)(long)v->Data();
2590  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2591  poly p = (poly)u->CopyD(POLY_CMD);
2592  if (sw & SIMPL_NORM)
2593  {
2594    pNorm(p);
2595  }
2596  res->data = (char * )p;
2597  return FALSE;
2598}
2599static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2600{
2601  ideal result;
2602  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2603  tHomog hom=testHomog;
2604  if (w!=NULL)
2605  {
2606    w=ivCopy(w);
2607    hom=isHomog;
2608  }
2609  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
2610  idSkipZeroes(result);
2611  res->data = (char *)result;
2612  setFlag(res,FLAG_STD);
2613  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2614  return FALSE;
2615}
2616static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2617{
2618  assumeStdFlag(u);
2619  ideal result;
2620  intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2621  tHomog hom=testHomog;
2622  if (w!=NULL)
2623  {
2624    w=ivCopy(w);
2625    hom=isHomog;
2626  }
2627  ideal i1=(ideal)u->Data();
2628  ideal i0=idInit(1,i1->rank);
2629  i0->m[0]=(poly)v->Data();
2630  i1=idSimpleAdd(i1,i0);
2631  i0->m[0]=NULL;
2632  idDelete(&i0);
2633  BITSET save_test=test;
2634  test|=Sy_bit(OPT_SB_1);
2635  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2636  test=save_test;
2637  idDelete(&i1);
2638  idSkipZeroes(result);
2639  res->data = (char *)result;
2640  setFlag(res,FLAG_STD);
2641  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2642  return FALSE;
2643}
2644static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2645{
2646  idhdl h=(idhdl)u->data;
2647  int i=(int)(long)v->Data();
2648  if ((0<i) && (i<=IDRING(h)->N))
2649    res->data=omStrDup(IDRING(h)->names[i-1]);
2650  else
2651  {
2652    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2653    return TRUE;
2654  }
2655  return FALSE;
2656}
2657static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2658{
2659  res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2660  return FALSE;
2661}
2662#define jjWRONG2 (proc2)jjWRONG
2663#define jjWRONG3 (proc3)jjWRONG
2664static BOOLEAN jjWRONG(leftv res, leftv u)
2665{
2666  return TRUE;
2667}
2668
2669static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2670{
2671  char * s=(char *)u->Data();
2672  if(strcmp(s, "with")==0)
2673    return jjLOAD(res, v, TRUE);
2674  WerrorS("invalid second argument");
2675  WerrorS("load(\"libname\" [,\"with\"]);");
2676  return TRUE;
2677}
2678
2679/*=================== operations with 2 args.: table =================*/
2680
2681struct sValCmd2 dArith2[]=
2682{
2683// operations:
2684// proc        cmd              res             arg1        arg2   plural
2685 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2686,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2687,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2688,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2689,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2690,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2691,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2692,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
2693,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2694,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2695,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
2696,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2697,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2698,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2699,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2700,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2701,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2702,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
2703,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
2704,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  RING_CMD ALLOW_PLURAL}
2705,{jjRSUM,      '+',            QRING_CMD,      RING_CMD,   QRING_CMD ALLOW_PLURAL}
2706,{jjRSUM,      '+',            QRING_CMD,      QRING_CMD,  QRING_CMD ALLOW_PLURAL}
2707,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2708,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2709,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2710,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2711,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2712,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2713,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2714,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2715,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2716,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2717,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2718,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2719,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2720,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
2721,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2722,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2723,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2724,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2725,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2726,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2727,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2728,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2729,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2730,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
2731,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2732,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2733,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2734,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD ALLOW_PLURAL}
2735,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2736,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2737,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2738,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2739,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2740,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2741,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2742,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2743,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2744,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2745,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2746,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2747,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2748,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2749,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2750,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2751,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2752,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2753,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2754,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2755,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2756,{jjMOD_N,     '%',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2757,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2758,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2759,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2760,{jjMOD_N,     INTMOD_CMD,     NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2761,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2762,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2763,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2764,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2765,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2766,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2767,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2768,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2769,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2770,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2771,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2772,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2773,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2774,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2775,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2776,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2777,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2778,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2779,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2780,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2781,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2782,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2783,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2784,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2785,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2786,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2787,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2788,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2789,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2790,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2791,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2792,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2793,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2794,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2795,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2796,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2797,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2798,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2799,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2800,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2801,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2802,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2803,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2804,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2805,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2806,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2807,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2808,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2809,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2810,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2811,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2812,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2813,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2814,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2815,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2816,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2817,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2818,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2819,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2820,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
2821,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2822,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2823,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2824,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
2825,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2826,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2827,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2828,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
2829,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2830,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2831,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2832,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2833,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2834,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2835,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2836,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2837,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
2838,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2839,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2840// and the procedures with 2 arguments:
2841,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
2842,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2843,{jjBETTI2,    BETTI_CMD,      INTMAT_CMD,     LIST_CMD,   INT_CMD ALLOW_PLURAL}
2844,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2845,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2846,{jjBETTI2_ID, BETTI_CMD,      INTMAT_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2847#ifdef HAVE_PLURAL
2848,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2849#endif
2850,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2851,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2852,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2853,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2854,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2855,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2856,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2857,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2858,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2859,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
2860,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2861,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2862,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2863,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2864,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2865,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2866,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2867,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2868,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2869,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
2870,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2871,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2872,{jjEXPORTTO,  EXPORTTO_CMD,   NONE,           PACKAGE_CMD, IDHDL ALLOW_PLURAL}
2873,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
2874#ifdef HAVE_FACTORY
2875,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2876,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2877,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2878#else
2879,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2880,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2881,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2882#endif
2883,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2884,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2885#ifdef HAVE_FGLM
2886,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2887,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2888,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
2889#else
2890,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2891,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2892,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2893#endif
2894,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2895,{jjFWALK,     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2896
2897,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2898,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2899#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
2900,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2901#else
2902,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2903#endif
2904,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
2905,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
2906,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2907,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2908,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2909,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2910,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2911,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2912,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2913,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2914,{jjIMPORTFROM,IMPORTFROM_CMD, NONE,           PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
2915,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2916,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
2917,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2918,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2919,{jjJanetBasis2, JANET_CMD,    IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2920,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2921,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2922,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2923,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2924,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
2925,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2926,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2927,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
2928,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
2929,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
2930,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2931,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2932,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2933,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2934,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
2935,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2936,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2937,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
2938,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2939,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2940,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2941,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2942//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2943//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2944,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2945,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2946#ifdef HAVE_PLURAL
2947,{jjPlural_num_poly, NCALGEBRA_CMD,  NONE,  POLY_CMD,   POLY_CMD   NO_PLURAL}
2948,{jjPlural_num_mat,  NCALGEBRA_CMD,  NONE,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
2949,{jjPlural_mat_poly, NCALGEBRA_CMD,  NONE,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
2950,{jjPlural_mat_mat,  NCALGEBRA_CMD,  NONE,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
2951#endif
2952#ifdef HAVE_PLURAL
2953,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
2954,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, QRING_CMD,   DEF_CMD ALLOW_PLURAL}
2955#endif
2956,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2957,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2958,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
2959,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2960,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2961,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2962,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2963,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2964,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2965,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2966,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
2967,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2968,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2969,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2970//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2971//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2972,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2973,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2974,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2975,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2976,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2977,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2978,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2979//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2980//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2981,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2982,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
2983,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
2984,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2985,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2986,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
2987,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
2988,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2989,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2990,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
2991,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2992,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
2993,{NULL,        0,              0,              0,          0 NO_PLURAL}
2994};
2995/*=================== operations with 1 arg.: static proc =================*/
2996static BOOLEAN jjDUMMY(leftv res, leftv u)
2997{
2998  res->data = (char *)u->CopyD();
2999  return FALSE;
3000}
3001static BOOLEAN jjNULL(leftv res, leftv u)
3002{
3003  return FALSE;
3004}
3005//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3006//{
3007//  res->data = (char *)((int)(long)u->Data()+1);
3008//  return FALSE;
3009//}
3010//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3011//{
3012//  res->data = (char *)((int)(long)u->Data()-1);
3013//  return FALSE;
3014//}
3015static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3016{
3017  if (IDTYP((idhdl)u->data)==INT_CMD)
3018  {
3019    if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
3020    else                IDINT((idhdl)u->data)--;
3021    return FALSE;
3022  }
3023  return TRUE;
3024}
3025static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3026{
3027  res->data = (char *)(-(int)(long)u->Data());
3028  return FALSE;
3029}
3030static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3031{
3032  number n=(number)u->CopyD(NUMBER_CMD);
3033  n=nNeg(n);
3034  res->data = (char *)n;
3035  return FALSE;
3036}
3037static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3038{
3039  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3040  return FALSE;
3041}
3042static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3043{
3044  poly m1=pISet(-1);
3045  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3046  return FALSE;
3047}
3048static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3049{
3050  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3051  (*iv)*=(-1);
3052  res->data = (char *)iv;
3053  return FALSE;
3054}
3055static BOOLEAN jjPROC1(leftv res, leftv u)
3056{
3057  return jjPROC(res,u,NULL);
3058}
3059static BOOLEAN jjBAREISS(leftv res, leftv v)
3060{
3061  //matrix m=(matrix)v->Data();
3062  //lists l=mpBareiss(m,FALSE);
3063  intvec *iv;
3064  ideal m;
3065  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3066  lists l=(lists)omAllocBin(slists_bin);
3067  l->Init(2);
3068  l->m[0].rtyp=MODUL_CMD;
3069  l->m[1].rtyp=INTVEC_CMD;
3070  l->m[0].data=(void *)m;
3071  l->m[1].data=(void *)iv;
3072  res->data = (char *)l;
3073  return FALSE;
3074}
3075//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3076//{
3077//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
3078//  ivTriangMat(m);
3079//  res->data = (char *)m;
3080//  return FALSE;
3081//}
3082static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3083{
3084  return iiExprArithM(res,u,iiOp);
3085}
3086static BOOLEAN jjCHAR(leftv res, leftv v)
3087{
3088  res->data = (char *)rChar((ring)v->Data());
3089  return FALSE;
3090}
3091static BOOLEAN jjCOLS(leftv res, leftv v)
3092{
3093  res->data = (char *)MATCOLS((matrix)(v->Data()));
3094  return FALSE;
3095}
3096static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3097{
3098  res->data = (char *)((intvec*)(v->Data()))->cols();
3099  return FALSE;
3100}
3101static BOOLEAN jjCONTENT(leftv res, leftv v)
3102{
3103  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3104  poly p=(poly)v->CopyD(POLY_CMD);
3105  if (p!=NULL) pCleardenom(p);
3106  res->data = (char *)p;
3107  return FALSE;
3108}
3109static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3110{
3111  res->data = (char *)nSize((number)v->Data());
3112  return FALSE;
3113}
3114static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3115{
3116  lists l=(lists)v->Data();
3117  res->data = (char *)(l->nr+1);
3118  return FALSE;
3119}
3120static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3121{
3122  matrix m=(matrix)v->Data();
3123  res->data = (char *)(MATROWS(m)*MATCOLS(m));
3124  return FALSE;
3125}
3126static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3127{
3128  res->data = (char *)((intvec*)(v->Data()))->length();
3129  return FALSE;
3130}
3131static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3132{
3133  ring r=(ring)v->Data();
3134  int elems=-1;
3135  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
3136  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3137  {
3138    elems=(int)pow(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3139  }
3140  res->data = (char *)elems;
3141  return FALSE;
3142}
3143static BOOLEAN jjDEG(leftv res, leftv v)
3144{
3145  int dummy;
3146  poly p=(poly)v->Data();
3147  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3148  else res->data=(char *)-1;
3149  return FALSE;
3150}
3151static BOOLEAN jjDEG_M(leftv res, leftv u)
3152{
3153  ideal I=(ideal)u->Data();
3154  int d=-1;
3155  int dummy;
3156  int i;
3157  for(i=IDELEMS(I);i>=0;i--)
3158    if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3159  res->data = (char *)d;
3160  return FALSE;
3161}
3162static BOOLEAN jjDEGREE(leftv res, leftv v)
3163{
3164  assumeStdFlag(v);
3165  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3166  scDegree((ideal)v->Data(),module_w,currQuotient);
3167  return FALSE;
3168}
3169static BOOLEAN jjDEFINED(leftv res, leftv v)
3170{
3171  if ((v->rtyp==IDHDL)
3172  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3173  {
3174    res->data=(void *)(IDLEV((idhdl)v->data)+1);
3175  }
3176  else if (v->rtyp!=0) res->data=(void *)(-1);
3177  return FALSE;
3178}
3179#ifdef HAVE_FACTORY
3180static BOOLEAN jjDET(leftv res, leftv v)
3181{
3182  matrix m=(matrix)v->Data();
3183  poly p;
3184  if (smCheckDet((ideal)m,m->cols(),TRUE))
3185  {
3186    ideal I=idMatrix2Module(mpCopy(m));
3187    p=smCallDet(I);
3188    idDelete(&I);
3189  }
3190  else
3191    p=singclap_det(m);
3192  res ->data = (char *)p;
3193  return FALSE;
3194}
3195static BOOLEAN jjDET_I(leftv res, leftv v)
3196{
3197  intvec * m=(intvec*)v->Data();
3198  int i,j;
3199  i=m->rows();j=m->cols();
3200  if(i==j)
3201    res->data = (char *)singclap_det_i(m);
3202  else
3203  {
3204    Werror("det of %d x %d intmat",i,j);
3205    return TRUE;
3206  }
3207  return FALSE;
3208}
3209static BOOLEAN jjDET_S(leftv res, leftv v)
3210{
3211  ideal I=(ideal)v->Data();
3212  poly p;
3213  if (smCheckDet(I,IDELEMS(I),FALSE))
3214  {
3215    matrix m=idModule2Matrix(idCopy(I));
3216    p=singclap_det(m);
3217    idDelete((ideal *)&m);
3218  }
3219  else
3220    p=smCallDet(I);
3221  res->data = (char *)p;
3222  return FALSE;
3223}
3224#endif
3225static BOOLEAN jjDIM(leftv res, leftv v)
3226{
3227  assumeStdFlag(v);
3228  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
3229  return FALSE;
3230}
3231static BOOLEAN jjDUMP(leftv res, leftv v)
3232{
3233  si_link l = (si_link)v->Data();
3234  if (slDump(l))
3235  {
3236    const char *s;
3237    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3238    else                            s=sNoName;
3239    Werror("cannot dump to `%s`",s);
3240    return TRUE;
3241  }
3242  else
3243    return FALSE;
3244}
3245static BOOLEAN jjE(leftv res, leftv v)
3246{
3247  res->data = (char *)pOne();
3248  pSetComp((poly)res->data,(int)(long)v->Data());
3249  pSetm((poly)res->data);
3250  return FALSE;
3251}
3252static BOOLEAN jjEXECUTE(leftv res, leftv v)
3253{
3254  char * d = (char *)v->Data();
3255  char * s = (char *)omAlloc(strlen(d) + 13);
3256  strcpy( s, (char *)d);
3257  strcat( s, "\n;RETURN();\n");
3258  newBuffer(s,BT_execute);
3259  return yyparse();
3260}
3261#ifdef HAVE_FACTORY
3262static BOOLEAN jjFACSTD(leftv res, leftv v)
3263{
3264  ideal_list p,h;
3265  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3266  p=h;
3267  int l=0;
3268  while (p!=NULL) { p=p->next;l++; }
3269  lists L=(lists)omAllocBin(slists_bin);
3270  L->Init(l);
3271  l=0;
3272  while(h!=NULL)
3273  {
3274    L->m[l].data=(char *)h->d;
3275    L->m[l].rtyp=IDEAL_CMD;
3276    p=h->next;
3277    omFreeSize(h,sizeof(*h));
3278    h=p;
3279    l++;
3280  }
3281  res->data=(void *)L;
3282  return FALSE;
3283}
3284static BOOLEAN jjFAC_P(leftv res, leftv u)
3285{
3286  intvec *v=NULL;
3287  singclap_factorize_retry=0;
3288  ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3289  if (f==NULL) return TRUE;
3290  ivTest(v);
3291  lists l=(lists)omAllocBin(slists_bin);
3292  l->Init(2);
3293  l->m[0].rtyp=IDEAL_CMD;
3294  l->m[0].data=(void *)f;
3295  l->m[1].rtyp=INTVEC_CMD;
3296  l->m[1].data=(void *)v;
3297  res->data=(void *)l;
3298  return FALSE;
3299}
3300#endif
3301static BOOLEAN jjGETDUMP(leftv res, leftv v)
3302{
3303  si_link l = (si_link)v->Data();
3304  if (slGetDump(l))
3305  {
3306    const char *s;
3307    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3308    else                            s=sNoName;
3309    Werror("cannot get dump from `%s`",s);
3310    return TRUE;
3311  }
3312  else
3313    return FALSE;
3314}
3315static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3316{
3317  assumeStdFlag(v);
3318  ideal I=(ideal)v->Data();
3319  res->data=(void *)iiHighCorner(I,0);
3320  return FALSE;
3321}
3322static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3323{
3324  assumeStdFlag(v);
3325  intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3326  BOOLEAN delete_w=FALSE;
3327  ideal I=(ideal)v->Data();
3328  int i;
3329  poly p=NULL,po=NULL;
3330  int rk=idRankFreeModule(I);
3331  if (w==NULL)
3332  {
3333    w = new intvec(rk);
3334    delete_w=TRUE;
3335  }
3336  for(i=rk;i>0;i--)
3337  {
3338    p=iiHighCorner(I,i);
3339    if (p==NULL)
3340    {
3341      WerrorS("module must be zero-dimensional");
3342      if (delete_w) delete w;
3343      return TRUE;
3344    }
3345    if (po==NULL)
3346    {
3347      po=p;
3348    }
3349    else
3350    {
3351      // now po!=NULL, p!=NULL
3352      int d=(pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - pFDeg(p,currRing)+(*w)[i-1]);
3353      if (d==0)
3354        d=pLmCmp(po,p);
3355      if (d > 0)
3356      {
3357        pDelete(&p);
3358      }
3359      else // (d < 0)
3360      {
3361        pDelete(&po); po=p;
3362      }
3363    }
3364  }
3365  if (delete_w) delete w;
3366  res->data=(void *)po;
3367  return FALSE;
3368}
3369static BOOLEAN jjHILBERT(leftv res, leftv v)
3370{
3371  assumeStdFlag(v);
3372  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3373  //scHilbertPoly((ideal)v->Data(),currQuotient);
3374  hLookSeries((ideal)v->Data(),module_w,currQuotient);
3375  return FALSE;
3376}
3377static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3378{
3379  res->data=(void *)hSecondSeries((intvec *)v->Data());
3380  return FALSE;
3381}
3382static BOOLEAN jjHOMOG1(leftv res, leftv v)
3383{
3384  intvec *w;
3385  res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
3386  if ((res->data!=NULL) && (v->rtyp==IDHDL))
3387  {
3388    atSet((idhdl)v->data,omStrDup("isHomog"),w,INTVEC_CMD);
3389  }
3390  else if (w!=NULL) delete w;
3391  return FALSE;
3392}
3393static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3394{
3395  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3396  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3397  if (IDELEMS((ideal)mat)==0)
3398  {
3399    idDelete((ideal *)&mat);
3400    mat=(matrix)idInit(1,1);
3401  }
3402  else
3403  {
3404    MATROWS(mat)=1;
3405    mat->rank=1;
3406    idTest((ideal)mat);
3407  }
3408  res->data=(char *)mat;
3409  return FALSE;
3410}
3411static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3412{
3413  map m=(map)v->CopyD(MAP_CMD);
3414  omFree((ADDRESS)m->preimage);
3415  m->preimage=NULL;
3416  ideal I=(ideal)m;
3417  I->rank=1;
3418  res->data=(char *)I;
3419  return FALSE;
3420}
3421static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3422{
3423  if (currRing!=NULL)
3424  {
3425    ring q=(ring)v->Data();
3426    if (rEqual(currRing, q, 0))
3427    {
3428      if (q->qideal==NULL)
3429        res->data=(char *)idInit(1,1);
3430      else
3431        res->data=(char *)idCopy(q->qideal);
3432      return FALSE;
3433    }
3434  }
3435  WerrorS("can only get ideal from identical qring");
3436  return TRUE;
3437}
3438static BOOLEAN jjIm2Iv(leftv res, leftv v)
3439{
3440  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3441  iv->makeVector();
3442  res->data = iv;
3443  return FALSE;
3444}
3445static BOOLEAN jjIMPART(leftv res, leftv v)
3446{
3447  res->data = (char *)nImPart((number)v->Data());
3448  return FALSE;
3449}
3450static BOOLEAN jjINDEPSET(leftv res, leftv v)
3451{
3452  assumeStdFlag(v);
3453  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3454  return FALSE;
3455}
3456static BOOLEAN jjINTERRED(leftv res, leftv v)
3457{
3458  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3459  //if (result==NULL) return TRUE;
3460  res->data = result;
3461  return FALSE;
3462}
3463static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3464{
3465  res->data = (char *)pVar((poly)v->Data());
3466  return FALSE;
3467}
3468static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3469{
3470  res->data = (char *)(r_IsRingVar((char *)v->Data(), currRing)+1);
3471  return FALSE;
3472}
3473static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3474{
3475  res->data = (char *)0;
3476  return FALSE;
3477}
3478static BOOLEAN jjJACOB_P(leftv res, leftv v)
3479{
3480  ideal i=idInit(pVariables,1);
3481  int k;
3482  poly p=(poly)(v->Data());
3483  for (k=pVariables;k>0;k--)
3484  {
3485    i->m[k-1]=pDiff(p,k);
3486  }
3487  res->data = (char *)i;
3488  return FALSE;
3489}
3490static BOOLEAN jjKBASE(leftv res, leftv v)
3491{
3492  assumeStdFlag(v);
3493  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3494  return FALSE;
3495}
3496#ifdef MDEBUG
3497static BOOLEAN jjpHead(leftv res, leftv v)
3498{
3499  res->data=(char *)pHead((poly)v->Data());
3500  return FALSE;
3501}
3502#endif
3503static BOOLEAN jjL2R(leftv res, leftv v)
3504{
3505  res->data=(char *)syConvList((lists)v->Data());
3506  if (res->data != NULL)
3507    return FALSE;
3508  else
3509    return TRUE;
3510}
3511static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3512{
3513  poly p=(poly)v->Data();
3514  if (p==NULL)
3515  {
3516    res->data=(char *)nInit(0);
3517  }
3518  else
3519  {
3520    res->data=(char *)nCopy(pGetCoeff(p));
3521  }
3522  return FALSE;
3523}
3524static BOOLEAN jjLEADEXP(leftv res, leftv v)
3525{
3526  poly p=(poly)v->Data();
3527  int s=pVariables;
3528  if (v->Typ()==VECTOR_CMD) s++;
3529  intvec *iv=new intvec(s);
3530  if (p!=NULL)
3531  {
3532    for(int i = pVariables;i;i--)
3533    {
3534      (*iv)[i-1]=pGetExp(p,i);
3535    }
3536    if (s!=pVariables)
3537      (*iv)[pVariables]=pGetComp(p);
3538  }
3539  res->data=(char *)iv;
3540  return FALSE;
3541}
3542static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3543{
3544  poly p=(poly)v->Data();
3545  if (p == NULL)
3546  {
3547    res->data = (char*) NULL;
3548  }
3549  else
3550  {
3551    poly lm = pLmInit(p);
3552    pSetCoeff(lm, nInit(1));
3553    res->data = (char*) lm;
3554  }
3555  return FALSE;
3556}
3557static BOOLEAN jjLISTRING(leftv res, leftv v)
3558{
3559  ring r=rCompose((lists)v->Data());
3560  if (r==NULL) return TRUE;
3561  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3562  res->data=(char *)r;
3563  return FALSE;
3564}
3565static BOOLEAN jjMEMORY(leftv res, leftv v)
3566{
3567  omUpdateInfo();
3568  switch(((int)(long)v->Data()))
3569  {
3570  case 0:
3571    res->data = (char *)om_Info.UsedBytes;
3572    break;
3573  case 1:
3574    res->data = (char *)om_Info.CurrentBytesSystem;
3575    break;
3576  case 2:
3577    res->data = (char *)om_Info.MaxBytesSystem;
3578    break;
3579
3580  default:
3581    omPrintStats(stdout);
3582    omPrintInfo(stdout);
3583    omPrintBinStats(stdout);
3584    res->data = (char *)0;
3585  }
3586  return FALSE;
3587  res->data = (char *)0;
3588  return FALSE;
3589}
3590static BOOLEAN jjMONITOR1(leftv res, leftv v)
3591{
3592  monitor((char *)(v->Data()),PROT_I);
3593  return FALSE;
3594}
3595static BOOLEAN jjMSTD(leftv res, leftv v)
3596{
3597  int t=v->Typ();
3598  ideal r,m;
3599  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3600  lists l=(lists)omAllocBin(slists_bin);
3601  l->Init(2);
3602  l->m[0].rtyp=t;
3603  l->m[0].data=(char *)r;
3604  setFlag(&(l->m[0]),FLAG_STD);
3605  l->m[1].rtyp=t;
3606  l->m[1].data=(char *)m;
3607  res->data=(char *)l;
3608  return FALSE;
3609}
3610static BOOLEAN jjMULT(leftv res, leftv v)
3611{
3612  assumeStdFlag(v);
3613  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3614  return FALSE;
3615}
3616static BOOLEAN jjNAMEOF(leftv res, leftv v)
3617{
3618  res->data = (char *)v->name;
3619  if (res->data==NULL) res->data=omStrDup("");
3620  v->name=NULL;
3621  return FALSE;
3622}
3623static BOOLEAN jjNAMES(leftv res, leftv v)
3624{
3625  res->data=ipNameList(((ring)v->Data())->idroot);
3626  return FALSE;
3627}
3628static BOOLEAN jjNVARS(leftv res, leftv v)
3629{
3630  res->data = (char *)(((ring)(v->Data()))->N);
3631  return FALSE;
3632}
3633static BOOLEAN jjOpenClose(leftv res, leftv v)
3634{
3635  si_link l=(si_link)v->Data();
3636  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3637  else                return slClose(l);
3638}
3639static BOOLEAN jjORD(leftv res, leftv v)
3640{
3641  poly p=(poly)v->Data();
3642  res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3643  return FALSE;
3644}
3645static BOOLEAN jjPAR1(leftv res, leftv v)
3646{
3647  int i=(int)(long)v->Data();
3648  int p=0;
3649  p=rPar(currRing);
3650  if ((0<i) && (i<=p))
3651  {
3652    res->data=(char *)nPar(i);
3653  }
3654  else
3655  {
3656    Werror("par number %d out of range 1..%d",i,p);
3657    return TRUE;
3658  }
3659  return FALSE;
3660}
3661static BOOLEAN jjPARDEG(leftv res, leftv v)
3662{
3663  res->data = (char *)nParDeg((number)v->Data());
3664  return FALSE;
3665}
3666static BOOLEAN jjPARSTR1(leftv res, leftv v)
3667{
3668  if (currRing==NULL)
3669  {
3670    WerrorS("no ring active");
3671    return TRUE;
3672  }
3673  int i=(int)(long)v->Data();
3674  int p=0;
3675  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3676    res->data=omStrDup(currRing->parameter[i-1]);
3677  else
3678  {
3679    Werror("par number %d out of range 1..%d",i,p);
3680    return TRUE;
3681  }
3682  return FALSE;
3683}
3684static BOOLEAN jjP2I(leftv res, leftv v)
3685{
3686  poly p=(poly)v->Data();
3687  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3688  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3689  {
3690    WerrorS("poly must be constant");
3691    return TRUE;
3692  }
3693  res->data = (char *)nInt(pGetCoeff(p));
3694  return FALSE;
3695}
3696static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3697{
3698  map mapping=(map)v->Data();
3699  syMake(res,omStrDup(mapping->preimage));
3700  return FALSE;
3701}
3702static BOOLEAN jjPRIME(leftv res, leftv v)
3703{
3704  int i = IsPrime((int)(long)(v->Data()));
3705  res->data = (char *)(i > 1 ? i : 2);
3706  return FALSE;
3707}
3708static BOOLEAN jjPRUNE(leftv res, leftv v)
3709{
3710  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3711  ideal v_id=(ideal)v->Data();
3712  if (w!=NULL) 
3713  {
3714    w=ivCopy(w);
3715    intvec **ww=&w;
3716    res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3717    atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3718  }
3719  else
3720    res->data = (char *)idMinEmbedding(v_id);
3721  return FALSE;
3722}
3723static BOOLEAN jjP2N(leftv res, leftv v)
3724{
3725  number n;
3726  poly p;
3727  if (((p=(poly)v->Data())!=NULL)
3728  && (pIsConstant(p)))
3729  {
3730    n=nCopy(pGetCoeff(p));
3731  }
3732  else
3733  {
3734    n=nInit(0);
3735  }
3736  res->data = (char *)n;
3737  return FALSE;
3738}
3739static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3740{
3741  char *s= (char *)v->Data();
3742  int i = 1;
3743  int l = strlen(s);
3744  while (cmds[i].tokval!=0)
3745  {
3746    if (strcmp(s, cmds[i].name) == 0)
3747    {
3748      res->data = (char *)1;
3749      return FALSE;
3750    }
3751    i++;
3752  }
3753  //res->data = (char *)0;
3754  return FALSE;
3755}
3756static BOOLEAN jjREAD(leftv res, leftv v)
3757{
3758  return jjREAD2(res,v,NULL);
3759}
3760static BOOLEAN jjREGULARITY(leftv res, leftv v)
3761{
3762  res->data = (char *)iiRegularity((lists)v->Data());
3763  return FALSE;
3764}
3765static BOOLEAN jjREPART(leftv res, leftv v)
3766{
3767  res->data = (char *)nRePart((number)v->Data());
3768  return FALSE;
3769}
3770static BOOLEAN jjRINGLIST(leftv res, leftv v)
3771{
3772  ring r=(ring)v->Data();
3773  if (r!=NULL)
3774    res->data = (char *)rDecompose((ring)v->Data());
3775  return (r==NULL);
3776}
3777static BOOLEAN jjROWS(leftv res, leftv v)
3778{
3779  ideal i = (ideal)v->Data();
3780  res->data = (char *)i->rank;
3781  return FALSE;
3782}
3783static BOOLEAN jjROWS_IV(leftv res, leftv v)
3784{
3785  res->data = (char *)((intvec*)(v->Data()))->rows();
3786  return FALSE;
3787}
3788static BOOLEAN jjRPAR(leftv res, leftv v)
3789{
3790  res->data = (char *)rPar(((ring)v->Data()));
3791  return FALSE;
3792}
3793static BOOLEAN jjSLIM_GB(leftv res, leftv u)
3794{
3795  if (currQuotient!=NULL)
3796  {
3797    Werror("qring not supported by slimgb at the moment");
3798    return TRUE;
3799  }
3800  if (pOrdSgn!=1)
3801  {
3802    Werror("ordering must be global for slimgb");
3803    return TRUE;
3804  }
3805  res->data=(char *)t_rep_gb(currRing, (ideal)u->Data());
3806  setFlag(res,FLAG_STD);
3807  return FALSE;
3808}
3809static BOOLEAN jjSTD(leftv res, leftv v)
3810{
3811  ideal result;
3812  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3813  tHomog hom=testHomog;
3814  if (w!=NULL)
3815  {
3816    w=ivCopy(w);
3817    hom=isHomog;
3818  }
3819  result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3820  idSkipZeroes(result);
3821  res->data = (char *)result;
3822  setFlag(res,FLAG_STD);
3823  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3824  return FALSE;
3825}
3826static BOOLEAN jjSort_Id(leftv res, leftv v)
3827{
3828  res->data = (char *)idSort((ideal)v->Data());
3829  return FALSE;
3830}
3831#if 1
3832static BOOLEAN jjSYZYGY(leftv res, leftv v)
3833{
3834  intvec *w=NULL;
3835  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3836  if (w!=NULL) delete w;
3837  return FALSE;
3838}
3839#else
3840// activate, if idSyz hadle moduke weights correctly !
3841static BOOLEAN jjSYZYGY(leftv res, leftv v)
3842{
3843  intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
3844  ideal v_id=(ideal)v->Data();
3845  tHomog hom=testHomog;
3846  int add_row_shift=0;
3847  if (w!=NULL)
3848  {
3849    w=ivCopy(w);
3850    add_row_shift=w->min_in();
3851    (*w)-=add_row_shift;
3852    if (idHomModule(v_id,currQuotient,&w))
3853      hom=isHomog;
3854    else
3855    {
3856      //WarnS("wrong weights");
3857      delete w; w=NULL;
3858      hom=testHomog;
3859    }
3860  }
3861  res->data = (char *)idSyzygies(v_id,hom,&w);
3862  if (w!=NULL)
3863  {
3864    atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3865  }
3866  return FALSE;
3867}
3868#endif
3869static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3870{
3871  res->data = (char *)ivTrace((intvec*)(v->Data()));
3872  return FALSE;
3873}
3874static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3875{
3876  res->data = (char *)ivTranp((intvec*)(v->Data()));
3877  return FALSE;
3878}
3879
3880#ifdef HAVE_PLURAL
3881
3882static BOOLEAN jjOPPOSITE(leftv res, leftv a)
3883{
3884  ring    r = (ring)a->Data();
3885  if (rIsPluralRing(r))
3886  {
3887    res->data = rOpposite(r);
3888  }
3889  else res->data = rCopy(r);
3890  return FALSE;
3891}
3892
3893static BOOLEAN jjENVELOPE(leftv res, leftv a)
3894{
3895  ring    r = (ring)a->Data();
3896  if (rIsPluralRing(r))
3897  {
3898    //    ideal   i;
3899//     if (a->rtyp == QRING_CMD)
3900//     {
3901//       i = r->qideal;
3902//       r->qideal = NULL;
3903//     }
3904    ring s = rEnvelope(r);
3905//     if (a->rtyp == QRING_CMD)
3906//     {
3907//       ideal is  = idOppose(r,i); /* twostd? */
3908//       is        = idAdd(is,i);
3909//       s->qideal = i;
3910//     }
3911    res->data = s;
3912  }
3913  else  res->data = rCopy(r);
3914  return FALSE;
3915}
3916
3917static BOOLEAN jjTWOSTD(leftv res, leftv a)
3918{
3919  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
3920  else  res->data=(ideal)a->Data();
3921  setFlag(res,FLAG_STD);
3922  setFlag(res,FLAG_TWOSTD);
3923  return FALSE;
3924}
3925#endif
3926
3927static BOOLEAN jjTYPEOF(leftv res, leftv v)
3928{
3929  switch ((int)(long)v->data)
3930  {
3931    case INT_CMD:     res->data=omStrDup("int"); break;
3932    case POLY_CMD:   res->data=omStrDup("poly"); break;
3933    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3934    case STRING_CMD:  res->data=omStrDup("string"); break;
3935    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3936    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3937    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3938    case MODUL_CMD:   res->data=omStrDup("module"); break;
3939    case MAP_CMD:     res->data=omStrDup("map"); break;
3940    case PROC_CMD:    res->data=omStrDup("proc"); break;
3941    case RING_CMD:    res->data=omStrDup("ring"); break;
3942    case QRING_CMD:   res->data=omStrDup("qring"); break;
3943    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3944    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3945    case LIST_CMD:   res->data=omStrDup("list"); break;
3946    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3947    case LINK_CMD:   res->data=omStrDup("link"); break;
3948    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3949    case DEF_CMD:
3950    case NONE:    res->data=omStrDup("none"); break;
3951    default:       res->data=omStrDup("?unknown type?");
3952  }
3953  return FALSE;
3954}
3955static BOOLEAN jjVAR1(leftv res, leftv v)
3956{
3957  int i=(int)(long)v->Data();
3958  if ((0<i) && (i<=currRing->N))
3959  {
3960    poly p=pOne();
3961    pSetExp(p,i,1);
3962    pSetm(p);
3963    res->data=(char *)p;
3964  }
3965  else
3966  {
3967    Werror("var number %d out of range 1..%d",i,currRing->N);
3968    return TRUE;
3969  }
3970  return FALSE;
3971}
3972static BOOLEAN jjVARSTR1(leftv res, leftv v)
3973{
3974  if (currRing==NULL)
3975  {
3976    WerrorS("no ring active");
3977    return TRUE;
3978  }
3979  int i=(int)(long)v->Data();
3980  if ((0<i) && (i<=currRing->N))
3981    res->data=omStrDup(currRing->names[i-1]);
3982  else
3983  {
3984    Werror("var number %d out of range 1..%d",i,currRing->N);
3985    return TRUE;
3986  }
3987  return FALSE;
3988}
3989static BOOLEAN jjVDIM(leftv res, leftv v)
3990{
3991  assumeStdFlag(v);
3992  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
3993  return FALSE;
3994}
3995
3996static BOOLEAN jjLOAD1(leftv res, leftv v)
3997{
3998  return jjLOAD(res, v,iiOp==LIB_CMD);
3999}
4000static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4001{
4002#ifdef HAVE_NS
4003  char * s=(char *)v->CopyD();
4004  char libnamebuf[256];
4005  lib_types LT = type_of_LIB(s, libnamebuf);
4006#ifdef HAVE_DYNAMIC_LOADING
4007  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN autoexport);
4008#endif /* HAVE_DYNAMIC_LOADING */
4009
4010  switch(LT)
4011  {
4012      default:
4013      case LT_NONE:
4014        Werror("%s: unknown type", s);
4015        break;
4016      case LT_NOTFOUND:
4017        Werror("cannot open %s", s);
4018        break;
4019
4020      case LT_SINGULAR:
4021      {
4022        char *plib = iiConvName(s);
4023        idhdl pl = IDROOT->get(plib,0);
4024        if (pl==NULL)
4025        {
4026          pl = enterid( plib,0, PACKAGE_CMD, &IDROOT, TRUE );
4027          IDPACKAGE(pl)->language = LANG_SINGULAR;
4028          IDPACKAGE(pl)->libname=omStrDup(plib);
4029        }
4030        else if (IDTYP(pl)!=PACKAGE_CMD)
4031        {
4032          Werror("can not create package `%s`",plib);
4033          omFree(plib);
4034          return TRUE;
4035        }
4036        package savepack=currPack;
4037        currPack=IDPACKAGE(pl);
4038        char libnamebuf[256];
4039        FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4040        BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, FALSE, TRUE);
4041        currPack=savepack;
4042        IDPACKAGE(pl)->loaded=(!bo);
4043        return bo;
4044      }
4045      case LT_ELF:
4046      case LT_HPUX:
4047#ifdef HAVE_DYNAMIC_LOADING
4048        return load_modules(s, libnamebuf, autoexport);
4049#else /* HAVE_DYNAMIC_LOADING */
4050        WerrorS("Dynamic modules are not supported by this version of Singular");
4051        break;
4052#endif /* HAVE_DYNAMIC_LOADING */
4053  }
4054#endif
4055  return TRUE;
4056}
4057
4058/*=================== operations with 1 arg.: table =================*/
4059
4060#ifdef INIT_BUG
4061#define XS(A) -((short)A)
4062#define jjstrlen       (proc1)1
4063#define jjpLength      (proc1)2
4064#define jjidElem       (proc1)3
4065#define jjmpDetBareiss (proc1)4
4066#define jjidFreeModule (proc1)5
4067#define jjidVec2Ideal  (proc1)6
4068#define jjrCharStr     (proc1)7
4069#ifndef MDEBUG
4070#define jjpHead        (proc1)8
4071#endif
4072#define jjidHead       (proc1)9
4073#define jjidMaxIdeal   (proc1)10
4074#define jjidMinBase    (proc1)11
4075#define jjsyMinBase    (proc1)12
4076#define jjpMaxComp     (proc1)13
4077#define jjmpTrace      (proc1)14
4078#define jjmpTransp     (proc1)15
4079#define jjrOrdStr      (proc1)16
4080#define jjrVarStr      (proc1)18
4081#define jjrParStr      (proc1)19
4082#define jjCOUNT_RES    (proc1)22
4083#define jjDIM_R        (proc1)23
4084#define jjMINRES_R     (proc1)24
4085#define jjidTransp     (proc1)25
4086
4087extern struct sValCmd1 dArith1[];
4088void jjInitTab1()
4089{
4090  int i=0;
4091  for (;dArith1[i].cmd!=0;i++)
4092  {
4093    if (dArith1[i].res<0)
4094    {
4095      switch ((int)dArith1[i].p)
4096      {
4097        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
4098        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
4099        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
4100        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
4101#ifndef HAVE_FACTORY
4102        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4103#endif
4104        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4105        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
4106#ifndef MDEBUG
4107        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
4108#endif
4109        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
4110        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
4111        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
4112        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
4113        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
4114        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
4115        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
4116        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
4117        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
4118        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
4119        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
4120        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
4121        case (int)jjMINRES_R:     dArith1[i].p=(proc1)syMinimize; break;
4122        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
4123#ifdef GENTABLE
4124        default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4125#endif
4126      }
4127    }
4128  }
4129}
4130#else
4131#if defined(PROC_BUG)
4132#define XS(A) A
4133static BOOLEAN jjstrlen(leftv res, leftv v)
4134{
4135  res->data = (char *)strlen((char *)v->Data());
4136  return FALSE;
4137}
4138static BOOLEAN jjpLength(leftv res, leftv v)
4139{
4140  res->data = (char *)pLength((poly)v->Data());
4141  return FALSE;
4142}
4143static BOOLEAN jjidElem(leftv res, leftv v)
4144{
4145  res->data = (char *)idElem((ideal)v->Data());
4146  return FALSE;
4147}
4148static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4149{
4150  res->data = (char *)mpDetBareiss((matrix)v->Data());
4151  return FALSE;
4152}
4153static BOOLEAN jjidFreeModule(leftv res, leftv v)
4154{
4155  res->data = (char *)idFreeModule((int)(long)v->Data());
4156  return FALSE;
4157}
4158static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4159{
4160  res->data = (char *)idVec2Ideal((poly)v->Data());
4161  return FALSE;
4162}
4163static BOOLEAN jjrCharStr(leftv res, leftv v)
4164{
4165  res->data = rCharStr((ring)v->Data());
4166  return FALSE;
4167}
4168#ifndef MDEBUG
4169static BOOLEAN jjpHead(leftv res, leftv v)
4170{
4171  res->data = (char *)pHead((poly)v->Data());
4172  return FALSE;
4173}
4174#endif
4175static BOOLEAN jjidHead(leftv res, leftv v)
4176{
4177  res->data = (char *)idHead((ideal)v->Data());
4178  return FALSE;
4179}
4180static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4181{
4182  res->data = (char *)idMaxIdeal((int)(long)v->Data());
4183  return FALSE;
4184}
4185static BOOLEAN jjidMinBase(leftv res, leftv v)
4186{
4187  res->data = (char *)idMinBase((ideal)v->Data());
4188  return FALSE;
4189}
4190static BOOLEAN jjsyMinBase(leftv res, leftv v)
4191{
4192  res->data = (char *)syMinBase((ideal)v->Data());
4193  return FALSE;
4194}
4195static BOOLEAN jjpMaxComp(leftv res, leftv v)
4196{
4197  res->data = (char *)pMaxComp((poly)v->Data());
4198  return FALSE;
4199}
4200static BOOLEAN jjmpTrace(leftv res, leftv v)
4201{
4202  res->data = (char *)mpTrace((matrix)v->Data());
4203  return FALSE;
4204}
4205static BOOLEAN jjmpTransp(leftv res, leftv v)
4206{
4207  res->data = (char *)mpTransp((matrix)v->Data());
4208  return FALSE;
4209}
4210static BOOLEAN jjrOrdStr(leftv res, leftv v)
4211{
4212  res->data = rOrdStr((ring)v->Data());
4213  return FALSE;
4214}
4215static BOOLEAN jjrVarStr(leftv res, leftv v)
4216{
4217  res->data = rVarStr((ring)v->Data());
4218  return FALSE;
4219}
4220static BOOLEAN jjrParStr(leftv res, leftv v)
4221{
4222  res->data = rParStr((ring)v->Data());
4223  return FALSE;
4224}
4225static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4226{
4227  res->data=(char *)syLength((syStrategy)v->Data());
4228  return FALSE;
4229}
4230static BOOLEAN jjDIM_R(leftv res, leftv v)
4231{
4232  res->data = (char *)syDim((syStrategy)v->Data());
4233  return FALSE;
4234}
4235static BOOLEAN jjMINRES_R(leftv res, leftv v)
4236{
4237  res->data=(char *)syMinimize((syStrategy)v->Data());
4238  return FALSE;
4239}
4240static BOOLEAN jjidTransp(leftv res, leftv v)
4241{
4242  res->data = (char *)idTransp((ideal)v->Data());
4243  return FALSE;
4244}
4245#else
4246#define XS(A)          -((short)A)
4247#define jjstrlen       (proc1)strlen
4248#define jjpLength      (proc1)pLength
4249#define jjidElem       (proc1)idElem
4250#define jjmpDetBareiss (proc1)mpDetBareiss
4251#define jjidFreeModule (proc1)idFreeModule
4252#define jjidVec2Ideal  (proc1)idVec2Ideal
4253#define jjrCharStr     (proc1)rCharStr
4254#ifndef MDEBUG
4255#define jjpHead        (proc1)pHeadProc
4256#endif
4257#define jjidHead       (proc1)idHead
4258#define jjidMaxIdeal   (proc1)idMaxIdeal
4259#define jjidMinBase    (proc1)idMinBase
4260#define jjsyMinBase    (proc1)syMinBase
4261#define jjpMaxComp     (proc1)pMaxCompProc
4262#define jjmpTrace      (proc1)mpTrace
4263#define jjmpTransp     (proc1)mpTransp
4264#define jjrOrdStr      (proc1)rOrdStr
4265#define jjrVarStr      (proc1)rVarStr
4266#define jjrParStr      (proc1)rParStr
4267#define jjCOUNT_RES    (proc1)syLength
4268#define jjDIM_R        (proc1)syDim
4269#define jjMINRES_R     (proc1)syMinimize
4270#define jjidTransp     (proc1)idTransp
4271#endif
4272#endif
4273static BOOLEAN jjnInt(leftv res, leftv u)
4274{
4275  number n=(number)u->CopyD(NUMBER_CMD);
4276  res->data=(char *)nInt(n);
4277  nDelete(&n);
4278  return FALSE;
4279}
4280#define s short
4281struct sValCmd1 dArith1[]=
4282{
4283// operations:
4284// proc         cmd               res             arg           plural
4285// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4286//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4287 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4288,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4289,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4290,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4291,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4292,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4293,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4294,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4295,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4296,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4297,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4298// and the procedures with 1 argument:
4299,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4300//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4301,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4302,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4303,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4304,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4305,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4306,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4307,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4308#ifdef HAVE_FACTORY
4309,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4310#else
4311,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4312#endif
4313,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4314,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4315,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4316//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4317,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4318,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4319,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4320,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4321,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4322,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4323,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4324,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4325,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4326,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
4327,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
4328,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4329,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
4330,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
4331,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4332,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4333,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4334,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
4335,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4336,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
4337,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4338,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4339,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4340,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4341,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
4342,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
4343,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
4344#ifdef HAVE_FACTORY
4345,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4346,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
4347,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
4348#else
4349,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4350,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
4351#endif
4352,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
4353,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
4354,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4355,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4356,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
4357,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4358,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
4359#ifdef HAVE_FACTORY
4360,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4361#else
4362,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4363#endif
4364#ifdef HAVE_FGLM
4365,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4366#else
4367,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4368#endif
4369,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
4370#ifdef HAVE_FACTORY
4371,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4372#else
4373,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4374#endif
4375,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
4376,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
4377,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
4378,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
4379,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
4380,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
4381,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4382,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4383,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
4384,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
4385,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
4386,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
4387,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
4388,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4389,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4390,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
4391,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
4392,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4393,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4394,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4395,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
4396,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4397,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4398,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4399,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4400,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
4401,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
4402,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
4403,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4404,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4405,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4406,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4407,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
4408#ifdef MDEBUG
4409,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4410#else
4411,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
4412#endif
4413,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
4414#ifdef MDEBUG
4415,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4416#else
4417,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
4418#endif
4419,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4420,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4421,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4422,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
4423,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4424,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4425,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4426,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
4427,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
4428,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
4429,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4430,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4431,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
4432,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
4433,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
4434,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
4435,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
4436,{jjMINRES_R,   MINRES_CMD,      XS(RESOLUTION_CMD), RESOLUTION_CMD ALLOW_PLURAL}
4437,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4438,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4439,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
4440,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
4441,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4442,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
4443,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4444,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
4445,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4446,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4447,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4448,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4449,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4450,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4451,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4452,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4453,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4454,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4455,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4456,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4457,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4458,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
4459,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4460,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4461,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4462,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4463,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4464,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
4465,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
4466,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
4467,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
4468,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4469,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4470,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4471,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
4472,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
4473,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
4474,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4475,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
4476,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
4477,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4478,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4479,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4480,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
4481,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
4482//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
4483,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4484,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4485,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4486,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4487,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4488,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4489,{jjSLIM_GB,    SLIM_GB_CMD,     MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4490,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4491,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4492,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4493,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4494,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
4495,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
4496,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4497,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4498#ifdef HAVE_PLURAL
4499,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4500,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4501,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4502,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4503,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4504#endif
4505,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
4506,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
4507,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4508,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
4509,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4510,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4511,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
4512,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4513,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4514,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4515,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4516,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4517,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
4518,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4519,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4520,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4521,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4522,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4523,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4524,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4525,{NULL,         0,               0,              0              NO_PLURAL}
4526};
4527#undef s
4528/*=================== operations with 3 args.: static proc =================*/
4529static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4530{
4531  char *s= (char *)u->Data();
4532  int   r = (int)(long)v->Data();
4533  int   c = (int)(long)w->Data();
4534  int l = strlen(s);
4535
4536  if ( (r<1) || (r>l) || (c<0) )
4537  {
4538    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4539    return TRUE;
4540  }
4541  res->data = (char *)omAlloc(c+1);
4542  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4543  return FALSE;
4544}
4545static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4546{
4547  intvec *iv = (intvec *)u->Data();
4548  int   r = (int)(long)v->Data();
4549  int   c = (int)(long)w->Data();
4550  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4551  {
4552    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4553           r,c,u->Fullname(),iv->rows(),iv->cols());
4554    return TRUE;
4555  }
4556  res->data=u->data;
4557  u->data=NULL;
4558  res->rtyp=u->rtyp;
4559  u->rtyp=0;
4560  res->name=u->name;
4561  u->name=NULL;
4562  Subexpr e=jjMakeSub(v);
4563          e->next=jjMakeSub(w);
4564  if (u->e==NULL) res->e=e;
4565  else
4566  {
4567    Subexpr h=u->e;
4568    while (h->next!=NULL) h=h->next;
4569    h->next=e;
4570    res->e=u->e;
4571    u->e=NULL;
4572  }
4573  return FALSE;
4574}
4575static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4576{
4577  matrix m= (matrix)u->Data();
4578  int   r = (int)(long)v->Data();
4579  int   c = (int)(long)w->Data();
4580  //Print("gen. elem %d, %d\n",r,c);
4581  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4582  {
4583    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4584      MATROWS(m),MATCOLS(m));
4585    return TRUE;
4586  }
4587  res->data=u->data;
4588  u->data=NULL;
4589  res->rtyp=u->rtyp;
4590  u->rtyp=0;
4591  res->name=u->name;
4592  u->name=NULL;
4593  Subexpr e=jjMakeSub(v);
4594          e->next=jjMakeSub(w);
4595  if (u->e==NULL)
4596    res->e=e;
4597  else
4598  {
4599    Subexpr h=u->e;
4600    while (h->next!=NULL) h=h->next;
4601    h->next=e;
4602    res->e=u->e;
4603    u->e=NULL;
4604  }
4605  return FALSE;
4606}
4607static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4608{
4609  sleftv t;
4610  sleftv ut;
4611  leftv p=NULL;
4612  intvec *iv=(intvec *)w->Data();
4613  int l;
4614  BOOLEAN nok;
4615
4616  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4617  {
4618    WerrorS("cannot build expression lists from unnamed objects");
4619    return TRUE;
4620  }
4621  memcpy(&ut,u,sizeof(ut));
4622  memset(&t,0,sizeof(t));
4623  t.rtyp=INT_CMD;
4624  for (l=0;l< iv->length(); l++)
4625  {
4626    t.data=(char *)(*iv)[l];
4627    if (p==NULL)
4628    {
4629      p=res;
4630    }
4631    else
4632    {
4633      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4634      p=p->next;
4635    }
4636    memcpy(u,&ut,sizeof(ut));
4637    if (u->Typ() == MATRIX_CMD)
4638      nok=jjBRACK_Ma(p,u,v,&t);
4639    else /* INTMAT_CMD */
4640      nok=jjBRACK_Im(p,u,v,&t);
4641    if (nok)
4642    {
4643      while (res->next!=NULL)
4644      {
4645        p=res->next->next;
4646        omFreeBin((ADDRESS)res->next, sleftv_bin);
4647        // res->e aufraeumen !!!!
4648        res->next=p;
4649      }
4650      return TRUE;
4651    }
4652  }
4653  return FALSE;
4654}
4655static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4656{
4657  sleftv t;
4658  sleftv ut;
4659  leftv p=NULL;
4660  intvec *iv=(intvec *)v->Data();
4661  int l;
4662  BOOLEAN nok;
4663
4664  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4665  {
4666    WerrorS("cannot build expression lists from unnamed objects");
4667    return TRUE;
4668  }
4669  memcpy(&ut,u,sizeof(ut));
4670  memset(&t,0,sizeof(t));
4671  t.rtyp=INT_CMD;
4672  for (l=0;l< iv->length(); l++)
4673  {
4674    t.data=(char *)((*iv)[l]);
4675    if (p==NULL)
4676    {
4677      p=res;
4678    }
4679    else
4680    {
4681      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4682      p=p->next;
4683    }
4684    memcpy(u,&ut,sizeof(ut));
4685    if (u->Typ() == MATRIX_CMD)
4686      nok=jjBRACK_Ma(p,u,&t,w);
4687    else /* INTMAT_CMD */
4688      nok=jjBRACK_Im(p,u,&t,w);
4689    if (nok)
4690    {
4691      while (res->next!=NULL)
4692      {
4693        p=res->next->next;
4694        omFreeBin((ADDRESS)res->next, sleftv_bin);
4695        // res->e aufraeumen !!
4696        res->next=p;
4697      }
4698      return TRUE;
4699    }
4700  }
4701  return FALSE;
4702}
4703static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4704{
4705  sleftv t1,t2,ut;
4706  leftv p=NULL;
4707  intvec *vv=(intvec *)v->Data();
4708  intvec *wv=(intvec *)w->Data();
4709  int vl;
4710  int wl;
4711  BOOLEAN nok;
4712
4713  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4714  {
4715    WerrorS("cannot build expression lists from unnamed objects");
4716    return TRUE;
4717  }
4718  memcpy(&ut,u,sizeof(ut));
4719  memset(&t1,0,sizeof(sleftv));
4720  memset(&t2,0,sizeof(sleftv));
4721  t1.rtyp=INT_CMD;
4722  t2.rtyp=INT_CMD;
4723  for (vl=0;vl< vv->length(); vl++)
4724  {
4725    t1.data=(char *)((*vv)[vl]);
4726    for (wl=0;wl< wv->length(); wl++)
4727    {
4728      t2.data=(char *)((*wv)[wl]);
4729      if (p==NULL)
4730      {
4731        p=res;
4732      }
4733      else
4734      {
4735        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4736        p=p->next;
4737      }
4738      memcpy(u,&ut,sizeof(ut));
4739      if (u->Typ() == MATRIX_CMD)
4740        nok=jjBRACK_Ma(p,u,&t1,&t2);
4741      else /* INTMAT_CMD */
4742        nok=jjBRACK_Im(p,u,&t1,&t2);
4743      if (nok)
4744      {
4745        res->CleanUp();
4746        return TRUE;
4747      }
4748    }
4749  }
4750  return FALSE;
4751}
4752static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4753{
4754  v->next=(leftv)omAllocBin(sleftv_bin);
4755  memcpy(v->next,w,sizeof(sleftv));
4756  memset(w,0,sizeof(sleftv));
4757  return jjPROC(res,u,v);
4758}
4759static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4760{
4761  u->next=(leftv)omAllocBin(sleftv_bin);
4762  memcpy(u->next,v,sizeof(sleftv));
4763  u->next->next=(leftv)omAllocBin(sleftv_bin);
4764  memcpy(u->next->next,w,sizeof(sleftv));
4765  BOOLEAN r=iiExprArithM(res,u,iiOp);
4766  // iiExprArithM did the CleanUp
4767  w->rtyp=0; w->data=NULL;
4768  return r;
4769}
4770static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4771{
4772  intvec *iv;
4773  ideal m;
4774  lists l=(lists)omAllocBin(slists_bin);
4775  int k=(int)(long)w->Data();
4776  if (k>=0)
4777  {
4778    smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
4779    l->Init(2);
4780    l->m[0].rtyp=MODUL_CMD;
4781    l->m[1].rtyp=INTVEC_CMD;
4782    l->m[0].data=(void *)m;
4783    l->m[1].data=(void *)iv;
4784  }
4785  else
4786  {
4787    m=smCallSolv((ideal)u->Data());
4788    l->Init(1);
4789    l->m[0].rtyp=IDEAL_CMD;
4790    l->m[0].data=(void *)m;
4791  }
4792  res->data = (char *)l;
4793  return FALSE;
4794}
4795static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4796{
4797  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4798  {
4799    WerrorS("3rd argument must be a name of a matrix");
4800    return TRUE;
4801  }
4802  ideal i=(ideal)u->Data();
4803  int rank=(int)i->rank;
4804  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4805  if (r) return TRUE;
4806  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4807  return FALSE;
4808}
4809static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4810{
4811  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4812           (ideal)(v->Data()),(poly)(w->Data()));
4813  return FALSE;
4814}
4815static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4816{
4817  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4818  {
4819    WerrorS("3rd argument must be a name of a matrix");
4820    return TRUE;
4821  }
4822  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4823  poly p=(poly)u->CopyD(POLY_CMD);
4824  ideal i=idInit(1,1);
4825  i->m[0]=p;
4826  sleftv t;
4827  memset(&t,0,sizeof(t));
4828  t.data=(char *)i;
4829  t.rtyp=IDEAL_CMD;
4830  int rank=1;
4831  if (u->Typ()==VECTOR_CMD)
4832  {
4833    i->rank=rank=pMaxComp(p);
4834    t.rtyp=MODUL_CMD;
4835  }
4836  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4837  t.CleanUp();
4838  if (r) return TRUE;
4839  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4840  return FALSE;
4841}
4842static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4843{
4844  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4845    (intvec *)w->Data());
4846  setFlag(res,FLAG_STD);
4847  return FALSE;
4848}
4849static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4850{
4851  /*4
4852  * look for the substring what in the string where
4853  * starting at position n
4854  * return the position of the first char of what in where
4855  * or 0
4856  */
4857  int n=(int)(long)w->Data();
4858  char *where=(char *)u->Data();
4859  char *what=(char *)v->Data();
4860  char *found;
4861  if ((1>n)||(n>(int)strlen(where)))
4862  {
4863    Werror("start position %d out of range",n);
4864    return TRUE;
4865  }
4866  found = strchr(where+n-1,*what);
4867  if (*(what+1)!='\0')
4868  {
4869    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4870    {
4871      found=strchr(found+1,*what);
4872    }
4873  }
4874  if (found != NULL)
4875  {
4876    res->data=(char *)((found-where)+1);
4877  }
4878  return FALSE;
4879}
4880static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
4881{
4882  if ((int)(long)w->Data()==0)
4883    res->data=(char *)walkProc(u,v);
4884  else
4885    res->data=(char *)fractalWalkProc(u,v);
4886  setFlag( res, FLAG_STD );
4887  return FALSE;
4888}
4889static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4890{
4891  assumeStdFlag(u);
4892  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4893  intvec *wdegree=(intvec*)w->Data();
4894  if (wdegree->length()!=pVariables)
4895  {
4896    Werror("weight vector must have size %d, not %d",
4897           pVariables,wdegree->length());
4898    return TRUE;
4899  }
4900  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4901  switch((int)(long)v->Data())
4902  {
4903    case 1:
4904      res->data=(void *)iv;
4905      return FALSE;
4906    case 2:
4907      res->data=(void *)hSecondSeries(iv);
4908      delete iv;
4909      return FALSE;
4910  }
4911  WerrorS(feNotImplemented);
4912  delete iv;
4913  return TRUE;
4914}
4915static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4916{
4917  intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
4918  intvec* arg = (intvec*) u->Data();
4919  int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
4920
4921  for (i=0; i<n; i++)
4922  {
4923    (*im)[i] = (*arg)[i];
4924  }
4925
4926  res->data = (char *)im;
4927  return FALSE;
4928}
4929static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4930{
4931  short *iw=iv2array((intvec *)w->Data());
4932  res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
4933  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4934  return FALSE;
4935}
4936static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
4937{
4938  if (!pIsUnit((poly)v->Data()))
4939  {
4940    WerrorS("2nd argument must be a unit");
4941    return TRUE;
4942  }
4943  res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4944  return FALSE;
4945}
4946static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4947{
4948  res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
4949                             (intvec *)w->Data());
4950  return FALSE;
4951}
4952static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4953{
4954  if (!mpIsDiagUnit((matrix)v->Data()))
4955  {
4956    WerrorS("2nd argument must be a diagonal matrix of units");
4957    return TRUE;
4958  }
4959  res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
4960                               (matrix)v->CopyD());
4961  return FALSE;
4962}
4963static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4964{
4965  assumeStdFlag(w);
4966  res->data = (char *)idMinors(
4967                        (matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
4968  return FALSE;
4969}
4970static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4971{
4972  idhdl h;
4973  ring rr;
4974  map mapping;
4975
4976  if ((v->name==NULL) || (w->name==NULL))
4977  {
4978    WerrorS("2nd/3rd arguments must have names");
4979    return TRUE;
4980  }
4981  rr=(ring)u->Data();
4982  const char *ring_name=u->Name();
4983  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4984  {
4985    if (h->typ==MAP_CMD)
4986    {
4987      mapping=IDMAP(h);
4988      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4989      if ((preim_ring==NULL)
4990      || (IDRING(preim_ring)!=currRing))
4991      {
4992        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4993        return TRUE;
4994      }
4995    }
4996    else if (h->typ==IDEAL_CMD)
4997    {
4998      mapping=IDMAP(h);
4999    }
5000    else
5001    {
5002      Werror("`%s` is no map nor ideal",IDID(h));
5003      return TRUE;
5004    }
5005  }
5006  else
5007  {
5008    Werror("`%s` is not defined in `%s`",v->name,ring_name);
5009    return TRUE;
5010  }
5011  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5012  {
5013    if (h->typ==IDEAL_CMD)
5014    {
5015      if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5016      || ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5017      {
5018        WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5019      }
5020      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5021    }
5022    else
5023    {
5024      Werror("`%s` is no ideal",IDID(h));
5025      return TRUE;
5026    }
5027  }
5028  else
5029  {
5030    Werror("`%s` is not defined in `%s`",w->name,ring_name);
5031    return TRUE;
5032  }
5033  return FALSE;
5034}
5035static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5036{
5037  int di, k;
5038  int i=(int)(long)u->Data();
5039  int r=(int)(long)v->Data();
5040  int c=(int)(long)w->Data();
5041  if ((r<=0) || (c<=0)) return TRUE;
5042  intvec *iv = new intvec(r, c, 0);
5043  if (iv->rows()==0)
5044  {
5045    delete iv;
5046    return TRUE;
5047  }
5048  if (i!=0)
5049  {
5050    if (i<0) i = -i;
5051    di = 2 * i + 1;
5052    for (k=0; k<iv->length(); k++)
5053    {
5054#ifdef buildin_rand
5055      (*iv)[k] = ((siRand() % di) - i);
5056#else
5057      (*iv)[k] = ((rand() % di) - i);
5058#endif
5059    }
5060  }
5061  res->data = (char *)iv;
5062  return FALSE;
5063}
5064static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5065  int &ringvar, poly &monomexpr)
5066{
5067  monomexpr=(poly)w->Data();
5068  poly p=(poly)v->Data();
5069  #if 0
5070  if (pLength(monomexpr)>1)
5071  {
5072    Werror("`%s` substitutes a ringvar only by a term",
5073      Tok2Cmdname(SUBST_CMD));
5074    return TRUE;
5075  }
5076  #endif
5077  if (!(ringvar=pVar(p)))
5078  {
5079    if (rField_is_Extension(currRing))
5080    {
5081      assume(currRing->algring!=NULL);
5082      lnumber n=(lnumber)pGetCoeff(p);
5083      ringvar=-p_Var(n->z,currRing->algring);
5084    }
5085    if(ringvar==0)
5086    {
5087      WerrorS("ringvar/par expected");
5088      return TRUE;
5089    }
5090  }
5091  return FALSE;
5092}
5093static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5094{
5095  int ringvar;
5096  poly monomexpr;
5097  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5098  if (nok) return TRUE;
5099  if (ringvar>0)
5100  {
5101    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5102      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5103    else
5104      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5105  }
5106  else
5107  {
5108    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5109  }
5110  return FALSE;
5111}
5112static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5113{
5114  int ringvar;
5115  poly monomexpr;
5116  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5117  if (nok) return TRUE;
5118  if (ringvar>0)
5119  {
5120    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
5121      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5122    else
5123      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5124  }
5125  else
5126  {
5127    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5128  }
5129  return FALSE;
5130}
5131// we do not want to have jjSUBST_Id_X inlined:
5132static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5133                            int input_type);
5134static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5135{
5136  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5137}
5138static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5139{
5140  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5141}
5142static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5143{
5144  sleftv tmp;
5145  memset(&tmp,0,sizeof(tmp));
5146  // do not check the result, conversion from int/number to poly works always
5147  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5148  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5149  tmp.CleanUp();
5150  return b;
5151}
5152static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5153{
5154  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5155  ideal I=(ideal)u->CopyD(IDEAL_CMD);
5156  int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5157  //for(i=i-1;i>=0;i--)
5158  //{
5159  //  m->m[i]=I->m[i];
5160  //  I->m[i]=NULL;
5161  //}
5162  memcpy4(m->m,I->m,i*sizeof(poly));
5163  memset(I->m,0,i*sizeof(poly));
5164  idDelete(&I);
5165  res->data = (char *)m;
5166  return FALSE;
5167}
5168static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5169{
5170  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5171           (int)(long)v->Data(),(int)(long)w->Data());
5172  return FALSE;
5173}
5174static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5175{
5176  matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5177  matrix I=(matrix)u->CopyD(MATRIX_CMD);
5178  int r=si_min(MATROWS(I),(int)(long)v->Data());
5179  int c=si_min(MATCOLS(I),(int)(long)w->Data());
5180  int i,j;
5181  for(i=r;i>0;i--)
5182  {
5183    for(j=c;j>0;j--)
5184    {
5185      MATELEM(m,i,j)=MATELEM(I,i,j);
5186      MATELEM(I,i,j)=NULL;
5187    }
5188  }
5189  idDelete((ideal *)&I);
5190  res->data = (char *)m;
5191  return FALSE;
5192}
5193static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5194{
5195  if (w->rtyp!=IDHDL) return TRUE;
5196  BITSET save_test=test;
5197  int ul= IDELEMS((ideal)u->Data());
5198  int vl= IDELEMS((ideal)v->Data());
5199  ideal m
5200    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5201             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5202  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5203  test=save_test;
5204  return FALSE;
5205}
5206static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5207{
5208  assumeStdFlag(v);
5209  if (!idIsZeroDim((ideal)v->Data()))
5210  {
5211    Werror("`%s` must be 0-dimensional",v->Name());
5212    return TRUE;
5213  }
5214  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5215    (poly)w->CopyD());
5216  return FALSE;
5217}
5218static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5219{
5220  assumeStdFlag(v);
5221  if (!idIsZeroDim((ideal)v->Data()))
5222  {
5223    Werror("`%s` must be 0-dimensional",v->Name());
5224    return TRUE;
5225  }
5226  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5227    (matrix)w->CopyD());
5228  return FALSE;
5229}
5230static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5231{
5232  assumeStdFlag(v);
5233  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5234    0,(int)(long)w->Data());
5235  return FALSE;
5236}
5237static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5238{
5239  assumeStdFlag(v);
5240  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5241    0,(int)(long)w->Data());
5242  return FALSE;
5243}
5244#ifdef OLD_RES
5245static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5246{
5247  int maxl=(int)v->Data();
5248  int l=0;
5249  resolvente r;
5250  intvec **weights=NULL;
5251  int wmaxl=maxl;
5252  maxl--;
5253  if ((maxl==-1) && (iiOp!=MRES_CMD))
5254    maxl = pVariables-1;
5255  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5256  {
5257    intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5258    if (iv!=NULL)
5259    {
5260      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5261      weights[0] = ivCopy(iv);
5262      l=1;
5263    }
5264    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
5265  }
5266  else
5267    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5268  if (r==NULL) return TRUE;
5269  int t3=u->Typ();
5270  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5271  return FALSE;
5272  return TRUE;
5273}
5274#endif
5275static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5276{
5277  res->data=(void *)rInit(u,v,w);
5278  return (res->data==NULL);
5279}
5280static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5281{
5282  int yes;
5283  jjSTATUS2(res, u, v);
5284  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5285  omFree((ADDRESS) res->data);
5286  res->data = (void *) yes;
5287  return FALSE;
5288}
5289static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5290{
5291  ideal result;
5292  intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
5293  tHomog hom=testHomog;
5294  if (ww!=NULL)
5295  {
5296    ww=ivCopy(ww);
5297    hom=isHomog;
5298  }
5299  result=kStd((ideal)(u->Data()),
5300              currQuotient,
5301              hom,
5302              &ww,                  // module weights
5303              (intvec *)v->Data(),  // hilbert series
5304              0,0,                  // syzComp, newIdeal
5305              (intvec *)w->Data()); // weights of vars
5306  idSkipZeroes(result);
5307  res->data = (char *)result;
5308  setFlag(res,FLAG_STD);
5309  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5310  return FALSE;
5311}
5312
5313/*=================== operations with 3 args.: table =================*/
5314struct sValCmd3 dArith3[]=
5315{
5316// operations:
5317// proc             cmd          res         arg1        arg2        arg3   plural
5318 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5319,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5320,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5321,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5322,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5323,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5324,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5325,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5326,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5327,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5328,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
5329,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
5330,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5331,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5332,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5333,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5334,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
5335,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
5336,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5337,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5338,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
5339,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5340,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5341,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5342,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
5343//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5344,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5345,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5346,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5347,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5348,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5349,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5350,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
5351,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
5352,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5353,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5354,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
5355,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
5356,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5357,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5358,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5359,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5360,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
5361,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5362#ifdef OLD_RES
5363,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5364,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5365#endif
5366,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5367,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5368,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5369,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5370,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
5371,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5372,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5373,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5374,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5375,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5376,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5377,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
5378,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
5379,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5380,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5381#ifdef OLD_RES
5382,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5383,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5384#endif
5385#ifdef HAVE_FACTORY
5386,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5387#else
5388,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5389#endif
5390,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5391#ifdef OLD_RES
5392,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5393,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5394#endif
5395,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
5396,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5397,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5398,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5399,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5400,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5401,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5402,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5403,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5404,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
5405,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
5406,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
5407,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
5408,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
5409,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
5410};
5411/*=================== operations with many arg.: static proc =================*/
5412static BOOLEAN jjBREAK0(leftv res, leftv v)
5413{
5414#ifdef HAVE_SDB
5415  sdb_show_bp();
5416#endif
5417  return FALSE;
5418}
5419static BOOLEAN jjBREAK1(leftv res, leftv v)
5420{
5421#ifdef HAVE_SDB
5422  if(v->Typ()==PROC_CMD)
5423  {
5424    int lineno=0;
5425    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
5426    {
5427      lineno=(int)(long)v->next->Data();
5428    }
5429    return sdb_set_breakpoint(v->Name(),lineno);
5430  }
5431  return TRUE;
5432#else
5433 return FALSE;
5434#endif
5435}
5436static BOOLEAN jjCALL1ARG(leftv res, leftv v)
5437{
5438  return iiExprArith1(res,v,iiOp);
5439}
5440static BOOLEAN jjCALL2ARG(leftv res, leftv u)
5441{
5442  leftv v=u->next;
5443  u->next=NULL;
5444  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
5445  u->next=v;
5446  return b;
5447}
5448static BOOLEAN jjCALL3ARG(leftv res, leftv u)
5449{
5450  leftv v = u->next;
5451  leftv w = v->next;
5452  u->next = NULL;
5453  v->next = NULL;
5454  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5455  u->next = v;
5456  v->next = w;
5457  return b;
5458}
5459
5460static BOOLEAN jjCOEF_M(leftv res, leftv v)
5461{
5462  if((v->Typ() != VECTOR_CMD)
5463  || (v->next->Typ() != POLY_CMD)
5464  || (v->next->next->Typ() != MATRIX_CMD)
5465  || (v->next->next->next->Typ() != MATRIX_CMD))
5466     return TRUE;
5467  if (v->next->next->rtyp!=IDHDL) return TRUE;
5468  idhdl c=(idhdl)v->next->next->data;
5469  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
5470  idhdl m=(idhdl)v->next->next->next->data;
5471  idDelete((ideal *)&(c->data.uideal));
5472  idDelete((ideal *)&(m->data.uideal));
5473  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
5474    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
5475  return FALSE;
5476}
5477
5478static BOOLEAN jjDIVISION4(leftv res, leftv v)
5479{ // may have 3 or 4 arguments
5480  leftv v1=v;
5481  leftv v2=v1->next;
5482  leftv v3=v2->next;
5483  leftv v4=v3->next;
5484  assumeStdFlag(v2);
5485
5486  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
5487  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
5488
5489  if(i1==0||i2==0||v3->Typ()!=INT_CMD||(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
5490  {
5491    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
5492    return TRUE;
5493  }
5494
5495  sleftv w1,w2;
5496  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
5497  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
5498  ideal P=(ideal)w1.Data();
5499  ideal Q=(ideal)w2.Data();
5500
5501  int n=(int)(long)v3->Data();
5502  short *w=NULL;
5503  if(v4!=NULL)
5504  {
5505    w=iv2array((intvec *)v4->Data());
5506    short *w0=w+1;
5507    int i=pVariables;
5508    while(i>0&&*w0>0)
5509    {
5510      w0++;
5511      i--;
5512    }
5513    if(i>0)
5514      WarnS("not all weights are positive!");
5515  }
5516
5517  matrix T;
5518  ideal R;
5519  idLiftW(P,Q,n,T,R,w);
5520
5521  if(w!=NULL)
5522    omFree(w);
5523  lists L=(lists) omAllocBin(slists_bin);
5524  L->Init(2);
5525  L->m[1].rtyp=v1->Typ();
5526  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
5527  {
5528    if(v1->Typ()==POLY_CMD)
5529      pShift(&R->m[0],-1);
5530    L->m[1].data=(void *)R->m[0];
5531    R->m[0]=NULL;
5532    idDelete(&R);
5533  }
5534  else
5535  if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
5536    L->m[1].data=(void *)idModule2Matrix(R);
5537  else
5538    L->m[1].rtyp=MODUL_CMD;
5539  L->m[0].rtyp=MATRIX_CMD;
5540  L->m[0].data=(char *)T;
5541
5542  res->data=L;
5543  res->rtyp=LIST_CMD;
5544
5545  return FALSE;
5546}
5547
5548//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
5549//{
5550//  int l=u->listLength();
5551//  if (l<2) return TRUE;
5552//  BOOLEAN b;
5553//  leftv v=u->next;
5554//  leftv zz=v;
5555//  leftv z=zz;
5556//  u->next=NULL;
5557//  do
5558//  {
5559//    leftv z=z->next;
5560//    b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
5561//    if (b) break;
5562//  } while (z!=NULL);
5563//  u->next=zz;
5564//  return b;
5565//}
5566static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5567{
5568  int s=1;
5569  leftv h=v;
5570  if (h!=NULL) s=exprlist_length(h);
5571  ideal id=idInit(s,1);
5572  int rank=1;
5573  int i=0;
5574  poly p;
5575  while (h!=NULL)
5576  {
5577    switch(h->Typ())
5578    {
5579      case POLY_CMD:
5580      {
5581        p=(poly)h->CopyD(POLY_CMD);
5582        break;
5583      }
5584      case INT_CMD:
5585      {
5586        number n=nInit((int)(long)h->Data());
5587        if (!nIsZero(n))
5588        {
5589          p=pOne();
5590          pSetCoeff(p,n);
5591        }
5592        else
5593        {
5594          p=NULL;
5595          nDelete(&n);
5596        }
5597        break;
5598      }
5599      case NUMBER_CMD:
5600      {
5601        number n=(number)h->CopyD(NUMBER_CMD);
5602        if (!nIsZero(n))
5603        {
5604          p=pOne();
5605          pSetCoeff(p,n);
5606        }
5607        else
5608        {
5609          p=NULL;
5610          nDelete(&n);
5611        }
5612        break;
5613      }
5614      case VECTOR_CMD:
5615      {
5616        p=(poly)h->CopyD(VECTOR_CMD);
5617        if (iiOp!=MODUL_CMD)
5618        {
5619          idDelete(&id);
5620          pDelete(&p);
5621          return TRUE;
5622        }
5623        rank=si_max(rank,(int)pMaxComp(p));
5624        break;
5625      }
5626      default:
5627      {
5628        idDelete(&id);
5629        return TRUE;
5630      }
5631    }
5632    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
5633    {
5634      pSetCompP(p,1);
5635    }
5636    id->m[i]=p;
5637    i++;
5638    h=h->next;
5639  }
5640  id->rank=rank;
5641  res->data=(char *)id;
5642  return FALSE;
5643}
5644static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
5645{
5646  leftv h=v;
5647  int l=v->listLength();
5648  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
5649  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
5650  int t=0;
5651  // try to convert to IDEAL_CMD
5652  while (h!=NULL)
5653  {
5654    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
5655    {
5656      t=IDEAL_CMD;
5657    }
5658    else break;
5659    h=h->next;
5660  }
5661  // if failure, try MODUL_CMD
5662  if (t==0)
5663  {
5664    h=v;
5665    while (h!=NULL)
5666    {
5667      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
5668      {
5669        t=MODUL_CMD;
5670      }
5671      else break;
5672      h=h->next;
5673    }
5674  }
5675  // check for success  in converting
5676  if (t==0)
5677  {
5678    WerrorS("cannot convert to ideal or module");
5679    return TRUE;
5680  }
5681  // call idMultSect
5682  h=v;
5683  int i=0;
5684  sleftv tmp;
5685  while (h!=NULL)
5686  {
5687    if (h->Typ()==t)
5688    {
5689      r[i]=(ideal)h->Data(); /*no copy*/
5690      h=h->next;
5691    }
5692    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
5693    {
5694      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5695      omFreeSize((ADDRESS)r,l*sizeof(ideal));
5696      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
5697      return TRUE;
5698    }
5699    else
5700    {
5701      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
5702      copied[i]=TRUE;
5703      h=tmp.next;
5704    }
5705    i++;
5706  }
5707  res->rtyp=t;
5708  res->data=(char *)idMultSect(r,i);
5709  while(i>0)
5710  {
5711    i--;
5712    if (copied[i]) idDelete(&(r[i]));
5713  }
5714  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5715  omFreeSize((ADDRESS)r,l*sizeof(ideal));
5716  return FALSE;
5717}
5718static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
5719{
5720  int i=0;
5721  leftv h=v;
5722  if (h!=NULL) i=exprlist_length(h);
5723  intvec *iv=new intvec(i);
5724  i=0;
5725  while (h!=NULL)
5726  {
5727    if(h->Typ()==INT_CMD)
5728    {
5729      (*iv)[i]=(int)(long)h->Data();
5730    }
5731    else
5732    {
5733      delete iv;
5734      return TRUE;
5735    }
5736    i++;
5737    h=h->next;
5738  }
5739  res->data=(char *)iv;
5740  return FALSE;
5741}
5742static BOOLEAN jjJET4(leftv res, leftv u)
5743{
5744  leftv u1=u;
5745  leftv u2=u1->next;
5746  leftv u3=u2->next;
5747  leftv u4=u3->next;
5748  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5749     (u4->Typ()==INTVEC_CMD)||
5750     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5751     (u4->Typ()==INTVEC_CMD))
5752  {
5753    if(!pIsUnit((poly)u2->Data()))
5754    {
5755      WerrorS("2nd argument must be a unit");
5756      return TRUE;
5757    }
5758    res->rtyp=u1->Typ();
5759    res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
5760                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
5761    return FALSE;
5762  }
5763  else
5764  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5765     (u4->Typ()==INTVEC_CMD)||
5766     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5767     (u4->Typ()==INTVEC_CMD))
5768  {
5769    if(!mpIsDiagUnit((matrix)u2->Data()))
5770    {
5771      WerrorS("2nd argument must be a diagonal matrix of units");
5772      return TRUE;
5773    }
5774    res->rtyp=u1->Typ();
5775    res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
5776                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
5777    return FALSE;
5778  }
5779  else
5780  {
5781    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
5782           Tok2Cmdname(iiOp));
5783    return TRUE;
5784  }
5785}
5786static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
5787{
5788  if ((yyInRingConstruction)
5789  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
5790  {
5791    memcpy(res,u,sizeof(sleftv));
5792    memset(u,0,sizeof(sleftv));
5793    return FALSE;
5794  }
5795  leftv v=u->next;
5796  BOOLEAN b;
5797  if(v==NULL)
5798    b=iiExprArith1(res,u,iiOp);
5799  else
5800  {
5801    u->next=NULL;
5802    b=iiExprArith2(res,u,iiOp,v);
5803    u->next=v;
5804  }
5805  return b;
5806}
5807static BOOLEAN jjLIST_PL(leftv res, leftv v)
5808{
5809  int sl=0;
5810  if (v!=NULL) sl = v->listLength();
5811  lists L;
5812  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
5813  {
5814    int add_row_shift = 0;
5815    intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
5816    if (weights!=NULL)  add_row_shift=weights->min_in();
5817    L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
5818  }
5819  else
5820  {
5821    L=(lists)omAllocBin(slists_bin);
5822    leftv h=NULL;
5823    int i;
5824    int rt;
5825
5826    L->Init(sl);
5827    for (i=0;i<sl;i++)
5828    {
5829      if (h!=NULL) { /* e.g. not in the first step:
5830                     * h is the pointer to the old sleftv,
5831                     * v is the pointer to the next sleftv
5832                     * (in this moment) */
5833                     h->next=v;
5834                   }
5835      h=v;
5836      v=v->next;
5837      h->next=NULL;
5838      rt=h->Typ();
5839      if (rt==0)
5840      {
5841        L->Clean();
5842        Werror("`%s` is undefined",h->Fullname());
5843        return TRUE;
5844      }
5845      if ((rt==RING_CMD)||(rt==QRING_CMD))
5846      {
5847        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
5848        ((ring)L->m[i].data)->ref++;
5849      }
5850      else
5851        L->m[i].Copy(h);
5852    }
5853  }
5854  res->data=(char *)L;
5855  return FALSE;
5856}
5857static BOOLEAN jjNAMES0(leftv res, leftv v)
5858{
5859  res->data=(void *)ipNameList(IDROOT);
5860  return FALSE;
5861}
5862static BOOLEAN jjOPTION_PL(leftv res, leftv v)
5863{
5864  if(v==NULL)
5865  {
5866    res->data=(char *)showOption();
5867    return FALSE;
5868  }
5869  res->rtyp=NONE;
5870  return setOption(res,v);
5871}
5872static BOOLEAN jjREDUCE4(leftv res, leftv u)
5873{
5874  leftv u1=u;
5875  leftv u2=u1->next;
5876  leftv u3=u2->next;
5877  leftv u4=u3->next;
5878  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
5879  {
5880    int save_d=Kstd1_deg;
5881    Kstd1_deg=(int)(long)u3->Data();
5882    kModW=(intvec *)u4->Data();
5883    BITSET save=verbose;
5884    verbose|=Sy_bit(V_DEG_STOP);
5885    u2->next=NULL;
5886    BOOLEAN r=jjCALL2ARG(res,u);
5887    kModW=NULL;
5888    Kstd1_deg=save_d;
5889    verbose=save;
5890    u->next->next=u3;
5891    return r;
5892  }
5893  else
5894  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5895     (u4->Typ()==INT_CMD))
5896  {
5897    assumeStdFlag(u3);
5898    if(!mpIsDiagUnit((matrix)u2->Data()))
5899    {
5900      WerrorS("2nd argument must be a diagonal matrix of units");
5901      return TRUE;
5902    }
5903    res->rtyp=IDEAL_CMD;
5904    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5905                           mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
5906    return FALSE;
5907  }
5908  else
5909  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5910     (u4->Typ()==INT_CMD))
5911  {
5912    assumeStdFlag(u3);
5913    if(!pIsUnit((poly)u2->Data()))
5914    {
5915      WerrorS("2nd argument must be a unit");
5916      return TRUE;
5917    }
5918    res->rtyp=POLY_CMD;
5919    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5920                           pCopy((poly)u2->Data()),(int)(long)u4->Data());
5921    return FALSE;
5922  }
5923  else
5924  {
5925    Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
5926    return TRUE;
5927  }
5928}
5929static BOOLEAN jjREDUCE5(leftv res, leftv u)
5930{
5931  leftv u1=u;
5932  leftv u2=u1->next;
5933  leftv u3=u2->next;
5934  leftv u4=u3->next;
5935  leftv u5=u4->next;
5936  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5937     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5938  {
5939    assumeStdFlag(u3);
5940    if(!mpIsDiagUnit((matrix)u2->Data()))
5941    {
5942      WerrorS("2nd argument must be a diagonal matrix of units");
5943      return TRUE;
5944    }
5945    res->rtyp=IDEAL_CMD;
5946    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5947                           mpCopy((matrix)u2->Data()),
5948                           (int)(long)u4->Data(),(intvec*)u5->Data());
5949    return FALSE;
5950  }
5951  else
5952  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5953     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5954  {
5955    assumeStdFlag(u3);
5956    if(!pIsUnit((poly)u2->Data()))
5957    {
5958      WerrorS("2nd argument must be a unit");
5959      return TRUE;
5960    }
5961    res->rtyp=POLY_CMD;
5962    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5963                           pCopy((poly)u2->Data()),
5964                           (int)(long)u4->Data(),(intvec*)u5->Data());
5965    return FALSE;
5966  }
5967  else
5968  {
5969    Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
5970           Tok2Cmdname(iiOp));
5971    return TRUE;
5972  }
5973}
5974static BOOLEAN jjRESERVED0(leftv res, leftv v)
5975{
5976  int i=1;
5977  loop
5978  {
5979    Print("%-20s",cmds[i].name);
5980    i++;
5981    if(cmds[i].name==NULL)
5982      break;
5983    if ((i%3)==1) PrintLn();
5984  }
5985  PrintLn();
5986  return FALSE;
5987}
5988static BOOLEAN jjSTRING_PL(leftv res, leftv v)
5989{
5990  if (v == NULL)
5991  {
5992    res->data = omStrDup("");
5993    return FALSE;
5994  }
5995  int n = v->listLength();
5996  if (n == 1)
5997  {
5998    res->data = v->String();
5999    return FALSE;
6000  }
6001
6002  char** slist = (char**) omAlloc(n*sizeof(char*));
6003  int i, j;
6004
6005  for (i=0, j=0; i<n; i++, v = v ->next)
6006  {
6007    slist[i] = v->String();
6008    assume(slist[i] != NULL);
6009    j+=strlen(slist[i]);
6010  }
6011  char* s = (char*) omAlloc((j+1)*sizeof(char));
6012  *s='\0';
6013  for (i=0;i<n;i++)
6014  {
6015    strcat(s, slist[i]);
6016    omFree(slist[i]);
6017  }
6018  omFreeSize(slist, n*sizeof(char*));
6019  res->data = s;
6020  return FALSE;
6021}
6022static BOOLEAN jjTEST(leftv res, leftv v)
6023{
6024  do
6025  {
6026    if (v->Typ()!=INT_CMD)
6027      return TRUE;
6028    test_cmd((int)(long)v->Data());
6029    v=v->next;
6030  }
6031  while (v!=NULL);
6032  return FALSE;
6033}
6034
6035#if defined(__alpha) && !defined(linux)
6036extern "C"
6037{
6038  void usleep(unsigned long usec);
6039};
6040#endif
6041
6042static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6043{
6044  if ((v->Typ() != LINK_CMD) ||
6045      (v->next->Typ() != STRING_CMD) ||
6046      (v->next->next->Typ() != STRING_CMD) ||
6047      (v->next->next->next->Typ() != INT_CMD))
6048    return TRUE;
6049  jjSTATUS3(res, v, v->next, v->next->next);
6050#if defined(HAVE_USLEEP)
6051  if (((long) res->data) == 0L)
6052  {
6053    int i_s = (int)(long) v->next->next->next->Data();
6054    if (i_s > 0)
6055    {
6056      usleep((int)(long) v->next->next->next->Data());
6057      jjSTATUS3(res, v, v->next, v->next->next);
6058    }
6059  }
6060#elif defined(HAVE_SLEEP)
6061  if (((int) res->data) == 0)
6062  {
6063    int i_s = (int) v->next->next->next->Data();
6064    if (i_s > 0)
6065    {
6066      sleep((is - 1)/1000000 + 1);
6067      jjSTATUS3(res, v, v->next, v->next->next);
6068    }
6069  }
6070#endif
6071  return FALSE;
6072}
6073static BOOLEAN jjSUBST_M(leftv res, leftv u)
6074{
6075  leftv v = u->next; // number of args > 0
6076  if (v==NULL) return TRUE;
6077  leftv w = v->next;
6078  if (w==NULL) return TRUE;
6079  leftv rest = w->next;;
6080
6081  u->next = NULL;
6082  v->next = NULL;
6083  w->next = NULL;
6084  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6085  if ((rest!=NULL) && (!b))
6086  {
6087    sleftv tmp_res;
6088    leftv tmp_next=res->next;
6089    res->next=rest;
6090    memset(&tmp_res,0,sizeof(tmp_res));
6091    b = iiExprArithM(&tmp_res,res,iiOp);
6092    memcpy(res,&tmp_res,sizeof(tmp_res));
6093    res->next=tmp_next;
6094  }
6095  u->next = v;
6096  v->next = w;
6097  // rest was w->next, but is already cleaned
6098  return b;
6099}
6100
6101/*=================== operations with many arg.: table =================*/
6102/* number_of_args:  -1: any, -2: any >0, .. */
6103struct sValCmdM dArithM[]=
6104{
6105// operations:
6106// proc         cmd               res            number_of_args plural
6107 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2       ALLOW_PLURAL}
6108,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0        ALLOW_PLURAL}
6109,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2       ALLOW_PLURAL}
6110,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2        ALLOW_PLURAL}
6111,{jjCOEF_M,    COEF_CMD,        NONE,               4        ALLOW_PLURAL}
6112,{jjCALL2ARG,  DIVISION_CMD,    ANY_TYPE/*or set by p*/,2    ALLOW_PLURAL}
6113,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,3    NO_PLURAL}
6114,{jjDIVISION4, DIVISION_CMD,    ANY_TYPE/*or set by p*/,4    NO_PLURAL}
6115,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2       ALLOW_PLURAL}
6116//,{jjEXPORTTO_M,  EXPORTTO_CMD,    NONE,             -2       ALLOW_PLURAL}
6117,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1        ALLOW_PLURAL}
6118,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1       ALLOW_PLURAL}
6119,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2        ALLOW_PLURAL}
6120,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2       ALLOW_PLURAL}
6121,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1        ALLOW_PLURAL}
6122,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2       ALLOW_PLURAL}
6123,{jjCALL2ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 2   ALLOW_PLURAL}
6124,{jjCALL3ARG,  JET_CMD,         POLY_CMD,/*or set by p*/ 3   ALLOW_PLURAL}
6125,{jjJET4,      JET_CMD,         POLY_CMD,/*or set by p*/ 4   ALLOW_PLURAL}
6126,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1       ALLOW_PLURAL}
6127,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1        ALLOW_PLURAL}
6128,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1       ALLOW_PLURAL}
6129,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1       ALLOW_PLURAL}
6130,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0       ALLOW_PLURAL}
6131,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 ALLOW_PLURAL}
6132,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  2 ALLOW_PLURAL}
6133,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  3 ALLOW_PLURAL}
6134,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  4 ALLOW_PLURAL}
6135,{jjREDUCE5,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,  5 ALLOW_PLURAL}
6136,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1       ALLOW_PLURAL}
6137,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0       ALLOW_PLURAL}
6138,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1       ALLOW_PLURAL}
6139,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3        ALLOW_PLURAL}
6140,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2       ALLOW_PLURAL}
6141,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2       ALLOW_PLURAL}
6142,{jjTEST,      TEST_CMD,        NONE,               -2       ALLOW_PLURAL}
6143,{iiWRITE,     WRITE_CMD,       NONE,               -2       ALLOW_PLURAL}
6144,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2       ALLOW_PLURAL}
6145,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3       ALLOW_PLURAL}
6146,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4       ALLOW_PLURAL}
6147,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6       NO_PLURAL}
6148,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4       NO_PLURAL}
6149,{NULL,        0,               0,                   0       NO_PLURAL}
6150};
6151#ifdef MDEBUG
6152static Subexpr jjDBMakeSub(leftv e,char *f, int l)
6153#else
6154static Subexpr jjMakeSub(leftv e)
6155#endif
6156{
6157  assume( e->Typ()==INT_CMD );
6158  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
6159  r->start =(int)(long)e->Data();
6160  return r;
6161}
6162
6163/*================ generating tables ============================*/
6164#ifdef GENTABLE
6165extern struct sValAssign dAssign[];
6166struct sValCmdTab dArithTab1[]={ {0,0}};
6167#define JJTAB1LEN 0
6168struct sValCmdTab dArithTab2[]={ {0,0}};
6169#define JJTAB2LEN 0
6170void ttGen1()
6171{
6172  FILE *outfile = myfopen("iparith.inc","w");
6173  int i,j,l1=0,l2=0;
6174  currRing=(ring)omAllocBin(sip_sring_bin);
6175  fprintf(outfile,
6176  "/****************************************\n"
6177  "*  Computer Algebra System SINGULAR     *\n"
6178  "****************************************/\n\n");
6179/*-------------------------------------------------------------------*/
6180  fprintf(outfile,"// syntax table for Singular\n//\n");
6181  fprintf(outfile,"// - search for an exact match of the argument types\n");
6182  fprintf(outfile,"// - otherwise search for the first possibility\n");
6183  fprintf(outfile,"//   with converted types of the arguments\n");
6184  fprintf(outfile,"// - otherwise report an error\n//\n");
6185
6186  int op;
6187  i=0;
6188  while ((op=dArith1[i].cmd)!=0)
6189  {
6190    if (dArith1[i].p==jjWRONG)
6191      fprintf(outfile,"// DUMMY ");
6192    char *s = iiTwoOps(op);
6193    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
6194          s,
6195          Tok2Cmdname(dArith1[i].arg),
6196          Tok2Cmdname(ABS(dArith1[i].res)));
6197    i++;
6198  }
6199  fprintf(outfile,"/*---------------------------------------------*/\n");
6200  i=0;
6201  while ((op=dArith2[i].cmd)!=0)
6202  {
6203    if (dArith2[i].p==jjWRONG2)
6204      fprintf(outfile,"// DUMMY ");
6205    char *s = iiTwoOps(op);
6206    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
6207          s,
6208          Tok2Cmdname(dArith2[i].arg1),
6209          Tok2Cmdname(dArith2[i].arg2),
6210          Tok2Cmdname(dArith2[i].res));
6211    i++;
6212  }
6213  fprintf(outfile,"/*---------------------------------------------*/\n");
6214  i=0;
6215  while ((op=dArith3[i].cmd)!=0)
6216  {
6217    char *s = iiTwoOps(op);
6218    if (dArith3[i].p==jjWRONG3)
6219      fprintf(outfile,"// DUMMY ");
6220    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
6221          s,
6222          Tok2Cmdname(dArith3[i].arg1),
6223          Tok2Cmdname(dArith3[i].arg2),
6224          Tok2Cmdname(dArith3[i].arg3),
6225          Tok2Cmdname(dArith3[i].res));
6226    i++;
6227  }
6228  fprintf(outfile,"/*---------------------------------------------*/\n");
6229  i=0;
6230  while ((op=dArithM[i].cmd)!=0)
6231  {
6232    char *s = iiTwoOps(op);
6233    fprintf(outfile,"// operation: %s (...)  ->  %s",
6234          s,
6235          Tok2Cmdname(dArithM[i].res));
6236    switch(dArithM[i].number_of_args)
6237    {
6238      case -2:
6239         fprintf(outfile," ( number of arguments >0 )\n");
6240         break;
6241      case -1:
6242         fprintf(outfile," ( any number of arguments )\n");
6243         break;
6244      default:
6245         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
6246         break;
6247    }
6248    i++;
6249  }
6250  fprintf(outfile,"/*---------------------------------------------*/\n");
6251  i=0;
6252  while ((op=dAssign[i].res)!=0)
6253  {
6254    fprintf(outfile,"// assign: %s =  %s\n",
6255          Tok2Cmdname(op/*dAssign[i].res*/),
6256          Tok2Cmdname(dAssign[i].arg));
6257    i++;
6258  }
6259/*-------------------------------------------------------------------*/
6260  fprintf(outfile,"/*---------------------------------------------*/\n");
6261  for (j=257;j<=MAX_TOK+1;j++)
6262  {
6263    for(i=257;i<=MAX_TOK+1;i++)
6264    {
6265      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
6266      && iiTestConvert(i,j))
6267      {
6268        fprintf(outfile,"// convert %s -> %s\n",
6269          Tok2Cmdname(i), Tok2Cmdname(j));
6270        if (j==ANY_TYPE) break;
6271      }
6272    }
6273  }
6274  fprintf(outfile,"/*---------------------------------------------*/\n");
6275  char ops[]="=><+*/[.^,%(;";
6276  for(i=0;ops[i]!='\0';i++)
6277    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
6278  for (i=257;i<=MAX_TOK;i++)
6279  {
6280    char *s=iiTwoOps(i);
6281    if (s[0]!='$')
6282    {
6283      fprintf(outfile,"// token %d : %s\n", i, s);
6284    }
6285  }
6286/*-------------------------------------------------------------------*/
6287  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
6288/*-------------------------------------------------------------------*/
6289  fprintf(outfile,"/*---------------------------------------------*/\n");
6290  fprintf(outfile,
6291  "struct sValCmdTab dArithTab1[]=\n"
6292  "{\n");
6293  for (j=1;j<=MAX_TOK+1;j++)
6294  {
6295    for(i=0;dArith1[i].cmd!=0;i++)
6296    {
6297      if (dArith1[i].cmd==j)
6298      {
6299        fprintf(outfile," { %d,%d },\n",j,i);
6300        l1++;
6301        break;
6302      }
6303    }
6304  }
6305  fprintf(outfile," { 10000,0 }\n};\n");
6306  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
6307/*-------------------------------------------------------------------*/
6308  fprintf(outfile,
6309  "struct sValCmdTab dArithTab2[]=\n"
6310  "{\n");
6311  for (j=1;j<=MAX_TOK+1;j++)
6312  {
6313    for(i=0;dArith2[i].cmd!=0;i++)
6314    {
6315      if (dArith2[i].cmd==j)
6316      {
6317        fprintf(outfile," { %d,%d },\n",j,i);
6318        l2++;
6319        break;
6320      }
6321    }
6322  }
6323  fprintf(outfile," { 10000,0 }\n};\n");
6324  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
6325  fclose(outfile);
6326}
6327/*-------------------------------------------------------------------*/
6328void ttGen2()
6329{
6330  FILE *outfile = myfopen("iparith.inc","a");
6331  fprintf(outfile,
6332  "/****************************************\n"
6333  "*  Computer Algebra System SINGULAR     *\n"
6334  "****************************************/\n\n");
6335/*-------------------------------------------------------------------*/
6336  fprintf(outfile,"// identifier table for Singular\n//\n");
6337
6338  fprintf(outfile,
6339  "cmdnames cmds[] =\n"
6340  "{  // name-string     alias  tokval toktype\n"
6341  "{ \"$INVALID$\",            0,  -1, 0},\n");
6342  int i=1;
6343  int m=-1;
6344  int id_nr=0;
6345  BOOLEAN f=FALSE;
6346  loop
6347  {
6348    while (cmds[i].tokval!=0)
6349    {
6350      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
6351      {
6352        if(m==-1)
6353        {
6354          m=i;
6355          f=TRUE;
6356        }
6357        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6358        {
6359          m=i;
6360          f=TRUE;
6361        }
6362      }
6363      i++;
6364    }
6365    if(f)
6366    {
6367      id_nr++;
6368      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
6369      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
6370                                             20-strlen(cmds[m].name),
6371                                             cmds[m].alias,
6372                                             cmds[m].tokval);
6373      switch(cmds[m].toktype)
6374      {
6375        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
6376        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
6377        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
6378        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
6379        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
6380        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
6381        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
6382        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
6383        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
6384        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
6385        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
6386        case NONE:             fprintf(outfile,"NONE },\n"); break;
6387        default:               if((cmds[m].toktype>' ')
6388                               &&(cmds[m].toktype<127))
6389                               {
6390                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
6391                               }
6392                               else
6393                               {
6394                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
6395                               }
6396                               break;
6397      }
6398      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
6399      cmds[m].name=NULL;
6400      m=-1;
6401      i=1;
6402      f=FALSE;
6403    }
6404    else break;
6405  }
6406  fprintf(outfile,
6407"/* list of scanner identifiers/only for feread/reservedName */\n");
6408  f=FALSE;
6409  i=1;m=-1;
6410  loop
6411  {
6412    while (cmds[i].tokval!=0)
6413    {
6414      if (cmds[i].name!=NULL)
6415      {
6416        if(m==-1)
6417        {
6418          m=i;
6419          f=TRUE;
6420        }
6421        else if(strcmp(cmds[m].name,cmds[i].name)>0)
6422        {
6423          m=i;
6424          f=TRUE;
6425        }
6426      }
6427      i++;
6428    }
6429    if(f)
6430    {
6431      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
6432                                             20-strlen(cmds[m].name),
6433                                             0/*cmds[m].alias*/
6434                                             /*-1 cmds[m].tokval*/
6435                                             /*0 cmds[m].toktype*/);
6436      cmds[m].name=NULL;
6437      m=-1;
6438      i=1;
6439      f=FALSE;
6440    }
6441    else break;
6442  }
6443  fprintf(outfile,
6444"/* end of list marker */\n"
6445"  { NULL, 0, 0, 0}\n"
6446"};\n"
6447"#ifdef HAVE_RTIMER\n"
6448"#define LAST_IDENTIFIER %d\n"
6449"#else\n"
6450"#define LAST_IDENTIFIER %d\n"
6451"#endif\n",id_nr,id_nr-1);
6452  fclose(outfile);
6453}
6454/*-------------------------------------------------------------------*/
6455#if 0
6456void ttGen3()
6457{
6458  FILE *outfile = myfopen("mpsr_tok.inc","w");
6459  fprintf(outfile,
6460  "/****************************************\n"
6461  "*  Computer Algebra System SINGULAR     *\n"
6462  "****************************************/\n\n");
6463/*-------------------------------------------------------------------*/
6464  fprintf(outfile,"// token table for Singular\n//\n");
6465
6466  fprintf(outfile,
6467  "short vtok[] =\n"
6468  "{\n");
6469  // operations with 1 arg: ===========================================
6470  int i=0;
6471  while (dArith1[i].cmd!=0)
6472  {
6473    if ((dArith1[i].p!=jjWRONG)
6474    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
6475    {
6476      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
6477    }
6478    i++;
6479  }
6480  // operations with 2 args: ===========================================
6481  i=0;
6482  while (dArith2[i].cmd!=0)
6483  {
6484    if ((dArith2[i].p!=jjWRONG2)
6485    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
6486    {
6487      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
6488    }
6489    i++;
6490  }
6491  // operations with 3 args: ===========================================
6492  i=0;
6493  while (dArith3[i].cmd!=0)
6494  {
6495    if (
6496    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
6497    {
6498      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
6499    }
6500    i++;
6501  }
6502  // operations with many args: ===========================================
6503  i=0;
6504  while (dArithM[i].cmd!=0)
6505  {
6506    if (
6507    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
6508    {
6509      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
6510    }
6511    i++;
6512  }
6513  // ====================================================================
6514  fprintf(outfile,
6515  "/* end of list marker */\n"
6516  " %d };\n",MAX_TOK);
6517  fclose(outfile);
6518}
6519#endif
6520void ttGen4()
6521{
6522  FILE *outfile = myfopen("plural_cmd.inc","w");
6523  int i;
6524  char *old_s="";
6525  fprintf(outfile,
6526  "@c *****************************************\n"
6527  "@c *  Computer Algebra System SINGULAR     *\n"
6528  "@c *****************************************\n\n");
6529/*-------------------------------------------------------------------*/
6530  fprintf(outfile,"@multicolumn .45 .45\n");
6531  int op;
6532  i=0;
6533  while ((op=dArith1[i].cmd)!=0)
6534  {
6535    if (dArith1[i].p!=jjWRONG)
6536    {
6537      char *s = iiTwoOps(op);
6538      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6539      {
6540        old_s=s;
6541        switch (dArith1[i].valid_for_plural)
6542        {
6543          case NO_PLURAL_N:
6544            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6545            break;
6546          case ALLOW_PLURAL_N:
6547            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6548            break;
6549          case COMM_PLURAL_N:
6550            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6551            break;
6552        }
6553      }
6554    }
6555    i++;
6556  }
6557  fprintf(outfile,"@c ---------------------------------------------\n");
6558  i=0;
6559  while ((op=dArith2[i].cmd)!=0)
6560  {
6561    if (dArith2[i].p!=jjWRONG2)
6562    {
6563      char *s = iiTwoOps(op);
6564      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6565      {
6566        old_s=s;
6567        switch (dArith2[i].valid_for_plural)
6568        {
6569          case NO_PLURAL_N:
6570            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6571            break;
6572          case ALLOW_PLURAL_N:
6573            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6574            break;
6575          case COMM_PLURAL_N:
6576            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6577            break;
6578        }
6579      }
6580    }
6581    i++;
6582  }
6583  fprintf(outfile,"@c ---------------------------------------------\n");
6584  i=0;
6585  while ((op=dArith3[i].cmd)!=0)
6586  {
6587    char *s = iiTwoOps(op);
6588    if (dArith3[i].p!=jjWRONG3)
6589    {
6590      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6591      {
6592        old_s=s;
6593        switch (dArith3[i].valid_for_plural)
6594        {
6595          case NO_PLURAL_N:
6596            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6597            break;
6598          case ALLOW_PLURAL_N:
6599            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6600            break;
6601          case COMM_PLURAL_N:
6602            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6603            break;
6604        }
6605      }
6606    }
6607    i++;
6608  }
6609  fprintf(outfile,"@c ---------------------------------------------\n");
6610  i=0;
6611  while ((op=dArithM[i].cmd)!=0)
6612  {
6613    char *s = iiTwoOps(op);
6614    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6615    {
6616        old_s=s;
6617        switch (dArithM[i].valid_for_plural)
6618        {
6619          case NO_PLURAL_N:
6620            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6621            break;
6622          case ALLOW_PLURAL_N:
6623            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6624            break;
6625          case COMM_PLURAL_N:
6626            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6627            break;
6628        }
6629    }
6630    i++;
6631  }
6632  fprintf(outfile,"@c ---------------------------------------------\n");
6633  fprintf(outfile,"@end table\n");
6634  fclose(outfile);
6635}
6636/*-------------------------------------------------------------------*/
6637#else
6638#include "iparith.inc"
6639#endif
6640
6641/*=================== operations with 2 args. ============================*/
6642
6643BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
6644{
6645#ifndef GENTABLE
6646  memset(res,0,sizeof(sleftv));
6647
6648  if (!errorreported)
6649  {
6650#ifdef SIQ
6651    if (siq>0)
6652    {
6653      //Print("siq:%d\n",siq);
6654      command d=(command)omAlloc0Bin(ip_command_bin);
6655      memcpy(&d->arg1,a,sizeof(sleftv));
6656      memcpy(&d->arg2,b,sizeof(sleftv));
6657      d->argc=2;
6658      d->op=op;
6659      res->data=(char *)d;
6660      res->rtyp=COMMAND;
6661      return FALSE;
6662    }
6663#endif
6664    int at=a->Typ();
6665    int bt=b->Typ();
6666    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
6667    int index=i;
6668
6669    iiOp=op;
6670    while (dArith2[i].cmd==op)
6671    {
6672      if ((at==dArith2[i].arg1)
6673      && (bt==dArith2[i].arg2))
6674      {
6675        res->rtyp=dArith2[i].res;
6676        #ifdef HAVE_PLURAL
6677        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6678        {
6679          if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6680          {
6681            WerrorS(ii_not_for_plural);
6682            break;
6683          }
6684          else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6685          {
6686            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6687          }
6688          /* else ALLOW_PLURAL */
6689        }
6690        #endif
6691        if (dArith2[i].p(res,a,b))
6692        {
6693          break;// leave loop, goto error handling
6694        }
6695        a->CleanUp();
6696        b->CleanUp();
6697        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6698        return FALSE;
6699      }
6700      i++;
6701    }
6702    // implicite type conversion ----------------------------------------------
6703    if (dArith2[i].cmd!=op)
6704    {
6705      int ai,bi;
6706      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6707      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
6708      BOOLEAN failed=FALSE;
6709      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6710      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
6711      while (dArith2[i].cmd==op)
6712      {
6713        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6714        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
6715        {
6716          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
6717          {
6718            res->rtyp=dArith2[i].res;
6719            #ifdef HAVE_PLURAL
6720            if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6721            {
6722              if (dArith2[i].valid_for_plural==0 /*NO_PLURAL*/)
6723              {
6724                WerrorS(ii_not_for_plural);
6725                break;
6726              }
6727              else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
6728              {
6729                Warn("assume commutative subalgebra for cmd `%s`",
6730                      Tok2Cmdname(i));
6731              }
6732              /* else ALLOW_PLURAL */
6733            }
6734            #endif
6735            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
6736            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
6737            || (dArith2[i].p(res,an,bn)));
6738            // everything done, clean up temp. variables
6739            if (failed)
6740            {
6741              // leave loop, goto error handling
6742              break;
6743            }
6744            else
6745            {
6746              // everything ok, clean up and return
6747              an->CleanUp();
6748              bn->CleanUp();
6749              omFreeBin((ADDRESS)an, sleftv_bin);
6750              omFreeBin((ADDRESS)bn, sleftv_bin);
6751              a->CleanUp();
6752              b->CleanUp();
6753              return FALSE;
6754            }
6755          }
6756        }
6757        i++;
6758      }
6759      an->CleanUp();
6760      bn->CleanUp();
6761      omFreeBin((ADDRESS)an, sleftv_bin);
6762      omFreeBin((ADDRESS)bn, sleftv_bin);
6763    }
6764    // error handling ---------------------------------------------------
6765    const char *s=NULL;
6766    if (!errorreported)
6767    {
6768      if ((at==0) && (a->Fullname()!=sNoName))
6769      {
6770        s=a->Fullname();
6771      }
6772      else if ((bt==0) && (b->Fullname()!=sNoName))
6773      {
6774        s=b->Fullname();
6775      }
6776      if (s!=NULL)
6777        Werror("`%s` is not defined",s);
6778      else
6779      {
6780        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
6781        s = iiTwoOps(op);
6782        if (proccall)
6783        {
6784          Werror("%s(`%s`,`%s`) is not supported"
6785                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
6786        }
6787        else
6788        {
6789          Werror("`%s` %s `%s` is not supported"
6790                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
6791        }
6792        if (BVERBOSE(V_SHOW_USE))
6793        {
6794          while (dArith2[i].cmd==op)
6795          {
6796            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
6797            && (dArith2[i].res!=0)
6798            && (dArith2[i].p!=jjWRONG2))
6799            {
6800              if (proccall)
6801                Werror("expected %s(`%s`,`%s`)"
6802                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
6803              else
6804                Werror("expected `%s` %s `%s`"
6805                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
6806            }
6807            i++;
6808          }
6809        }
6810      }
6811    }
6812    res->rtyp = UNKNOWN;
6813  }
6814  a->CleanUp();
6815  b->CleanUp();
6816#endif
6817  return TRUE;
6818}
6819
6820/*==================== operations with 1 arg. ===============================*/
6821
6822BOOLEAN iiExprArith1(leftv res, leftv a, int op)
6823{
6824#ifndef GENTABLE
6825  memset(res,0,sizeof(sleftv));
6826
6827  if (!errorreported)
6828  {
6829#ifdef SIQ
6830    if (siq>0)
6831    {
6832      //Print("siq:%d\n",siq);
6833      command d=(command)omAlloc0Bin(ip_command_bin);
6834      memcpy(&d->arg1,a,sizeof(sleftv));
6835      d->op=op;
6836      d->argc=1;
6837      res->data=(char *)d;
6838      res->rtyp=COMMAND;
6839      return FALSE;
6840    }
6841#endif
6842    int at=a->Typ();
6843    BOOLEAN failed=FALSE;
6844
6845    iiOp=op;
6846    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
6847    int ti = i;
6848    while (dArith1[i].cmd==op)
6849    {
6850      if (at==dArith1[i].arg)
6851      {
6852        int r=res->rtyp=dArith1[i].res;
6853        #ifdef HAVE_PLURAL
6854        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6855        {
6856          if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
6857          {
6858            WerrorS(ii_not_for_plural);
6859            break;
6860          }
6861          else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
6862          {
6863            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6864          }
6865          /* else ALLOW_PLURAL */
6866        }
6867        #endif
6868        if (r<0)
6869        {
6870          res->rtyp=-r;
6871          #ifdef PROC_BUG
6872          dArith1[i].p(res,a);
6873          #else
6874          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
6875          #endif
6876        }
6877        else if (dArith1[i].p(res,a))
6878        {
6879          break;// leave loop, goto error handling
6880        }
6881        if (a->Next()!=NULL)
6882        {
6883          res->next=(leftv)omAllocBin(sleftv_bin);
6884          failed=iiExprArith1(res->next,a->next,op);
6885        }
6886        a->CleanUp();
6887        return failed;
6888      }
6889      i++;
6890    }
6891    // implicite type conversion --------------------------------------------
6892    if (dArith1[i].cmd!=op)
6893    {
6894      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6895      i=ti;
6896      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
6897      while (dArith1[i].cmd==op)
6898      {
6899        int ai;
6900        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
6901        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
6902        {
6903          int r=res->rtyp=dArith1[i].res;
6904          #ifdef HAVE_PLURAL
6905          if ((currRing!=NULL) && (rIsPluralRing(currRing)))
6906          {
6907            if (dArith1[i].valid_for_plural==0 /*NO_PLURAL*/)
6908            {
6909              WerrorS(ii_not_for_plural);
6910              break;
6911            }
6912            else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
6913            {
6914              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
6915            }
6916            /* else ALLOW_PLURAL */
6917          }
6918          #endif
6919          if (r<0)
6920          {
6921            res->rtyp=-r;
6922            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
6923            if (!failed)
6924            {
6925              #ifdef PROC_BUG
6926              dArith1[i].p(res,a);
6927              #else
6928              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
6929              #endif
6930            }
6931          }
6932          else
6933          {
6934            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
6935            || (dArith1[i].p(res,an)));
6936          }
6937          // everything done, clean up temp. variables
6938          if (failed)
6939          {
6940            // leave loop, goto error handling
6941            break;
6942          }
6943          else
6944          {
6945            if (an->Next() != NULL)
6946            {
6947              res->next = (leftv)omAllocBin(sleftv_bin);
6948              failed=iiExprArith1(res->next,an->next,op);
6949            }
6950            // everything ok, clean up and return
6951            an->CleanUp();
6952            omFreeBin((ADDRESS)an, sleftv_bin);
6953            a->CleanUp();
6954            return failed;
6955          }
6956        }
6957        i++;
6958      }
6959      an->CleanUp();
6960      omFreeBin((ADDRESS)an, sleftv_bin);
6961    }
6962    // error handling
6963    if (!errorreported)
6964    {
6965      if ((at==0) && (a->Fullname()!=sNoName))
6966      {
6967        Werror("`%s` is not defined",a->Fullname());
6968      }
6969      else
6970      {
6971        i=ti;
6972        char *s = iiTwoOps(op);
6973        Werror("%s(`%s`) is not supported"
6974                ,s,Tok2Cmdname(at));
6975        if (BVERBOSE(V_SHOW_USE))
6976        {
6977          while (dArith1[i].cmd==op)
6978          {
6979            if ((dArith1[i].res!=0)
6980            && (dArith1[i].p!=jjWRONG))
6981              Werror("expected %s(`%s`)"
6982                ,s,Tok2Cmdname(dArith1[i].arg));
6983            i++;
6984          }
6985        }
6986      }
6987    }
6988    res->rtyp = UNKNOWN;
6989  }
6990  a->CleanUp();
6991#endif
6992  return TRUE;
6993}
6994
6995/*=================== operations with 3 args. ============================*/
6996
6997BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
6998{
6999#ifndef GENTABLE
7000  memset(res,0,sizeof(sleftv));
7001
7002  if (!errorreported)
7003  {
7004#ifdef SIQ
7005    if (siq>0)
7006    {
7007      //Print("siq:%d\n",siq);
7008      command d=(command)omAlloc0Bin(ip_command_bin);
7009      memcpy(&d->arg1,a,sizeof(sleftv));
7010      memcpy(&d->arg2,b,sizeof(sleftv));
7011      memcpy(&d->arg3,c,sizeof(sleftv));
7012      d->op=op;
7013      d->argc=3;
7014      res->data=(char *)d;
7015      res->rtyp=COMMAND;
7016      return FALSE;
7017    }
7018#endif
7019    int at=a->Typ();
7020    int bt=b->Typ();
7021    int ct=c->Typ();
7022
7023    iiOp=op;
7024    int i=0;
7025    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7026    while (dArith3[i].cmd==op)
7027    {
7028      if ((at==dArith3[i].arg1)
7029      && (bt==dArith3[i].arg2)
7030      && (ct==dArith3[i].arg3))
7031      {
7032        res->rtyp=dArith3[i].res;
7033        #ifdef HAVE_PLURAL
7034        if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7035        {
7036            if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7037            {
7038              WerrorS(ii_not_for_plural);
7039              break;
7040            }
7041            else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7042            {
7043              Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7044            }
7045            /* else ALLOW_PLURAL */
7046        }
7047        #endif
7048        if (dArith3[i].p(res,a,b,c))
7049        {
7050          break;// leave loop, goto error handling
7051        }
7052        a->CleanUp();
7053        b->CleanUp();
7054        c->CleanUp();
7055        return FALSE;
7056      }
7057      i++;
7058    }
7059    // implicite type conversion ----------------------------------------------
7060    if (dArith3[i].cmd!=op)
7061    {
7062      int ai,bi,ci;
7063      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7064      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7065      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
7066      BOOLEAN failed=FALSE;
7067      i=0;
7068      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7069      while (dArith3[i].cmd==op)
7070      {
7071        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
7072        {
7073          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
7074          {
7075            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
7076            {
7077              res->rtyp=dArith3[i].res;
7078              #ifdef HAVE_PLURAL
7079              if ((currRing!=NULL)
7080              && (rIsPluralRing(currRing)))
7081              {
7082                if (dArith3[i].valid_for_plural==0 /*NO_PLURAL*/)
7083                {
7084                   WerrorS(ii_not_for_plural);
7085                   break;
7086                 }
7087                 else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7088                 {
7089                   Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7090                 }
7091                 /* else ALLOW_PLURAL */
7092              }
7093              #endif
7094              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
7095                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
7096                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
7097                || (dArith3[i].p(res,an,bn,cn)));
7098              // everything done, clean up temp. variables
7099              if (failed)
7100              {
7101                // leave loop, goto error handling
7102                break;
7103              }
7104              else
7105              {
7106                // everything ok, clean up and return
7107                an->CleanUp();
7108                bn->CleanUp();
7109                cn->CleanUp();
7110                omFreeBin((ADDRESS)an, sleftv_bin);
7111                omFreeBin((ADDRESS)bn, sleftv_bin);
7112                omFreeBin((ADDRESS)cn, sleftv_bin);
7113                a->CleanUp();
7114                b->CleanUp();
7115                c->CleanUp();
7116        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7117                return FALSE;
7118              }
7119            }
7120          }
7121        }
7122        i++;
7123      }
7124      an->CleanUp();
7125      bn->CleanUp();
7126      cn->CleanUp();
7127      omFreeBin((ADDRESS)an, sleftv_bin);
7128      omFreeBin((ADDRESS)bn, sleftv_bin);
7129      omFreeBin((ADDRESS)cn, sleftv_bin);
7130    }
7131    // error handling ---------------------------------------------------
7132    if (!errorreported)
7133    {
7134      const char *s=NULL;
7135      if ((at==0) && (a->Fullname()!=sNoName))
7136      {
7137        s=a->Fullname();
7138      }
7139      else if ((bt==0) && (b->Fullname()!=sNoName))
7140      {
7141        s=b->Fullname();
7142      }
7143      else if ((ct==0) && (c->Fullname()!=sNoName))
7144      {
7145        s=c->Fullname();
7146      }
7147      if (s!=NULL)
7148        Werror("`%s` is not defined",s);
7149      else
7150      {
7151        i=0;
7152        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7153        char *s = iiTwoOps(op);
7154        Werror("%s(`%s`,`%s`,`%s`) is not supported"
7155                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
7156        if (BVERBOSE(V_SHOW_USE))
7157        {
7158          while (dArith3[i].cmd==op)
7159          {
7160            if(((at==dArith3[i].arg1)
7161            ||(bt==dArith3[i].arg2)
7162            ||(ct==dArith3[i].arg3))
7163            && (dArith3[i].res!=0))
7164            {
7165              Werror("expected %s(`%s`,`%s`,`%s`)"
7166                  ,s,Tok2Cmdname(dArith3[i].arg1)
7167                  ,Tok2Cmdname(dArith3[i].arg2)
7168                  ,Tok2Cmdname(dArith3[i].arg3));
7169            }
7170            i++;
7171          }
7172        }
7173      }
7174    }
7175    res->rtyp = UNKNOWN;
7176  }
7177  a->CleanUp();
7178  b->CleanUp();
7179  c->CleanUp();
7180        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7181#endif
7182  return TRUE;
7183}
7184/*==================== operations with many arg. ===============================*/
7185
7186BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
7187{
7188  // cnt = 0: all
7189  // cnt = 1: only first one
7190  leftv next;
7191  BOOLEAN failed = TRUE;
7192  if(v==NULL) return failed;
7193  res->rtyp = LIST_CMD;
7194  if(cnt) v->next = NULL;
7195  next = v->next;             // saving next-pointer
7196  failed = jjLIST_PL(res, v);
7197  v->next = next;             // writeback next-pointer
7198  return failed;
7199}
7200
7201BOOLEAN iiExprArithM(leftv res, leftv a, int op)
7202{
7203#ifndef GENTABLE
7204  memset(res,0,sizeof(sleftv));
7205
7206  if (!errorreported)
7207  {
7208#ifdef SIQ
7209    if (siq>0)
7210    {
7211      //Print("siq:%d\n",siq);
7212      command d=(command)omAlloc0Bin(ip_command_bin);
7213      d->op=op;
7214      res->data=(char *)d;
7215      if (a!=NULL)
7216      {
7217        d->argc=a->listLength();
7218        // else : d->argc=0;
7219        memcpy(&d->arg1,a,sizeof(sleftv));
7220        switch(d->argc)
7221        {
7222          case 3:
7223            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
7224            a->next->next->rtyp=0;
7225            a->next->next->data=NULL;
7226            a->next->next->name=NULL;
7227            a->next->next->attribute=NULL;
7228            /* no break */
7229          case 2:
7230            memcpy(&d->arg2,a->next,sizeof(sleftv));
7231            a->next->rtyp=0;
7232            a->next->name=NULL;
7233            a->next->data=NULL;
7234            a->next->attribute=NULL;
7235            d->arg2.next=NULL;
7236            /* no break */
7237          case 1:
7238            d->arg1.next=NULL;
7239        }
7240        if (d->argc>3) a->next=NULL;
7241        a->rtyp=0;
7242        a->data=NULL;
7243        a->name=NULL;
7244        a->CleanUp();
7245      }
7246      res->rtyp=COMMAND;
7247      return FALSE;
7248    }
7249#endif
7250    BOOLEAN failed=FALSE;
7251    int args=0;
7252    if (a!=NULL) args=a->listLength();
7253
7254    iiOp=op;
7255    int i=0;
7256    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
7257    while (dArithM[i].cmd==op)
7258    {
7259      if ((args==dArithM[i].number_of_args)
7260      || (dArithM[i].number_of_args==-1)
7261      || ((dArithM[i].number_of_args==-2)&&(args>0)))
7262      {
7263        res->rtyp=dArithM[i].res;
7264        #ifdef HAVE_PLURAL
7265        if ((currRing!=NULL)
7266        && (rIsPluralRing(currRing)))
7267        {
7268          if (dArithM[i].valid_for_plural==0 /*NO_PLURAL*/)
7269          {
7270            WerrorS(ii_not_for_plural);
7271            break;
7272          }
7273          else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
7274          {
7275            Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7276          }
7277          /* else ALLOW_PLURAL */
7278        }
7279        #endif
7280        if (dArithM[i].p(res,a))
7281        {
7282          break;// leave loop, goto error handling
7283        }
7284        if (a!=NULL) a->CleanUp();
7285        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7286        return failed;
7287      }
7288      i++;
7289    }
7290    // error handling
7291    if (!errorreported)
7292    {
7293      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
7294      {
7295        Werror("`%s` is not defined",a->Fullname());
7296      }
7297      else
7298      {
7299        char *s = iiTwoOps(op);
7300        Werror("%s(...) is not supported",s);
7301      }
7302    }
7303    res->rtyp = UNKNOWN;
7304  }
7305  if (a!=NULL) a->CleanUp();
7306        //Print("op: %d,result typ:%d\n",op,res->rtyp);
7307#endif
7308  return TRUE;
7309}
7310
7311/*=================== general utilities ============================*/
7312int IsCmd(char *n, int & tok)
7313{
7314  int an=1;
7315  int i,v;
7316#ifndef GENTABLE
7317  int en=LAST_IDENTIFIER;
7318
7319  loop
7320  {
7321    if(an>=en-1)
7322    {
7323      if (strcmp(n, cmds[an].name) == 0)
7324      {
7325        i=an;
7326        break;
7327      }
7328      else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
7329      {
7330        i=en;
7331        break;
7332      }
7333      else
7334      {
7335        return 0;
7336      }
7337    }
7338    i=(an+en)/2;
7339    if (*n < *(cmds[i].name))
7340    {
7341      en=i-1;
7342    }
7343    else if (*n > *(cmds[i].name))
7344    {
7345      an=i+1;
7346    }
7347    else
7348    {
7349      v=strcmp(n,cmds[i].name);
7350      if(v<0)
7351      {
7352        en=i-1;
7353      }
7354      else if(v>0)
7355      {
7356        an=i+1;
7357      }
7358      else /*v==0*/
7359      {
7360        break;
7361      }
7362    }
7363  }
7364  lastreserved=cmds[i].name;
7365  tok=cmds[i].tokval;
7366  if(cmds[i].alias==2)
7367  {
7368    Warn("outdated identifier `%s` used - please change your code",
7369    cmds[i].name);
7370    cmds[i].alias=1;
7371  }
7372  if (currRingHdl==NULL)
7373  {
7374    #ifdef SIQ
7375    if (siq<=0)
7376    {
7377    #endif
7378      if ((tok>=BEGIN_RING) && (tok<=END_RING))
7379      {
7380        WerrorS("no ring active");
7381        return 0;
7382      }
7383    #ifdef SIQ
7384    }
7385    #endif
7386  }
7387  if (!expected_parms)
7388  {
7389    switch (tok)
7390    {
7391      case IDEAL_CMD:
7392      case INT_CMD:
7393      case INTVEC_CMD:
7394      case MAP_CMD:
7395      case MATRIX_CMD:
7396      case MODUL_CMD:
7397      case POLY_CMD:
7398      case PROC_CMD:
7399      case RING_CMD:
7400      case STRING_CMD:
7401        cmdtok = tok;
7402        break;
7403    }
7404  }
7405  return cmds[i].toktype;
7406#else
7407  return 0;
7408#endif
7409}
7410static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
7411{
7412#ifndef GENTABLE
7413  int a=0;
7414  int e=len;
7415  int p=len/2;
7416  do
7417  {
7418     if (op==dArithTab[p].cmd) return dArithTab[p].start;
7419     if (op<dArithTab[p].cmd) e=p-1;
7420     else   a = p+1;
7421     p=a+(e-a)/2;
7422  }
7423  while ( a <= e);
7424
7425#endif
7426  assume(0);
7427  return 0;
7428}
7429
Note: See TracBrowser for help on using the repository browser.