source: git/Singular/iparith.cc @ 4f3177

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