source: git/Singular/iparith.cc @ 3b8515

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