source: git/Singular/iparith.cc @ 298d0a

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