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

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