source: git/Singular/iparith.cc @ 2ef280

spielwiese
Last change on this file since 2ef280 was 2ef280, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes: exportto git-svn-id: file:///usr/local/Singular/svn/trunk@8085 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 208.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.355 2005-05-06 17:31:04 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 iiExport(v,0,(idhdl)u->data);
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  {
3620    Werror("ordering must be global for slimgb");
3621    return TRUE;
3622  }
3623  res->data=(char *)t_rep_gb(currRing, (ideal)u->Data());
3624  return FALSE;
3625}
3626static BOOLEAN jjSTD(leftv res, leftv v)
3627{
3628  ideal result;
3629  intvec *w=(intvec *)atGet(v,"isHomog");
3630  tHomog hom=testHomog;
3631  if (w!=NULL)
3632  {
3633    w=ivCopy(w);
3634    hom=isHomog;
3635  }
3636  result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3637  idSkipZeroes(result);
3638  res->data = (char *)result;
3639  setFlag(res,FLAG_STD);
3640  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3641  return FALSE;
3642}
3643static BOOLEAN jjSort_Id(leftv res, leftv v)
3644{
3645  res->data = (char *)idSort((ideal)v->Data());
3646  return FALSE;
3647}
3648static BOOLEAN jjSYZYGY(leftv res, leftv v)
3649{
3650  intvec *w=NULL;
3651  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3652  if (w!=NULL) delete w;
3653  return FALSE;
3654}
3655static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3656{
3657  res->data = (char *)ivTrace((intvec*)(v->Data()));
3658  return FALSE;
3659}
3660static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3661{
3662  res->data = (char *)ivTranp((intvec*)(v->Data()));
3663  return FALSE;
3664}
3665
3666#ifdef HAVE_PLURAL
3667
3668static BOOLEAN jjOPPOSITE(leftv res, leftv a)
3669{
3670  ring    r = (ring)a->Data();
3671  if (rIsPluralRing(r))
3672  {
3673    res->data = rOpposite(r);
3674  }
3675  else res->data = rCopy(r);
3676  return FALSE;
3677}
3678
3679static BOOLEAN jjENVELOPE(leftv res, leftv a)
3680{
3681  ring    r = (ring)a->Data();
3682  if (rIsPluralRing(r))
3683  {
3684    //    ideal   i;
3685//     if (a->rtyp == QRING_CMD)
3686//     {
3687//       i = r->qideal;
3688//       r->qideal = NULL;
3689//     }
3690    ring s = rEnvelope(r);
3691//     if (a->rtyp == QRING_CMD)
3692//     {
3693//       ideal is  = idOppose(r,i); /* twostd? */
3694//       is        = idAdd(is,i);
3695//       s->qideal = i;
3696//     }
3697    res->data = s;
3698  }
3699  else  res->data = rCopy(r);
3700  return FALSE;
3701}
3702
3703static BOOLEAN jjTWOSTD(leftv res, leftv a)
3704{
3705  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
3706  else  res->data=(ideal)a->Data();
3707  setFlag(res,FLAG_STD);
3708  setFlag(res,FLAG_TWOSTD);
3709  return FALSE;
3710}
3711#endif
3712
3713static BOOLEAN jjTYPEOF(leftv res, leftv v)
3714{
3715  switch ((int)v->data)
3716  {
3717    case INT_CMD:     res->data=omStrDup("int"); break;
3718    case POLY_CMD:   res->data=omStrDup("poly"); break;
3719    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3720    case STRING_CMD:  res->data=omStrDup("string"); break;
3721    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3722    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3723    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3724    case MODUL_CMD:   res->data=omStrDup("module"); break;
3725    case MAP_CMD:     res->data=omStrDup("map"); break;
3726    case PROC_CMD:    res->data=omStrDup("proc"); break;
3727    case RING_CMD:    res->data=omStrDup("ring"); break;
3728    case QRING_CMD:   res->data=omStrDup("qring"); break;
3729    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3730    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3731    case LIST_CMD:   res->data=omStrDup("list"); break;
3732    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3733    case LINK_CMD:   res->data=omStrDup("link"); break;
3734    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3735    case DEF_CMD:
3736    case NONE:    res->data=omStrDup("none"); break;
3737    default:       res->data=omStrDup("?unknown type?");
3738  }
3739  return FALSE;
3740}
3741static BOOLEAN jjVAR1(leftv res, leftv v)
3742{
3743  int i=(int)v->Data();
3744  if ((0<i) && (i<=currRing->N))
3745  {
3746    poly p=pOne();
3747    pSetExp(p,i,1);
3748    pSetm(p);
3749    res->data=(char *)p;
3750  }
3751  else
3752  {
3753    Werror("var number %d out of range 1..%d",i,currRing->N);
3754    return TRUE;
3755  }
3756  return FALSE;
3757}
3758static BOOLEAN jjVARSTR1(leftv res, leftv v)
3759{
3760  if (currRing==NULL)
3761  {
3762    WerrorS("no ring active");
3763    return TRUE;
3764  }
3765  int i=(int)v->Data();
3766  if ((0<i) && (i<=currRing->N))
3767    res->data=omStrDup(currRing->names[i-1]);
3768  else
3769  {
3770    Werror("var number %d out of range 1..%d",i,currRing->N);
3771    return TRUE;
3772  }
3773  return FALSE;
3774}
3775static BOOLEAN jjVDIM(leftv res, leftv v)
3776{
3777  assumeStdFlag(v);
3778  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
3779  return FALSE;
3780}
3781
3782static BOOLEAN jjLOAD1(leftv res, leftv v)
3783{
3784  return jjLOAD(res, v);
3785}
3786
3787static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
3788{
3789  char * s=(char *)v->CopyD();
3790  char libnamebuf[256];
3791  lib_types LT = type_of_LIB(s, libnamebuf);
3792#ifdef HAVE_DYNAMIC_LOADING
3793  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN tellerror);
3794#endif /* HAVE_DYNAMIC_LOADING */
3795
3796  switch(LT)
3797  {
3798      default:
3799      case LT_NONE:
3800        Werror("%s: unknown type", s);
3801        break;
3802      case LT_NOTFOUND:
3803        Werror("cannot open %s", s);
3804        break;
3805
3806      case LT_SINGULAR:
3807        return iiLibCmd(s);
3808
3809      case LT_ELF:
3810      case LT_HPUX:
3811#ifdef HAVE_DYNAMIC_LOADING
3812        return load_modules(s, libnamebuf, autoexport);
3813#else /* HAVE_DYNAMIC_LOADING */
3814        WerrorS("Dynamic modules are not supported by this version of Singular");
3815        break;
3816#endif /* HAVE_DYNAMIC_LOADING */
3817  }
3818  return TRUE;
3819}
3820
3821/*=================== operations with 1 arg.: table =================*/
3822
3823#ifdef INIT_BUG
3824#define XS(A) -((short)A)
3825#define jjstrlen       (proc1)1
3826#define jjpLength      (proc1)2
3827#define jjidElem       (proc1)3
3828#define jjmpDetBareiss (proc1)4
3829#define jjidFreeModule (proc1)5
3830#define jjidVec2Ideal  (proc1)6
3831#define jjrCharStr     (proc1)7
3832#ifndef MDEBUG
3833#define jjpHead        (proc1)8
3834#endif
3835#define jjidHead       (proc1)9
3836#define jjidMaxIdeal   (proc1)10
3837#define jjidMinBase    (proc1)11
3838#define jjsyMinBase    (proc1)12
3839#define jjpMaxComp     (proc1)13
3840#define jjmpTrace      (proc1)14
3841#define jjmpTransp     (proc1)15
3842#define jjrOrdStr      (proc1)16
3843#define jjrVarStr      (proc1)18
3844#define jjrParStr      (proc1)19
3845#define jjCOUNT_RES    (proc1)22
3846#define jjDIM_R        (proc1)23
3847#define jjMINRES_R     (proc1)24
3848#define jjidTransp     (proc1)25
3849
3850extern struct sValCmd1 dArith1[];
3851void jjInitTab1()
3852{
3853  int i=0;
3854  for (;dArith1[i].cmd!=0;i++)
3855  {
3856    if (dArith1[i].res<0)
3857    {
3858      switch ((int)dArith1[i].p)
3859      {
3860        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
3861        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
3862        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
3863        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
3864#ifndef HAVE_FACTORY
3865        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
3866#endif
3867        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
3868        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
3869#ifndef MDEBUG
3870        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
3871#endif
3872        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
3873        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
3874        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
3875        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
3876        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
3877        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
3878        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
3879        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
3880        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
3881        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
3882        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
3883        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
3884        case (int)jjMINRES_R:     dArith1[i].p=(proc1)syMinimize; break;
3885        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
3886#ifdef GENTABLE
3887        default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
3888#endif
3889      }
3890    }
3891  }
3892}
3893#else
3894#if defined(PROC_BUG)
3895#define XS(A) A
3896static BOOLEAN jjstrlen(leftv res, leftv v)
3897{
3898  res->data = (char *)strlen((char *)v->Data());
3899  return FALSE;
3900}
3901static BOOLEAN jjpLength(leftv res, leftv v)
3902{
3903  res->data = (char *)pLength((poly)v->Data());
3904  return FALSE;
3905}
3906static BOOLEAN jjidElem(leftv res, leftv v)
3907{
3908  res->data = (char *)idElem((ideal)v->Data());
3909  return FALSE;
3910}
3911static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
3912{
3913  res->data = (char *)mpDetBareiss((matrix)v->Data());
3914  return FALSE;
3915}
3916static BOOLEAN jjidFreeModule(leftv res, leftv v)
3917{
3918  res->data = (char *)idFreeModule((int)v->Data());
3919  return FALSE;
3920}
3921static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
3922{
3923  res->data = (char *)idVec2Ideal((poly)v->Data());
3924  return FALSE;
3925}
3926static BOOLEAN jjrCharStr(leftv res, leftv v)
3927{
3928  res->data = rCharStr((ring)v->Data());
3929  return FALSE;
3930}
3931#ifndef MDEBUG
3932static BOOLEAN jjpHead(leftv res, leftv v)
3933{
3934  res->data = (char *)pHead((poly)v->Data());
3935  return FALSE;
3936}
3937#endif
3938static BOOLEAN jjidHead(leftv res, leftv v)
3939{
3940  res->data = (char *)idHead((ideal)v->Data());
3941  return FALSE;
3942}
3943static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
3944{
3945  res->data = (char *)idMaxIdeal((int)v->Data());
3946  return FALSE;
3947}
3948static BOOLEAN jjidMinBase(leftv res, leftv v)
3949{
3950  res->data = (char *)idMinBase((ideal)v->Data());
3951  return FALSE;
3952}
3953static BOOLEAN jjsyMinBase(leftv res, leftv v)
3954{
3955  res->data = (char *)syMinBase((ideal)v->Data());
3956  return FALSE;
3957}
3958static BOOLEAN jjpMaxComp(leftv res, leftv v)
3959{
3960  res->data = (char *)pMaxComp((poly)v->Data());
3961  return FALSE;
3962}
3963static BOOLEAN jjmpTrace(leftv res, leftv v)
3964{
3965  res->data = (char *)mpTrace((matrix)v->Data());
3966  return FALSE;
3967}
3968static BOOLEAN jjmpTransp(leftv res, leftv v)
3969{
3970  res->data = (char *)mpTransp((matrix)v->Data());
3971  return FALSE;
3972}
3973static BOOLEAN jjrOrdStr(leftv res, leftv v)
3974{
3975  res->data = rOrdStr((ring)v->Data());
3976  return FALSE;
3977}
3978static BOOLEAN jjrVarStr(leftv res, leftv v)
3979{
3980  res->data = rVarStr((ring)v->Data());
3981  return FALSE;
3982}
3983static BOOLEAN jjrParStr(leftv res, leftv v)
3984{
3985  res->data = rParStr((ring)v->Data());
3986  return FALSE;
3987}
3988static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
3989{
3990  res->data=(char *)syLength((syStrategy)v->Data());
3991  return FALSE;
3992}
3993static BOOLEAN jjDIM_R(leftv res, leftv v)
3994{
3995  res->data = (char *)syDim((syStrategy)v->Data());
3996  return FALSE;
3997}
3998static BOOLEAN jjMINRES_R(leftv res, leftv v)
3999{
4000  res->data=(char *)syMinimize((syStrategy)v->Data());
4001  return FALSE;
4002}
4003static BOOLEAN jjidTransp(leftv res, leftv v)
4004{
4005  res->data = (char *)idTransp((ideal)v->Data());
4006  return FALSE;
4007}
4008#else
4009#define XS(A)          -((short)A)
4010#define jjstrlen       (proc1)strlen
4011#define jjpLength      (proc1)pLength
4012#define jjidElem       (proc1)idElem
4013#define jjmpDetBareiss (proc1)mpDetBareiss
4014#define jjidFreeModule (proc1)idFreeModule
4015#define jjidVec2Ideal  (proc1)idVec2Ideal
4016#define jjrCharStr     (proc1)rCharStr
4017#ifndef MDEBUG
4018#define jjpHead        (proc1)pHeadProc
4019#endif
4020#define jjidHead       (proc1)idHead
4021#define jjidMaxIdeal   (proc1)idMaxIdeal
4022#define jjidMinBase    (proc1)idMinBase
4023#define jjsyMinBase    (proc1)syMinBase
4024#define jjpMaxComp     (proc1)pMaxCompProc
4025#define jjmpTrace      (proc1)mpTrace
4026#define jjmpTransp     (proc1)mpTransp
4027#define jjrOrdStr      (proc1)rOrdStr
4028#define jjrVarStr      (proc1)rVarStr
4029#define jjrParStr      (proc1)rParStr
4030#define jjCOUNT_RES    (proc1)syLength
4031#define jjDIM_R        (proc1)syDim
4032#define jjMINRES_R     (proc1)syMinimize
4033#define jjidTransp     (proc1)idTransp
4034#endif
4035#endif
4036static BOOLEAN jjnInt(leftv res, leftv u)
4037{
4038  number n=(number)u->CopyD(NUMBER_CMD);
4039  res->data=(char *)nInt(n);
4040  nDelete(&n);
4041  return FALSE;
4042}
4043#define s short
4044struct sValCmd1 dArith1[]=
4045{
4046// operations:
4047// proc         cmd               res             arg           plural
4048// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
4049//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
4050 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
4051,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
4052,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
4053,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4054,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4055,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4056,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4057,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4058,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4059,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
4060,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
4061// and the procedures with 1 argument:
4062,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
4063//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
4064,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
4065,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
4066,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
4067,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4068,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     MODUL_CMD      ALLOW_PLURAL}
4069,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
4070,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
4071#ifdef HAVE_FACTORY
4072,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4073#else
4074,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
4075#endif
4076,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4077,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4078,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
4079//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
4080,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4081,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4082,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4083,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4084,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
4085,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4086,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4087,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4088,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4089,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
4090,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
4091,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4092,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
4093,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
4094,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4095,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4096,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4097,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
4098,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4099,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
4100,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4101,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4102,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4103,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4104,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
4105,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
4106,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
4107#ifdef HAVE_FACTORY
4108,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4109,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
4110,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
4111#else
4112,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4113,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
4114#endif
4115,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
4116,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
4117,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
4118,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4119,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
4120,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4121,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
4122#ifdef HAVE_FACTORY
4123,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4124#else
4125,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
4126#endif
4127#ifdef HAVE_FGLM
4128,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4129#else
4130,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4131#endif
4132,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
4133#ifdef HAVE_FACTORY
4134,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4135#else
4136,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4137#endif
4138,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
4139,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
4140,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
4141,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
4142,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
4143,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
4144,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4145,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4146,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
4147,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
4148,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
4149,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
4150,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
4151,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4152,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4153,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
4154,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
4155,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4156,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4157,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4158,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
4159,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4160,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4161,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4162,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4163,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
4164,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
4165,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
4166,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4167,{jjJanetBasis, JANET_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4168,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4169,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4170,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
4171#ifdef MDEBUG
4172,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4173#else
4174,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
4175#endif
4176,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
4177#ifdef MDEBUG
4178,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4179#else
4180,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
4181#endif
4182,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4183,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4184,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4185,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
4186,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4187,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4188,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4189,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
4190,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
4191,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
4192,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
4193,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
4194,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
4195,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
4196,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
4197,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
4198,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
4199,{jjMINRES_R,   MINRES_CMD,      XS(RESOLUTION_CMD), RESOLUTION_CMD ALLOW_PLURAL}
4200,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4201,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
4202,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
4203,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
4204,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
4205,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
4206,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4207,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
4208,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4209,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4210,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4211,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
4212,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4213,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4214,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
4215,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
4216,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
4217,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
4218,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
4219,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4220,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4221,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
4222,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
4223,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4224,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4225,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4226,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
4227,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
4228,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
4229,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
4230,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
4231,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4232,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4233,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4234,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
4235,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
4236,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
4237,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
4238,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
4239,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
4240,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4241,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
4242,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
4243,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
4244,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
4245//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
4246,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
4247,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4248,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
4249,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4250,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
4251,{jjSLIM_GB,    SLIM_GB_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
4252,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4253,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4254,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4255,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4256,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
4257,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
4258,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4259,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
4260#ifdef HAVE_PLURAL
4261,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4262,{jjENVELOPE,   ENVELOPE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4263,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
4264,{jjOPPOSITE,   OPPOSITE_CMD,    QRING_CMD,      QRING_CMD      ALLOW_PLURAL}
4265,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4266#endif
4267,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
4268,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
4269,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
4270,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
4271,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
4272,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
4273,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
4274,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
4275,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
4276,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
4277,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
4278,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
4279,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
4280,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
4281,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
4282,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
4283,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
4284,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
4285,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4286,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4287,{NULL,         0,               0,              0              NO_PLURAL}
4288};
4289#undef s
4290/*=================== operations with 3 args.: static proc =================*/
4291static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4292{
4293  char *s= (char *)u->Data();
4294  int   r = (int)v->Data();
4295  int   c = (int)w->Data();
4296  int l = strlen(s);
4297
4298  if ( (r<1) || (r>l) || (c<0) )
4299  {
4300    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4301    return TRUE;
4302  }
4303  res->data = (char *)omAlloc(c+1);
4304  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4305  return FALSE;
4306}
4307static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4308{
4309  intvec *iv = (intvec *)u->Data();
4310  int   r = (int)v->Data();
4311  int   c = (int)w->Data();
4312  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4313  {
4314    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4315           r,c,u->Fullname(),iv->rows(),iv->cols());
4316    return TRUE;
4317  }
4318  res->data=u->data;
4319  u->data=NULL;
4320  res->rtyp=u->rtyp;
4321  u->rtyp=0;
4322  res->name=u->name;
4323  u->name=NULL;
4324  Subexpr e=jjMakeSub(v);
4325          e->next=jjMakeSub(w);
4326  if (u->e==NULL) res->e=e;
4327  else
4328  {
4329    Subexpr h=u->e;
4330    while (h->next!=NULL) h=h->next;
4331    h->next=e;
4332    res->e=u->e;
4333    u->e=NULL;
4334  }
4335  return FALSE;
4336}
4337static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4338{
4339  matrix m= (matrix)u->Data();
4340  int   r = (int)v->Data();
4341  int   c = (int)w->Data();
4342  //Print("gen. elem %d, %d\n",r,c);
4343  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4344  {
4345    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4346      MATROWS(m),MATCOLS(m));
4347    return TRUE;
4348  }
4349  res->data=u->data;
4350  u->data=NULL;
4351  res->rtyp=u->rtyp;
4352  u->rtyp=0;
4353  res->name=u->name;
4354  u->name=NULL;
4355  Subexpr e=jjMakeSub(v);
4356          e->next=jjMakeSub(w);
4357  if (u->e==NULL)
4358    res->e=e;
4359  else
4360  {
4361    Subexpr h=u->e;
4362    while (h->next!=NULL) h=h->next;
4363    h->next=e;
4364    res->e=u->e;
4365    u->e=NULL;
4366  }
4367  return FALSE;
4368}
4369static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4370{
4371  sleftv t;
4372  sleftv ut;
4373  leftv p=NULL;
4374  intvec *iv=(intvec *)w->Data();
4375  int l;
4376  BOOLEAN nok;
4377
4378  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4379  {
4380    WerrorS("cannot build expression lists from unnamed objects");
4381    return TRUE;
4382  }
4383  memcpy(&ut,u,sizeof(ut));
4384  memset(&t,0,sizeof(t));
4385  t.rtyp=INT_CMD;
4386  for (l=0;l< iv->length(); l++)
4387  {
4388    t.data=(char *)(*iv)[l];
4389    if (p==NULL)
4390    {
4391      p=res;
4392    }
4393    else
4394    {
4395      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4396      p=p->next;
4397    }
4398    memcpy(u,&ut,sizeof(ut));
4399    if (u->Typ() == MATRIX_CMD)
4400      nok=jjBRACK_Ma(p,u,v,&t);
4401    else /* INTMAT_CMD */
4402      nok=jjBRACK_Im(p,u,v,&t);
4403    if (nok)
4404    {
4405      while (res->next!=NULL)
4406      {
4407        p=res->next->next;
4408        omFreeBin((ADDRESS)res->next, sleftv_bin);
4409        // res->e aufraeumen !!!!
4410        res->next=p;
4411      }
4412      return TRUE;
4413    }
4414  }
4415  return FALSE;
4416}
4417static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4418{
4419  sleftv t;
4420  sleftv ut;
4421  leftv p=NULL;
4422  intvec *iv=(intvec *)v->Data();
4423  int l;
4424  BOOLEAN nok;
4425
4426  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4427  {
4428    WerrorS("cannot build expression lists from unnamed objects");
4429    return TRUE;
4430  }
4431  memcpy(&ut,u,sizeof(ut));
4432  memset(&t,0,sizeof(t));
4433  t.rtyp=INT_CMD;
4434  for (l=0;l< iv->length(); l++)
4435  {
4436    t.data=(char *)((*iv)[l]);
4437    if (p==NULL)
4438    {
4439      p=res;
4440    }
4441    else
4442    {
4443      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4444      p=p->next;
4445    }
4446    memcpy(u,&ut,sizeof(ut));
4447    if (u->Typ() == MATRIX_CMD)
4448      nok=jjBRACK_Ma(p,u,&t,w);
4449    else /* INTMAT_CMD */
4450      nok=jjBRACK_Im(p,u,&t,w);
4451    if (nok)
4452    {
4453      while (res->next!=NULL)
4454      {
4455        p=res->next->next;
4456        omFreeBin((ADDRESS)res->next, sleftv_bin);
4457        // res->e aufraeumen !!
4458        res->next=p;
4459      }
4460      return TRUE;
4461    }
4462  }
4463  return FALSE;
4464}
4465static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4466{
4467  sleftv t1,t2,ut;
4468  leftv p=NULL;
4469  intvec *vv=(intvec *)v->Data();
4470  intvec *wv=(intvec *)w->Data();
4471  int vl;
4472  int wl;
4473  BOOLEAN nok;
4474
4475  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4476  {
4477    WerrorS("cannot build expression lists from unnamed objects");
4478    return TRUE;
4479  }
4480  memcpy(&ut,u,sizeof(ut));
4481  memset(&t1,0,sizeof(sleftv));
4482  memset(&t2,0,sizeof(sleftv));
4483  t1.rtyp=INT_CMD;
4484  t2.rtyp=INT_CMD;
4485  for (vl=0;vl< vv->length(); vl++)
4486  {
4487    t1.data=(char *)((*vv)[vl]);
4488    for (wl=0;wl< wv->length(); wl++)
4489    {
4490      t2.data=(char *)((*wv)[wl]);
4491      if (p==NULL)
4492      {
4493        p=res;
4494      }
4495      else
4496      {
4497        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4498        p=p->next;
4499      }
4500      memcpy(u,&ut,sizeof(ut));
4501      if (u->Typ() == MATRIX_CMD)
4502        nok=jjBRACK_Ma(p,u,&t1,&t2);
4503      else /* INTMAT_CMD */
4504        nok=jjBRACK_Im(p,u,&t1,&t2);
4505      if (nok)
4506      {
4507        res->CleanUp();
4508        return TRUE;
4509      }
4510    }
4511  }
4512  return FALSE;
4513}
4514static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4515{
4516  v->next=(leftv)omAllocBin(sleftv_bin);
4517  memcpy(v->next,w,sizeof(sleftv));
4518  memset(w,0,sizeof(sleftv));
4519  return jjPROC(res,u,v);
4520}
4521static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4522{
4523  u->next=(leftv)omAllocBin(sleftv_bin);
4524  memcpy(u->next,v,sizeof(sleftv));
4525  u->next->next=(leftv)omAllocBin(sleftv_bin);
4526  memcpy(u->next->next,w,sizeof(sleftv));
4527  BOOLEAN r=iiExprArithM(res,u,iiOp);
4528  // iiExprArithM did the CleanUp
4529  w->rtyp=0; w->data=NULL;
4530  return r;
4531}
4532static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4533{
4534  intvec *iv;
4535  ideal m;
4536  lists l=(lists)omAllocBin(slists_bin);
4537  int k=(int)w->Data();
4538  if (k>=0)
4539  {
4540    smCallNewBareiss((ideal)u->Data(),(int)v->Data(),(int)w->Data(),m,&iv);
4541    l->Init(2);
4542    l->m[0].rtyp=MODUL_CMD;
4543    l->m[1].rtyp=INTVEC_CMD;
4544    l->m[0].data=(void *)m;
4545    l->m[1].data=(void *)iv;
4546  }
4547  else
4548  {
4549    m=smCallSolv((ideal)u->Data());
4550    l->Init(1);
4551    l->m[0].rtyp=IDEAL_CMD;
4552    l->m[0].data=(void *)m;
4553  }
4554  res->data = (char *)l;
4555  return FALSE;
4556}
4557static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4558{
4559  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4560  {
4561    WerrorS("3rd argument must be a name of a matrix");
4562    return TRUE;
4563  }
4564  ideal i=(ideal)u->Data();
4565  int rank=(int)i->rank;
4566  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4567  if (r) return TRUE;
4568  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4569  return FALSE;
4570}
4571static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4572{
4573  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4574           (ideal)(v->Data()),(poly)(w->Data()));
4575  return FALSE;
4576}
4577static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4578{
4579  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4580  {
4581    WerrorS("3rd argument must be a name of a matrix");
4582    return TRUE;
4583  }
4584  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4585  poly p=(poly)u->CopyD(POLY_CMD);
4586  ideal i=idInit(1,1);
4587  i->m[0]=p;
4588  sleftv t;
4589  memset(&t,0,sizeof(t));
4590  t.data=(char *)i;
4591  t.rtyp=IDEAL_CMD;
4592  int rank=1;
4593  if (u->Typ()==VECTOR_CMD)
4594  {
4595    i->rank=rank=pMaxComp(p);
4596    t.rtyp=MODUL_CMD;
4597  }
4598  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4599  t.CleanUp();
4600  if (r) return TRUE;
4601  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4602  return FALSE;
4603}
4604static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4605{
4606  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4607    (intvec *)w->Data());
4608  setFlag(res,FLAG_STD);
4609  return FALSE;
4610}
4611static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4612{
4613  /*4
4614  * look for the substring what in the string where
4615  * starting at position n
4616  * return the position of the first char of what in where
4617  * or 0
4618  */
4619  int n=(int)w->Data();
4620  char *where=(char *)u->Data();
4621  char *what=(char *)v->Data();
4622  char *found;
4623  if ((1>n)||(n>(int)strlen(where)))
4624  {
4625    Werror("start position %d out of range",n);
4626    return TRUE;
4627  }
4628  found = strchr(where+n-1,*what);
4629  if (*(what+1)!='\0')
4630  {
4631    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4632    {
4633      found=strchr(found+1,*what);
4634    }
4635  }
4636  if (found != NULL)
4637  {
4638    res->data=(char *)((found-where)+1);
4639  }
4640  return FALSE;
4641}
4642static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
4643{
4644  if ((int)w->Data()==0)
4645    res->data=(char *)walkProc(u,v);
4646  else
4647    res->data=(char *)fractalWalkProc(u,v);
4648  setFlag( res, FLAG_STD );
4649  return FALSE;
4650}
4651static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4652{
4653  assumeStdFlag(u);
4654  intvec *module_w=(intvec *)atGet(u,"isHomog");
4655  intvec *wdegree=(intvec*)w->Data();
4656  if (wdegree->length()!=pVariables)
4657  {
4658    Werror("weight vector must have size %d, not %d",
4659           pVariables,wdegree->length());
4660    return TRUE;
4661  }
4662  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4663  switch((int)v->Data())
4664  {
4665    case 1:
4666      res->data=(void *)iv;
4667      return FALSE;
4668    case 2:
4669      res->data=(void *)hSecondSeries(iv);
4670      delete iv;
4671      return FALSE;
4672  }
4673  WerrorS(feNotImplemented);
4674  delete iv;
4675  return TRUE;
4676}
4677static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4678{
4679  intvec* im= new intvec((int)v->Data(),(int)w->Data(), 0);
4680  intvec* arg = (intvec*) u->Data();
4681  int i, n = min(im->cols()*im->rows(), arg->cols()*arg->rows());
4682
4683  for (i=0; i<n; i++)
4684  {
4685    (*im)[i] = (*arg)[i];
4686  }
4687
4688  res->data = (char *)im;
4689  return FALSE;
4690}
4691static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4692{
4693  short *iw=iv2array((intvec *)w->Data());
4694  res->data = (char *)ppJetW((poly)u->Data(),(int)v->Data(),iw);
4695  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4696  return FALSE;
4697}
4698static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
4699{
4700  if (!pIsUnit((poly)v->Data()))
4701  {
4702    WerrorS("2nd argument must be a unit");
4703    return TRUE;
4704  }
4705  res->data = (char *)pSeries((int)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4706  return FALSE;
4707}
4708static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4709{
4710  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
4711                             (intvec *)w->Data());
4712  return FALSE;
4713}
4714static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4715{
4716  if (!mpIsDiagUnit((matrix)v->Data()))
4717  {
4718    WerrorS("2nd argument must be a diagonal matrix of units");
4719    return TRUE;
4720  }
4721  res->data = (char *)idSeries((int)w->Data(),(ideal)u->CopyD(),
4722                               (matrix)v->CopyD());
4723  return FALSE;
4724}
4725static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4726{
4727  assumeStdFlag(w);
4728  res->data = (char *)idMinors(
4729                        (matrix)u->Data(),(int)v->Data(),(ideal)w->Data());
4730  return FALSE;
4731}
4732static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4733{
4734  idhdl h;
4735  ring rr;
4736  map mapping;
4737
4738  if ((v->name==NULL) || (w->name==NULL))
4739  {
4740    WerrorS("2nd/3rd arguments must have names");
4741    return TRUE;
4742  }
4743  rr=(ring)u->Data();
4744  const char *ring_name=u->Name();
4745  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4746  {
4747    if (h->typ==MAP_CMD)
4748    {
4749      mapping=IDMAP(h);
4750      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4751      if ((preim_ring==NULL)
4752      || (IDRING(preim_ring)!=currRing))
4753      {
4754        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4755        return TRUE;
4756      }
4757    }
4758    else if (h->typ==IDEAL_CMD)
4759    {
4760      mapping=IDMAP(h);
4761    }
4762    else
4763    {
4764      Werror("`%s` is no map nor ideal",IDID(h));
4765      return TRUE;
4766    }
4767  }
4768  else
4769  {
4770    Werror("`%s` is not defined in `%s`",v->name,ring_name);
4771    return TRUE;
4772  }
4773  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4774  {
4775    if (h->typ==IDEAL_CMD)
4776    {
4777      if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
4778      || ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
4779      {
4780        WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
4781      }
4782      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4783    }
4784    else
4785    {
4786      Werror("`%s` is no ideal",IDID(h));
4787      return TRUE;
4788    }
4789  }
4790  else
4791  {
4792    Werror("`%s` is not defined in `%s`",w->name,ring_name);
4793    return TRUE;
4794  }
4795  return FALSE;
4796}
4797static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4798{
4799  int di, k;
4800  int i=(int)u->Data();
4801  int r=(int)v->Data();
4802  int c=(int)w->Data();
4803  if ((r<=0) || (c<=0)) return TRUE;
4804  intvec *iv = new intvec(r, c, 0);
4805  if (iv->rows()==0)
4806  {
4807    delete iv;
4808    return TRUE;
4809  }
4810  if (i!=0)
4811  {
4812    if (i<0) i = -i;
4813    di = 2 * i + 1;
4814    for (k=0; k<iv->length(); k++)
4815    {
4816#ifdef buildin_rand
4817      (*iv)[k] = ((siRand() % di) - i);
4818#else
4819      (*iv)[k] = ((rand() % di) - i);
4820#endif
4821    }
4822  }
4823  res->data = (char *)iv;
4824  return FALSE;
4825}
4826static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4827  int &ringvar, poly &monomexpr)
4828{
4829  monomexpr=(poly)w->Data();
4830  poly p=(poly)v->Data();
4831  #if 0
4832  if (pLength(monomexpr)>1)
4833  {
4834    Werror("`%s` substitutes a ringvar only by a term",
4835      Tok2Cmdname(SUBST_CMD));
4836    return TRUE;
4837  }
4838  #endif
4839  if (!(ringvar=pVar(p)))
4840  {
4841    if (rField_is_Extension(currRing))
4842    {
4843      assume(currRing->algring!=NULL);
4844      lnumber n=(lnumber)pGetCoeff(p);
4845      ringvar=-p_Var(n->z,currRing->algring);
4846    }
4847    if(ringvar==0)
4848    {
4849      WerrorS("ringvar/par expected");
4850      return TRUE;
4851    }
4852  }
4853  return FALSE;
4854}
4855static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4856{
4857  int ringvar;
4858  poly monomexpr;
4859  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4860  if (nok) return TRUE;
4861  if (ringvar>0)
4862  {
4863    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
4864      res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4865    else
4866      res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
4867  }
4868  else
4869  {
4870    res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
4871  }
4872  return FALSE;
4873}
4874static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4875{
4876  int ringvar;
4877  poly monomexpr;
4878  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4879  if (nok) return TRUE;
4880  if (ringvar>0)
4881  {
4882    if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
4883      res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4884    else
4885      res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
4886  }
4887  else
4888  {
4889    res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
4890  }
4891  return FALSE;
4892}
4893// we do not want to have jjSUBST_Id_X inlined:
4894static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4895                            int input_type);
4896static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4897{
4898  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4899}
4900static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4901{
4902  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4903}
4904static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4905{
4906  sleftv tmp;
4907  memset(&tmp,0,sizeof(tmp));
4908  // do not check the result, conversion from int/number to poly works always
4909  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4910  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4911  tmp.CleanUp();
4912  return b;
4913}
4914static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4915{
4916  matrix m=mpNew((int)v->Data(),(int)w->Data());
4917  ideal I=(ideal)u->CopyD(IDEAL_CMD);
4918  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4919  //for(i=i-1;i>=0;i--)
4920  //{
4921  //  m->m[i]=I->m[i];
4922  //  I->m[i]=NULL;
4923  //}
4924  memcpy4(m->m,I->m,i*sizeof(poly));
4925  memset(I->m,0,i*sizeof(poly));
4926  idDelete(&I);
4927  res->data = (char *)m;
4928  return FALSE;
4929}
4930static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4931{
4932  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4933           (int)v->Data(),(int)w->Data());
4934  return FALSE;
4935}
4936static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4937{
4938  matrix m=mpNew((int)v->Data(),(int)w->Data());
4939  matrix I=(matrix)u->CopyD(MATRIX_CMD);
4940  int r=min(MATROWS(I),(int)v->Data());
4941  int c=min(MATCOLS(I),(int)w->Data());
4942  int i,j;
4943  for(i=r;i>0;i--)
4944  {
4945    for(j=c;j>0;j--)
4946    {
4947      MATELEM(m,i,j)=MATELEM(I,i,j);
4948      MATELEM(I,i,j)=NULL;
4949    }
4950  }
4951  idDelete((ideal *)&I);
4952  res->data = (char *)m;
4953  return FALSE;
4954}
4955static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4956{
4957  if (w->rtyp!=IDHDL) return TRUE;
4958  BITSET save_test=test;
4959  int ul= IDELEMS((ideal)u->Data());
4960  int vl= IDELEMS((ideal)v->Data());
4961  ideal m
4962    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
4963             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
4964  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4965  test=save_test;
4966  return FALSE;
4967}
4968static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
4969{
4970  assumeStdFlag(v);
4971  if (!idIsZeroDim((ideal)v->Data()))
4972  {
4973    Werror("`%s` must be 0-dimensional",v->Name());
4974    return TRUE;
4975  }
4976  res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
4977    (poly)w->CopyD());
4978  return FALSE;
4979}
4980static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
4981{
4982  assumeStdFlag(v);
4983  if (!idIsZeroDim((ideal)v->Data()))
4984  {
4985    Werror("`%s` must be 0-dimensional",v->Name());
4986    return TRUE;
4987  }
4988  res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
4989    (matrix)w->CopyD());
4990  return FALSE;
4991}
4992static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4993{
4994  assumeStdFlag(v);
4995  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4996    0,(int)w->Data());
4997  return FALSE;
4998}
4999static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5000{
5001  assumeStdFlag(v);
5002  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5003    0,(int)w->Data());
5004  return FALSE;
5005}
5006#ifdef OLD_RES
5007static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5008{
5009  int maxl=(int)v->Data();
5010  int l=0;
5011  resolvente r;
5012  intvec **weights=NULL;
5013  int wmaxl=maxl;
5014  maxl--;
5015  if ((maxl==-1) && (iiOp!=MRES_CMD))
5016    maxl = pVariables-1;
5017  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
5018  {
5019    intvec * iv=(intvec*)atGet(u,"isHomog");
5020    if (iv!=NULL)
5021    {
5022      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5023      weights[0] = ivCopy(iv);
5024      l=1;
5025    }
5026    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
5027  }
5028  else
5029    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5030  if (r==NULL) return TRUE;
5031  int t3=u->Typ();
5032  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5033  return FALSE;
5034  return TRUE;
5035}
5036#endif
5037static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5038{
5039  res->data=(void *)rInit(u,v,w);
5040  return (res->data==NULL);
5041}
5042static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5043{
5044  int yes;
5045  jjSTATUS2(res, u, v);
5046  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
5047  omFree((ADDRESS) res->data);
5048  res->data = (void *) yes;
5049  return FALSE;
5050}
5051static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5052{
5053  ideal result;
5054  intvec *ww=(intvec *)atGet(u,"isHomog");
5055  tHomog hom=testHomog;
5056  if (ww!=NULL)
5057  {
5058    ww=ivCopy(ww);
5059    hom=isHomog;
5060  }
5061  result=kStd((ideal)(u->Data()),
5062              currQuotient,
5063              hom,
5064              &ww,                  // module weights
5065              (intvec *)v->Data(),  // hilbert series
5066              0,0,                  // syzComp, newIdeal
5067              (intvec *)w->Data()); // weights of vars
5068  idSkipZeroes(result);
5069  res->data = (char *)result;
5070  setFlag(res,FLAG_STD);
5071  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5072  return FALSE;
5073}
5074
5075/*=================== operations with 3 args.: table =================*/
5076struct sValCmd3 dArith3[]=
5077{
5078// operations:
5079// proc             cmd          res         arg1        arg2        arg3   plural
5080 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5081,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5082,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5083,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5084,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5085,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5086,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5087,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5088,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5089,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5090,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
5091,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
5092,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5093,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5094,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5095,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
5096,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
5097,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
5098,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5099,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5100,{jjFWALK3,         FWALK_CMD,  IDEAL_CMD,  RING_CMD,   DEF_CMD,    INT_CMD NO_PLURAL}
5101,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5102,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
5103,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5104,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
5105//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5106,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5107,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5108,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5109,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5110,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5111,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
5112,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
5113,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
5114,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5115,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5116,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
5117,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
5118,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5119,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5120,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
5121,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
5122,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
5123,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5124#ifdef OLD_RES
5125,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5126,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5127#endif
5128,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5129,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5130,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5131,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE ALLOW_PLURAL}
5132,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
5133,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5134,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5135,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5136,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5137,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
5138,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
5139,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
5140,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
5141,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5142,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  MATRIX_CMD ALLOW_PLURAL}
5143#ifdef OLD_RES
5144,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5145,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
5146#endif
5147#ifdef HAVE_FACTORY
5148,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5149#else
5150,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
5151#endif
5152,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
5153#ifdef OLD_RES
5154,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5155,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
5156#endif
5157,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
5158,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5159,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5160,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5161,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5162,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5163,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5164,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5165,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
5166,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
5167,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
5168,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
5169,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
5170,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
5171,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
5172};
5173/*=================== operations with many arg.: static proc =================*/
5174static BOOLEAN jjBREAK0(leftv res, leftv v)
5175{
5176#ifdef HAVE_SDB
5177  sdb_show_bp();
5178#endif
5179  return FALSE;
5180}
5181static BOOLEAN jjBREAK1(leftv res, leftv v)
5182{
5183#ifdef HAVE_SDB
5184  if(v->Typ()==PROC_CMD)
5185  {
5186    int lineno=0;
5187    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
5188    {
5189      lineno=(int)v->next->Data();
5190    }
5191    return sdb_set_breakpoint(v->Name(),lineno);
5192  }
5193  return TRUE;
5194#else
5195 return FALSE;
5196#endif
5197}
5198static BOOLEAN jjCALL1ARG(leftv res, leftv v)
5199{
5200  return iiExprArith1(res,v,iiOp);
5201}
5202static BOOLEAN jjCALL2ARG(leftv res, leftv u)
5203{
5204  leftv v=u->next;
5205  u->next=NULL;
5206  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
5207  u->next=v;
5208  return b;
5209}
5210static BOOLEAN jjCALL3ARG(leftv res, leftv u)
5211{
5212  leftv v = u->next;
5213  leftv w = v->next;
5214  u->next = NULL;
5215  v->next = NULL;
5216  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5217  u->next = v;
5218  v->next = w;
5219  return b;
5220}
5221
5222static BOOLEAN jjCOEF_M(leftv res, leftv v)
5223{
5224  if((v->Typ() != VECTOR_CMD)
5225  || (v->next->Typ() != POLY_CMD)
5226  || (v->next->next->Typ() != MATRIX_CMD)
5227  || (v->next->next->next->Typ() != MATRIX_CMD))
5228     return TRUE;
5229  if (v->next->next->rtyp!=IDHDL) return TRUE;
5230  idhdl c=(idhdl)v->next->next->data;
5231  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
5232  idhdl m=(idhdl)v->next->next->next->data;
5233  idDelete((ideal *)&(c->data.uideal));
5234  idDelete((ideal *)&(m->data.uideal));
5235  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
5236    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
5237  return FALSE;
5238}
5239
5240static BOOLEAN jjDIVISION4(leftv res, leftv v)
5241{ // may have 3 or 4 arguments
5242  leftv v1=v;
5243  leftv v2=v1->next;
5244  leftv v3=v2->next;
5245  leftv v4=v3->next;
5246  assumeStdFlag(v2);
5247
5248  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
5249  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
5250
5251  if(i1==0||i2==0||v3->Typ()!=INT_CMD||(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
5252  {
5253    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
5254    return TRUE;
5255  }
5256
5257  sleftv w1,w2;
5258  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
5259  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
5260  ideal P=(ideal)w1.Data();
5261  ideal Q=(ideal)w2.Data();
5262
5263  int n=(int)v3->Data();
5264  short *w=NULL;
5265  if(v4!=NULL)
5266  {
5267    w=iv2array((intvec *)v4->Data());
5268    short *w0=w+1;
5269    int i=pVariables;
5270    while(i>0&&*w0>0)
5271    {
5272      w0++;
5273      i--;
5274    }
5275    if(i>0)
5276      WarnS("not all weights are positive!");
5277  }
5278
5279  matrix T;
5280  ideal R;
5281  idLiftW(P,Q,n,T,R,w);
5282
5283  if(w!=NULL)
5284    omFree(w);
5285  lists L=(lists) omAllocBin(slists_bin);
5286  L->Init(2);
5287  L->m[1].rtyp=v1->Typ();
5288  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
5289  {
5290    if(v1->Typ()==POLY_CMD)
5291      pShift(&R->m[0],-1);
5292    L->m[1].data=(void *)R->m[0];
5293    R->m[0]=NULL;
5294    idDelete(&R);
5295  }
5296  else
5297  if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
5298    L->m[1].data=(void *)idModule2Matrix(R);
5299  else
5300    L->m[1].rtyp=MODUL_CMD;
5301  L->m[0].rtyp=MATRIX_CMD;
5302  L->m[0].data=(char *)T;
5303
5304  res->data=L;
5305  res->rtyp=LIST_CMD;
5306
5307  return FALSE;
5308}
5309
5310//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
5311//{
5312//  int l=u->listLength();
5313//  if (l<2) return TRUE;
5314//  BOOLEAN b;
5315//  leftv v=u->next;
5316//  leftv zz=v;
5317//  leftv z=zz;
5318//  u->next=NULL;
5319//  do
5320//  {
5321//    leftv z=z->next;
5322//    b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
5323//    if (b) break;
5324//  } while (z!=NULL);
5325//  u->next=zz;
5326//  return b;
5327//}
5328static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5329{
5330  int s=1;
5331  leftv h=v;
5332  if (h!=NULL) s=exprlist_length(h);
5333  ideal id=idInit(s,1);
5334  int rank=1;
5335  int i=0;
5336  poly p;
5337  while (h!=NULL)
5338  {
5339    switch(h->Typ())