source: git/Singular/iparith.cc @ b52e66

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