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

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