source: git/Singular/iparith.cc @ ac3da3

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