source: git/Singular/iparith.cc @ a96f4d

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