source: git/Singular/iparith.cc @ 6676a2

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