source: git/Singular/iparith.cc @ 0b8c8d

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