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

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