source: git/Singular/iparith.cc @ a5f15a

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