source: git/Singular/iparith.cc @ 561f4c

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