source: git/Singular/iparith.cc @ 0570a7

spielwiese
Last change on this file since 0570a7 was 0570a7, checked in by Viktor Levandovskyy <levandov@…>, 20 years ago
*levandov: plural interface calls fixed git-svn-id: file:///usr/local/Singular/svn/trunk@6979 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 197.3 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.309 2003-12-17 19:39:00 levandov 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 "algmap.h"
46#include "units.h"
47#ifdef HAVE_FACTORY
48#include "clapsing.h"
49#include "kstdfac.h"
50#endif
51#ifdef HAVE_FGLM
52#include "fglm.h"
53#endif
54
55#include "ipshell.h"
56
57#include "mpr_inout.h"
58
59#ifdef HAVE_PLURAL
60#include "gring.h"
61#define ALLOW_PLURAL    ,1
62#define NO_PLURAL       ,0
63#define COMM_PLURAL     ,2
64#else
65#define ALLOW_PLURAL
66#define NO_PLURAL
67#define COMM_PLURAL
68#endif
69
70/*=============== types =====================*/
71struct sValCmdTab
72{
73  short cmd;
74  short start;
75};
76
77typedef sValCmdTab jjValCmdTab[];
78
79/* ifdef GENTABLE: definitions are in ipshell.h */
80#ifndef GENTABLE
81typedef char * (*Proc1)(char *);
82struct sValCmd1
83{
84  proc1 p;
85  short cmd;
86  short res;
87  short arg;
88#ifdef HAVE_PLURAL
89  short valid_for_plural;
90#endif
91};
92
93typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
94struct sValCmd2
95{
96  proc2 p;
97  short cmd;
98  short res;
99  short arg1;
100  short arg2;
101#ifdef HAVE_PLURAL
102  short valid_for_plural;
103#endif
104};
105
106typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
107struct sValCmd3
108{
109  proc3 p;
110  short cmd;
111  short res;
112  short arg1;
113  short arg2;
114  short arg3;
115#ifdef HAVE_PLURAL
116  short valid_for_plural;
117#endif
118};
119struct sValCmdM
120{
121  proc1 p;
122  short cmd;
123  short res;
124  short number_of_args; /* -1: any, -2: any >0, .. */
125#ifdef HAVE_PLURAL
126  short valid_for_plural;
127#endif
128};
129#endif
130
131/*============= proc =======================*/
132static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
133static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
134#ifdef MDEBUG
135#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
136static Subexpr jjDBMakeSub(leftv e,char *f, int l);
137#else
138static Subexpr jjMakeSub(leftv e);
139#endif
140
141/*============= vars ======================*/
142extern int cmdtok;
143extern BOOLEAN expected_parms;
144
145#define ii_div_by_0 "div. by 0"
146int iiOp; /* the current operation*/
147
148#ifdef GENTABLE
149cmdnames cmds[] =
150{  // name-string alias tokval          toktype
151  { "$INVALID$",   0, -1,                 0},
152  { "and",         0, '&' ,               LOGIC_OP},
153  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
154  { "bareiss",     0, BAREISS_CMD ,       CMD_123},
155  { "betti",       0, BETTI_CMD ,         CMD_12},
156  { "break",       0, BREAK_CMD ,         BREAK_CMD},
157  { "breakpoint",  0, BREAKPOINT_CMD ,    CMD_M},
158  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
159  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
160  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
161  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
162  { "close",       0, CLOSE_CMD ,         CMD_1},
163  { "coef",        0, COEF_CMD ,          CMD_M},
164  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
165  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
166  { "contract",    0, CONTRACT_CMD ,      CMD_2},
167  { "convhull",    0, NEWTONPOLY_CMD,     CMD_1},
168  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
169  { "def",         0, DEF_CMD ,           ROOT_DECL},
170  { "defined",     0, DEFINED_CMD ,       CMD_1},
171  { "deg",         0, DEG_CMD ,           CMD_12},
172  { "degree",      0, DEGREE_CMD ,        CMD_1},
173  { "delete",      0, DELETE_CMD ,        CMD_2},
174  { "det",         0, DET_CMD ,           CMD_1},
175  { "diff",        0, DIFF_CMD ,          CMD_2},
176  { "dim",         0, DIM_CMD ,           CMD_1},
177  { "div",         0, INTDIV_CMD ,        MULDIV_OP},
178  { "division",    0, DIVISION_CMD ,      CMD_M},
179  { "dump",        0, DUMP_CMD,           CMD_1},
180  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
181  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
182  { "ERROR",       0, ERROR_CMD ,         CMD_1},
183  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
184  { "else",        0, ELSE_CMD ,          ELSE_CMD},
185  { "eval",        0, EVAL ,              EVAL},
186  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
187  { "execute",     0, EXECUTE_CMD ,       CMD_1},
188  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
189  { "factorize",   0, FAC_CMD ,           CMD_12},
190  { "fetch",       0, FETCH_CMD ,         CMD_2},
191  { "fglm",        0, FGLM_CMD ,          CMD_2},
192  { "fglmquot",    0, FGLMQUOT_CMD,       CMD_2},
193  { "find",        0, FIND_CMD ,          CMD_23},
194  { "finduni",     0, FINDUNI_CMD,        CMD_1},
195  { "forif",       0, IF_CMD ,            IF_CMD},
196  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
197  { "facstd",      0, FACSTD_CMD ,        CMD_12},
198  { "gen",         0, E_CMD ,             CMD_1},
199  { "getdump",     0, GETDUMP_CMD,        CMD_1},
200  { "gcd",         0, GCD_CMD ,           CMD_2},
201  { "GCD",         2, GCD_CMD ,           CMD_2},
202  { "hilb",        0, HILBERT_CMD ,       CMD_123},
203  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
204  { "homog",       0, HOMOG_CMD ,         CMD_12},
205  { "hres",        0, HRES_CMD ,          CMD_2},
206  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
207  { "if",          0, IF_CMD ,            IF_CMD},
208  { "imap",        0, IMAP_CMD ,          CMD_2},
209  { "impart",      0, IMPART_CMD ,        CMD_1},
210  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
211  { "insert",      0, INSERT_CMD ,        CMD_23},
212  { "int",         0, INT_CMD ,           ROOT_DECL},
213  { "interred",    0, INTERRED_CMD ,      CMD_1},
214  { "intersect",   0, INTERSECT_CMD ,     CMD_M},
215  { "intmat",      0, INTMAT_CMD ,        INTMAT_CMD},
216  { "intvec",      0, INTVEC_CMD ,        ROOT_DECL_LIST},
217  { "jacob",       0, JACOB_CMD ,         CMD_1},
218  { "jet",         0, JET_CMD ,           CMD_M},
219  { "kbase",       0, KBASE_CMD ,         CMD_12},
220  { "keepring",    0, KEEPRING_CMD ,      KEEPRING_CMD},
221  { "kill",        0, KILL_CMD ,          KILL_CMD},
222  { "killattrib",  0, KILLATTR_CMD ,      CMD_12},
223  { "koszul",      0, KOSZUL_CMD ,        CMD_23},
224  { "kres",        0, KRES_CMD ,          CMD_2},
225  { "laguerre",    0, LAGSOLVE_CMD,       CMD_3},
226  { "lead",        0, LEAD_CMD ,          CMD_1},
227  { "leadcoef",    0, LEADCOEF_CMD ,      CMD_1},
228  { "leadexp",     0, LEADEXP_CMD ,       CMD_1},
229  { "leadmonom",   0, LEADMONOM_CMD ,     CMD_1},
230  { "LIB",         0, LIB_CMD ,           SYSVAR},
231  { "lift",        0, LIFT_CMD ,          CMD_23},
232  { "liftstd",     0, LIFTSTD_CMD ,       CMD_2},
233  { "link",        0, LINK_CMD ,          ROOT_DECL},
234  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
235  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
236  { "load",        0, LOAD_CMD ,          CMD_12},
237  { "lres",        0, LRES_CMD ,          CMD_2},
238  { "map",         0, MAP_CMD ,           RING_DECL},
239  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
240  { "maxideal",    0, MAXID_CMD ,         CMD_1},
241  { "memory",      0, MEMORY_CMD ,        CMD_1},
242  { "minbase",     0, MINBASE_CMD ,       CMD_1},
243  { "minor",       0, MINOR_CMD ,         CMD_23},
244  { "minres",      0, MINRES_CMD ,        CMD_1},
245  { "mod",         0, INTMOD_CMD ,        MULDIV_OP},
246  { "module",      0, MODUL_CMD ,         MODUL_CMD},
247  { "modulo",      0, MODULO_CMD ,        CMD_2},
248  { "monitor",     0, MONITOR_CMD ,       CMD_12},
249  { "mpresmat",    0, MPRES_CMD,          CMD_2},
250  { "mult",        0, MULTIPLICITY_CMD ,  CMD_1},
251  #ifdef OLD_RES
252  { "mres",        0, MRES_CMD ,          CMD_23},
253  #else
254  { "mres",        0, MRES_CMD ,          CMD_2},
255  #endif
256  { "mstd",        0, MSTD_CMD ,          CMD_1},
257  { "nameof",      0, NAMEOF_CMD ,        CMD_1},
258  { "names",       0, NAMES_CMD ,         CMD_M},
259  #ifdef HAVE_PLURAL
260  { "ncalgebra",   0, NCALGEBRA_CMD ,     CMD_2},
261  #endif
262  { "ncols",       0, COLS_CMD ,          CMD_1},
263  { "not",         0, NOT ,               NOT},
264  { "npars",       0, NPARS_CMD ,         CMD_1},
265  #ifdef OLD_RES
266  { "nres",        0, RES_CMD ,           CMD_23},
267  #else
268  { "nres",        0, RES_CMD ,           CMD_2},
269  #endif
270  { "nrows",       0, ROWS_CMD ,          CMD_1},
271  { "number",      0, NUMBER_CMD ,        RING_DECL},
272  { "nvars",       0, NVARS_CMD ,         CMD_1},
273  { "open",        0, OPEN_CMD ,          CMD_1},
274  { "option",      0, OPTION_CMD ,        CMD_M},
275  { "or",          0, '|' ,               LOGIC_OP},
276  { "ord",         0, ORD_CMD ,           CMD_1},
277  { "ordstr",      0, ORDSTR_CMD ,        CMD_1},
278  { "package",     0, PACKAGE_CMD ,       ROOT_DECL},
279  { "par",         0, PAR_CMD ,           CMD_1},
280  { "parameter",   0, PARAMETER ,         PARAMETER},
281  { "pardeg",      0, PARDEG_CMD ,        CMD_1},
282  { "parstr",      0, PARSTR_CMD ,        CMD_12},
283  { "poly",        0, POLY_CMD ,          RING_DECL},
284  { "preimage",    0, PREIMAGE_CMD ,      CMD_13},
285  { "prime",       0, PRIME_CMD ,         CMD_1},
286  { "print",       0, PRINT_CMD ,         CMD_12},
287  { "prune",       0, PRUNE_CMD ,         CMD_1},
288  { "proc",        0, PROC_CMD ,          PROC_CMD},
289  { "qhweight",    0, QHWEIGHT_CMD ,      CMD_1},
290  { "qring",       0, QRING_CMD ,         ROOT_DECL},
291  { "quote",       0, QUOTE ,             QUOTE},
292  { "quotient",    0, QUOTIENT_CMD ,      CMD_2},
293  { "random",      0, RANDOM_CMD ,        CMD_23},
294  { "read",        0, READ_CMD ,          CMD_12},
295  { "reduce",      0, REDUCE_CMD ,        CMD_M},
296  { "regularity",  0, REGULARITY_CMD ,    CMD_1},
297  { "repart",      0, REPART_CMD ,        CMD_1},
298  { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
299  { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},
300  { "resultant",   0, RESULTANT_CMD,      CMD_3},
301  { "return",      0, RETURN ,            RETURN},
302  { "RETURN",      0, END_GRAMMAR ,       RETURN},
303  { "ring",        0, RING_CMD ,          RING_CMD},
304  { "ringlist",    0, RINGLIST_CMD ,      CMD_1},
305  { "rvar",        0, IS_RINGVAR ,        CMD_1},
306  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
307  { "simplex",     0, SIMPLEX_CMD,        CMD_M},
308  { "simplify",    0, SIMPLIFY_CMD ,      CMD_2},
309  { "size",        0, COUNT_CMD ,         CMD_1},
310  { "sortvec",     0, SORTVEC_CMD ,       CMD_1},
311  #ifdef OLD_RES
312  { "sres",        0, SRES_CMD ,          CMD_23},
313  #else
314  { "sres",        0, SRES_CMD ,          CMD_2},
315  #endif
316  { "status",      0, STATUS_CMD,         CMD_M},
317  { "std",         0, STD_CMD ,           CMD_123},
318  { "string",      0, STRING_CMD ,        ROOT_DECL_LIST},
319  { "subst",       0, SUBST_CMD ,         CMD_M},
320  { "system",      0, SYSTEM_CMD,         CMD_M},
321  { "syz",         0, SYZYGY_CMD ,        CMD_1},
322  { "test",        0, TEST_CMD ,          CMD_M},
323  { "trace",       0, TRACE_CMD ,         CMD_1},
324  { "transpose",   0, TRANSPOSE_CMD ,     CMD_1},
325  { "type",        0, TYPE_CMD ,          TYPE_CMD},
326  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
327  { "uressolve",   0, URSOLVE_CMD,        CMD_M},
328  { "vandermonde", 0, VANDER_CMD,         CMD_3},
329  { "var",         0, VAR_CMD ,           CMD_1},
330  { "varstr",      0, VARSTR_CMD ,        CMD_12},
331  { "vdim",        0, VDIM_CMD ,          CMD_1},
332  { "vector",      0, VECTOR_CMD ,        RING_DECL},
333  { "wedge",       0, WEDGE_CMD ,         CMD_2},
334  { "weight",      0, WEIGHT_CMD ,        CMD_1},
335  { "whileif",     0, IF_CMD ,            IF_CMD},
336  { "write",       0, WRITE_CMD ,         CMD_M},
337/* delete for next version:*/
338  { "IN",          1, LEAD_CMD ,          CMD_1},
339  { "NF",          1, REDUCE_CMD ,        CMD_M},
340  { "multiplicity",1, MULTIPLICITY_CMD ,  CMD_1},
341  { "verbose",     2, OPTION_CMD ,        CMD_M},
342//  { "rank",        1, ROWS_CMD ,          CMD_1},
343//  { "Current",     0, -1 ,                SYSVAR},
344//  { "Top",         0, -1 ,                SYSVAR},
345//  { "Up",          0, -1 ,                SYSVAR},
346
347/* set sys vars*/
348  { "degBound",    0, VMAXDEG ,           SYSVAR},
349  { "echo",        0, VECHO ,             SYSVAR},
350  { "minpoly",     0, VMINPOLY ,          SYSVAR},
351  { "multBound",   0, VMAXMULT ,          SYSVAR},
352  { "noether",     0, VNOETHER ,          SYSVAR},
353  { "pagelength",  0, VPAGELENGTH ,       SYSVAR},
354  { "pagewidth",   0, VCOLMAX ,           SYSVAR},
355  { "printlevel",  0, VPRINTLEVEL ,       SYSVAR},
356  { "short",       0, VSHORTOUT ,         SYSVAR},
357  { "timer",       0, VTIMER ,            SYSVAR},
358  { "rtimer",      0, VRTIMER,            SYSVAR},
359  { "TRACE",       0, TRACE ,             SYSVAR},
360  { "voice",       0, VOICE ,             SYSVAR},
361
362/* other reserved words:scanner.l */
363  { "pause",       2, -1 ,             0},
364  { "while",       0, -1 ,             0},
365  { "for",         0, -1 ,             0},
366  { "help",        0, -1 ,             0},
367  { "newline",     0, -1 ,             0},
368  { "exit",        0, -1 ,             0},
369  { "quit",        0, -1 ,             0},
370/* end of list marker */
371  { NULL, 0, 0, 0}
372};
373#endif
374
375/*=================== operations with 2 args.: static proc =================*/
376static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
377{
378  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
379  int bb = (int)(v->Data());
380  if (errorreported) return TRUE;
381  switch (iiOp)
382  {
383    case '+': (*aa) += bb; break;
384    case '-': (*aa) -= bb; break;
385    case '*': (*aa) *= bb; break;
386    case '/':
387    case INTDIV_CMD: (*aa) /= bb; break;
388    case '%':
389    case INTMOD_CMD: (*aa) %= bb; break;
390  }
391  res->data=(char *)aa;
392  return FALSE;
393}
394static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
395{
396  return jjOP_IV_I(res,v,u);
397}
398static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
399{
400  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
401  int bb = (int)(v->Data());
402  int i=min(aa->rows(),aa->cols());
403  switch (iiOp)
404  {
405    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
406              break;
407    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
408              break;
409  }
410  res->data=(char *)aa;
411  return FALSE;
412}
413static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
414{
415  return jjOP_IM_I(res,v,u);
416}
417static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
418{
419  res->data=(char *)new intvec((int)u->Data(),(int)v->Data());
420  return FALSE;
421}
422static void jjEQUAL_REST(leftv res,leftv u,leftv v)
423{
424  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
425  {
426    int save_iiOp=iiOp;
427    if (iiOp==NOTEQUAL)
428      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
429    else
430      iiExprArith2(res,u->next,iiOp,v->next);
431    iiOp=save_iiOp;
432  }
433  if (iiOp==NOTEQUAL) res->data=(char *)(!(int)res->data);
434}
435static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
436{
437  intvec*    a = (intvec * )(u->Data());
438  intvec*    b = (intvec * )(v->Data());
439  int r=a->compare(b);
440  switch  (iiOp)
441  {
442    case '<':
443      res->data  = (char *) (r<0);
444      break;
445    case '>':
446      res->data  = (char *) (r>0);
447      break;
448    case LE:
449      res->data  = (char *) (r<=0);
450      break;
451    case GE:
452      res->data  = (char *) (r>=0);
453      break;
454    case EQUAL_EQUAL:
455    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
456      res->data  = (char *) (r==0);
457      break;
458  }
459  jjEQUAL_REST(res,u,v);
460  return r==-2;
461}
462static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
463{
464  intvec* a = (intvec * )(u->Data());
465  int     b = (int )     (v->Data());
466  int r=a->compare(b);
467  switch  (iiOp)
468  {
469    case '<':
470      res->data  = (char *) (r<0);
471      break;
472    case '>':
473      res->data  = (char *) (r>0);
474      break;
475    case LE:
476      res->data  = (char *) (r<=0);
477      break;
478    case GE:
479      res->data  = (char *) (r>=0);
480      break;
481    case EQUAL_EQUAL:
482    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
483      res->data  = (char *) (r==0);
484      break;
485  }
486  jjEQUAL_REST(res,u,v);
487  return FALSE;
488}
489static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
490{
491  poly p=(poly)u->Data();
492  poly q=(poly)v->Data();
493  int r=pCmp(p,q);
494  if (r==0)
495  {
496    /* compare lead coeffs */
497    number h=nSub(pGetCoeff(p),pGetCoeff(q));
498    r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
499    nDelete(&h);
500  }
501  else if (p==NULL)
502  {
503    if (q==NULL)
504    {
505      /* compare 0, 0 */
506      r=0;
507    }
508    else if(pIsConstant(q))
509    {
510      /* compare 0, const */
511      r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
512    }
513  }
514  else if (q==NULL)
515  {
516    if (pIsConstant(p))
517    {
518      /* compare const, 0 */
519      r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
520    }
521  }
522  switch  (iiOp)
523  {
524    case '<':
525      res->data  = (char *) (r < 0);
526      break;
527    case '>':
528      res->data  = (char *) (r > 0);
529      break;
530    case LE:
531      res->data  = (char *) (r <= 0);
532      break;
533    case GE:
534      res->data  = (char *) (r >= 0);
535      break;
536    //case EQUAL_EQUAL:
537    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
538    //  res->data  = (char *) (r == 0);
539    //  break;
540  }
541  jjEQUAL_REST(res,u,v);
542  return FALSE;
543}
544static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
545{
546  char*    a = (char * )(u->Data());
547  char*    b = (char * )(v->Data());
548  int result = strcmp(a,b);
549  switch  (iiOp)
550  {
551    case '<':
552      res->data  = (char *) (result  < 0);
553      break;
554    case '>':
555      res->data  = (char *) (result  > 0);
556      break;
557    case LE:
558      res->data  = (char *) (result  <= 0);
559      break;
560    case GE:
561      res->data  = (char *) (result  >= 0);
562      break;
563    case EQUAL_EQUAL:
564    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
565      res->data  = (char *) (result  == 0);
566      break;
567  }
568  jjEQUAL_REST(res,u,v);
569  return FALSE;
570}
571static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
572{
573  if (u->Next()!=NULL)
574  {
575    u=u->next;
576    res->next = (leftv)omAllocBin(sleftv_bin);
577    return iiExprArith2(res->next,u,iiOp,v);
578  }
579  else if (v->Next()!=NULL)
580  {
581    v=v->next;
582    res->next = (leftv)omAllocBin(sleftv_bin);
583    return iiExprArith2(res->next,u,iiOp,v);
584  }
585  return FALSE;
586}
587static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
588{
589  int b=(int)u->Data();
590  int e=(int)v->Data();
591  int rc = 1;
592  BOOLEAN overflow=FALSE;
593  if (e >= 0)
594  {
595    if (b==0)
596    {
597      rc=0;
598    }
599    else
600    {
601      int oldrc;
602      while ((e--)!=0)
603      {
604        oldrc=rc;
605        rc *= b;
606        if (!overflow)
607        {
608          if(rc/b!=oldrc) overflow=TRUE;
609        }
610      }
611      if (overflow)
612        WarnS("int overflow(^), result may be wrong");
613    }
614    res->data = (char *)rc;
615    if (u!=NULL) return jjOP_REST(res,u,v);
616    return FALSE;
617  }
618  else
619  {
620    WerrorS("exponent must be non-negative");
621    return TRUE;
622  }
623}
624static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
625{
626  int e=(int)v->Data();
627  number n=(number)u->CopyD(NUMBER_CMD);
628  if (e<0)
629  {
630    number m=nInvers(n);
631    nDelete(&n);
632    n=m;
633    e=-e;
634  }
635  nPower(n,e,(number*)&res->data);
636  nDelete(&n);
637  if (u!=NULL) return jjOP_REST(res,u,v);
638  return FALSE;
639}
640static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
641{
642  res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)v->Data());
643  if (u!=NULL) return jjOP_REST(res,u,v);
644  return FALSE;
645}
646static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
647{
648  res->data = (char *)idPower((ideal)(u->Data()),(int)(v->Data()));
649  if (u!=NULL) return jjOP_REST(res,u,v);
650  return FALSE;
651}
652static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
653{
654  u=u->next;
655  v=v->next;
656  if (u==NULL)
657  {
658    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
659    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
660    {
661      do
662      {
663        if (res->next==NULL)
664          res->next = (leftv)omAlloc0Bin(sleftv_bin);
665        leftv tmp_v=v->next;
666        v->next=NULL;
667        BOOLEAN b=iiExprArith1(res->next,v,'-');
668        v->next=tmp_v;
669        if (b)
670          return TRUE;
671        v=tmp_v;
672        res=res->next;
673      } while (v!=NULL);
674      return FALSE;
675    }
676    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
677    {
678      res->next = (leftv)omAlloc0Bin(sleftv_bin);
679      res=res->next;
680      res->data = v->CopyD();
681      res->rtyp = v->Typ();
682      v=v->next;
683      if (v==NULL) return FALSE;
684    }
685  }
686  if (v!=NULL)                     /* u<>NULL, v<>NULL */
687  {
688    do
689    {
690      res->next = (leftv)omAlloc0Bin(sleftv_bin);
691      leftv tmp_u=u->next; u->next=NULL;
692      leftv tmp_v=v->next; v->next=NULL;
693      BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
694      u->next=tmp_u;
695      v->next=tmp_v;
696      if (b)
697        return TRUE;
698      u=tmp_u;
699      v=tmp_v;
700      res=res->next;
701    } while ((u!=NULL) && (v!=NULL));
702    return FALSE;
703  }
704  loop                             /* u<>NULL, v==NULL */
705  {
706    res->next = (leftv)omAlloc0Bin(sleftv_bin);
707    res=res->next;
708    res->data = u->CopyD();
709    res->rtyp = u->Typ();
710    u=u->next;
711    if (u==NULL) return FALSE;
712  }
713}
714static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
715{
716#ifdef HAVE_NS
717  idhdl packhdl;
718
719  switch(u->Typ())
720  {
721      case 0:
722        Print("%s of type 'ANY'. Trying load.\n", v->name);
723        //if(iiTryLoadLib(u, u->name))
724        {
725          Werror("'%s' no such package", u->name);
726          return TRUE;
727        }
728        //syMake(u,u->name,NULL);
729        // else: use next case !!! no break !!!
730
731      case PACKAGE_CMD:
732        packhdl = (idhdl)u->data;
733        if((!IDPACKAGE(packhdl)->loaded)
734        && (IDPACKAGE(packhdl)->language > LANG_TOP))
735        {
736          //if(iiReLoadLib(packhdl))
737          //  Werror("unable to reload package '%s'", IDID(packhdl));
738          Werror("'%s' not loaded", u->name);
739          return TRUE;
740        }
741        if(v->rtyp == IDHDL)
742        {
743          v->name = omStrDup(v->name);
744        }
745        v->req_packhdl=IDPACKAGE(packhdl);
746        v->packhdl=IDPACKAGE(packhdl);
747        syMake(v, v->name, packhdl);
748        memcpy(res, v, sizeof(sleftv));
749        memset(v, 0, sizeof(sleftv));
750        break;
751
752      case DEF_CMD:
753        break;
754
755      default:
756        WerrorS("<package>::<id> expected");
757        return TRUE;
758  }
759#else
760  WerrorS("package is not supported in this version");
761#endif /* HAVE_NS */
762  return FALSE;
763}
764static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
765{
766  unsigned int a=(unsigned int)u->Data();
767  unsigned int b=(unsigned int)v->Data();
768  unsigned int c=a+b;
769  res->data = (char *)c;
770  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
771  {
772    WarnS("int overflow(+), result may be wrong");
773  }
774  return jjPLUSMINUS_Gen(res,u,v);
775}
776static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
777{
778  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
779  return jjPLUSMINUS_Gen(res,u,v);
780}
781static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
782{
783  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
784  return jjPLUSMINUS_Gen(res,u,v);
785}
786static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
787{
788  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
789  if (res->data==NULL)
790  {
791     WerrorS("intmat size not compatible");
792     return TRUE;
793  }
794  return jjPLUSMINUS_Gen(res,u,v);
795}
796static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
797{
798  res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
799  if (res->data==NULL)
800  {
801     WerrorS("matrix size not compatible");
802     return TRUE;
803  }
804  return jjPLUSMINUS_Gen(res,u,v);
805}
806static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
807{
808  matrix m=(matrix)u->Data();
809  matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
810  if (iiOp=='+')
811    res->data = (char *)mpAdd(m , p);
812  else
813    res->data = (char *)mpSub(m , p);
814  idDelete((ideal *)&p);
815  return jjPLUSMINUS_Gen(res,u,v);
816}
817static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
818{
819  return jjPLUS_MA_P(res,v,u);
820}
821static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
822{
823  char*    a = (char * )(u->Data());
824  char*    b = (char * )(v->Data());
825  char*    r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
826  strcpy(r,a);
827  strcat(r,b);
828  res->data=r;
829  return jjPLUSMINUS_Gen(res,u,v);
830}
831static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
832{
833  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
834  return jjPLUSMINUS_Gen(res,u,v);
835}
836static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
837{
838  unsigned int a=(unsigned int)u->Data();
839  unsigned int b=(unsigned int)v->Data();
840  unsigned int c=a-b;
841  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
842  {
843    WarnS("int overflow(-), result may be wrong");
844  }
845  res->data = (char *)c;
846  return jjPLUSMINUS_Gen(res,u,v);
847}
848static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
849{
850  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
851  return jjPLUSMINUS_Gen(res,u,v);
852}
853static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
854{
855  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
856  return jjPLUSMINUS_Gen(res,u,v);
857}
858static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
859{
860  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
861  if (res->data==NULL)
862  {
863     WerrorS("intmat size not compatible");
864     return TRUE;
865  }
866  return jjPLUSMINUS_Gen(res,u,v);
867}
868static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
869{
870  res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
871  if (res->data==NULL)
872  {
873     WerrorS("matrix size not compatible");
874     return TRUE;
875  }
876  return jjPLUSMINUS_Gen(res,u,v);
877}
878static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
879{
880  int a=(int)u->Data();
881  int b=(int)v->Data();
882  int c=a * b;
883  if ((b!=0) && (c/b !=a))
884    WarnS("int overflow(*), result may be wrong");
885  res->data = (char *)c;
886  if ((u->Next()!=NULL) || (v->Next()!=NULL))
887    return jjOP_REST(res,u,v);
888  return FALSE;
889}
890static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
891{
892  res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
893  if ((v->next!=NULL) || (u->next!=NULL))
894    return jjOP_REST(res,u,v);
895  return FALSE;
896}
897static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
898{
899  poly a;
900  poly b;
901
902  if (v->next==NULL)
903  {
904    a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
905    if (u->next==NULL)
906    {
907      b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
908      res->data = (char *)(pMult( a, b));
909      return FALSE;
910    }
911    // u->next exists: copy v
912    b=pCopy((poly)v->Data());
913    res->data = (char *)(pMult( a, b));
914    return jjOP_REST(res,u,v);
915  }
916  // v->next exists: copy u
917  a=pCopy((poly)u->Data());
918  b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
919  res->data = (char *)(pMult( a, b));
920  return jjOP_REST(res,u,v);
921}
922static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
923{
924  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
925  if ((v->next!=NULL) || (u->next!=NULL))
926    return jjOP_REST(res,u,v);
927  return FALSE;
928}
929static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
930{
931  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
932  if (res->data==NULL)
933  {
934     WerrorS("intmat size not compatible");
935     return TRUE;
936  }
937  if ((v->next!=NULL) || (u->next!=NULL))
938    return jjOP_REST(res,u,v);
939  return FALSE;
940}
941static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
942{
943  poly p=(poly)v->CopyD(POLY_CMD);
944  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
945  ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
946  if (r>0) I->rank=r;
947  res->data = (char *)I;
948  return FALSE;
949}
950static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
951{
952  return jjTIMES_MA_P1(res,v,u);
953}
954static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
955{
956  number n=(number)v->CopyD(NUMBER_CMD);
957  poly p=pOne();
958  pSetCoeff(p,n);
959  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
960  return FALSE;
961}
962static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
963{
964  return jjTIMES_MA_N1(res,v,u);
965}
966static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
967{
968  res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)v->Data());
969  return FALSE;
970}
971static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
972{
973  return jjTIMES_MA_I1(res,v,u);
974}
975static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
976{
977  res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
978  if (res->data==NULL)
979  {
980     WerrorS("matrix size not compatible");
981     return TRUE;
982  }
983  if ((v->next!=NULL) || (u->next!=NULL))
984    return jjOP_REST(res,u,v);
985  return FALSE;
986}
987static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
988{
989  res->data = (char *)((int)u->Data() >= (int)v->Data());
990  return FALSE;
991}
992static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
993{
994  number h=nSub((number)u->Data(),(number)v->Data());
995  res->data = (char *) (nGreaterZero(h)||(nIsZero(h)));
996  nDelete(&h);
997  return FALSE;
998}
999static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1000{
1001  res->data = (char *)((int)u->Data()>(int)v->Data());
1002  return FALSE;
1003}
1004static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1005{
1006  number h=nSub((number)u->Data(),(number)v->Data());
1007  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1008  nDelete(&h);
1009  return FALSE;
1010}
1011static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1012{
1013  res->data = (char *)((int)u->Data() <= (int)v->Data());
1014  return FALSE;
1015}
1016static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1017{
1018  number h=nSub((number)v->Data(),(number)u->Data());
1019  res->data = (char *) (nGreaterZero(h)||nIsZero(h));
1020  nDelete(&h);
1021  return FALSE;
1022}
1023static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1024{
1025  res->data = (char *)((int)u->Data() < (int)v->Data());
1026  return FALSE;
1027}
1028static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1029{
1030  number h=nSub((number)v->Data(),(number)u->Data());
1031  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1032  nDelete(&h);
1033  return FALSE;
1034}
1035static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1036{
1037  int a= (int) u->Data();
1038  int b= (int) v->Data();
1039  if (b==0)
1040  {
1041    WerrorS(ii_div_by_0);
1042    return TRUE;
1043  }
1044  int bb=ABS(b);
1045  int c=a%bb;
1046  if(c<0) c+=bb;
1047  int r=0;
1048  switch (iiOp)
1049  {
1050    case INTMOD_CMD:
1051        r=c;            break;
1052    case '%':
1053        r= (a % b);     break;
1054    case INTDIV_CMD:
1055        r=((a-c) /b);   break;
1056    case '/':
1057        r= (a / b);     break;
1058  }
1059  res->data=(void *)r;
1060  return FALSE;
1061}
1062static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1063{
1064  number q=(number)v->Data();
1065  if (nIsZero(q))
1066  {
1067    WerrorS(ii_div_by_0);
1068    return TRUE;
1069  }
1070  q = nDiv((number)u->Data(),q);
1071  nNormalize(q);
1072  res->data = (char *)q;
1073  return FALSE;
1074}
1075static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1076{
1077  poly q=(poly)v->Data();
1078  if (q==NULL)
1079  {
1080    WerrorS(ii_div_by_0);
1081    return TRUE;
1082  }
1083  poly p=(poly)(u->Data());
1084  if (p==NULL)
1085  {
1086    res->data=NULL;
1087    return FALSE;
1088  }
1089  if (pNext(q)!=NULL)
1090  {
1091#ifdef HAVE_FACTORY
1092    if(pGetComp(p)==0)
1093    {
1094      res->data=(void*)(singclap_pdivide(p /*(poly)(u->Data())*/ ,
1095                                         q /*(poly)(v->Data())*/ ));
1096    }
1097    else
1098    {
1099      int comps=pMaxComp(p);
1100      ideal I=idInit(comps,1);
1101      p=pCopy(p);
1102      poly h;
1103      int i;
1104      // conversion to a list of polys:
1105      while (p!=NULL)
1106      {
1107        i=pGetComp(p)-1;
1108        h=pNext(p);
1109        pNext(p)=NULL;
1110        pSetComp(p,0);
1111        I->m[i]=pAdd(I->m[i],p);
1112        p=h;
1113      }
1114      // division and conversion to vector:
1115      h=NULL;
1116      p=NULL;
1117      for(i=comps-1;i>=0;i--)
1118      {
1119        if (I->m[i]!=NULL)
1120        {
1121          h=singclap_pdivide(I->m[i],q);
1122          pSetCompP(h,i+1);
1123          p=pAdd(p,h);
1124        }
1125      }
1126      idDelete(&I);
1127      res->data=(void *)p;
1128    }
1129#else
1130    WerrorS("division only by a monomial");
1131    return TRUE;
1132#endif
1133  }
1134  else
1135  {
1136    res->data = (char *)pDivideM(pCopy(p),pHead(q));
1137  }
1138  return FALSE;
1139}
1140static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1141{
1142  poly q=(poly)v->Data();
1143  if (q==NULL)
1144  {
1145    WerrorS(ii_div_by_0);
1146    return TRUE;
1147  }
1148  matrix m=(matrix)(u->Data());
1149  int r=m->rows();
1150  int c=m->cols();
1151  matrix mm=mpNew(r,c);
1152  int i,j;
1153  for(i=r;i>0;i--)
1154  {
1155    for(j=c;j>0;j--)
1156    {
1157      if (pNext(q)!=NULL)
1158      {
1159      #ifdef HAVE_FACTORY
1160        MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1161                                           q /*(poly)(v->Data())*/ );
1162      #else
1163        WerrorS("division only by a monomial");
1164        return TRUE;
1165      #endif
1166      }
1167      else
1168        MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1169    }
1170  }
1171  res->data=(char *)mm;
1172  return FALSE;
1173}
1174static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1175{
1176  res->data = (char *)((int)u->Data() == (int)v->Data());
1177  jjEQUAL_REST(res,u,v);
1178  return FALSE;
1179}
1180static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1181{
1182  res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
1183  jjEQUAL_REST(res,u,v);
1184  return FALSE;
1185}
1186static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1187{
1188  res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
1189  jjEQUAL_REST(res,u,v);
1190  return FALSE;
1191}
1192static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1193{
1194  poly p=(poly)u->Data();
1195  poly q=(poly)v->Data();
1196  if (p==NULL)
1197  {
1198    res->data=(char *)(q==NULL);
1199  }
1200  else
1201  {
1202    if (q==NULL) res->data=(char *)FALSE;
1203    else
1204    {
1205      int r=pCmp(p,q);
1206      if (r==0)
1207      {
1208        p=pSub(pCopy(p),pCopy(q));
1209        res->data = (char *) (p==NULL);
1210        pDelete(&p);
1211      }
1212      else
1213        res->data = (char *) FALSE;
1214    }
1215  }
1216  jjEQUAL_REST(res,u,v);
1217  return FALSE;
1218}
1219static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1220{
1221  res->data = (char *)((int)u->Data() && (int)v->Data());
1222  return FALSE;
1223}
1224static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1225{
1226  res->data = (char *)((int)u->Data() || (int)v->Data());
1227  return FALSE;
1228}
1229static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1230{
1231  res->rtyp=u->rtyp; u->rtyp=0;
1232  res->data=u->data; u->data=NULL;
1233  res->name=u->name; u->name=NULL;
1234  res->e=u->e;       u->e=NULL;
1235  if (res->e==NULL) res->e=jjMakeSub(v);
1236  else
1237  {
1238    Subexpr sh=res->e;
1239    while (sh->next != NULL) sh=sh->next;
1240    sh->next=jjMakeSub(v);
1241  }
1242  return FALSE;
1243}
1244static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1245{
1246  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1247  {
1248    WerrorS("indexed object must have a name");
1249    return TRUE;
1250  }
1251  intvec * iv=(intvec *)v->Data();
1252  leftv p=NULL;
1253  int i;
1254  sleftv t;
1255
1256  memset(&t,0,sizeof(t));
1257  t.rtyp=INT_CMD;
1258  for (i=0;i<iv->length(); i++)
1259  {
1260    t.data=(char *)(*iv)[i];
1261    if (p==NULL)
1262    {
1263      p=res;
1264    }
1265    else
1266    {
1267      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1268      p=p->next;
1269    }
1270    p->rtyp=IDHDL;
1271    p->data=u->data;
1272    p->name=u->name;
1273    p->flag|=u->flag;
1274    p->e=jjMakeSub(&t);
1275  }
1276  u->rtyp=0;
1277  u->data=NULL;
1278  u->name=NULL;
1279  return FALSE;
1280}
1281static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1282{
1283  poly p=(poly)u->Data();
1284  int i=(int)v->Data();
1285  int j=0;
1286  while (p!=NULL)
1287  {
1288    j++;
1289    if (j==i)
1290    {
1291      res->data=(char *)pHead(p);
1292      return FALSE;
1293    }
1294    pIter(p);
1295  }
1296  return FALSE;
1297}
1298static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1299{
1300  poly p=(poly)u->Data();
1301  poly r=NULL;
1302  intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1303  int i;
1304  int sum=0;
1305  for(i=iv->length()-1;i>=0;i--)
1306    sum+=(*iv)[i];
1307  int j=0;
1308  while ((p!=NULL) && (sum>0))
1309  {
1310    j++;
1311    for(i=iv->length()-1;i>=0;i--)
1312    {
1313      if (j==(*iv)[i])
1314      {
1315        r=pAdd(r,pHead(p));
1316        sum-=j;
1317        (*iv)[i]=0;
1318        break;
1319      }
1320    }
1321    pIter(p);
1322  }
1323  delete iv;
1324  res->data=(char *)r;
1325  return FALSE;
1326}
1327static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1328{
1329  poly p=(poly)u->CopyD(VECTOR_CMD);
1330  poly r=p; // pointer to the beginning of component i
1331  poly o=NULL;
1332  int i=(int)v->Data();
1333  while (p!=NULL)
1334  {
1335    if (pGetComp(p)!=i)
1336    {
1337      if (r==p) r=pNext(p);
1338      if (o!=NULL)
1339      {
1340        pDeleteLm(&pNext(o));
1341        p=pNext(o);
1342      }
1343      else
1344        pDeleteLm(&p);
1345    }
1346    else
1347    {
1348      pSetComp(p, 0);
1349      o=p;
1350      p=pNext(o);
1351    }
1352  }
1353  res->data=(char *)r;
1354  return FALSE;
1355}
1356static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1357{
1358  poly p=(poly)u->CopyD(VECTOR_CMD);
1359  if (p!=NULL)
1360  {
1361    poly r=pOne();
1362    poly hp=r;
1363    intvec *iv=(intvec *)v->Data();
1364    int i;
1365    loop
1366    {
1367      for(i=0;i<iv->length();i++)
1368      {
1369        if (pGetComp(p)==(*iv)[i])
1370        {
1371          poly h;
1372          pSplit(p,&h);
1373          pNext(hp)=p;
1374          p=h;
1375          pIter(hp);
1376          break;
1377        }
1378      }
1379      if (p==NULL) break;
1380      if (i==iv->length())
1381      {
1382        pDeleteLm(&p);
1383        if (p==NULL) break;
1384      }
1385    }
1386    pDeleteLm(&r);
1387    res->data=(char *)r;
1388  }
1389  return FALSE;
1390}
1391static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1392{
1393  if(u->name==NULL) return TRUE;
1394  char * nn = (char *)omAlloc(strlen(u->name) + 14);
1395  sprintf(nn,"%s(%d)",u->name,(int)v->Data());
1396  omFree((ADDRESS)u->name);
1397  u->name=NULL;
1398  char *n=omStrDup(nn);
1399  omFree((ADDRESS)nn);
1400  syMake(res,n);
1401  return FALSE;
1402}
1403static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1404{
1405  intvec * iv=(intvec *)v->Data();
1406  leftv p=NULL;
1407  int i;
1408  int slen = strlen(u->name) + 14;
1409  char *n = (char*) omAlloc(slen);
1410
1411  for (i=0;i<iv->length(); i++)
1412  {
1413    if (p==NULL)
1414    {
1415      p=res;
1416    }
1417    else
1418    {
1419      p->next=(leftv)omAlloc0Bin(sleftv_bin);
1420      p=p->next;
1421    }
1422    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1423    syMake(p,omStrDup(n));
1424  }
1425  omFree((ADDRESS)u->name);
1426  u->name = NULL;
1427  omFreeSize(n, slen);
1428  return FALSE;
1429}
1430static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1431{
1432#ifdef HAVE_NS
1433  leftv sl;
1434  if (u->req_packhdl==currPack)
1435    sl = iiMake_proc((idhdl)u->data,NULL,v);
1436  else
1437    sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1438#else /* HAVE_NS */
1439  leftv sl = iiMake_proc((idhdl)u->data,v);
1440#endif /* HAVE_NS */
1441  if (sl==NULL)
1442  {
1443    return TRUE;
1444  }
1445  else
1446  {
1447    memcpy(res,sl,sizeof(sleftv));
1448  }
1449  return FALSE;
1450}
1451static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1452{
1453  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1454  leftv sl=NULL;
1455  if ((v->e==NULL)&&(v->name!=NULL))
1456  {
1457    map m=(map)u->Data();
1458    sl=iiMap(m,v->name);
1459  }
1460  else
1461  {
1462    Werror("%s(<name>) expected",u->Name());
1463  }
1464  if (sl==NULL) return TRUE;
1465  memcpy(res,sl,sizeof(sleftv));
1466  omFreeBin((ADDRESS)sl, sleftv_bin);
1467  return FALSE;
1468}
1469static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1470{
1471  u->next=(leftv)omAllocBin(sleftv_bin);
1472  memcpy(u->next,v,sizeof(sleftv));
1473  BOOLEAN r=iiExprArithM(res,u,iiOp);
1474  // iiExprArithM did the CleanUp
1475  return r;
1476}
1477static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1478{
1479  res->data=(char *)mpCoeffProc((poly)u->Data(),(poly)v->Data());
1480  return FALSE;
1481}
1482static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1483{
1484  int i=pVar((poly)v->Data());
1485  if (i==0)
1486  {
1487    WerrorS("ringvar expected");
1488    return TRUE;
1489  }
1490  res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1491  return FALSE;
1492}
1493static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1494{
1495  poly p = pInit();
1496  int i;
1497
1498  for (i=1; i<=pVariables; i++)
1499  {
1500    pSetExp(p, i, 1);
1501  }
1502  res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1503                                    (ideal)(v->Data()), p);
1504  pDelete(&p);
1505  return FALSE;
1506}
1507static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1508{
1509  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1510  return FALSE;
1511}
1512static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1513{
1514  short *iv=iv2array((intvec *)v->Data());
1515  ideal I=(ideal)u->Data();
1516  int d=-1;
1517  int i;
1518  for(i=IDELEMS(I);i>=0;i--) d=max(d,pDegW(I->m[i],iv));
1519  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1520  res->data = (char *)d;
1521  return FALSE;
1522}
1523static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1524{
1525  short *iv=iv2array((intvec *)v->Data());
1526  res->data = (char *)pDegW((poly)u->Data(),iv);
1527  omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1528  return FALSE;
1529}
1530static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1531{
1532  int i=pVar((poly)v->Data());
1533  if (i==0)
1534  {
1535    WerrorS("ringvar expected");
1536    return TRUE;
1537  }
1538  res->data=(char *)pDiff((poly)(u->Data()),i);
1539  return FALSE;
1540}
1541static BOOLEAN jjDIFF_ID(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 *)idDiff((matrix)(u->Data()),i);
1550  return FALSE;
1551}
1552static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1553{
1554  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1555  return FALSE;
1556}
1557static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1558{
1559  assumeStdFlag(v);
1560  if(currQuotient==NULL)
1561    res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1562  else
1563  {
1564    ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1565    res->data = (char *)scDimInt((ideal)(v->Data()),q);
1566    idDelete(&q);
1567  }
1568  return FALSE;
1569}
1570static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1571{
1572  ideal vi=(ideal)v->Data();
1573  int vl= IDELEMS(vi);
1574  ideal ui=(ideal)u->Data();
1575  int ul= IDELEMS(ui);
1576  ideal R; matrix U;
1577  ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1578  // now make sure that all matices have the corect size:
1579  matrix T = idModule2formatedMatrix(m,vl,ul);
1580  if (MATCOLS(U) != ul)
1581  {
1582    int mul=min(ul,MATCOLS(U));
1583    matrix UU=mpNew(ul,ul);
1584    int i,j;
1585    for(i=mul;i>0;i--)
1586    {
1587      for(j=mul;j>0;j--)
1588      {
1589        MATELEM(UU,i,j)=MATELEM(U,i,j);
1590        MATELEM(U,i,j)=NULL;
1591      }
1592    }
1593    idDelete((ideal *)&U);
1594    U=UU;
1595  }
1596  lists L=(lists)omAllocBin(slists_bin);
1597  L->Init(3);
1598  L->m[0].rtyp=MATRIX_CMD;   L->m[0].data=(void *)T;
1599  L->m[1].rtyp=u->Typ();     L->m[1].data=(void *)R;
1600  L->m[2].rtyp=MATRIX_CMD;   L->m[2].data=(void *)U;
1601  res->data=(char *)L;
1602  return FALSE;
1603}
1604static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1605{
1606  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1607  setFlag(res,FLAG_STD);
1608  return FALSE;
1609}
1610static BOOLEAN jjERROR(leftv res, leftv u)
1611{
1612  WerrorS((char *)u->Data());
1613  return TRUE;
1614}
1615static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1616{
1617  int uu=(int)u->Data();int vv=(int)v->Data();
1618  int p0=ABS(uu),p1=ABS(vv);
1619  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1620
1621  while ( p1!=0 )
1622  {
1623    q=p0 / p1;
1624    r=p0 % p1;
1625    p0 = p1; p1 = r;
1626    r = g0 - g1 * q;
1627    g0 = g1; g1 = r;
1628    r = f0 - f1 * q;
1629    f0 = f1; f1 = r;
1630  }
1631  int a = f0;
1632  int b = g0;
1633  if ( uu /*(int)u->Data()*/ < 0 ) a=-a;
1634  if ( vv /*(int)v->Data()*/ < 0 ) b=-b;
1635  lists L=(lists)omAllocBin(slists_bin);
1636  L->Init(3);
1637  L->m[0].rtyp=INT_CMD;   L->m[0].data=(void *)p0;
1638  L->m[1].rtyp=INT_CMD;   L->m[1].data=(void *)a;
1639  L->m[2].rtyp=INT_CMD;   L->m[2].data=(void *)b;
1640  res->rtyp=LIST_CMD;
1641  res->data=(char *)L;
1642  return FALSE;
1643}
1644#ifdef HAVE_FACTORY
1645static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1646{
1647  poly r,pa,pb;
1648  BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1649  if (ret) return TRUE;
1650  lists L=(lists)omAllocBin(slists_bin);
1651  L->Init(3);
1652  res->data=(char *)L;
1653  L->m[0].data=(void *)r;
1654  L->m[0].rtyp=POLY_CMD;
1655  L->m[1].data=(void *)pa;
1656  L->m[1].rtyp=POLY_CMD;
1657  L->m[2].data=(void *)pb;
1658  L->m[2].rtyp=POLY_CMD;
1659  return FALSE;
1660}
1661static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1662{
1663  ideal_list p,h;
1664  h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
1665  p=h;
1666  int l=0;
1667  while (p!=NULL) { p=p->next;l++; }
1668  lists L=(lists)omAllocBin(slists_bin);
1669  L->Init(l);
1670  l=0;
1671  while(h!=NULL) 
1672  {
1673    L->m[l].data=(char *)h->d;
1674    L->m[l].rtyp=IDEAL_CMD;
1675    p=h->next;
1676    omFreeSize(h,sizeof(*h));
1677    h=p;
1678    l++;
1679  }
1680  res->data=(void *)L;
1681  return FALSE;
1682}
1683#endif
1684static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1685{
1686  ring r=(ring)u->Data();
1687  idhdl w;
1688  int op=iiOp;
1689  nMapFunc nMap;
1690
1691  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1692  {
1693    int *perm=NULL;
1694    int *par_perm=NULL;
1695    int par_perm_size=0;
1696    BOOLEAN bo;
1697    //if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1698    if ((nMap=nSetMap(r))==NULL)
1699    {
1700      if (rEqual(r,currRing))
1701      {
1702        nMap=nCopy;
1703      }
1704      else
1705      // Allow imap/fetch to be make an exception only for:
1706      if ( (rField_is_Q_a(r) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
1707            (rField_is_Q() || rField_is_Q_a() ||
1708             (rField_is_Zp() || rField_is_Zp_a())))
1709           ||
1710           (rField_is_Zp_a(r) &&  // Zp(a..) -> Zp(a..) || Zp
1711            (rField_is_Zp(currRing, rInternalChar(r)) ||
1712             rField_is_Zp_a(currRing, rInternalChar(r)))) )
1713      {
1714        par_perm_size=rPar(r);
1715        BITSET save_test=test;
1716        naSetChar(rInternalChar(r),r);
1717        nSetChar(currRing);
1718        test=save_test;
1719      }
1720      else
1721      {
1722        goto err_fetch;
1723      }
1724    }
1725    if ((iiOp!=FETCH_CMD) || (r->N!=pVariables) || (rPar(r)!=rPar(currRing)))
1726    {
1727      perm=(int *)omAlloc0((r->N+1)*sizeof(int));
1728      if (par_perm_size!=0)
1729        par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
1730      op=IMAP_CMD;
1731      if (iiOp==IMAP_CMD)
1732      {
1733        maFindPerm(r->names,       r->N,       r->parameter,        r->P,
1734                   currRing->names,currRing->N,currRing->parameter, currRing->P,
1735                   perm,par_perm, currRing->ch);
1736      }
1737      else
1738      {
1739        int i;
1740        if (par_perm_size!=0)
1741          for(i=0;i<min(rPar(r),rPar(currRing));i++) par_perm[i]=-(i+1);
1742        for(i=1;i<=min(r->N,pVariables);i++) perm[i]=i;
1743      }
1744    }
1745    if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1746    {
1747      int i;
1748      for(i=0;i<min(r->N,pVariables);i++)
1749      {
1750        Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
1751      }
1752      for(i=0;i<min(rPar(r),rPar(currRing));i++) // possibly empty loop
1753      {
1754        Print("// par nr %d: %s -> %s\n",
1755              i,r->parameter[i],currRing->parameter[i]);
1756      }
1757    }
1758    sleftv tmpW;
1759    memset(&tmpW,0,sizeof(sleftv));
1760    tmpW.rtyp=IDTYP(w);
1761    tmpW.data=IDDATA(w);
1762    if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1763                         perm,par_perm,par_perm_size,nMap)))
1764    {
1765      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1766    }
1767    if (perm!=NULL)
1768      omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
1769    if (par_perm!=NULL)
1770      omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
1771    return bo;
1772  }
1773  else
1774  {
1775    Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1776  }
1777  return TRUE;
1778err_fetch:
1779  Werror("no identity map from %s",u->Fullname());
1780  return TRUE;
1781}
1782static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1783{
1784  /*4
1785  * look for the substring what in the string where
1786  * return the position of the first char of what in where
1787  * or 0
1788  */
1789  char *where=(char *)u->Data();
1790  char *what=(char *)v->Data();
1791  char *found = strstr(where,what);
1792  if (found != NULL)
1793  {
1794    res->data=(char *)((found-where)+1);
1795  }
1796  /*else res->data=NULL;*/
1797  return FALSE;
1798}
1799static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1800{
1801  int uu=(int)u->Data();int vv=(int)v->Data();
1802  int p0=ABS(uu),p1=ABS(vv);
1803  int r;
1804
1805  while ( p1!=0 )
1806  {
1807    r=p0 % p1;
1808    p0 = p1; p1 = r;
1809  }
1810  res->rtyp=INT_CMD;
1811  res->data=(char *)p0;
1812  return FALSE;
1813}
1814static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
1815{
1816  number a=(number) u->Data();
1817  number b=(number) v->Data();
1818  if (nIsZero(a))
1819  {
1820    if (nIsZero(b)) res->data=(char *)nInit(1);
1821    else            res->data=(char *)nCopy(b);
1822  }
1823  else
1824  {
1825    if (nIsZero(b))  res->data=(char *)nCopy(a);
1826    else res->data=(char *)nGcd(a, b, currRing);
1827  }
1828  return FALSE;
1829}
1830#ifdef HAVE_FACTORY
1831static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
1832{
1833  res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
1834                                 (poly)(v->CopyD(POLY_CMD)));
1835  return FALSE;
1836}
1837#endif
1838static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1839{
1840  assumeStdFlag(u);
1841  intvec *module_w=(intvec*)atGet(u,"isHomog");
1842  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1843  switch((int)v->Data())
1844  {
1845    case 1:
1846      res->data=(void *)iv;
1847      return FALSE;
1848    case 2:
1849      res->data=(void *)hSecondSeries(iv);
1850      delete iv;
1851      return FALSE;
1852  }
1853  WerrorS(feNotImplemented);
1854  delete iv;
1855  return TRUE;
1856}
1857static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1858{
1859  int i=pVar((poly)v->Data());
1860  if (i==0)
1861  {
1862    WerrorS("ringvar expected");
1863    return TRUE;
1864  }
1865  res->data = (char *)pHomogen((poly)u->Data(),i);
1866  return FALSE;
1867}
1868static BOOLEAN jjHOMOG_ID(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 *)idHomogen((ideal)u->Data(),i);
1877  return FALSE;
1878}
1879static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1880{
1881  assumeStdFlag(u);
1882  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(v->Data()),
1883                    currQuotient);
1884  return FALSE;
1885}
1886static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1887{
1888  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1889  setFlag(res,FLAG_STD);
1890  return FALSE;
1891}
1892static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1893{
1894  res->data = (char *)pJet((poly)u->CopyD(), (int)v->Data());
1895  return FALSE;
1896}
1897static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1898{
1899  res->data = (char *)idJet((ideal)u->Data(),(int)v->Data());
1900  return FALSE;
1901}
1902static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1903{
1904  assumeStdFlag(u);
1905  res->data = (char *)scKBase((int)v->Data(),
1906                              (ideal)(u->Data()),currQuotient);
1907  return FALSE;
1908}
1909static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1910{
1911  return mpKoszul(res, u,v);
1912}
1913static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1914{
1915  sleftv h;
1916  memset(&h,0,sizeof(sleftv));
1917  h.rtyp=INT_CMD;
1918  h.data=(void *)IDELEMS((ideal)v->Data());
1919  return mpKoszul(res, u, &h, v);
1920}
1921static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1922{
1923  ideal m;
1924  BITSET save_test=test;
1925  int ul= IDELEMS((ideal)u->Data());
1926  int vl= IDELEMS((ideal)v->Data());
1927  m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
1928  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1929  test=save_test;
1930  return FALSE;
1931}
1932static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
1933{
1934  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
1935  idhdl h=(idhdl)v->data;
1936  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
1937  res->data = (char *)idLiftStd((ideal)u->Data(),
1938                                &(h->data.umatrix),testHomog);
1939  setFlag(res,FLAG_STD);
1940  return FALSE;
1941}
1942static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
1943{
1944  res->data = (char *)idMinors((matrix)u->Data(),(int)v->Data());
1945  return (res->data==NULL);
1946}
1947static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
1948{
1949  res->data = (char *)idModulo((ideal)u->Data(),(ideal)v->Data());
1950  return FALSE;
1951}
1952static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
1953{
1954  char *opt=(char *)v->Data();
1955  int mode=0;
1956  while(*opt!='\0')
1957  {
1958    if (*opt=='i') mode |= PROT_I;
1959    else if (*opt=='o') mode |= PROT_O;
1960    opt++;
1961  }
1962  monitor((char *)(u->Data()),mode);
1963  return FALSE;
1964}
1965static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
1966{
1967  idhdl h=(idhdl)u->data;
1968  int i=(int)v->Data();
1969  int p=0;
1970  if ((0<i)
1971  && (IDRING(h)->parameter!=NULL)
1972  && (i<=(p=rPar(IDRING(h)))))
1973    res->data=omStrDup(IDRING(h)->parameter[i-1]);
1974  else
1975  {
1976    Werror("par number %d out of range 1..%d",i,p);
1977    return TRUE;
1978  }
1979  return FALSE;
1980}
1981
1982#ifdef HAVE_PLURAL
1983static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
1984{
1985  return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
1986}
1987
1988static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
1989{
1990  return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
1991}
1992
1993static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
1994{
1995  return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
1996}
1997
1998static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
1999{
2000  return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2001}
2002#endif
2003
2004static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2005{
2006  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2007    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2008  idDelMultiples((ideal)(res->data));
2009  return FALSE;
2010}
2011static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2012{
2013  int i=(int)u->Data();
2014  int j=(int)v->Data();
2015#ifdef buildin_rand
2016  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
2017#else
2018  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
2019#endif
2020  return FALSE;
2021}
2022static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2023{
2024  si_link l=(si_link)u->Data();
2025  leftv r=slRead(l,v);
2026  if (r==NULL)
2027  {
2028    const char *s;
2029    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2030    else                            s=sNoName;
2031    Werror("cannot read from `%s`",s);
2032    return TRUE;
2033  }
2034  memcpy(res,r,sizeof(sleftv));
2035  omFreeBin((ADDRESS)r, sleftv_bin);
2036  return FALSE;
2037}
2038static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2039{
2040  assumeStdFlag(v);
2041  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2042  return FALSE;
2043}
2044static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2045{
2046  assumeStdFlag(v);
2047  ideal ui=(ideal)u->Data();
2048  idTest(ui);
2049  ideal vi=(ideal)v->Data();
2050  idTest(vi);
2051  res->data = (char *)kNF(vi,currQuotient,ui);
2052  return FALSE;
2053}
2054static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2055{
2056  int maxl=(int)v->Data();
2057  if (maxl<0)
2058  {
2059    WerrorS("length for res must not be negative");
2060    return TRUE;
2061  }
2062  int l=0;
2063  //resolvente r;
2064  syStrategy r;
2065  intvec **weights=NULL;
2066  int wmaxl=maxl;
2067  ideal u_id=(ideal)u->Data();
2068
2069  maxl--;
2070  if ((maxl==-1) /*&& (iiOp!=MRES_CMD)*/)
2071  {
2072    maxl = pVariables-1+2*(iiOp==MRES_CMD);
2073    if (currQuotient!=NULL)
2074    {
2075      Warn(
2076      "full resolution in a qring may be infinite, setting max length to %d",
2077      maxl+1);
2078    }
2079  }
2080  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
2081  {
2082    intvec * iv=(intvec*)atGet(u,"isHomog");
2083    r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
2084  }
2085  else if (iiOp==SRES_CMD)
2086  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
2087    r=sySchreyer(u_id,maxl+1);
2088  else if (iiOp == LRES_CMD)
2089  {
2090    int dummy;
2091    if((currQuotient!=NULL)||
2092    (!idHomIdeal (u_id,NULL)))
2093    {
2094       WerrorS
2095       ("`lres` not implemented for inhomogeneous input or qring");
2096       return TRUE;
2097    }
2098    r=syLaScala3(u_id,&dummy);
2099  }
2100  else if (iiOp == KRES_CMD)
2101  {
2102    int dummy;
2103    if((currQuotient!=NULL)||
2104    (!idHomIdeal (u_id,NULL)))
2105    {
2106       WerrorS
2107       ("`lres` not implemented for inhomogeneous input or qring");
2108       return TRUE;
2109    }
2110    r=syKosz(u_id,&dummy);
2111  }
2112  else
2113  {
2114    int dummy;
2115    if((currQuotient!=NULL)||
2116    (!idHomIdeal (u_id,NULL)))
2117    {
2118       WerrorS
2119       ("`hres` not implemented for inhomogeneous input or qring");
2120       return TRUE;
2121    }
2122    r=syHilb(u_id,&dummy);
2123  }
2124  if (r==NULL) return TRUE;
2125  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2126  r->list_length=wmaxl;
2127  res->data=(void *)r;
2128  return FALSE;
2129}
2130static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2131{
2132  ring r;
2133  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2134  res->data = (char *)r;
2135  return (i==-1);
2136}
2137#define SIMPL_LMDIV 32
2138#define SIMPL_LMEQ  16
2139#define SIMPL_MULT 8
2140#define SIMPL_EQU  4
2141#define SIMPL_NULL 2
2142#define SIMPL_NORM 1
2143static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2144{
2145  int sw = (int)v->Data();
2146  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2147  ideal id = (ideal)u->CopyD(IDEAL_CMD);
2148  if (sw & SIMPL_LMDIV)
2149  {
2150    idDelDiv(id);
2151  }
2152  if (sw & SIMPL_LMEQ)
2153  {
2154    idDelLmEquals(id);
2155  }
2156  if (sw & SIMPL_NULL)
2157  {
2158    idSkipZeroes(id);
2159  }
2160  if (sw & SIMPL_NORM)
2161  {
2162    idNorm(id);
2163  }
2164  if (sw & SIMPL_MULT)
2165  {
2166    idDelMultiples(id);
2167  }
2168  else if(sw & SIMPL_EQU)
2169  {
2170    idDelEquals(id);
2171  }
2172  res->data = (char * )id;
2173  return FALSE;
2174}
2175#ifdef HAVE_FACTORY
2176static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2177{
2178  intvec *v=NULL;
2179  int sw=(int)dummy->Data();
2180  int fac_sw=sw;
2181  if ((sw<0)||(sw>2)) fac_sw=1;
2182  ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2183  if (f==NULL)
2184    return TRUE;
2185  switch(sw)
2186  {
2187    case 0:
2188    case 2:
2189    {
2190      lists l=(lists)omAllocBin(slists_bin);
2191      l->Init(2);
2192      l->m[0].rtyp=IDEAL_CMD;
2193      l->m[0].data=(void *)f;
2194      l->m[1].rtyp=INTVEC_CMD;
2195      l->m[1].data=(void *)v;
2196      res->data=(void *)l;
2197      res->rtyp=LIST_CMD;
2198      return FALSE;
2199    }
2200    case 1:
2201      res->data=(void *)f;
2202      return FALSE;
2203    case 3:
2204      {
2205        poly p=f->m[0];
2206        int i=IDELEMS(f);
2207        f->m[0]=NULL;
2208        while(i>1)
2209        {
2210          i--;
2211          p=pMult(p,f->m[i]);
2212          f->m[i]=NULL;
2213        }
2214        res->data=(void *)p;
2215        res->rtyp=POLY_CMD;
2216      }
2217      return FALSE;
2218  }
2219  WerrorS("invalid switch");
2220  return TRUE;
2221}
2222#endif
2223static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2224{
2225  res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2226  return FALSE;
2227}
2228static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2229{
2230  int sw = (int)v->Data();
2231  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2232  poly p = (poly)u->CopyD(POLY_CMD);
2233  if (sw & SIMPL_NORM)
2234  {
2235    pNorm(p);
2236  }
2237  res->data = (char * )p;
2238  return FALSE;
2239}
2240static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2241{
2242  ideal result;
2243  intvec *w=(intvec *)atGet(u,"isHomog");
2244  tHomog hom=testHomog;
2245  if (w!=NULL)
2246  {
2247    w=ivCopy(w);
2248    hom=isHomog;
2249  }
2250  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
2251  idSkipZeroes(result);
2252  res->data = (char *)result;
2253  setFlag(res,FLAG_STD);
2254  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2255  return FALSE;
2256}
2257static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2258{
2259  assumeStdFlag(u);
2260  ideal result;
2261  intvec *w=(intvec *)atGet(u,"isHomog");
2262  tHomog hom=testHomog;
2263  if (w!=NULL)
2264  {
2265    w=ivCopy(w);
2266    hom=isHomog;
2267  }
2268  ideal i1=(ideal)u->Data();
2269  ideal i0=idInit(1,i1->rank);
2270  i0->m[0]=(poly)v->Data();
2271  i1=idSimpleAdd(i1,i0);
2272  i0->m[0]=NULL;
2273  idDelete(&i0);
2274  BITSET save_test=test;
2275  test|=Sy_bit(OPT_SB_1);
2276  result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2277  test=save_test;
2278  idDelete(&i1);
2279  idSkipZeroes(result);
2280  res->data = (char *)result;
2281  setFlag(res,FLAG_STD);
2282  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2283  return FALSE;
2284}
2285static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2286{
2287  idhdl h=(idhdl)u->data;
2288  int i=(int)v->Data();
2289  if ((0<i) && (i<=IDRING(h)->N))
2290    res->data=omStrDup(IDRING(h)->names[i-1]);
2291  else
2292  {
2293    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2294    return TRUE;
2295  }
2296  return FALSE;
2297}
2298static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2299{
2300  res->data = (char *)mpWedge((matrix)u->Data(),(int)v->Data());
2301  return FALSE;
2302}
2303#define jjWRONG2 (proc2)jjWRONG
2304#define jjWRONG3 (proc3)jjWRONG
2305static BOOLEAN jjWRONG(leftv res, leftv u)
2306{
2307  return TRUE;
2308}
2309
2310static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2311{
2312  char * s=(char *)u->Data();
2313  if(strcmp(s, "with")==0)
2314    return jjLOAD(res, v, TRUE);
2315  WerrorS("invalid second argument");
2316  WerrorS("load(\"libname\" [,\"with\"]);");
2317  return TRUE;
2318}
2319
2320/*=================== operations with 2 args.: table =================*/
2321
2322struct sValCmd2 dArith2[]=
2323{
2324// operations:
2325// proc        cmd              res             arg1        arg2   plural
2326 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2327,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2328,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2329,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2330,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2331,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2332,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2333,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
2334,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2335,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2336,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD ALLOW_PLURAL}
2337,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2338,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2339,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2340,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2341,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2342,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2343,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD ALLOW_PLURAL}
2344,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD ALLOW_PLURAL}
2345,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2346,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2347,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2348,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2349,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2350,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2351,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2352,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2353,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2354,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2355,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2356,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2357,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2358,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD ALLOW_PLURAL}
2359,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2360,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2361,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2362,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2363,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2364,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2365,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2366,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2367,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2368,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD NO_PLURAL}
2369,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2370,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2371,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2372,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD NO_PLURAL}
2373,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2374,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2375,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
2376,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2377,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD ALLOW_PLURAL}
2378,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2379,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2380,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2381,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2382,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2383,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD NO_PLURAL}
2384,{jjDIV_Ma,    '/',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD NO_PLURAL}
2385,{jjDIVMOD_I,  '/',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2386,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2387,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2388,{jjDIVMOD_I,  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2389,{jjOP_IV_I,   INTDIV_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2390,{jjOP_IV_I,   INTDIV_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2391,{jjDIVMOD_I,  '%',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2392,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2393,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2394,{jjDIVMOD_I,  INTMOD_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2395,{jjOP_IV_I,   INTMOD_CMD,     INTVEC_CMD,     INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2396,{jjOP_IV_I,   INTMOD_CMD,     INTMAT_CMD,     INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2397,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2398,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2399,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2400,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2401,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2402,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2403,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2404,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2405,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2406,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2407,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2408,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2409,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2410,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2411,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2412,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2413,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2414,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2415,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2416,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2417,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2418,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2419,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2420,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2421,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2422,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2423,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2424,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2425,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2426,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2427,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2428,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2429,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2430,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2431,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2432,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2433,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2434,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2435,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2436,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2437,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2438,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2439,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2440,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2441,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2442,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2443,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2444,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2445,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2446,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2447,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2448,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2449,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2450,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2451,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2452,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2453,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2454,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  MODUL_CMD ALLOW_PLURAL}
2455,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2456,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD ALLOW_PLURAL}
2457,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2458,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2459,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2460,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD ALLOW_PLURAL}
2461,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2462,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2463,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD ALLOW_PLURAL}
2464,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD ALLOW_PLURAL}
2465,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2466,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2467,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2468,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2469,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2470,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2471,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2472,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2473,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD NO_PLURAL}
2474,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2475,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2476// and the procedures with 2 arguments:
2477,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD ALLOW_PLURAL}
2478,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2479,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2480,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2481,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2482,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2483,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2484,{jjCOEFFS2_KB,COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2485,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2486,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD ALLOW_PLURAL}
2487,{jjDEG_IV,    DEG_CMD,        INT_CMD,        VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2488,{jjDEG_M_IV,  DEG_CMD,        INT_CMD,        MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2489,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD ALLOW_PLURAL}
2490,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2491,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2492,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2493,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2494,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2495,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2496,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2497,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2498,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2499,{jjDIVISION,  DIVISION_CMD,   LIST_CMD,       MODUL_CMD,  MODUL_CMD NO_PLURAL}
2500,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2501,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2502,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD ALLOW_PLURAL}
2503#ifdef HAVE_FACTORY
2504,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2505,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2506,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2507#else
2508,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2509,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD NO_PLURAL}
2510,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2511#endif
2512,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2513,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2514#ifdef HAVE_FGLM
2515,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2516,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2517,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD NO_PLURAL}
2518#else
2519,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD NO_PLURAL}
2520,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD NO_PLURAL}
2521,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD NO_PLURAL}
2522#endif
2523,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD ALLOW_PLURAL}
2524,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2525,{jjGCD_N,     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2526#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
2527,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2528#else
2529,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD NO_PLURAL}
2530#endif
2531,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD NO_PLURAL}
2532,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD NO_PLURAL}
2533,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
2534,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2535,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2536,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
2537,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2538,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2539,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE ALLOW_PLURAL}
2540,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
2541,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2542,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD ALLOW_PLURAL}
2543,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2544,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2545,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2546,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2547,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2548,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2549,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD ALLOW_PLURAL}
2550,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2551,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2552,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD ALLOW_PLURAL}
2553,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD NO_PLURAL}
2554,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD NO_PLURAL}
2555,{jjRES,       KRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2556,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2557,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD NO_PLURAL}
2558,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD NO_PLURAL}
2559,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD NO_PLURAL}
2560#ifdef HAVE_PLURAL
2561,{jjPlural_num_poly, NCALGEBRA_CMD,  NONE,  POLY_CMD,   POLY_CMD   NO_PLURAL}
2562,{jjPlural_num_mat,  NCALGEBRA_CMD,  NONE,  POLY_CMD,   MATRIX_CMD NO_PLURAL}
2563,{jjPlural_mat_poly, NCALGEBRA_CMD,  NONE,  MATRIX_CMD, POLY_CMD   NO_PLURAL}
2564,{jjPlural_mat_mat,  NCALGEBRA_CMD,  NONE,  MATRIX_CMD, MATRIX_CMD NO_PLURAL}
2565#endif
2566,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2567,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2568,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD NO_PLURAL}
2569,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD ALLOW_PLURAL}
2570,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2571,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD NO_PLURAL}
2572,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2573//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2574//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2575,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2576,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2577,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2578,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2579,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD ALLOW_PLURAL}
2580,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD NO_PLURAL}
2581,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD NO_PLURAL}
2582,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD NO_PLURAL}
2583,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD ALLOW_PLURAL}
2584,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2585,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
2586,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2587,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
2588,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2589,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD ALLOW_PLURAL}
2590,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD ALLOW_PLURAL}
2591//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2592//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2593,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2594,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2595,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD ALLOW_PLURAL}
2596,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD ALLOW_PLURAL}
2597,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2598,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
2599,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD ALLOW_PLURAL}
2600//,{jjRES,       SRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD NO_PLURAL}
2601//,{jjRES,       SRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD NO_PLURAL}
2602,{jjRES,       SRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD NO_PLURAL}
2603,{jjRES,       SRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD NO_PLURAL}
2604,{jjCALL2MANY, SYSTEM_CMD,     ANY_TYPE/*set by p*/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
2605,{jjSTD_1,     STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
2606,{jjSTD_1,     STD_CMD,        MODUL_CMD,      MODUL_CMD,  VECTOR_CMD ALLOW_PLURAL}
2607,{jjSTD_HILB,  STD_CMD,        IDEAL_CMD,      IDEAL_CMD,  INTVEC_CMD NO_PLURAL}
2608,{jjSTD_HILB,  STD_CMD,        MODUL_CMD,      MODUL_CMD,  INTVEC_CMD NO_PLURAL}
2609,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD ALLOW_PLURAL}
2610,{jjVARSTR2,   VARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD ALLOW_PLURAL}
2611,{jjWEDGE,     WEDGE_CMD,      MATRIX_CMD,     MATRIX_CMD, INT_CMD NO_PLURAL}
2612,{jjLOAD_E,    LOAD_CMD,       NONE,           STRING_CMD, STRING_CMD ALLOW_PLURAL}
2613,{nuMPResMat,  MPRES_CMD,      MODUL_CMD,      IDEAL_CMD,  INT_CMD NO_PLURAL}
2614,{NULL,        0,              0,              0,          0 NO_PLURAL}
2615};
2616/*=================== operations with 1 arg.: static proc =================*/
2617static BOOLEAN jjDUMMY(leftv res, leftv u)
2618{
2619  res->data = (char *)u->CopyD();
2620  return FALSE;
2621}
2622static BOOLEAN jjNULL(leftv res, leftv u)
2623{
2624  return FALSE;
2625}
2626//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2627//{
2628//  res->data = (char *)((int)u->Data()+1);
2629//  return FALSE;
2630//}
2631//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
2632//{
2633//  res->data = (char *)((int)u->Data()-1);
2634//  return FALSE;
2635//}
2636static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2637{
2638  if (IDTYP((idhdl)u->data)==INT_CMD)
2639  {
2640    if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
2641    else                IDINT((idhdl)u->data)--;
2642    return FALSE;
2643  }
2644  return TRUE;
2645}
2646static BOOLEAN jjUMINUS_I(leftv res, leftv u)
2647{
2648  res->data = (char *)(-(int)u->Data());
2649  return FALSE;
2650}
2651static BOOLEAN jjUMINUS_N(leftv res, leftv u)
2652{
2653  number n=(number)u->CopyD(NUMBER_CMD);
2654  n=nNeg(n);
2655  res->data = (char *)n;
2656  return FALSE;
2657}
2658static BOOLEAN jjUMINUS_P(leftv res, leftv u)
2659{
2660  res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
2661  return FALSE;
2662}
2663static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
2664{
2665  poly m1=pISet(-1);
2666  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
2667  return FALSE;
2668}
2669static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
2670{
2671  intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
2672  (*iv)*=(-1);
2673  res->data = (char *)iv;
2674  return FALSE;
2675}
2676static BOOLEAN jjPROC1(leftv res, leftv u)
2677{
2678  if ((u->rtyp!=IDHDL) || (u->e!=NULL))
2679    return TRUE;
2680#ifdef HAVE_NS
2681  leftv sl = iiMake_proc((idhdl) u->data,u->req_packhdl,NULL);
2682#else /* HAVE_NS */
2683  leftv sl = iiMake_proc((idhdl) u->data,NULL);
2684#endif /* HAVE_NS */
2685  if (sl==NULL)
2686  {
2687    return TRUE;
2688  }
2689  else
2690  {
2691    memcpy(res,sl,sizeof(sleftv));
2692  }
2693  return FALSE;
2694}
2695static BOOLEAN jjBAREISS(leftv res, leftv v)
2696{
2697  //matrix m=(matrix)v->Data();
2698  //lists l=mpBareiss(m,FALSE);
2699  intvec *iv;
2700  ideal m;
2701  smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
2702  lists l=(lists)omAllocBin(slists_bin);
2703  l->Init(2);
2704  l->m[0].rtyp=MODUL_CMD;
2705  l->m[1].rtyp=INTVEC_CMD;
2706  l->m[0].data=(void *)m;
2707  l->m[1].data=(void *)iv;
2708  res->data = (char *)l;
2709  return FALSE;
2710}
2711//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
2712//{
2713//  intvec *m=(intvec *)v->CopyD(INTMAT_CMD);
2714//  ivTriangMat(m);
2715//  res->data = (char *)m;
2716//  return FALSE;
2717//}
2718static BOOLEAN jjCALL1MANY(leftv res, leftv u)
2719{
2720  return iiExprArithM(res,u,iiOp);
2721}
2722static BOOLEAN jjCHAR(leftv res, leftv v)
2723{
2724  res->data = (char *)rChar((ring)v->Data());
2725  return FALSE;
2726}
2727static BOOLEAN jjCOLS(leftv res, leftv v)
2728{
2729  res->data = (char *)MATCOLS((matrix)(v->Data()));
2730  return FALSE;
2731}
2732static BOOLEAN jjCOLS_IV(leftv res, leftv v)
2733{
2734  res->data = (char *)((intvec*)(v->Data()))->cols();
2735  return FALSE;
2736}
2737static BOOLEAN jjCONTENT(leftv res, leftv v)
2738{
2739  // CopyD for POLY_CMD and VECTOR_CMD are identical:
2740  poly p=(poly)v->CopyD(POLY_CMD);
2741  if (p!=NULL) pCleardenom(p);
2742  res->data = (char *)p;
2743  return FALSE;
2744}
2745static BOOLEAN jjCOUNT_N(leftv res, leftv v)
2746{
2747  res->data = (char *)nSize((number)v->Data());
2748  return FALSE;
2749}
2750static BOOLEAN jjCOUNT_L(leftv res, leftv v)
2751{
2752  lists l=(lists)v->Data();
2753  res->data = (char *)(l->nr+1);
2754  return FALSE;
2755}
2756static BOOLEAN jjCOUNT_M(leftv res, leftv v)
2757{
2758  matrix m=(matrix)v->Data();
2759  res->data = (char *)(MATROWS(m)*MATCOLS(m));
2760  return FALSE;
2761}
2762static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
2763{
2764  res->data = (char *)((intvec*)(v->Data()))->length();
2765  return FALSE;
2766}
2767static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
2768{
2769  ring r=(ring)v->Data();
2770  int elems=-1;
2771  if (rField_is_Zp(r)||rField_is_GF(r)) elems=rInternalChar(r);
2772  else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
2773  {
2774    elems=ABS(rInternalChar(r)*naParDeg(r->minpoly));
2775  }
2776  res->data = (char *)elems;
2777  return FALSE;
2778}
2779static BOOLEAN jjDEG(leftv res, leftv v)
2780{
2781  int dummy;
2782  poly p=(poly)v->Data();
2783  if (p!=NULL) res->data = (char *)pLDeg(p,&dummy);
2784  else res->data=(char *)-1;
2785  return FALSE;
2786}
2787static BOOLEAN jjDEG_M(leftv res, leftv u)
2788{
2789  ideal I=(ideal)u->Data();
2790  int d=-1;
2791  int dummy;
2792  int i;
2793  for(i=IDELEMS(I);i>=0;i--)
2794    if (I->m[i]!=NULL) d=max(d,pLDeg(I->m[i],&dummy));
2795  res->data = (char *)d;
2796  return FALSE;
2797}
2798static BOOLEAN jjDEGREE(leftv res, leftv v)
2799{
2800  assumeStdFlag(v);
2801  scDegree((ideal)v->Data(),currQuotient);
2802  return FALSE;
2803}
2804static BOOLEAN jjDEFINED(leftv res, leftv v)
2805{
2806  if ((v->rtyp==IDHDL)
2807  && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
2808  {
2809    res->data=(void *)(IDLEV((idhdl)v->data)+1);
2810  }
2811  else if (v->rtyp!=0) res->data=(void *)(-1);
2812  return FALSE;
2813}
2814#ifdef HAVE_FACTORY
2815static BOOLEAN jjDET(leftv res, leftv v)
2816{
2817  matrix m=(matrix)v->Data();
2818  poly p;
2819  if (smCheckDet((ideal)m,m->cols(),TRUE))
2820  {
2821    ideal I=idMatrix2Module(mpCopy(m));
2822    p=smCallDet(I);
2823    idDelete(&I);
2824  }
2825  else
2826    p=singclap_det(m);
2827  res ->data = (char *)p;
2828  return FALSE;
2829}
2830static BOOLEAN jjDET_I(leftv res, leftv v)
2831{
2832  intvec * m=(intvec*)v->Data();
2833  int i,j;
2834  i=m->rows();j=m->cols();
2835  if(i==j)
2836    res->data = (char *)singclap_det_i(m);
2837  else
2838  {
2839    Werror("det of %d x %d intmat",i,j);
2840    return TRUE;
2841  }
2842  return FALSE;
2843}
2844static BOOLEAN jjDET_S(leftv res, leftv v)
2845{
2846  ideal I=(ideal)v->Data();
2847  poly p;
2848  if (smCheckDet(I,IDELEMS(I),FALSE))
2849  {
2850    matrix m=idModule2Matrix(idCopy(I));
2851    p=singclap_det(m);
2852    idDelete((ideal *)&m);
2853  }
2854  else
2855    p=smCallDet(I);
2856  res->data = (char *)p;
2857  return FALSE;
2858}
2859#endif
2860static BOOLEAN jjDIM(leftv res, leftv v)
2861{
2862  assumeStdFlag(v);
2863  res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
2864  return FALSE;
2865}
2866static BOOLEAN jjDUMP(leftv res, leftv v)
2867{
2868  si_link l = (si_link)v->Data();
2869  if (slDump(l))
2870  {
2871    const char *s;
2872    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2873    else                            s=sNoName;
2874    Werror("cannot dump to `%s`",s);
2875    return TRUE;
2876  }
2877  else
2878    return FALSE;
2879}
2880static BOOLEAN jjE(leftv res, leftv v)
2881{
2882  res->data = (char *)pOne();
2883  pSetComp((poly)res->data,(int)v->Data());
2884  pSetm((poly)res->data);
2885  return FALSE;
2886}
2887static BOOLEAN jjEXECUTE(leftv res, leftv v)
2888{
2889  char * d = (char *)v->Data();
2890  char * s = (char *)omAlloc(strlen(d) + 13);
2891  strcpy( s, (char *)d);
2892  strcat( s, "\n;RETURN();\n");
2893  newBuffer(s,BT_execute);
2894  return yyparse();
2895}
2896#ifdef HAVE_FACTORY
2897static BOOLEAN jjFACSTD(leftv res, leftv v)
2898{
2899  res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
2900  setFlag(res,FLAG_STD);
2901  return FALSE;
2902}
2903static BOOLEAN jjFAC_P(leftv res, leftv u)
2904{
2905  intvec *v=NULL;
2906  ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
2907  if (f==NULL) return TRUE;
2908  ivTest(v);
2909  lists l=(lists)omAllocBin(slists_bin);
2910  l->Init(2);
2911  l->m[0].rtyp=IDEAL_CMD;
2912  l->m[0].data=(void *)f;
2913  l->m[1].rtyp=INTVEC_CMD;
2914  l->m[1].data=(void *)v;
2915  res->data=(void *)l;
2916  return FALSE;
2917}
2918#endif
2919static BOOLEAN jjGETDUMP(leftv res, leftv v)
2920{
2921  si_link l = (si_link)v->Data();
2922  if (slGetDump(l))
2923  {
2924    const char *s;
2925    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2926    else                            s=sNoName;
2927    Werror("cannot get dump from `%s`",s);
2928    return TRUE;
2929  }
2930  else
2931    return FALSE;
2932}
2933static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
2934{
2935  assumeStdFlag(v);
2936  ideal I=(ideal)v->Data();
2937  res->data=(void *)iiHighCorner(I,0);
2938  return FALSE;
2939}
2940static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
2941{
2942  assumeStdFlag(v);
2943  intvec *w=(intvec*)atGet(v,"isHomog");
2944  BOOLEAN delete_w=FALSE;
2945  ideal I=(ideal)v->Data();
2946  int i;
2947  poly p=NULL,po=NULL;
2948  int rk=idRankFreeModule(I);
2949  if (w==NULL)
2950  {
2951    w = new intvec(rk);
2952    delete_w=TRUE;
2953  }
2954  for(i=rk;i>0;i--)
2955  {
2956    p=iiHighCorner(I,i);
2957    if (p==NULL)
2958    {
2959      Werror("module must be zero-dimensional");
2960      if (delete_w) delete w;
2961      return TRUE;
2962    }
2963    if (po==NULL)
2964    {
2965      po=p;
2966    }
2967    else
2968    {
2969      // now po!=NULL, p!=NULL
2970      int d=(pFDeg(po)-(*w)[pGetComp(po)-1] - pFDeg(p)+(*w)[i-1]);
2971      if (d==0)
2972        d=pLmCmp(po,p);
2973      if (d > 0)
2974      {
2975        pDelete(&p);
2976      }
2977      else // (d < 0)
2978      {
2979        pDelete(&po); po=p;
2980      }
2981    }
2982  }
2983  if (delete_w) delete w;
2984  res->data=(void *)po;
2985  return FALSE;
2986}
2987static BOOLEAN jjHILBERT(leftv res, leftv v)
2988{
2989  assumeStdFlag(v);
2990  intvec *module_w=(intvec*)atGet(v,"isHomog");
2991  //scHilbertPoly((ideal)v->Data(),currQuotient);
2992  hLookSeries((ideal)v->Data(),module_w,currQuotient);
2993  return FALSE;
2994}
2995static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
2996{
2997  res->data=(void *)hSecondSeries((intvec *)v->Data());
2998  return FALSE;
2999}
3000static BOOLEAN jjHOMOG1(leftv res, leftv v)
3001{
3002  intvec *w;
3003  res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
3004  if ((v->rtyp==IDHDL)&&(w!=NULL))
3005    atSet((idhdl)v->data,omStrDup("isHomog"),w,INTVEC_CMD);
3006  return FALSE;
3007}
3008static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3009{
3010  matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3011  IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3012  if (IDELEMS((ideal)mat)==0)
3013  {
3014    idDelete((ideal *)&mat);
3015    mat=(matrix)idInit(1,1);
3016  }
3017  else
3018  {
3019    MATROWS(mat)=1;
3020    mat->rank=1;
3021    idTest((ideal)mat);
3022  }
3023  res->data=(char *)mat;
3024  return FALSE;
3025}
3026static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3027{
3028  map m=(map)v->CopyD(MAP_CMD);
3029  omFree((ADDRESS)m->preimage);
3030  m->preimage=NULL;
3031  ideal I=(ideal)m;
3032  I->rank=1;
3033  res->data=(char *)I;
3034  return FALSE;
3035}
3036static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3037{
3038  if (currRing!=NULL)
3039  {
3040    ring q=(ring)v->Data();
3041    if (rEqual(currRing, q, 0))
3042    {
3043      if (q->qideal==NULL)
3044        res->data=(char *)idInit(1,1);
3045      else
3046        res->data=(char *)idCopy(q->qideal);
3047      return FALSE;
3048    }
3049  }
3050  WerrorS("can only get ideal from identical qring");
3051  return TRUE;
3052}
3053static BOOLEAN jjIm2Iv(leftv res, leftv v)
3054{
3055  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
3056  iv->makeVector();
3057  res->data = iv;
3058  return FALSE;
3059}
3060static BOOLEAN jjIMPART(leftv res, leftv v)
3061{
3062  res->data = (char *)nImPart((number)v->Data());
3063  return FALSE;
3064}
3065static BOOLEAN jjINDEPSET(leftv res, leftv v)
3066{
3067  assumeStdFlag(v);
3068  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3069  return FALSE;
3070}
3071static BOOLEAN jjINTERRED(leftv res, leftv v)
3072{
3073  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3074  //if (result==NULL) return TRUE;
3075  idSkipZeroes(result);
3076  res->data = result;
3077  return FALSE;
3078}
3079static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3080{
3081  res->data = (char *)pVar((poly)v->Data());
3082  return FALSE;
3083}
3084static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3085{
3086  res->data = (char *)(r_IsRingVar((char *)v->Data(), currRing)+1);
3087  return FALSE;
3088}
3089static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3090{
3091  res->data = (char *)0;
3092  return FALSE;
3093}
3094static BOOLEAN jjJACOB_P(leftv res, leftv v)
3095{
3096  ideal i=idInit(pVariables,1);
3097  int k;
3098  poly p=(poly)(v->Data());
3099  for (k=pVariables;k>0;k--)
3100  {
3101    i->m[k-1]=pDiff(p,k);
3102  }
3103  res->data = (char *)i;
3104  return FALSE;
3105}
3106static BOOLEAN jjKBASE(leftv res, leftv v)
3107{
3108  assumeStdFlag(v);
3109  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3110  return FALSE;
3111}
3112#ifdef MDEBUG
3113static BOOLEAN jjpHead(leftv res, leftv v)
3114{
3115  res->data=(char *)pHead((poly)v->Data());
3116  return FALSE;
3117}
3118#endif
3119static BOOLEAN jjL2R(leftv res, leftv v)
3120{
3121  res->data=(char *)syConvList((lists)v->Data());
3122  if (res->data != NULL)
3123    return FALSE;
3124  else
3125    return TRUE;
3126}
3127static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3128{
3129  poly p=(poly)v->Data();
3130  if (p==NULL)
3131  {
3132    res->data=(char *)nInit(0);
3133  }
3134  else
3135  {
3136    res->data=(char *)nCopy(pGetCoeff(p));
3137  }
3138  return FALSE;
3139}
3140static BOOLEAN jjLEADEXP(leftv res, leftv v)
3141{
3142  poly p=(poly)v->Data();
3143  int s=pVariables;
3144  if (v->Typ()==VECTOR_CMD) s++;
3145  intvec *iv=new intvec(s);
3146  if (p!=NULL)
3147  {
3148    for(int i = pVariables;i;i--)
3149    {
3150      (*iv)[i-1]=pGetExp(p,i);
3151    }
3152    if (s!=pVariables)
3153      (*iv)[pVariables]=pGetComp(p);
3154  }
3155  res->data=(char *)iv;
3156  return FALSE;
3157}
3158static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3159{
3160  poly p=(poly)v->Data();
3161  if (p == NULL)
3162  {
3163    res->data = (char*) NULL;
3164  }
3165  else
3166  {
3167    poly lm = pLmInit(p);
3168    pSetCoeff(lm, nInit(1));
3169    res->data = (char*) lm;
3170  }
3171  return FALSE;
3172}
3173static BOOLEAN jjLISTRING(leftv res, leftv v)
3174{
3175  ring r=rCompose((lists)v->Data());
3176  if (r==NULL) return TRUE;
3177  if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3178  res->data=(char *)r;
3179  return FALSE;
3180}
3181static BOOLEAN jjMEMORY(leftv res, leftv v)
3182{
3183  omUpdateInfo();
3184  switch(((int)v->Data()))
3185  {
3186  case 0:
3187    res->data = (char *)om_Info.UsedBytes;
3188    break;
3189  case 1:
3190    res->data = (char *)om_Info.CurrentBytesSystem;
3191    break;
3192  case 2:
3193    res->data = (char *)om_Info.MaxBytesSystem;
3194    break;
3195
3196  default:
3197    omPrintStats(stdout);
3198    omPrintInfo(stdout);
3199    omPrintBinStats(stdout);
3200    res->data = (char *)0;
3201  }
3202  return FALSE;
3203  res->data = (char *)0;
3204  return FALSE;
3205}
3206static BOOLEAN jjMONITOR1(leftv res, leftv v)
3207{
3208  monitor((char *)(v->Data()),PROT_I);
3209  return FALSE;
3210}
3211static BOOLEAN jjMSTD(leftv res, leftv v)
3212{
3213  int t=v->Typ();
3214  ideal r,m;
3215  r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3216  lists l=(lists)omAllocBin(slists_bin);
3217  l->Init(2);
3218  l->m[0].rtyp=t;
3219  l->m[0].data=(char *)r;
3220  setFlag(&(l->m[0]),FLAG_STD);
3221  l->m[1].rtyp=t;
3222  l->m[1].data=(char *)m;
3223  res->data=(char *)l;
3224  return FALSE;
3225}
3226static BOOLEAN jjMULT(leftv res, leftv v)
3227{
3228  assumeStdFlag(v);
3229  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3230  return FALSE;
3231}
3232static BOOLEAN jjNAMEOF(leftv res, leftv v)
3233{
3234  res->data = (char *)v->name;
3235  if (res->data==NULL) res->data=omStrDup("");
3236  v->name=NULL;
3237  return FALSE;
3238}
3239static BOOLEAN jjNAMES(leftv res, leftv v)
3240{
3241  res->data=ipNameList(((ring)v->Data())->idroot);
3242  return FALSE;
3243}
3244static BOOLEAN jjNVARS(leftv res, leftv v)
3245{
3246  res->data = (char *)(((ring)(v->Data()))->N);
3247  return FALSE;
3248}
3249static BOOLEAN jjOpenClose(leftv res, leftv v)
3250{
3251  si_link l=(si_link)v->Data();
3252  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3253  else                return slClose(l);
3254}
3255static BOOLEAN jjORD(leftv res, leftv v)
3256{
3257  poly p=(poly)v->Data();
3258  res->data=(char *)( p==NULL ? -1 : pFDeg(p) );
3259  return FALSE;
3260}
3261static BOOLEAN jjPAR1(leftv res, leftv v)
3262{
3263  int i=(int)v->Data();
3264  int p=0;
3265  p=rPar(currRing);
3266  if ((0<i) && (i<=p))
3267  {
3268    res->data=(char *)nPar(i);
3269  }
3270  else
3271  {
3272    Werror("par number %d out of range 1..%d",i,p);
3273    return TRUE;
3274  }
3275  return FALSE;
3276}
3277static BOOLEAN jjPARDEG(leftv res, leftv v)
3278{
3279  res->data = (char *)nParDeg((number)v->Data());
3280  return FALSE;
3281}
3282static BOOLEAN jjPARSTR1(leftv res, leftv v)
3283{
3284  if (currRing==NULL)
3285  {
3286    WerrorS("no ring active");
3287    return TRUE;
3288  }
3289  int i=(int)v->Data();
3290  int p=0;
3291  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3292    res->data=omStrDup(currRing->parameter[i-1]);
3293  else
3294  {
3295    Werror("par number %d out of range 1..%d",i,p);
3296    return TRUE;
3297  }
3298  return FALSE;
3299}
3300static BOOLEAN jjP2I(leftv res, leftv v)
3301{
3302  poly p=(poly)v->Data();
3303  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3304  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3305  {
3306    WerrorS("poly must be constant");
3307    return TRUE;
3308  }
3309  res->data = (char *)nInt(pGetCoeff(p));
3310  return FALSE;
3311}
3312static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3313{
3314  map mapping=(map)v->Data();
3315  syMake(res,omStrDup(mapping->preimage));
3316  return FALSE;
3317}
3318static BOOLEAN jjPRIME(leftv res, leftv v)
3319{
3320  int i = IsPrime((int)(v->Data()));
3321  res->data = (char *)(i > 1 ? i : 2);
3322  return FALSE;
3323}
3324static BOOLEAN jjPRUNE(leftv res, leftv v)
3325{
3326  res->data = (char *)idMinEmbedding((ideal)v->Data());
3327  return FALSE;
3328}
3329static BOOLEAN jjP2N(leftv res, leftv v)
3330{
3331  number n;
3332  poly p;
3333  if (((p=(poly)v->Data())!=NULL)
3334  && (pIsConstant(p)))
3335  {
3336    n=nCopy(pGetCoeff(p));
3337  }
3338  else
3339  {
3340    n=nInit(0);
3341  }
3342  res->data = (char *)n;
3343  return FALSE;
3344}
3345static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3346{
3347  char *s= (char *)v->Data();
3348  int i = 1;
3349  int l = strlen(s);
3350  while (cmds[i].tokval!=0)
3351  {
3352    if (strcmp(s, cmds[i].name) == 0)
3353    {
3354      res->data = (char *)1;
3355      return FALSE;
3356    }
3357    i++;
3358  }
3359  //res->data = (char *)0;
3360  return FALSE;
3361}
3362static BOOLEAN jjREAD(leftv res, leftv v)
3363{
3364  return jjREAD2(res,v,NULL);
3365}
3366static BOOLEAN jjREGULARITY(leftv res, leftv v)
3367{
3368  res->data = (char *)iiRegularity((lists)v->Data());
3369  return FALSE;
3370}
3371static BOOLEAN jjREPART(leftv res, leftv v)
3372{
3373  res->data = (char *)nRePart((number)v->Data());
3374  return FALSE;
3375}
3376static BOOLEAN jjRINGLIST(leftv res, leftv v)
3377{
3378  ring r=(ring)v->Data();
3379  if (r!=NULL)
3380    res->data = (char *)rDecompose((ring)v->Data());
3381  return (r==NULL);
3382}
3383static BOOLEAN jjROWS(leftv res, leftv v)
3384{
3385  ideal i = (ideal)v->Data();
3386  res->data = (char *)i->rank;
3387  return FALSE;
3388}
3389static BOOLEAN jjROWS_IV(leftv res, leftv v)
3390{
3391  res->data = (char *)((intvec*)(v->Data()))->rows();
3392  return FALSE;
3393}
3394static BOOLEAN jjRPAR(leftv res, leftv v)
3395{
3396  res->data = (char *)rPar(((ring)v->Data()));
3397  return FALSE;
3398}
3399static BOOLEAN jjSTD(leftv res, leftv v)
3400{
3401  ideal result;
3402  intvec *w=(intvec *)atGet(v,"isHomog");
3403  tHomog hom=testHomog;
3404  if (w!=NULL)
3405  {
3406    w=ivCopy(w);
3407    hom=isHomog;
3408  }
3409  result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3410  idSkipZeroes(result);
3411  res->data = (char *)result;
3412  setFlag(res,FLAG_STD);
3413  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3414  return FALSE;
3415}
3416static BOOLEAN jjSort_Id(leftv res, leftv v)
3417{
3418  res->data = (char *)idSort((ideal)v->Data());
3419  return FALSE;
3420}
3421static BOOLEAN jjSYZYGY(leftv res, leftv v)
3422{
3423  intvec *w=NULL;
3424  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3425  if (w!=NULL) delete w;
3426  return FALSE;
3427}
3428static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3429{
3430  res->data = (char *)ivTrace((intvec*)(v->Data()));
3431  return FALSE;
3432}
3433static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3434{
3435  res->data = (char *)ivTranp((intvec*)(v->Data()));
3436  return FALSE;
3437}
3438static BOOLEAN jjTYPEOF(leftv res, leftv v)
3439{
3440  switch ((int)v->data)
3441  {
3442    case INT_CMD:     res->data=omStrDup("int"); break;
3443    case POLY_CMD:   res->data=omStrDup("poly"); break;
3444    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3445    case STRING_CMD:  res->data=omStrDup("string"); break;
3446    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3447    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3448    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3449    case MODUL_CMD:   res->data=omStrDup("module"); break;
3450    case MAP_CMD:     res->data=omStrDup("map"); break;
3451    case PROC_CMD:    res->data=omStrDup("proc"); break;
3452    case RING_CMD:    res->data=omStrDup("ring"); break;
3453    case QRING_CMD:   res->data=omStrDup("qring"); break;
3454    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3455    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3456    case LIST_CMD:   res->data=omStrDup("list"); break;
3457    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3458    case LINK_CMD:   res->data=omStrDup("link"); break;
3459    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3460    case DEF_CMD:
3461    case NONE:    res->data=omStrDup("none"); break;
3462    default:       res->data=omStrDup("?unknown type?");
3463  }
3464  return FALSE;
3465}
3466static BOOLEAN jjVAR1(leftv res, leftv v)
3467{
3468  int i=(int)v->Data();
3469  if ((0<i) && (i<=currRing->N))
3470  {
3471    poly p=pOne();
3472    pSetExp(p,i,1);
3473    pSetm(p);
3474    res->data=(char *)p;
3475  }
3476  else
3477  {
3478    Werror("var number %d out of range 1..%d",i,currRing->N);
3479    return TRUE;
3480  }
3481  return FALSE;
3482}
3483static BOOLEAN jjVARSTR1(leftv res, leftv v)
3484{
3485  if (currRing==NULL)
3486  {
3487    WerrorS("no ring active");
3488    return TRUE;
3489  }
3490  int i=(int)v->Data();
3491  if ((0<i) && (i<=currRing->N))
3492    res->data=omStrDup(currRing->names[i-1]);
3493  else
3494  {
3495    Werror("var number %d out of range 1..%d",i,currRing->N);
3496    return TRUE;
3497  }
3498  return FALSE;
3499}
3500static BOOLEAN jjVDIM(leftv res, leftv v)
3501{
3502  assumeStdFlag(v);
3503  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
3504  return FALSE;
3505}
3506
3507static BOOLEAN jjLOAD1(leftv res, leftv v)
3508{
3509  return jjLOAD(res, v);
3510}
3511
3512static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
3513{
3514  char * s=(char *)v->CopyD();
3515  char libnamebuf[256];
3516  lib_types LT = type_of_LIB(s, libnamebuf);
3517#ifdef HAVE_DYNAMIC_LOADING
3518  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN tellerror);
3519#endif /* HAVE_DYNAMIC_LOADING */
3520
3521  switch(LT)
3522  {
3523      default:
3524      case LT_NONE:
3525        Werror("%s: unknown type", s);
3526        break;
3527      case LT_NOTFOUND:
3528        Werror("cannot open %s", s);
3529        break;
3530
3531      case LT_SINGULAR:
3532        return iiLibCmd(s);
3533
3534      case LT_ELF:
3535      case LT_HPUX:
3536#ifdef HAVE_DYNAMIC_LOADING
3537        return load_modules(s, libnamebuf, autoexport);
3538#else /* HAVE_DYNAMIC_LOADING */
3539        WerrorS("Dynamic modules are not supported by this version of Singular");
3540        break;
3541#endif /* HAVE_DYNAMIC_LOADING */
3542  }
3543  return TRUE;
3544}
3545
3546/*=================== operations with 1 arg.: table =================*/
3547
3548#ifdef INIT_BUG
3549#define XS(A) -((short)A)
3550#define jjstrlen       (proc1)1
3551#define jjpLength      (proc1)2
3552#define jjidElem       (proc1)3
3553#define jjmpDetBareiss (proc1)4
3554#define jjidFreeModule (proc1)5
3555#define jjidVec2Ideal  (proc1)6
3556#define jjrCharStr     (proc1)7
3557#ifndef MDEBUG
3558#define jjpHead        (proc1)8
3559#endif
3560#define jjidHead       (proc1)9
3561#define jjidMaxIdeal   (proc1)10
3562#define jjidMinBase    (proc1)11
3563#define jjsyMinBase    (proc1)12
3564#define jjpMaxComp     (proc1)13
3565#define jjmpTrace      (proc1)14
3566#define jjmpTransp     (proc1)15
3567#define jjrOrdStr      (proc1)16
3568#define jjrVarStr      (proc1)18
3569#define jjrParStr      (proc1)19
3570#define jjCOUNT_RES    (proc1)22
3571#define jjDIM_R        (proc1)23
3572#define jjMINRES_R     (proc1)24
3573#define jjidTransp     (proc1)25
3574
3575extern struct sValCmd1 dArith1[];
3576void jjInitTab1()
3577{
3578  int i=0;
3579  for (;dArith1[i].cmd!=0;i++)
3580  {
3581    if (dArith1[i].res<0)
3582    {
3583      switch ((int)dArith1[i].p)
3584      {
3585        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
3586        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
3587        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
3588        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
3589#ifndef HAVE_FACTORY
3590        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
3591#endif
3592        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
3593        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
3594#ifndef MDEBUG
3595        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
3596#endif
3597        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
3598        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
3599        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
3600        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
3601        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
3602        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
3603        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
3604        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
3605        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
3606        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
3607        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
3608        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
3609        case (int)jjMINRES_R:     dArith1[i].p=(proc1)syMinimize; break;
3610        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
3611#ifdef GENTABLE
3612        default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
3613#endif
3614      }
3615    }
3616  }
3617}
3618#else
3619#if defined(PROC_BUG)
3620#define XS(A) A
3621static BOOLEAN jjstrlen(leftv res, leftv v)
3622{
3623  res->data = (char *)strlen((char *)v->Data());
3624  return FALSE;
3625}
3626static BOOLEAN jjpLength(leftv res, leftv v)
3627{
3628  res->data = (char *)pLength((poly)v->Data());
3629  return FALSE;
3630}
3631static BOOLEAN jjidElem(leftv res, leftv v)
3632{
3633  res->data = (char *)idElem((ideal)v->Data());
3634  return FALSE;
3635}
3636static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
3637{
3638  res->data = (char *)mpDetBareiss((matrix)v->Data());
3639  return FALSE;
3640}
3641static BOOLEAN jjidFreeModule(leftv res, leftv v)
3642{
3643  res->data = (char *)idFreeModule((int)v->Data());
3644  return FALSE;
3645}
3646static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
3647{
3648  res->data = (char *)idVec2Ideal((poly)v->Data());
3649  return FALSE;
3650}
3651static BOOLEAN jjrCharStr(leftv res, leftv v)
3652{
3653  res->data = rCharStr((ring)v->Data());
3654  return FALSE;
3655}
3656#ifndef MDEBUG
3657static BOOLEAN jjpHead(leftv res, leftv v)
3658{
3659  res->data = (char *)pHead((poly)v->Data());
3660  return FALSE;
3661}
3662#endif
3663static BOOLEAN jjidHead(leftv res, leftv v)
3664{
3665  res->data = (char *)idHead((ideal)v->Data());
3666  return FALSE;
3667}
3668static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
3669{
3670  res->data = (char *)idMaxIdeal((int)v->Data());
3671  return FALSE;
3672}
3673static BOOLEAN jjidMinBase(leftv res, leftv v)
3674{
3675  res->data = (char *)idMinBase((ideal)v->Data());
3676  return FALSE;
3677}
3678static BOOLEAN jjsyMinBase(leftv res, leftv v)
3679{
3680  res->data = (char *)syMinBase((ideal)v->Data());
3681  return FALSE;
3682}
3683static BOOLEAN jjpMaxComp(leftv res, leftv v)
3684{
3685  res->data = (char *)pMaxComp((poly)v->Data());
3686  return FALSE;
3687}
3688static BOOLEAN jjmpTrace(leftv res, leftv v)
3689{
3690  res->data = (char *)mpTrace((matrix)v->Data());
3691  return FALSE;
3692}
3693static BOOLEAN jjmpTransp(leftv res, leftv v)
3694{
3695  res->data = (char *)mpTransp((matrix)v->Data());
3696  return FALSE;
3697}
3698static BOOLEAN jjrOrdStr(leftv res, leftv v)
3699{
3700  res->data = rOrdStr((ring)v->Data());
3701  return FALSE;
3702}
3703static BOOLEAN jjrVarStr(leftv res, leftv v)
3704{
3705  res->data = rVarStr((ring)v->Data());
3706  return FALSE;
3707}
3708static BOOLEAN jjrParStr(leftv res, leftv v)
3709{
3710  res->data = rParStr((ring)v->Data());
3711  return FALSE;
3712}
3713static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
3714{
3715  res->data=(char *)syLength((syStrategy)v->Data());
3716  return FALSE;
3717}
3718static BOOLEAN jjDIM_R(leftv res, leftv v)
3719{
3720  res->data = (char *)syDim((syStrategy)v->Data());
3721  return FALSE;
3722}
3723static BOOLEAN jjMINRES_R(leftv res, leftv v)
3724{
3725  res->data=(char *)syMinimize((syStrategy)v->Data());
3726  return FALSE;
3727}
3728static BOOLEAN jjidTransp(leftv res, leftv v)
3729{
3730  res->data = (char *)idTransp((ideal)v->Data());
3731  return FALSE;
3732}
3733#else
3734#define XS(A)          -((short)A)
3735#define jjstrlen       (proc1)strlen
3736#define jjpLength      (proc1)pLength
3737#define jjidElem       (proc1)idElem
3738#define jjmpDetBareiss (proc1)mpDetBareiss
3739#define jjidFreeModule (proc1)idFreeModule
3740#define jjidVec2Ideal  (proc1)idVec2Ideal
3741#define jjrCharStr     (proc1)rCharStr
3742#ifndef MDEBUG
3743#define jjpHead        (proc1)pHeadProc
3744#endif
3745#define jjidHead       (proc1)idHead
3746#define jjidMaxIdeal   (proc1)idMaxIdeal
3747#define jjidMinBase    (proc1)idMinBase
3748#define jjsyMinBase    (proc1)syMinBase
3749#define jjpMaxComp     (proc1)pMaxCompProc
3750#define jjmpTrace      (proc1)mpTrace
3751#define jjmpTransp     (proc1)mpTransp
3752#define jjrOrdStr      (proc1)rOrdStr
3753#define jjrVarStr      (proc1)rVarStr
3754#define jjrParStr      (proc1)rParStr
3755#define jjCOUNT_RES    (proc1)syLength
3756#define jjDIM_R        (proc1)syDim
3757#define jjMINRES_R     (proc1)syMinimize
3758#define jjidTransp     (proc1)idTransp
3759#endif
3760#endif
3761static BOOLEAN jjnInt(leftv res, leftv u)
3762{
3763  number n=(number)u->CopyD(NUMBER_CMD);
3764  res->data=(char *)nInt(n);
3765  nDelete(&n);
3766  return FALSE;
3767}
3768#define s short
3769struct sValCmd1 dArith1[]=
3770{
3771// operations:
3772// proc         cmd               res             arg           plural
3773// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD      ALLOW_PLURAL}
3774//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD      ALLOW_PLURAL}
3775 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL          ALLOW_PLURAL}
3776,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL          ALLOW_PLURAL}
3777,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD        ALLOW_PLURAL}
3778,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
3779,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
3780,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3781,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
3782,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
3783,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
3784,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD  ALLOW_PLURAL}
3785,{jjLOAD1,      '(',             NONE,           STRING_CMD     ALLOW_PLURAL}
3786// and the procedures with 1 argument:
3787,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD        ALLOW_PLURAL}
3788//,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD   NO_PLURAL}
3789,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD      NO_PLURAL}
3790,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD       ALLOW_PLURAL}
3791,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD ALLOW_PLURAL}
3792,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD       ALLOW_PLURAL}
3793,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD      ALLOW_PLURAL}
3794#ifdef HAVE_FACTORY
3795,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
3796#else
3797,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD      NO_PLURAL}
3798#endif
3799,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
3800,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
3801,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD       ALLOW_PLURAL}
3802//,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD   ALLOW_PLURAL}
3803,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
3804,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
3805,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
3806,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3807,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD     ALLOW_PLURAL}
3808,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
3809,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3810,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
3811,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
3812,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD     ALLOW_PLURAL}
3813,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD       ALLOW_PLURAL}
3814,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
3815,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD      ALLOW_PLURAL}
3816,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD      ALLOW_PLURAL}
3817,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
3818,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
3819,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3820,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD       ALLOW_PLURAL}
3821,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
3822,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD        ALLOW_PLURAL}
3823,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
3824,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
3825,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
3826,{jjDEG_M,      DEG_CMD,         INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
3827,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD      NO_PLURAL}
3828,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD      NO_PLURAL}
3829,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD        ALLOW_PLURAL}
3830#ifdef HAVE_FACTORY
3831,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3832,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD     NO_PLURAL}
3833,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD      NO_PLURAL}
3834#else
3835,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3836,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD     NO_PLURAL}
3837#endif
3838,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD      NO_PLURAL}
3839,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD      NO_PLURAL}
3840,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD NO_PLURAL}
3841,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
3842,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD        ALLOW_PLURAL}
3843,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
3844,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD     ALLOW_PLURAL}
3845#ifdef HAVE_FACTORY
3846,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
3847#else
3848,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD       NO_PLURAL}
3849#endif
3850#ifdef HAVE_FGLM
3851,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
3852#else
3853,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
3854#endif
3855,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD        ALLOW_PLURAL}
3856#ifdef HAVE_FACTORY
3857,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
3858#else
3859,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD      NO_PLURAL}
3860#endif
3861,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD       ALLOW_PLURAL}
3862,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD      NO_PLURAL}
3863,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD      NO_PLURAL}
3864,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD      NO_PLURAL}
3865,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD      NO_PLURAL}
3866,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD     NO_PLURAL}
3867,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
3868,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
3869,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD     ALLOW_PLURAL}
3870,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD     ALLOW_PLURAL}
3871,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD      ALLOW_PLURAL}
3872,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD       ALLOW_PLURAL}
3873,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD        ALLOW_PLURAL}
3874,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
3875,{jjIMPART,     IMPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
3876,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD      NO_PLURAL}
3877,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD        ALLOW_PLURAL}
3878,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
3879,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
3880,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD      NO_PLURAL}
3881,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD      NO_PLURAL}
3882,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
3883,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD     ALLOW_PLURAL}
3884,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD     ALLOW_PLURAL}
3885,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD       ALLOW_PLURAL}
3886,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD     ALLOW_PLURAL}
3887,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE       ALLOW_PLURAL}
3888,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD       ALLOW_PLURAL}
3889,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD      ALLOW_PLURAL}
3890,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
3891,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
3892,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL          ALLOW_PLURAL}
3893#ifdef MDEBUG
3894,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
3895#else
3896,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD       ALLOW_PLURAL}
3897#endif
3898,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD      ALLOW_PLURAL}
3899#ifdef MDEBUG
3900,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3901#else
3902,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD     ALLOW_PLURAL}
3903#endif
3904,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
3905,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
3906,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3907,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD       ALLOW_PLURAL}
3908,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3909,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
3910,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3911,{jjLOAD1,      LIB_CMD,         NONE,           STRING_CMD     ALLOW_PLURAL}
3912,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD       ALLOW_PLURAL}
3913,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD        ALLOW_PLURAL}
3914,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE       ALLOW_PLURAL}
3915,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD     ALLOW_PLURAL}
3916,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD        ALLOW_PLURAL}
3917,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD        ALLOW_PLURAL}
3918,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD      NO_PLURAL}
3919,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD      NO_PLURAL}
3920,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD       ALLOW_PLURAL}
3921,{jjMINRES_R,   MINRES_CMD,      XS(RESOLUTION_CMD), RESOLUTION_CMD ALLOW_PLURAL}
3922,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
3923,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD     ALLOW_PLURAL}
3924,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD      NO_PLURAL}
3925,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD      NO_PLURAL}
3926,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD      NO_PLURAL}
3927,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD      NO_PLURAL}
3928,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
3929,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD    ALLOW_PLURAL}
3930,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD       ALLOW_PLURAL}
3931,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
3932,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
3933,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD       ALLOW_PLURAL}
3934,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
3935,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
3936,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD       ALLOW_PLURAL}
3937,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD      ALLOW_PLURAL}
3938,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD       ALLOW_PLURAL}
3939,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD       ALLOW_PLURAL}
3940,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD     ALLOW_PLURAL}
3941,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
3942,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
3943,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD        ALLOW_PLURAL}
3944,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD     ALLOW_PLURAL}
3945,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
3946,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
3947,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
3948,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD       ALLOW_PLURAL}
3949,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD        NO_PLURAL}
3950,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD        ALLOW_PLURAL}
3951,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD       ALLOW_PLURAL}
3952,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD        ALLOW_PLURAL}
3953,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
3954,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
3955,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
3956,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE       ALLOW_PLURAL}
3957,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD       ALLOW_PLURAL}
3958,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD       NO_PLURAL}
3959,{jjREPART,     REPART_CMD,      NUMBER_CMD,     NUMBER_CMD     ALLOW_PLURAL}
3960,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD     ALLOW_PLURAL}
3961,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD       ALLOW_PLURAL}
3962,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
3963,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       RING_CMD       ALLOW_PLURAL}
3964,{jjRINGLIST,   RINGLIST_CMD,    LIST_CMD,       QRING_CMD      ALLOW_PLURAL}
3965,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD       ALLOW_PLURAL}
3966,{jjLISTRING,   RING_CMD,        RING_CMD,       LIST_CMD       ALLOW_PLURAL}
3967//,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD     ALLOW_PLURAL}
3968,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD     ALLOW_PLURAL}
3969,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
3970,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD     ALLOW_PLURAL}
3971,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3972,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD     ALLOW_PLURAL}
3973,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
3974,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
3975,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
3976,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
3977,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD     ALLOW_PLURAL}
3978,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD     ALLOW_PLURAL}
3979,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
3980,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
3981,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD     ALLOW_PLURAL}
3982,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD      ALLOW_PLURAL}
3983,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD     ALLOW_PLURAL}
3984,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD     ALLOW_PLURAL}
3985,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD     ALLOW_PLURAL}
3986,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD     ALLOW_PLURAL}
3987,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD     ALLOW_PLURAL}
3988,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD      ALLOW_PLURAL}
3989,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE       ALLOW_PLURAL}
3990,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD     ALLOW_PLURAL}
3991,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD      ALLOW_PLURAL}
3992,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD      ALLOW_PLURAL}
3993,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD        ALLOW_PLURAL}
3994,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD        ALLOW_PLURAL}
3995,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD       ALLOW_PLURAL}
3996,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD      ALLOW_PLURAL}
3997,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD      ALLOW_PLURAL}
3998,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD      ALLOW_PLURAL}
3999,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD     ALLOW_PLURAL}
4000,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
4001,{NULL,         0,               0,              0              NO_PLURAL}
4002};
4003#undef s
4004/*=================== operations with 3 args.: static proc =================*/
4005static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4006{
4007  char *s= (char *)u->Data();
4008  int   r = (int)v->Data();
4009  int   c = (int)w->Data();
4010  int l = strlen(s);
4011
4012  if ( (r<1) || (r>l) || (c<0) )
4013  {
4014    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4015    return TRUE;
4016  }
4017  res->data = (char *)omAlloc(c+1);
4018  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
4019  return FALSE;
4020}
4021static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4022{
4023  intvec *iv = (intvec *)u->Data();
4024  int   r = (int)v->Data();
4025  int   c = (int)w->Data();
4026  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
4027  {
4028    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4029           r,c,u->Fullname(),iv->rows(),iv->cols());
4030    return TRUE;
4031  }
4032  res->data=u->data;
4033  u->data=NULL;
4034  res->rtyp=u->rtyp;
4035  u->rtyp=0;
4036  res->name=u->name;
4037  u->name=NULL;
4038  Subexpr e=jjMakeSub(v);
4039          e->next=jjMakeSub(w);
4040  if (u->e==NULL) res->e=e;
4041  else
4042  {
4043    Subexpr h=u->e;
4044    while (h->next!=NULL) h=h->next;
4045    h->next=e;
4046    res->e=u->e;
4047    u->e=NULL;
4048  }
4049  return FALSE;
4050}
4051static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4052{
4053  matrix m= (matrix)u->Data();
4054  int   r = (int)v->Data();
4055  int   c = (int)w->Data();
4056  //Print("gen. elem %d, %d\n",r,c);
4057  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
4058  {
4059    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4060      MATROWS(m),MATCOLS(m));
4061    return TRUE;
4062  }
4063  res->data=u->data;
4064  u->data=NULL;
4065  res->rtyp=u->rtyp;
4066  u->rtyp=0;
4067  res->name=u->name;
4068  u->name=NULL;
4069  Subexpr e=jjMakeSub(v);
4070          e->next=jjMakeSub(w);
4071  if (u->e==NULL)
4072    res->e=e;
4073  else
4074  {
4075    Subexpr h=u->e;
4076    while (h->next!=NULL) h=h->next;
4077    h->next=e;
4078    res->e=u->e;
4079    u->e=NULL;
4080  }
4081  return FALSE;
4082}
4083static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4084{
4085  sleftv t;
4086  sleftv ut;
4087  leftv p=NULL;
4088  intvec *iv=(intvec *)w->Data();
4089  int l;
4090  BOOLEAN nok;
4091
4092  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4093  {
4094    WerrorS("cannot build expression lists from unnamed objects");
4095    return TRUE;
4096  }
4097  memcpy(&ut,u,sizeof(ut));
4098  memset(&t,0,sizeof(t));
4099  t.rtyp=INT_CMD;
4100  for (l=0;l< iv->length(); l++)
4101  {
4102    t.data=(char *)(*iv)[l];
4103    if (p==NULL)
4104    {
4105      p=res;
4106    }
4107    else
4108    {
4109      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4110      p=p->next;
4111    }
4112    memcpy(u,&ut,sizeof(ut));
4113    if (u->Typ() == MATRIX_CMD)
4114      nok=jjBRACK_Ma(p,u,v,&t);
4115    else /* INTMAT_CMD */
4116      nok=jjBRACK_Im(p,u,v,&t);
4117    if (nok)
4118    {
4119      while (res->next!=NULL)
4120      {
4121        p=res->next->next;
4122        omFreeBin((ADDRESS)res->next, sleftv_bin);
4123        // res->e aufraeumen !!!!
4124        res->next=p;
4125      }
4126      return TRUE;
4127    }
4128  }
4129  return FALSE;
4130}
4131static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4132{
4133  sleftv t;
4134  sleftv ut;
4135  leftv p=NULL;
4136  intvec *iv=(intvec *)v->Data();
4137  int l;
4138  BOOLEAN nok;
4139
4140  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4141  {
4142    WerrorS("cannot build expression lists from unnamed objects");
4143    return TRUE;
4144  }
4145  memcpy(&ut,u,sizeof(ut));
4146  memset(&t,0,sizeof(t));
4147  t.rtyp=INT_CMD;
4148  for (l=0;l< iv->length(); l++)
4149  {
4150    t.data=(char *)((*iv)[l]);
4151    if (p==NULL)
4152    {
4153      p=res;
4154    }
4155    else
4156    {
4157      p->next=(leftv)omAlloc0Bin(sleftv_bin);
4158      p=p->next;
4159    }
4160    memcpy(u,&ut,sizeof(ut));
4161    if (u->Typ() == MATRIX_CMD)
4162      nok=jjBRACK_Ma(p,u,&t,w);
4163    else /* INTMAT_CMD */
4164      nok=jjBRACK_Im(p,u,&t,w);
4165    if (nok)
4166    {
4167      while (res->next!=NULL)
4168      {
4169        p=res->next->next;
4170        omFreeBin((ADDRESS)res->next, sleftv_bin);
4171        // res->e aufraeumen !!
4172        res->next=p;
4173      }
4174      return TRUE;
4175    }
4176  }
4177  return FALSE;
4178}
4179static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4180{
4181  sleftv t1,t2,ut;
4182  leftv p=NULL;
4183  intvec *vv=(intvec *)v->Data();
4184  intvec *wv=(intvec *)w->Data();
4185  int vl;
4186  int wl;
4187  BOOLEAN nok;
4188
4189  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
4190  {
4191    WerrorS("cannot build expression lists from unnamed objects");
4192    return TRUE;
4193  }
4194  memcpy(&ut,u,sizeof(ut));
4195  memset(&t1,0,sizeof(sleftv));
4196  memset(&t2,0,sizeof(sleftv));
4197  t1.rtyp=INT_CMD;
4198  t2.rtyp=INT_CMD;
4199  for (vl=0;vl< vv->length(); vl++)
4200  {
4201    t1.data=(char *)((*vv)[vl]);
4202    for (wl=0;wl< wv->length(); wl++)
4203    {
4204      t2.data=(char *)((*wv)[wl]);
4205      if (p==NULL)
4206      {
4207        p=res;
4208      }
4209      else
4210      {
4211        p->next=(leftv)omAlloc0Bin(sleftv_bin);
4212        p=p->next;
4213      }
4214      memcpy(u,&ut,sizeof(ut));
4215      if (u->Typ() == MATRIX_CMD)
4216        nok=jjBRACK_Ma(p,u,&t1,&t2);
4217      else /* INTMAT_CMD */
4218        nok=jjBRACK_Im(p,u,&t1,&t2);
4219      if (nok)
4220      {
4221        res->CleanUp();
4222        return TRUE;
4223      }
4224    }
4225  }
4226  return FALSE;
4227}
4228static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4229{
4230  v->next=(leftv)omAllocBin(sleftv_bin);
4231  memcpy(v->next,w,sizeof(sleftv));
4232  BOOLEAN r=iiExprArith2(res,u,'(',v);
4233  v->rtyp=0; v->data=NULL;
4234  w->rtyp=0; w->data=NULL;
4235  return r;
4236}
4237static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4238{
4239  u->next=(leftv)omAllocBin(sleftv_bin);
4240  memcpy(u->next,v,sizeof(sleftv));
4241  u->next->next=(leftv)omAllocBin(sleftv_bin);
4242  memcpy(u->next->next,w,sizeof(sleftv));
4243  BOOLEAN r=iiExprArithM(res,u,iiOp);
4244  // iiExprArithM did the CleanUp
4245  w->rtyp=0; w->data=NULL;
4246  return r;
4247}
4248static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4249{
4250  intvec *iv;
4251  ideal m;
4252  lists l=(lists)omAllocBin(slists_bin);
4253  int k=(int)w->Data();
4254  if (k>=0)
4255  {
4256    smCallNewBareiss((ideal)v->Data(),(int)v->Data(),(int)w->Data(),m,&iv);
4257    l->Init(2);
4258    l->m[0].rtyp=MODUL_CMD;
4259    l->m[1].rtyp=INTVEC_CMD;
4260    l->m[0].data=(void *)m;
4261    l->m[1].data=(void *)iv;
4262  }
4263  else
4264  {
4265    m=smCallSolv((ideal)u->Data());
4266    l->Init(1);
4267    l->m[0].rtyp=IDEAL_CMD;
4268    l->m[0].data=(void *)m;
4269  }
4270  res->data = (char *)l;
4271  return FALSE;
4272}
4273static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4274{
4275  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4276  {
4277    WerrorS("3rd argument must be a name of a matrix");
4278    return TRUE;
4279  }
4280  ideal i=(ideal)u->Data();
4281  int rank=(int)i->rank;
4282  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4283  if (r) return TRUE;
4284  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4285  return FALSE;
4286}
4287static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4288{
4289  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4290           (ideal)(v->Data()),(poly)(w->Data()));
4291  return FALSE;
4292}
4293static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4294{
4295  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4296  {
4297    WerrorS("3rd argument must be a name of a matrix");
4298    return TRUE;
4299  }
4300  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4301  poly p=(poly)u->CopyD(POLY_CMD);
4302  ideal i=idInit(1,1);
4303  i->m[0]=p;
4304  sleftv t;
4305  memset(&t,0,sizeof(t));
4306  t.data=(char *)i;
4307  t.rtyp=IDEAL_CMD;
4308  int rank=1;
4309  if (u->Typ()==VECTOR_CMD)
4310  {
4311    i->rank=rank=pMaxComp(p);
4312    t.rtyp=MODUL_CMD;
4313  }
4314  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4315  t.CleanUp();
4316  if (r) return TRUE;
4317  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4318  return FALSE;
4319}
4320static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4321{
4322  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4323    (intvec *)w->Data());
4324  setFlag(res,FLAG_STD);
4325  return FALSE;
4326}
4327static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4328{
4329  /*4
4330  * look for the substring what in the string where
4331  * starting at position n
4332  * return the position of the first char of what in where
4333  * or 0
4334  */
4335  int n=(int)w->Data();
4336  char *where=(char *)u->Data();
4337  char *what=(char *)v->Data();
4338  char *found;
4339  if ((1>n)||(n>(int)strlen(where)))
4340  {
4341    Werror("start position %d out of range",n);
4342    return TRUE;
4343  }
4344  found = strchr(where+n-1,*what);
4345  if (*(what+1)!='\0')
4346  {
4347    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4348    {
4349      found=strchr(found+1,*what);
4350    }
4351  }
4352  if (found != NULL)
4353  {
4354    res->data=(char *)((found-where)+1);
4355  }
4356  return FALSE;
4357}
4358static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4359{
4360  assumeStdFlag(u);
4361  intvec *module_w=(intvec *)atGet(u,"isHomog");
4362  intvec *wdegree=(intvec*)w->Data();
4363  if (wdegree->length()!=pVariables)
4364  {
4365    Werror("weight vector must have size %d, not %d",
4366           pVariables,wdegree->length());
4367    return TRUE;
4368  }
4369  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4370  switch((int)v->Data())
4371  {
4372    case 1:
4373      res->data=(void *)iv;
4374      return FALSE;
4375    case 2:
4376      res->data=(void *)hSecondSeries(iv);
4377      delete iv;
4378      return FALSE;
4379  }
4380  WerrorS(feNotImplemented);
4381  delete iv;
4382  return TRUE;
4383}
4384static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4385{
4386  intvec* im= new intvec((int)v->Data(),(int)w->Data(), 0);
4387  intvec* arg = (intvec*) u->Data();
4388  int i, n = min(im->cols()*im->rows(), arg->cols()*arg->rows());
4389
4390  for (i=0; i<n; i++)
4391  {
4392    (*im)[i] = (*arg)[i];
4393  }
4394
4395  res->data = (char *)im;
4396  return FALSE;
4397}
4398static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4399{
4400  short *iw=iv2array((intvec *)w->Data());
4401  res->data = (char *)ppJetW((poly)u->Data(),(int)v->Data(),iw);
4402  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4403  return FALSE;
4404}
4405static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
4406{
4407  if (!pIsUnit((poly)v->Data()))
4408  {
4409    WerrorS("2nd argument must be a unit");
4410    return TRUE;
4411  }
4412  res->data = (char *)pSeries((int)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4413  return FALSE;
4414}
4415static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4416{
4417  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
4418                             (intvec *)w->Data());
4419  return FALSE;
4420}
4421static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4422{
4423  if (!mpIsDiagUnit((matrix)v->Data()))
4424  {
4425    WerrorS("2nd argument must be a diagonal matrix of units");
4426    return TRUE;
4427  }
4428  res->data = (char *)idSeries((int)w->Data(),(ideal)u->CopyD(),
4429                               (matrix)v->CopyD());
4430  return FALSE;
4431}
4432static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4433{
4434  assumeStdFlag(w);
4435  res->data = (char *)idMinors(
4436                        (matrix)u->Data(),(int)v->Data(),(ideal)w->Data());
4437  return FALSE;
4438}
4439static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4440{
4441  idhdl h;
4442  ring rr;
4443  map mapping;
4444
4445  if ((v->name==NULL) || (w->name==NULL))
4446  {
4447    WerrorS("2nd/3rd arguments must have names");
4448    return TRUE;
4449  }
4450  rr=(ring)u->Data();
4451  const char *ring_name=u->Name();
4452  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4453  {
4454    if (h->typ==MAP_CMD)
4455    {
4456      mapping=IDMAP(h);
4457      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4458      if ((preim_ring==NULL)
4459      || (IDRING(preim_ring)!=currRing))
4460      {
4461        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4462        return TRUE;
4463      }
4464    }
4465    else if (h->typ==IDEAL_CMD)
4466    {
4467      mapping=IDMAP(h);
4468    }
4469    else
4470    {
4471      Werror("`%s` is no map nor ideal",IDID(h));
4472      return TRUE;
4473    }
4474  }
4475  else
4476  {
4477    Werror("`%s` is not defined in `%s`",v->name,ring_name);
4478    return TRUE;
4479  }
4480  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4481  {
4482    if (h->typ==IDEAL_CMD)
4483    {
4484      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4485    }
4486    else
4487    {
4488      Werror("`%s` is no ideal",IDID(h));
4489      return TRUE;
4490    }
4491  }
4492  else
4493  {
4494    Werror("`%s` is not defined in `%s`",w->name,ring_name);
4495    return TRUE;
4496  }
4497  return FALSE;
4498}
4499static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4500{
4501  int di, k;
4502  int i=(int)u->Data();
4503  int r=(int)v->Data();
4504  int c=(int)w->Data();
4505  intvec *iv = new intvec(r, c, 0);
4506  if (iv->rows()==0)
4507  {
4508    delete iv;
4509    return TRUE;
4510  }
4511  if (i!=0)
4512  {
4513    if (i<0) i = -i;
4514    di = 2 * i + 1;
4515    for (k=0; k<iv->length(); k++)
4516    {
4517#ifdef buildin_rand
4518      (*iv)[k] = ((siRand() % di) - i);
4519#else
4520      (*iv)[k] = ((rand() % di) - i);
4521#endif
4522    }
4523  }
4524  res->data = (char *)iv;
4525  return FALSE;
4526}
4527static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4528  int &ringvar, poly &monomexpr)
4529{
4530  monomexpr=(poly)w->Data();
4531  #if 0
4532  if (pLength(monomexpr)>1)
4533  {
4534    Werror("`%s` substitutes a ringvar only by a term",
4535      Tok2Cmdname(SUBST_CMD));
4536    return TRUE;
4537  }
4538  #endif
4539  if (!(ringvar=pVar((poly)v->Data())))
4540  {
4541    WerrorS("ringvar expected");
4542    return TRUE;
4543  }
4544  return FALSE;
4545}
4546static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4547{
4548  int ringvar;
4549  poly monomexpr;
4550  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4551  if (nok) return TRUE;
4552  if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
4553    res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4554  else
4555    res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
4556  return FALSE;
4557}
4558static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4559{
4560  int ringvar;
4561  poly monomexpr;
4562  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4563  if (nok) return TRUE;
4564  if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
4565    res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4566  else
4567    res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
4568  return FALSE;
4569}
4570// we do not want to have jjSUBST_Id_X inlined:
4571static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4572                            int input_type);
4573static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4574{
4575  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4576}
4577static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4578{
4579  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4580}
4581static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4582{
4583  sleftv tmp;
4584  memset(&tmp,0,sizeof(tmp));
4585  // do not check the result, conversion from int/number to poly works always
4586  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4587  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4588  tmp.CleanUp();
4589  return b;
4590}
4591static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4592{
4593  matrix m=mpNew((int)v->Data(),(int)w->Data());
4594  ideal I=(ideal)u->CopyD(IDEAL_CMD);
4595  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4596  //for(i=i-1;i>=0;i--)
4597  //{
4598  //  m->m[i]=I->m[i];
4599  //  I->m[i]=NULL;
4600  //}
4601  memcpy4(m->m,I->m,i*sizeof(poly));
4602  memset(I->m,0,i*sizeof(poly));
4603  idDelete(&I);
4604  res->data = (char *)m;
4605  return FALSE;
4606}
4607static BOOLEAN jjSUBST_Par_N(leftv res, leftv u, leftv v,leftv w)
4608{
4609  // u: to change poly
4610  // v: number (parameter)
4611  // w: image of u (number)
4612  int i;
4613  lnumber a=(lnumber)v->Data();
4614  if (naParDeg((number)a)!=1)
4615  {
4616    WerrorS("first argument is not a parameter");
4617    return TRUE;
4618  }
4619  int r=rPar(currRing);
4620  ideal G=idMaxIdeal(1);
4621  ideal F=idInit(r,1);
4622  int par=-1;
4623  for(i=1;i<=r;i++)
4624  {
4625    if (napGetExp(a->z,i)!=0) { par=i; break;}
4626  }
4627  for(i=0;i<r;i++)
4628  {
4629    if (i==par) F->m[i]=(poly)w->CopyD();
4630    else
4631    {
4632      F->m[i]=pOne();pSetCoeff( F->m[i],naPar(i+1));
4633    }
4634  }
4635  res->data=(poly)maAlgpolyMap(currRing,(poly)u->Data(),F,G);
4636  idDelete(&F);
4637  idDelete(&G);
4638  return FALSE;
4639}
4640static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4641{
4642  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4643           (int)v->Data(),(int)w->Data());
4644  return FALSE;
4645}
4646static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4647{
4648  matrix m=mpNew((int)v->Data(),(int)w->Data());
4649  matrix I=(matrix)u->CopyD(MATRIX_CMD);
4650  int r=min(MATROWS(I),(int)v->Data());
4651  int c=min(MATCOLS(I),(int)w->Data());
4652  int i,j;
4653  for(i=r;i>0;i--)
4654  {
4655    for(j=c;j>0;j--)
4656    {
4657      MATELEM(m,i,j)=MATELEM(I,i,j);
4658      MATELEM(I,i,j)=NULL;
4659    }
4660  }
4661  idDelete((ideal *)&I);
4662  res->data = (char *)m;
4663  return FALSE;
4664}
4665static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4666{
4667  if (w->rtyp!=IDHDL) return TRUE;
4668  BITSET save_test=test;
4669  int ul= IDELEMS((ideal)u->Data());
4670  int vl= IDELEMS((ideal)v->Data());
4671  ideal m
4672    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
4673             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
4674  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4675  test=save_test;
4676  return FALSE;
4677}
4678static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
4679{
4680  assumeStdFlag(w);
4681  if (!idIsZeroDim((ideal)w->Data()))
4682  {
4683    Werror("`%s` must be 0-dimensional",v->Name());
4684    return TRUE;
4685  }
4686  res->data = (char *)redNF((ideal)w->CopyD(),(poly)u->CopyD(),
4687    (poly)v->CopyD());
4688  return FALSE;
4689}
4690static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
4691{
4692  assumeStdFlag(w);
4693  if (!idIsZeroDim((ideal)w->Data()))
4694  {
4695    Werror("`%s` must be 0-dimensional",v->Name());
4696    return TRUE;
4697  }
4698  res->data = (char *)redNF((ideal)w->CopyD(),(ideal)u->CopyD(),
4699    (matrix)v->CopyD());
4700  return FALSE;
4701}
4702static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4703{
4704  assumeStdFlag(v);
4705  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4706    0,(int)w->Data());
4707  return FALSE;
4708}
4709static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
4710{
4711  assumeStdFlag(v);
4712  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
4713    0,(int)w->Data());
4714  return FALSE;
4715}
4716#ifdef OLD_RES
4717static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
4718{
4719  int maxl=(int)v->Data();
4720  int l=0;
4721  resolvente r;
4722  intvec **weights=NULL;
4723  int wmaxl=maxl;
4724  maxl--;
4725  if ((maxl==-1) && (iiOp!=MRES_CMD))
4726    maxl = pVariables-1;
4727  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
4728  {
4729    intvec * iv=(intvec*)atGet(u,"isHomog");
4730    if (iv!=NULL)
4731    {
4732      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
4733      weights[0] = ivCopy(iv);
4734      l=1;
4735    }
4736    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
4737  }
4738  else
4739    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
4740  if (r==NULL) return TRUE;
4741  int t3=u->Typ();
4742  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
4743  return FALSE;
4744  return TRUE;
4745}
4746#endif
4747static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
4748{
4749  res->data=(void *)rInit(u,v,w);
4750  return (res->data==NULL);
4751}
4752static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
4753{
4754  int yes;
4755  jjSTATUS2(res, u, v);
4756  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
4757  omFree((ADDRESS) res->data);
4758  res->data = (void *) yes;
4759  return FALSE;
4760}
4761static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
4762{
4763  ideal result;
4764  intvec *ww=(intvec *)atGet(u,"isHomog");
4765  tHomog hom=testHomog;
4766  if (ww!=NULL)
4767  {
4768    ww=ivCopy(ww);
4769    hom=isHomog;
4770  }
4771  result=kStd((ideal)(u->Data()),
4772              currQuotient,
4773              hom,
4774              &ww,                  // module weights
4775              (intvec *)v->Data(),  // hilbert series
4776              0,0,                  // syzComp, newIdeal
4777              (intvec *)w->Data()); // weights of vars
4778  idSkipZeroes(result);
4779  res->data = (char *)result;
4780  setFlag(res,FLAG_STD);
4781  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
4782  return FALSE;
4783}
4784
4785/*=================== operations with 3 args.: table =================*/
4786struct sValCmd3 dArith3[]=
4787{
4788// operations:
4789// proc             cmd          res         arg1        arg2        arg3   plural
4790 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
4791,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
4792,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4793,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
4794,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4795,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
4796,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4797,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
4798,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4799,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4800,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD ALLOW_PLURAL}
4801,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD NO_PLURAL}
4802,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
4803,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
4804,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
4805,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD ALLOW_PLURAL}
4806,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD ALLOW_PLURAL}
4807,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD ALLOW_PLURAL}
4808,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
4809,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4810,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
4811,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD NO_PLURAL}
4812,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4813//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4814,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD ALLOW_PLURAL}
4815,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
4816,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4817,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4818,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4819,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4820,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD ALLOW_PLURAL}
4821,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD ALLOW_PLURAL}
4822,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD ALLOW_PLURAL}
4823,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
4824,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD ALLOW_PLURAL}
4825,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD ALLOW_PLURAL}
4826,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD NO_PLURAL}
4827,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4828,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
4829,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD ALLOW_PLURAL}
4830,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD ALLOW_PLURAL}
4831,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD NO_PLURAL}
4832,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4833#ifdef OLD_RES
4834,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
4835,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
4836#endif
4837,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD NO_PLURAL}
4838,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD NO_PLURAL}
4839,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE NO_PLURAL}
4840,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE NO_PLURAL}
4841,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD ALLOW_PLURAL}
4842,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
4843,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
4844,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD ALLOW_PLURAL}
4845,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
4846,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD ALLOW_PLURAL}
4847,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD ALLOW_PLURAL}
4848,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD ALLOW_PLURAL}
4849,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD ALLOW_PLURAL}
4850,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, IDEAL_CMD ALLOW_PLURAL}
4851,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, MODUL_CMD ALLOW_PLURAL}
4852#ifdef OLD_RES
4853,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
4854,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE ALLOW_PLURAL}
4855#endif
4856#ifdef HAVE_FACTORY
4857,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
4858#else
4859,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD NO_PLURAL}
4860#endif
4861,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD ALLOW_PLURAL}
4862#ifdef OLD_RES
4863,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
4864,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE NO_PLURAL}
4865#endif
4866,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD ALLOW_PLURAL}
4867,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
4868,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD NO_PLURAL}
4869,{jjSUBST_Par_N,    SUBST_CMD,  POLY_CMD,   POLY_CMD,   NUMBER_CMD, POLY_CMD  ALLOW_PLURAL}
4870,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4871,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4872,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4873,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4874,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4875,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD  ALLOW_PLURAL}
4876,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD  ALLOW_PLURAL}
4877,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD  ALLOW_PLURAL}
4878,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD   ALLOW_PLURAL}
4879,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD   NO_PLURAL}
4880,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD   NO_PLURAL}
4881,{NULL,             0,          0,          0,          0,          0         NO_PLURAL}
4882};
4883/*=================== operations with many arg.: static proc =================*/
4884static BOOLEAN jjBREAK0(leftv res, leftv v)
4885{
4886#ifdef HAVE_SDB
4887  sdb_show_bp();
4888#endif
4889  return FALSE;
4890}
4891static BOOLEAN jjBREAK1(leftv res, leftv v)
4892{
4893#ifdef HAVE_SDB
4894  if(v->Typ()==PROC_CMD)
4895  {
4896    int lineno=0;
4897    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
4898    {
4899      lineno=(int)v->next->Data();
4900    }
4901    return sdb_set_breakpoint(v->Name(),lineno);
4902  }
4903  return TRUE;
4904#else
4905 return FALSE;
4906#endif
4907}
4908static BOOLEAN jjCALL1ARG(leftv res, leftv v)
4909{
4910  return iiExprArith1(res,v,iiOp);
4911}
4912static BOOLEAN jjCALL2ARG(leftv res, leftv u)
4913{
4914  leftv v=u->next;
4915  u->next=NULL;
4916  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
4917  u->next=v;
4918  return b;
4919}
4920static BOOLEAN jjCALL3ARG(leftv res, leftv u)
4921{
4922  leftv v = u->next;
4923  leftv w = v->next;
4924  u->next = NULL;
4925  v->next = NULL;
4926  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4927  u->next = v;
4928  v->next = w;
4929  return b;
4930}
4931
4932static BOOLEAN jjCOEF_M(leftv res, leftv v)
4933{
4934  if((v->Typ() != VECTOR_CMD)
4935  || (v->next->Typ() != POLY_CMD)
4936  || (v->next->next->Typ() != MATRIX_CMD)
4937  || (v->next->next->next->Typ() != MATRIX_CMD))
4938     return TRUE;
4939  if (v->next->next->rtyp!=IDHDL) return TRUE;
4940  idhdl c=(idhdl)v->next->next->data;
4941  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
4942  idhdl m=(idhdl)v->next->next->next->data;
4943  idDelete((ideal *)&(c->data.uideal));
4944  idDelete((ideal *)&(m->data.uideal));
4945  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
4946    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
4947  return FALSE;
4948}
4949
4950static BOOLEAN jjDIVISION4(leftv res, leftv v)
4951{ // may have 3 or 4 arguments
4952  leftv v1=v;
4953  leftv v2=v1->next;
4954  leftv v3=v2->next;
4955  leftv v4=v3->next;
4956  assumeStdFlag(v2);
4957
4958  int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
4959  int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
4960
4961  if(i1==0||i2==0||v3->Typ()!=INT_CMD||(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
4962  {
4963    WarnS("<module>,<module>,<int>[,<intvec>] expected!");
4964    return TRUE;
4965  }
4966
4967  sleftv w1,w2;
4968  iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
4969  iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
4970  ideal P=(ideal)w1.Data();
4971  ideal Q=(ideal)w2.Data();
4972
4973  int n=(int)v3->Data();
4974  short *w=NULL;
4975  if(v4!=NULL)
4976  {
4977    w=iv2array((intvec *)v4->Data());
4978    short *w0=w+1;
4979    int i=pVariables;
4980    while(i>0&&*w0>0)
4981    {
4982      w0++;
4983      i--;
4984    }
4985    if(i>0)
4986      WarnS("not all weights are positive!");
4987  }
4988
4989  matrix T;
4990  ideal R;
4991  idLiftW(P,Q,n,T,R,w);
4992
4993  if(w!=NULL)
4994    omFree(w);
4995  lists L=(lists) omAllocBin(slists_bin);
4996  L->Init(2);
4997  L->m[1].rtyp=v1->Typ();
4998  if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
4999  {
5000    if(v1->Typ()==POLY_CMD)
5001      pShift(&R->m[0],-1);
5002    L->m[1].data=(void *)R->m[0];
5003    R->m[0]=NULL;
5004    idDelete(&R);
5005  }
5006  else
5007  if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
5008    L->m[1].data=(void *)idModule2Matrix(R);
5009  else
5010    L->m[1].rtyp=MODUL_CMD;
5011  L->m[0].rtyp=MATRIX_CMD;
5012  L->m[0].data=(char *)T;
5013
5014  res->data=L;
5015  //res->rtyp=LIST_CMD;
5016
5017  return FALSE;
5018}
5019
5020static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5021{
5022  int s=1;
5023  leftv h=v;
5024  if (h!=NULL) s=exprlist_length(h);
5025  ideal id=idInit(s,1);
5026  int rank=1;
5027  int i=0;
5028  poly p;
5029  while (h!=NULL)
5030  {
5031    switch(h->Typ())
5032    {
5033      case POLY_CMD:
5034      {
5035        p=(poly)h->CopyD(POLY_CMD);
5036        break;
5037      }
5038      case INT_CMD:
5039      {
5040        number n=nInit((int)h->Data());
5041        if (!nIsZero(n))
5042        {
5043          p=pOne();
5044          pSetCoeff(p,n);
5045        }
5046        else
5047        {
5048          p=NULL;
5049          nDelete(&n);
5050        }
5051        break;
5052      }
5053      case NUMBER_CMD:
5054      {
5055        number n=(number)h->CopyD(NUMBER_CMD);
5056        if (!nIsZero(n))
5057        {
5058          p=pOne();
5059          pSetCoeff(p,n);
5060        }
5061        else
5062        {
5063          p=NULL;
5064          nDelete(&n);
5065        }
5066        break;
5067      }
5068      case VECTOR_CMD:
5069      {
5070        p=(poly)h->CopyD(VECTOR_CMD);
5071        if (iiOp!=MODUL_CMD)
5072        {
5073          idDelete(&id);
5074          pDelete(&p);
5075          return TRUE;
5076        }
5077        rank=max(rank,pMaxComp(p));
5078        break;
5079      }
5080      default:
5081      {
5082        idDelete(&id);
5083        return TRUE;
5084      }
5085    }
5086    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
5087    {
5088      pSetCompP(p,1);
5089    }
5090    id->m[i]=p;
5091    i++;
5092    h=h->next;
5093  }
5094  id->rank=rank;
5095  res->data=(char *)id;
5096  return FALSE;
5097}
5098static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
5099{
5100  leftv h=v;
5101  int l=v->listLength();
5102  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
5103  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
5104  int t=0;
5105  // try to convert to IDEAL_CMD
5106  while (h!=NULL)
5107  {
5108    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
5109    {
5110      t=IDEAL_CMD;
5111    }
5112    else break;
5113    h=h->next;
5114  }
5115  // if failure, try MODUL_CMD
5116  if (t==0)
5117  {
5118    h=v;
5119    while (h!=NULL)
5120    {
5121      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
5122      {
5123        t=MODUL_CMD;
5124      }
5125      else break;
5126      h=h->next;
5127    }
5128  }
5129  // check for success  in converting
5130  if (t==0)
5131  {
5132    WerrorS("cannot convert to ideal or module");
5133    return TRUE;
5134  }
5135  // call idMultSect
5136  h=v;
5137  int i=0;
5138  sleftv tmp;
5139  while (h!=NULL)
5140  {
5141    if (h->Typ()==t)
5142    {
5143      r[i]=(ideal)h->Data(); /*no copy*/
5144      h=h->next;
5145    }
5146    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
5147    {
5148      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5149      omFreeSize((ADDRESS)r,l*sizeof(ideal));
5150      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
5151      return TRUE;
5152    }
5153    else
5154    {
5155      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
5156      copied[i]=TRUE;
5157      h=tmp.next;
5158    }
5159    i++;
5160  }
5161  res->rtyp=t;
5162  res->data=(char *)idMultSect(r,i);
5163  while(i>0)
5164  {
5165    i--;
5166    if (copied[i]) idDelete(&(r[i]));
5167  }
5168  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5169  omFreeSize((ADDRESS)r,l*sizeof(ideal));
5170  return FALSE;
5171}
5172static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
5173{
5174  int i=0;
5175  leftv h=v;
5176  if (h!=NULL) i=exprlist_length(h);
5177  intvec *iv=new intvec(i);
5178  i=0;
5179  while (h!=NULL)
5180  {
5181    if(h->Typ()==INT_CMD)
5182    {
5183      (*iv)[i]=(int)h->Data();
5184    }
5185    else
5186    {
5187      delete iv;
5188      return TRUE;
5189    }
5190    i++;
5191    h=h->next;
5192  }
5193  res->data=(char *)iv;
5194  return FALSE;
5195}
5196static BOOLEAN jjJET4(leftv res, leftv u)
5197{
5198  leftv u1=u;
5199  leftv u2=u1->next;
5200  leftv u3=u2->next;
5201  leftv u4=u3->next;
5202  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5203     (u4->Typ()==INTVEC_CMD)||
5204     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
5205     (u4->Typ()==INTVEC_CMD))
5206  {
5207    if(!pIsUnit((poly)u2->Data()))
5208    {
5209      Werror("2nd argument must be a unit");
5210      return TRUE;
5211    }
5212    res->rtyp=u1->Typ();
5213    res->data=(char*)pSeries((int)u3->Data(),pCopy((poly)u1->Data()),
5214                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
5215    return FALSE;
5216  }
5217  else
5218  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5219     (u4->Typ()==INTVEC_CMD)||
5220     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
5221     (u4->Typ()==INTVEC_CMD))
5222  {
5223    if(!mpIsDiagUnit((matrix)u2->Data()))
5224    {
5225      Werror("2nd argument must be a diagonal matrix of units");
5226      return TRUE;
5227    }
5228    res->rtyp=u1->Typ();
5229    res->data=(char*)idSeries((int)u3->Data(),idCopy((ideal)u1->Data()),
5230                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
5231    return FALSE;
5232  }
5233  else
5234  {
5235    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
5236           Tok2Cmdname(iiOp));
5237    return TRUE;
5238  }
5239}
5240static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
5241{
5242  if ((yyInRingConstruction)
5243  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
5244  {
5245    memcpy(res,u,sizeof(sleftv));
5246    memset(u,0,sizeof(sleftv));
5247    return FALSE;
5248  }
5249  leftv v=u->next;
5250  BOOLEAN b;
5251  if(v==NULL)
5252    b=iiExprArith1(res,u,iiOp);
5253  else
5254  {
5255    u->next=NULL;
5256    b=iiExprArith2(res,u,iiOp,v);
5257    u->next=v;
5258  }
5259  return b;
5260}
5261static BOOLEAN jjLIST_PL(leftv res, leftv v)
5262{
5263  int sl=0;
5264  if (v!=NULL) sl = v->listLength();
5265  lists L;
5266  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
5267  {
5268    L=syConvRes((syStrategy)v->Data());
5269  }
5270  else
5271  {
5272    L=(lists)omAllocBin(slists_bin);
5273    leftv h=NULL;
5274    int i;
5275    int rt;
5276
5277    L->Init(sl);
5278    for (i=0;i<sl;i++)
5279    {
5280      if (h!=NULL) { /* e.g. not in the first step:
5281                     * h is the pointer to the old sleftv,
5282                     * v is the pointer to the next sleftv
5283                     * (in this moment) */
5284                     h->next=v;
5285                   }
5286      h=v;
5287      v=v->next;
5288      h->next=NULL;
5289      rt=h->Typ();
5290      if (rt==0)
5291      {
5292        L->Clean();
5293        Werror("`%s` is undefined",h->Fullname());
5294        return TRUE;
5295      }
5296      if ((rt==RING_CMD)||(rt==QRING_CMD))
5297      {
5298        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
5299        ((ring)L->m[i].data)->ref++;
5300      }
5301      else
5302        L->m[i].Copy(h);
5303    }
5304  }
5305  res->data=(char *)L;
5306  return FALSE;
5307}
5308static BOOLEAN jjNAMES0(leftv res, leftv v)
5309{
5310  res->data=(void *)ipNameList(IDROOT);
5311  return FALSE;
5312}
5313static BOOLEAN jjOPTION_PL(leftv res, leftv v)
5314{
5315  if(v==NULL)
5316  {
5317    res->data=(char *)showOption();
5318    return FALSE;
5319  }
5320  res->rtyp=NONE;
5321  return setOption(res,v);
5322}
5323static BOOLEAN jjREDUCE4(leftv res, leftv u)
5324{
5325  leftv u1=u;
5326  leftv u2=u1->next;
5327  leftv u3=u2->next;
5328  leftv u4=u3->next;
5329  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
5330  {
5331    int save_d=Kstd1_deg;
5332    Kstd1_deg=(int)u3->Data();
5333    kModW=(intvec *)u4->Data();
5334    BITSET save=verbose;
5335    verbose|=Sy_bit(V_DEG_STOP);
5336    u2->next=NULL;
5337    BOOLEAN r=jjCALL2ARG(res,u);
5338    kModW=NULL;
5339    Kstd1_deg=save_d;
5340    verbose=save;
5341    u->next->next=u3;
5342    return r;
5343  }
5344  else
5345  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&