source: git/Singular/iparith.cc @ 97f271

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