source: git/Singular/iparith.cc @ 5fde970

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