source: git/Singular/iparith.cc @ 3eb1631

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