source: git/Singular/iparith.cc @ 660ed3

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