source: git/Singular/iparith.cc @ f8362b

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