source: git/Singular/iparith.cc @ 0f7ce1

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