source: git/Singular/iparith.cc @ 270e65

fieker-DuValspielwiese
Last change on this file since 270e65 was 270e65, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* first try for FiledQ optimizations git-svn-id: file:///usr/local/Singular/svn/trunk@4625 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.227 2000-09-20 13:25:39 obachman Exp $ */
5
6/*
7* ABSTRACT: table driven kernel interface, used by interpreter
8*/
9
10#include <stdlib.h>
11#include <string.h>
12#include <ctype.h>
13#include <stdio.h>
14#include <time.h>
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "omalloc.h"
22#include "polys.h"
23#include "febase.h"
24#include "sdb.h"
25#include "longalg.h"
26#include "ideals.h"
27#include "matpol.h"
28#include "kstd1.h"
29#include "timer.h"
30#include "ring.h"
31#include "subexpr.h"
32#include "lists.h"
33#include "longalg.h"
34#include "numbers.h"
35#include "stairc.h"
36#include "maps.h"
37#include "syz.h"
38#include "weight.h"
39#include "ipconv.h"
40#include "ipprint.h"
41#include "sing_dld.h"
42#include "attrib.h"
43#include "silink.h"
44#include "sparsmat.h"
45#include "algmap.h"
46#ifdef HAVE_FACTORY
47#include "clapsing.h"
48#include "kstdfac.h"
49#endif
50#ifdef HAVE_FGLM
51#include "fglm.h"
52#endif
53
54#include "ipshell.h"
55
56#include "mpr_inout.h"
57
58/*=============== types =====================*/
59struct sValCmdTab
60{
61  short cmd;
62  short start;
63};
64
65typedef sValCmdTab jjValCmdTab[];
66
67/* ifdef GENTABLE: definitions are in ipshell.h */
68#ifndef GENTABLE
69typedef char * (*Proc1)(char *);
70struct sValCmd1
71{
72  proc1 p;
73  short cmd;
74  short res;
75  short arg;
76};
77
78typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
79struct sValCmd2
80{
81  proc2 p;
82  short cmd;
83  short res;
84  short arg1;
85  short arg2;
86};
87
88typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
89struct sValCmd3
90{
91  proc3 p;
92  short cmd;
93  short res;
94  short arg1;
95  short arg2;
96  short arg3;
97};
98struct sValCmdM
99{
100  proc1 p;
101  short cmd;
102  short res;
103  short number_of_args; /* -1: any, -2: any >0, .. */
104};
105#endif
106
107/*============= proc =======================*/
108static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
109static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
110#ifdef MDEBUG
111#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
112static Subexpr jjDBMakeSub(leftv e,char *f, int l);
113#else
114static Subexpr jjMakeSub(leftv e);
115#endif
116
117/*============= vars ======================*/
118extern int cmdtok;
119extern BOOLEAN expected_parms;
120
121#define ii_div_by_0 "div. by 0"
122int iiOp; /* the current operation*/
123
124#ifdef GENTABLE
125cmdnames cmds[] =
126{  // name-string alias tokval          toktype
127  { "$INVALID$",   0, -1,                 0},
128  { "and",         0, '&' ,               LOGIC_OP},
129  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
130  { "bareiss",     0, BAREISS_CMD ,       CMD_123},
131  { "betti",       0, BETTI_CMD ,         CMD_12},
132  { "break",       0, BREAK_CMD ,         BREAK_CMD},
133  { "breakpoint",  0, BREAKPOINT_CMD ,    CMD_M},
134  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
135  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
136  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
137  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
138  { "close",       0, CLOSE_CMD ,         CMD_1},
139  { "coef",        0, COEF_CMD ,          CMD_M},
140  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
141  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
142  { "contract",    0, CONTRACT_CMD ,      CMD_2},
143  { "convhull",    0, NEWTONPOLY_CMD,     CMD_1},
144  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
145  { "def",         0, DEF_CMD ,           ROOT_DECL},
146  { "defined",     0, DEFINED_CMD ,       CMD_1},
147  { "deg",         0, DEG_CMD ,           CMD_12},
148  { "degree",      0, DEGREE_CMD ,        CMD_1},
149  { "delete",      0, DELETE_CMD ,        CMD_2},
150  { "det",         0, DET_CMD ,           CMD_1},
151  { "diff",        0, DIFF_CMD ,          CMD_2},
152  { "dim",         0, DIM_CMD ,           CMD_1},
153  { "div",         0, INTDIV_CMD ,        MULDIV_OP},
154  { "division",    0, DIVISION_CMD ,      CMD_2},
155#ifdef DRING
156  { "dring",       0, DRING_CMD ,         DRING_CMD},
157#endif
158  { "dump",        0, DUMP_CMD,           CMD_1},
159  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
160  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
161  { "ERROR",       0, ERROR_CMD ,         CMD_1},
162  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
163  { "else",        0, ELSE_CMD ,          ELSE_CMD},
164  { "eval",        0, EVAL ,              EVAL},
165  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
166  { "execute",     0, EXECUTE_CMD ,       CMD_1},
167  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
168#ifdef HAVE_NAMESPACES
169  { "exportto",    0, EXPORTTO_CMD ,      CMD_M},
170#endif
171  { "factorize",   0, FAC_CMD ,           CMD_12},
172  { "fetch",       0, FETCH_CMD ,         CMD_2},
173  { "fglm",        0, FGLM_CMD ,          CMD_2},
174  { "fglmquot",    0, FGLMQUOT_CMD,       CMD_2},
175  { "find",        0, FIND_CMD ,          CMD_23},
176  { "finduni",     0, FINDUNI_CMD,        CMD_1},
177  { "forif",       0, IF_CMD ,            IF_CMD},
178  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
179  { "facstd",      0, FACSTD_CMD ,        CMD_12},
180  { "gen",         0, E_CMD ,             CMD_1},
181  { "getdump",     0, GETDUMP_CMD,        CMD_1},
182  { "gcd",         0, GCD_CMD ,           CMD_2},
183  { "GCD",         2, GCD_CMD ,           CMD_2},
184  { "hilb",        0, HILBERT_CMD ,       CMD_123},
185  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
186  { "homog",       0, HOMOG_CMD ,         CMD_12},
187  { "hres",        0, HRES_CMD ,          CMD_2},
188  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
189  { "if",          0, IF_CMD ,            IF_CMD},
190  { "imap",        0, IMAP_CMD ,          CMD_2},
191#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,1,1);
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  MATROWS(mat)=1;
2796  mat->rank=1;
2797  res->data=(char *)mat;
2798  return FALSE;
2799}
2800static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
2801{
2802  map m=(map)v->CopyD(MAP_CMD);
2803  omFree((ADDRESS)m->preimage);
2804  m->preimage=NULL;
2805  ideal I=(ideal)m;
2806  I->rank=1;
2807  res->data=(char *)I;
2808  return FALSE;
2809}
2810static BOOLEAN jjIDEAL_R(leftv res, leftv v)
2811{
2812  if (currRing!=NULL)
2813  {
2814    ring q=(ring)v->Data();
2815    if (rEqual(currRing, q, 0))
2816    {
2817      if (q->qideal==NULL)
2818        res->data=(char *)idInit(1,1);
2819      else
2820        res->data=(char *)idCopy(q->qideal);
2821      return FALSE;
2822    }
2823  }
2824  WerrorS("can only get ideal from identical qring");
2825  return TRUE;
2826}
2827static BOOLEAN jjIm2Iv(leftv res, leftv v)
2828{
2829  intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
2830  iv->makeVector();
2831  res->data = iv;
2832  return FALSE;
2833}
2834static BOOLEAN jjINDEPSET(leftv res, leftv v)
2835{
2836  assumeStdFlag(v);
2837  res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
2838  return FALSE;
2839}
2840static BOOLEAN jjINTERRED(leftv res, leftv v)
2841{
2842  ideal result=kInterRed((ideal)(v->Data()),currQuotient);
2843  //if (result==NULL) return TRUE;
2844  idSkipZeroes(result);
2845  res->data = result;
2846  return FALSE;
2847}
2848static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
2849{
2850  res->data = (char *)pVar((poly)v->Data());
2851  return FALSE;
2852}
2853static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
2854{
2855  res->data = (char *)(rIsRingVar((char *)v->Data())+1);
2856  return FALSE;
2857}
2858static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
2859{
2860  res->data = (char *)0;
2861  return FALSE;
2862}
2863static BOOLEAN jjJACOB_P(leftv res, leftv v)
2864{
2865  ideal i=idInit(pVariables,1);
2866  int k;
2867  poly p=(poly)(v->Data());
2868  for (k=pVariables;k>0;k--)
2869  {
2870    i->m[k-1]=pDiff(p,k);
2871  }
2872  res->data = (char *)i;
2873  return FALSE;
2874}
2875static BOOLEAN jjKBASE(leftv res, leftv v)
2876{
2877  assumeStdFlag(v);
2878  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
2879  return FALSE;
2880}
2881static BOOLEAN jjKLAMMER_LIB(leftv res, leftv u)
2882{
2883  char * s=(char *)u->Data();
2884  return iiLibCmd(s);
2885}
2886#ifdef MDEBUG
2887static BOOLEAN jjpHead(leftv res, leftv v)
2888{
2889  res->data=(char *)pHead((poly)v->Data());
2890  return FALSE;
2891}
2892#endif
2893static BOOLEAN jjL2R(leftv res, leftv v)
2894{
2895  res->data=(char *)syConvList((lists)v->Data());
2896  if (res->data != NULL)
2897    return FALSE;
2898  else
2899    return TRUE;
2900}
2901static BOOLEAN jjLEADCOEF(leftv res, leftv v)
2902{
2903  poly p=(poly)v->Data();
2904  if (p==NULL)
2905  {
2906    res->data=(char *)nInit(0);
2907  }
2908  else
2909  {
2910    res->data=(char *)nCopy(pGetCoeff(p));
2911  }
2912  return FALSE;
2913}
2914static BOOLEAN jjLEADEXP(leftv res, leftv v)
2915{
2916  poly p=(poly)v->Data();
2917  int s=pVariables;
2918  if (v->Typ()==VECTOR_CMD) s++;
2919  intvec *iv=new intvec(s);
2920  if (p!=NULL)
2921  {
2922    for(int i = pVariables;i;i--)
2923    {
2924      (*iv)[i-1]=pGetExp(p,i);
2925    }
2926    if (s!=pVariables)
2927      (*iv)[pVariables]=pGetComp(p);
2928  }
2929  res->data=(char *)iv;
2930  return FALSE;
2931}
2932static BOOLEAN jjLEADMONOM(leftv res, leftv v)
2933{
2934  poly p=(poly)v->Data();
2935  if (p == NULL)
2936  {
2937    res->data = (char*) NULL;
2938  }
2939  else
2940  {
2941    poly lm = pLmInit(p);
2942    pSetCoeff(lm, nInit(1));
2943    res->data = (char*) lm;
2944  }
2945  return FALSE;
2946}
2947static BOOLEAN jjLIB(leftv res, leftv v)
2948{
2949  return iiLibCmd((char *)v->CopyD(STRING_CMD));
2950}
2951static BOOLEAN jjMEMORY(leftv res, leftv v)
2952{
2953  omUpdateInfo();
2954  switch(((int)v->Data()))
2955  {
2956  case 0:
2957    res->data = (char *)om_Info.UsedBytes;
2958    break;
2959  case 1:
2960    res->data = (char *)om_Info.CurrentBytesSystem;
2961    break;
2962  case 2:
2963    res->data = (char *)om_Info.MaxBytesSystem;
2964    break;
2965
2966  default:
2967    omPrintStats(stdout);
2968    omPrintInfo(stdout);
2969    omPrintBinStats(stdout);
2970    res->data = (char *)0;
2971  }
2972  return FALSE;
2973  res->data = (char *)0;
2974  return FALSE;
2975}
2976static BOOLEAN jjMONITOR1(leftv res, leftv v)
2977{
2978  monitor((char *)(v->Data()),PROT_I);
2979  return FALSE;
2980}
2981static BOOLEAN jjMSTD(leftv res, leftv v)
2982{
2983  res->data=(void *)min_std((ideal)v->Data(),currQuotient,testHomog,NULL);
2984  return FALSE;
2985}
2986static BOOLEAN jjMULT(leftv res, leftv v)
2987{
2988  assumeStdFlag(v);
2989  res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
2990  return FALSE;
2991}
2992static BOOLEAN jjNAMEOF(leftv res, leftv v)
2993{
2994  res->data = (char *)v->name;
2995  if (res->data==NULL) res->data=omStrDup("");
2996  v->name=NULL;
2997  return FALSE;
2998}
2999static BOOLEAN jjNAMES(leftv res, leftv v)
3000{
3001  res->data=ipNameList(((ring)v->Data())->idroot);
3002  return FALSE;
3003}
3004static BOOLEAN jjNVARS(leftv res, leftv v)
3005{
3006  res->data = (char *)(((ring)(v->Data()))->N);
3007  return FALSE;
3008}
3009static BOOLEAN jjOpenClose(leftv res, leftv v)
3010{
3011  si_link l=(si_link)v->Data();
3012  if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3013  else                return slClose(l);
3014}
3015static BOOLEAN jjORD(leftv res, leftv v)
3016{
3017  poly p=(poly)v->Data();
3018  res->data=(char *)( p==NULL ? -1 : pFDeg(p) );
3019  return FALSE;
3020}
3021static BOOLEAN jjPAR1(leftv res, leftv v)
3022{
3023  int i=(int)v->Data();
3024  int p=0;
3025  p=rPar(currRing);
3026  if ((0<i) && (i<=p))
3027  {
3028    res->data=(char *)nPar(i);
3029  }
3030  else
3031  {
3032    Werror("par number %d out of range 1..%d",i,p);
3033    return TRUE;
3034  }
3035  return FALSE;
3036}
3037static BOOLEAN jjPARDEG(leftv res, leftv v)
3038{
3039  res->data = (char *)nParDeg((number)v->Data());
3040  return FALSE;
3041}
3042static BOOLEAN jjPARSTR1(leftv res, leftv v)
3043{
3044  if (currRing==NULL)
3045  {
3046    WerrorS("no ring active");
3047    return TRUE;
3048  }
3049  int i=(int)v->Data();
3050  int p=0;
3051  if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3052    res->data=omStrDup(currRing->parameter[i-1]);
3053  else
3054  {
3055    Werror("par number %d out of range 1..%d",i,p);
3056    return TRUE;
3057  }
3058  return FALSE;
3059}
3060static BOOLEAN jjP2I(leftv res, leftv v)
3061{
3062  poly p=(poly)v->Data();
3063  if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
3064  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
3065  {
3066    WerrorS("poly must be constant");
3067    return TRUE;
3068  }
3069  res->data = (char *)nInt(pGetCoeff(p));
3070  return FALSE;
3071}
3072static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3073{
3074  map mapping=(map)v->Data();
3075  syMake(res,omStrDup(mapping->preimage));
3076  return FALSE;
3077}
3078static BOOLEAN jjPRIME(leftv res, leftv v)
3079{
3080  int i = IsPrime((int)(v->Data()));
3081  res->data = (char *)(i > 1 ? i : 2);
3082  return FALSE;
3083}
3084static BOOLEAN jjPRUNE(leftv res, leftv v)
3085{
3086  res->data = (char *)idMinEmbedding((ideal)v->Data());
3087  return FALSE;
3088}
3089static BOOLEAN jjP2N(leftv res, leftv v)
3090{
3091  number n;
3092  poly p;
3093  if (((p=(poly)v->Data())!=NULL)
3094  && (pIsConstant(p)))
3095  {
3096    n=nCopy(pGetCoeff(p));
3097  }
3098  else
3099  {
3100    n=nInit(0);
3101  }
3102  res->data = (char *)n;
3103  return FALSE;
3104}
3105static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3106{
3107  char *s= (char *)v->Data();
3108  int i = 1;
3109  int l = strlen(s);
3110  while (cmds[i].tokval!=0)
3111  {
3112    if (strcmp(s, cmds[i].name) == 0)
3113    {
3114      res->data = (char *)1;
3115      return FALSE;
3116    }
3117    i++;
3118  }
3119  //res->data = (char *)0;
3120  return FALSE;
3121}
3122static BOOLEAN jjREAD(leftv res, leftv v)
3123{
3124  return jjREAD2(res,v,NULL);
3125}
3126static BOOLEAN jjREGULARITY(leftv res, leftv v)
3127{
3128  res->data = (char *)iiRegularity((lists)v->Data());
3129  return FALSE;
3130}
3131static BOOLEAN jjROWS(leftv res, leftv v)
3132{
3133  ideal i = (ideal)v->Data();
3134  res->data = (char *)i->rank;
3135  return FALSE;
3136}
3137static BOOLEAN jjROWS_IV(leftv res, leftv v)
3138{
3139  res->data = (char *)((intvec*)(v->Data()))->rows();
3140  return FALSE;
3141}
3142static BOOLEAN jjRPAR(leftv res, leftv v)
3143{
3144  res->data = (char *)rPar(((ring)v->Data()));
3145  return FALSE;
3146}
3147static BOOLEAN jjSTD(leftv res, leftv v)
3148{
3149  ideal result;
3150  intvec *w=(intvec *)atGet(v,"isHomog");
3151  tHomog hom=testHomog;
3152  if (w!=NULL)
3153  {
3154    w=ivCopy(w);
3155    hom=isHomog;
3156  }
3157  //if (hasFlag(v,FLAG_STD))
3158  //  result=stdred((ideal)v->Data(),currQuotient,hom,&w);
3159  //else
3160    result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3161  idSkipZeroes(result);
3162  res->data = (char *)result;
3163  setFlag(res,FLAG_STD);
3164  if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3165  return FALSE;
3166}
3167static BOOLEAN jjSort_Id(leftv res, leftv v)
3168{
3169  res->data = (char *)idSort((ideal)v->Data());
3170  return FALSE;
3171}
3172static BOOLEAN jjSYZYGY(leftv res, leftv v)
3173{
3174  intvec *w=NULL;
3175  res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3176  if (w!=NULL) delete w;
3177  return FALSE;
3178}
3179static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3180{
3181  res->data = (char *)ivTrace((intvec*)(v->Data()));
3182  return FALSE;
3183}
3184static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3185{
3186  res->data = (char *)ivTranp((intvec*)(v->Data()));
3187  return FALSE;
3188}
3189static BOOLEAN jjTYPEOF(leftv res, leftv v)
3190{
3191  switch ((int)v->data)
3192  {
3193    case INT_CMD:     res->data=omStrDup("int"); break;
3194    case POLY_CMD:   res->data=omStrDup("poly"); break;
3195    case VECTOR_CMD:  res->data=omStrDup("vector"); break;
3196    case STRING_CMD:  res->data=omStrDup("string"); break;
3197    case INTVEC_CMD:  res->data=omStrDup("intvec"); break;
3198    case IDEAL_CMD:   res->data=omStrDup("ideal"); break;
3199    case MATRIX_CMD: res->data=omStrDup("matrix"); break;
3200    case MODUL_CMD:   res->data=omStrDup("module"); break;
3201    case MAP_CMD:     res->data=omStrDup("map"); break;
3202    case PROC_CMD:    res->data=omStrDup("proc"); break;
3203    case RING_CMD:    res->data=omStrDup("ring"); break;
3204    case QRING_CMD:   res->data=omStrDup("qring"); break;
3205    case INTMAT_CMD:  res->data=omStrDup("intmat"); break;
3206    case NUMBER_CMD:  res->data=omStrDup("number"); break;
3207    case LIST_CMD:   res->data=omStrDup("list"); break;
3208    case PACKAGE_CMD: res->data=omStrDup("package"); break;
3209    case LINK_CMD:   res->data=omStrDup("link"); break;
3210    case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
3211    case DEF_CMD:
3212    case NONE:    res->data=omStrDup("none"); break;
3213    default:       res->data=omStrDup("?unknown type?");
3214  }
3215  return FALSE;
3216}
3217static BOOLEAN jjVAR1(leftv res, leftv v)
3218{
3219  int i=(int)v->Data();
3220  if ((0<i) && (i<=currRing->N))
3221  {
3222    poly p=pOne();
3223    pSetExp(p,i,1);
3224    pSetm(p);
3225    res->data=(char *)p;
3226  }
3227  else
3228  {
3229    Werror("var number %d out of range 1..%d",i,currRing->N);
3230    return TRUE;
3231  }
3232  return FALSE;
3233}
3234static BOOLEAN jjVARSTR1(leftv res, leftv v)
3235{
3236  if (currRing==NULL)
3237  {
3238    WerrorS("no ring active");
3239    return TRUE;
3240  }
3241  int i=(int)v->Data();
3242  if ((0<i) && (i<=currRing->N))
3243    res->data=omStrDup(currRing->names[i-1]);
3244  else
3245  {
3246    Werror("var number %d out of range 1..%d",i,currRing->N);
3247    return TRUE;
3248  }
3249  return FALSE;
3250}
3251static BOOLEAN jjVDIM(leftv res, leftv v)
3252{
3253  assumeStdFlag(v);
3254  res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
3255  return FALSE;
3256}
3257
3258static BOOLEAN jjLOAD1(leftv res, leftv v)
3259{
3260  return jjLOAD(res, v);
3261}
3262
3263static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
3264{
3265  char * s=omStrDup((char *)v->Data());
3266  char libnamebuf[256];
3267  lib_types LT = type_of_LIB(s, libnamebuf);
3268  BOOLEAN result = TRUE;
3269#ifdef HAVE_DYNAMIC_LOADING
3270  extern BOOLEAN load_modules(char *newlib, char *fullpath, BOOLEAN tellerror);
3271#endif /* HAVE_DYNAMIC_LOADING */
3272
3273  switch(LT)
3274  {
3275      default:
3276      case LT_NONE:
3277        Werror("%s: unknown type", s);
3278        break;
3279
3280      case LT_SINGULAR:
3281#ifdef HAVE_NAMESPACES
3282        result = iiLibCmd(s, autoexport);
3283#else
3284        result = iiLibCmd(s);
3285#endif
3286        break;
3287
3288      case LT_ELF:
3289#ifdef HAVE_DYNAMIC_LOADING
3290        result = load_modules(s, libnamebuf, autoexport);
3291#else /* HAVE_DYNAMIC_LOADING */
3292        WerrorS("Dynamic modules are not supported by this version of Singular");
3293#endif /* HAVE_DYNAMIC_LOADING */
3294        break;
3295
3296      case LT_HPUX:
3297#ifdef HAVE_DYNAMIC_LOADING
3298        result = load_modules(s, libnamebuf, autoexport);
3299#else /* HAVE_DYNAMIC_LOADING */
3300        WerrorS("Dynamic modules are not supported by this version of Singular");
3301#endif /* HAVE_DYNAMIC_LOADING */
3302        break;
3303  }
3304  return result;
3305}
3306
3307/*=================== operations with 1 arg.: table =================*/
3308
3309#ifdef INIT_BUG
3310#define XS(A) -((short)A)
3311#define jjstrlen       (proc1)1
3312#define jjpLength      (proc1)2
3313#define jjidElem       (proc1)3
3314#define jjmpDetBareiss (proc1)4
3315#define jjidFreeModule (proc1)5
3316#define jjidVec2Ideal  (proc1)6
3317#define jjrCharStr     (proc1)7
3318#ifndef MDEBUG
3319#define jjpHead        (proc1)8
3320#endif
3321#define jjidHead       (proc1)9
3322#define jjidMaxIdeal   (proc1)10
3323#define jjidMinBase    (proc1)11
3324#define jjsyMinBase    (proc1)12
3325#define jjpMaxComp     (proc1)13
3326#define jjmpTrace      (proc1)14
3327#define jjmpTransp     (proc1)15
3328#define jjrOrdStr      (proc1)16
3329#define jjrVarStr      (proc1)18
3330#define jjrParStr      (proc1)19
3331#define jjCOUNT_RES    (proc1)22
3332#define jjDIM_R        (proc1)23
3333#define jjMINRES_R     (proc1)24
3334#define jjidTransp     (proc1)25
3335
3336extern struct sValCmd1 dArith1[];
3337void jjInitTab1()
3338{
3339  int i=0;
3340  for (;dArith1[i].cmd!=0;i++)
3341  {
3342    if (dArith1[i].res<0)
3343    {
3344      switch ((int)dArith1[i].p)
3345      {
3346        case (int)jjstrlen:       dArith1[i].p=(proc1)strlen; break;
3347        case (int)jjpLength:      dArith1[i].p=(proc1)pLength; break;
3348        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
3349        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
3350#ifndef HAVE_FACTORY
3351        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
3352#endif
3353        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
3354        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
3355#ifndef MDEBUG
3356        case (int)jjpHead:        dArith1[i].p=(proc1)pHeadProc; break;
3357#endif
3358        case (int)jjidHead:       dArith1[i].p=(proc1)idHead; break;
3359        case (int)jjidMaxIdeal:   dArith1[i].p=(proc1)idMaxIdeal; break;
3360        case (int)jjidMinBase:    dArith1[i].p=(proc1)idMinBase; break;
3361        case (int)jjsyMinBase:    dArith1[i].p=(proc1)syMinBase; break;
3362        case (int)jjpMaxComp:     dArith1[i].p=(proc1)pMaxCompProc; break;
3363        case (int)jjmpTrace:      dArith1[i].p=(proc1)mpTrace; break;
3364        case (int)jjmpTransp:     dArith1[i].p=(proc1)mpTransp; break;
3365        case (int)jjrOrdStr:      dArith1[i].p=(proc1)rOrdStr; break;
3366        case (int)jjrVarStr:      dArith1[i].p=(proc1)rVarStr; break;
3367        case (int)jjrParStr:      dArith1[i].p=(proc1)rParStr; break;
3368        case (int)jjCOUNT_RES:    dArith1[i].p=(proc1)syLength; break;
3369        case (int)jjDIM_R:        dArith1[i].p=(proc1)syDim; break;
3370        case (int)jjMINRES_R:     dArith1[i].p=(proc1)syMinimize; break;
3371        case (int)jjidTransp:     dArith1[i].p=(proc1)idTransp; break;
3372#ifdef GENTABLE
3373        default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
3374#endif
3375      }
3376    }
3377  }
3378}
3379#else
3380#if defined(PROC_BUG)
3381#define XS(A) A
3382static BOOLEAN jjstrlen(leftv res, leftv v)
3383{
3384  res->data = (char *)strlen((char *)v->Data());
3385  return FALSE;
3386}
3387static BOOLEAN jjpLength(leftv res, leftv v)
3388{
3389  res->data = (char *)pLength((poly)v->Data());
3390  return FALSE;
3391}
3392static BOOLEAN jjidElem(leftv res, leftv v)
3393{
3394  res->data = (char *)idElem((ideal)v->Data());
3395  return FALSE;
3396}
3397static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
3398{
3399  res->data = (char *)mpDetBareiss((matrix)v->Data());
3400  return FALSE;
3401}
3402static BOOLEAN jjidFreeModule(leftv res, leftv v)
3403{
3404  res->data = (char *)idFreeModule((int)v->Data());
3405  return FALSE;
3406}
3407static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
3408{
3409  res->data = (char *)idVec2Ideal((poly)v->Data());
3410  return FALSE;
3411}
3412static BOOLEAN jjrCharStr(leftv res, leftv v)
3413{
3414  res->data = rCharStr((ring)v->Data());
3415  return FALSE;
3416}
3417#ifndef MDEBUG
3418static BOOLEAN jjpHead(leftv res, leftv v)
3419{
3420  res->data = (char *)pHead((poly)v->Data());
3421  return FALSE;
3422}
3423#endif
3424static BOOLEAN jjidHead(leftv res, leftv v)
3425{
3426  res->data = (char *)idHead((ideal)v->Data());
3427  return FALSE;
3428}
3429static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
3430{
3431  res->data = (char *)idMaxIdeal((int)v->Data());
3432  return FALSE;
3433}
3434static BOOLEAN jjidMinBase(leftv res, leftv v)
3435{
3436  res->data = (char *)idMinBase((ideal)v->Data());
3437  return FALSE;
3438}
3439static BOOLEAN jjsyMinBase(leftv res, leftv v)
3440{
3441  res->data = (char *)syMinBase((ideal)v->Data());
3442  return FALSE;
3443}
3444static BOOLEAN jjpMaxComp(leftv res, leftv v)
3445{
3446  res->data = (char *)pMaxComp((poly)v->Data());
3447  return FALSE;
3448}
3449static BOOLEAN jjmpTrace(leftv res, leftv v)
3450{
3451  res->data = (char *)mpTrace((matrix)v->Data());
3452  return FALSE;
3453}
3454static BOOLEAN jjmpTransp(leftv res, leftv v)
3455{
3456  res->data = (char *)mpTransp((matrix)v->Data());
3457  return FALSE;
3458}
3459static BOOLEAN jjrOrdStr(leftv res, leftv v)
3460{
3461  res->data = rOrdStr((ring)v->Data());
3462  return FALSE;
3463}
3464static BOOLEAN jjrVarStr(leftv res, leftv v)
3465{
3466  res->data = rVarStr((ring)v->Data());
3467  return FALSE;
3468}
3469static BOOLEAN jjrParStr(leftv res, leftv v)
3470{
3471  res->data = rParStr((ring)v->Data());
3472  return FALSE;
3473}
3474static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
3475{
3476  res->data=(char *)syLength((syStrategy)v->Data());
3477  return FALSE;
3478}
3479static BOOLEAN jjDIM_R(leftv res, leftv v)
3480{
3481  res->data = (char *)syDim((syStrategy)v->Data());
3482  return FALSE;
3483}
3484static BOOLEAN jjMINRES_R(leftv res, leftv v)
3485{
3486  res->data=(char *)syMinimize((syStrategy)v->Data());
3487  return FALSE;
3488}
3489static BOOLEAN jjidTransp(leftv res, leftv v)
3490{
3491  res->data = (char *)idTransp((ideal)v->Data());
3492  return FALSE;
3493}
3494#else
3495#define XS(A)          -((short)A)
3496#define jjstrlen       (proc1)strlen
3497#define jjpLength      (proc1)pLength
3498#define jjidElem       (proc1)idElem
3499#define jjmpDetBareiss (proc1)mpDetBareiss
3500#define jjidFreeModule (proc1)idFreeModule
3501#define jjidVec2Ideal  (proc1)idVec2Ideal
3502#define jjrCharStr     (proc1)rCharStr
3503#ifndef MDEBUG
3504#define jjpHead        (proc1)pHead
3505#endif
3506#define jjidHead       (proc1)idHead
3507#define jjidMaxIdeal   (proc1)idMaxIdeal
3508#define jjidMinBase    (proc1)idMinBase
3509#define jjsyMinBase    (proc1)syMinBase
3510#define jjpMaxComp     (proc1)pMaxComp
3511#define jjmpTrace      (proc1)mpTrace
3512#define jjmpTransp     (proc1)mpTransp
3513#define jjrOrdStr      (proc1)rOrdStr
3514#define jjrVarStr      (proc1)rVarStr
3515#define jjrParStr      (proc1)rParStr
3516#define jjCOUNT_RES    (proc1)syLength
3517#define jjDIM_R        (proc1)syDim
3518#define jjMINRES_R     (proc1)syMinimize
3519#define jjidTransp     (proc1)idTransp
3520#endif
3521#endif
3522static BOOLEAN jjnInt(leftv res, leftv u)
3523{
3524  number n=(number)u->CopyD(NUMBER_CMD);
3525  res->data=(char *)nInt(n);
3526  nDelete(&n);
3527  return FALSE;
3528}
3529#define s short
3530struct sValCmd1 dArith1[]=
3531{
3532// operations:
3533// proc         cmd               res             arg
3534// {jjPLUSPLUS,   PLUSPLUS,        INT_CMD,        INT_CMD }
3535//,{jjMINUSMINUS, MINUSMINUS,      INT_CMD,        INT_CMD }
3536 {jjPLUSPLUS,   PLUSPLUS,        NONE,           IDHDL }
3537,{jjPLUSPLUS,   MINUSMINUS,      NONE,           IDHDL }
3538,{jjUMINUS_I,   '-',             INT_CMD,        INT_CMD }
3539,{jjUMINUS_N,   '-',             NUMBER_CMD,     NUMBER_CMD }
3540,{jjUMINUS_P,   '-',             POLY_CMD,       POLY_CMD }
3541,{jjUMINUS_P,   '-',             VECTOR_CMD,     VECTOR_CMD }
3542,{jjUMINUS_MA,  '-',             MATRIX_CMD,     MATRIX_CMD }
3543,{jjUMINUS_IV,  '-',             INTVEC_CMD,     INTVEC_CMD }
3544,{jjUMINUS_IV,  '-',             INTMAT_CMD,     INTMAT_CMD }
3545,{jjPROC1,      '(',             ANY_TYPE/*set by p*/,PROC_CMD }
3546,{jjKLAMMER_LIB,'(',             NONE,           STRING_CMD }
3547// and the procedures with 1 argument:
3548,{atATTRIB1,    ATTRIB_CMD,      NONE,           DEF_CMD }
3549,{jjBAREISS_IM, BAREISS_CMD,     INTMAT_CMD,     INTMAT_CMD }
3550,{jjBAREISS,    BAREISS_CMD,     LIST_CMD,       MODUL_CMD }
3551,{jjBETTI,      BETTI_CMD,       INTMAT_CMD,     LIST_CMD }
3552,{syBetti1,     BETTI_CMD,       INTMAT_CMD,     RESOLUTION_CMD }
3553,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD }
3554,{jjCHAR,       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD }
3555#ifdef HAVE_FACTORY
3556,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD }
3557#else
3558,{jjWRONG,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD }
3559#endif
3560,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD }
3561,{jjrCharStr,   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD }
3562,{jjOpenClose,  CLOSE_CMD,       NONE,           LINK_CMD }
3563,{jjWRONG,      COLS_CMD,        0,              VECTOR_CMD }
3564,{jjCOLS,       COLS_CMD,        INT_CMD,        MATRIX_CMD }
3565,{jjCOLS,       COLS_CMD,        INT_CMD,        IDEAL_CMD }
3566,{jjCOLS,       COLS_CMD,        INT_CMD,        MODUL_CMD }
3567,{jjCOLS_IV,    COLS_CMD,        INT_CMD,        INTMAT_CMD }
3568,{jjWRONG,      COLS_CMD,        0,              INTVEC_CMD }
3569,{jjCONTENT,    CONTENT_CMD,     POLY_CMD,       POLY_CMD }
3570,{jjCONTENT,    CONTENT_CMD,     VECTOR_CMD,     VECTOR_CMD }
3571,{jjCOUNT_N,    COUNT_CMD,       INT_CMD,        NUMBER_CMD }
3572,{jjCOUNT_RES,  COUNT_CMD,       XS(INT_CMD),    RESOLUTION_CMD }
3573,{jjstrlen,     COUNT_CMD,       XS(INT_CMD),    STRING_CMD }
3574,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    POLY_CMD }
3575,{jjpLength,    COUNT_CMD,       XS(INT_CMD),    VECTOR_CMD }
3576,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    IDEAL_CMD }
3577,{jjidElem,     COUNT_CMD,       XS(INT_CMD),    MODUL_CMD }
3578,{jjCOUNT_M,    COUNT_CMD,       INT_CMD,        MATRIX_CMD }
3579,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTVEC_CMD }
3580,{jjCOUNT_IV,   COUNT_CMD,       INT_CMD,        INTMAT_CMD }
3581,{jjCOUNT_L,    COUNT_CMD,       INT_CMD,        LIST_CMD }
3582,{jjCOUNT_RG,   COUNT_CMD,       INT_CMD,        RING_CMD }
3583,{jjNULL,       DEF_CMD,         DEF_CMD,        INT_CMD }
3584,{jjWRONG,      DEF_CMD,         0,              ANY_TYPE }
3585,{jjDEG,        DEG_CMD,         INT_CMD,        POLY_CMD }
3586,{jjDEG,        DEG_CMD,         INT_CMD,        VECTOR_CMD }
3587,{jjDEGREE,     DEGREE_CMD,      NONE,           IDEAL_CMD }
3588,{jjDEGREE,     DEGREE_CMD,      NONE,           MODUL_CMD }
3589,{jjDEFINED,    DEFINED_CMD,     INT_CMD,        DEF_CMD }
3590#ifdef HAVE_FACTORY
3591,{jjDET_I,      DET_CMD,         INT_CMD,        INTMAT_CMD }
3592,{jjDET,        DET_CMD,         POLY_CMD,       MATRIX_CMD }
3593,{jjDET_S,      DET_CMD,         POLY_CMD,       MODUL_CMD }
3594#else
3595,{jjWRONG,      DET_CMD,         INT_CMD,        INTMAT_CMD }
3596,{jjmpDetBareiss,DET_CMD,        XS(POLY_CMD),   MATRIX_CMD }
3597#endif
3598,{jjDIM,        DIM_CMD,         INT_CMD,        IDEAL_CMD }
3599,{jjDIM,        DIM_CMD,         INT_CMD,        MODUL_CMD }
3600,{jjDIM_R,      DIM_CMD,         XS(INT_CMD),    RESOLUTION_CMD }
3601,{jjDUMP,       DUMP_CMD,        NONE,           LINK_CMD }
3602,{jjE,          E_CMD,           VECTOR_CMD,     INT_CMD }
3603,{jjEXECUTE,    EXECUTE_CMD,     NONE,           STRING_CMD }
3604,{jjERROR,      ERROR_CMD,       NONE,           STRING_CMD }
3605#ifdef HAVE_FACTORY
3606,{jjFAC_P,      FAC_CMD,         LIST_CMD,       POLY_CMD }
3607#else
3608,{jjWRONG,      FAC_CMD,         LIST_CMD,       POLY_CMD }
3609#endif
3610#ifdef HAVE_FGLM
3611,{findUniProc,  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD}
3612#else
3613,{jjWRONG,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD}
3614#endif
3615,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD }
3616#ifdef HAVE_FACTORY
3617,{jjFACSTD,     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD }
3618#else
3619,{jjWRONG,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD }
3620#endif
3621,{jjGETDUMP,    GETDUMP_CMD,     NONE,           LINK_CMD }
3622,{jjHIGHCORNER, HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD }
3623,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD,     MODUL_CMD }
3624,{jjHILBERT,    HILBERT_CMD,     NONE,           IDEAL_CMD }
3625,{jjHILBERT,    HILBERT_CMD,     NONE,           MODUL_CMD }
3626,{jjHILBERT_IV, HILBERT_CMD,     INTVEC_CMD,     INTVEC_CMD }
3627,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        IDEAL_CMD }
3628,{jjHOMOG1,     HOMOG_CMD,       INT_CMD,        MODUL_CMD }
3629,{jjidVec2Ideal,IDEAL_CMD,       XS(IDEAL_CMD),  VECTOR_CMD }
3630,{jjIDEAL_Ma,   IDEAL_CMD,       IDEAL_CMD,      MATRIX_CMD }
3631,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      QRING_CMD }
3632,{jjIDEAL_R,    IDEAL_CMD,       IDEAL_CMD,      RING_CMD }
3633,{jjIDEAL_Map,  IDEAL_CMD,       IDEAL_CMD,      MAP_CMD }
3634,{jjDUMMY,      IDEAL_CMD,       IDEAL_CMD,      IDEAL_CMD }
3635,{jjINDEPSET,   INDEPSET_CMD,    INTVEC_CMD,     IDEAL_CMD }
3636,{jjDUMMY,      INT_CMD,         INT_CMD,        INT_CMD }
3637,{jjnInt,       INT_CMD,         INT_CMD,        NUMBER_CMD }
3638,{jjP2I,        INT_CMD,         INT_CMD,        POLY_CMD }
3639,{jjINTERRED,   INTERRED_CMD,    IDEAL_CMD,      IDEAL_CMD }
3640,{jjINTERRED,   INTERRED_CMD,    MODUL_CMD,      MODUL_CMD }
3641,{jjDUMMY,      INTMAT_CMD,      INTMAT_CMD,     INTMAT_CMD }
3642,{jjIm2Iv,      INTVEC_CMD,      INTVEC_CMD,     INTMAT_CMD }
3643,{jjDUMMY,      INTVEC_CMD,      INTVEC_CMD,     INTVEC_CMD }
3644,{jjIS_RINGVAR_P, IS_RINGVAR,    INT_CMD,        POLY_CMD }
3645,{jjIS_RINGVAR_S, IS_RINGVAR,    INT_CMD,        STRING_CMD }
3646,{jjIS_RINGVAR0,IS_RINGVAR,      INT_CMD,        ANY_TYPE }
3647,{jjJACOB_P,    JACOB_CMD,       IDEAL_CMD,      POLY_CMD }
3648,{mpJacobi,     JACOB_CMD,       MATRIX_CMD,     IDEAL_CMD }
3649,{jjKBASE,      KBASE_CMD,       IDEAL_CMD,      IDEAL_CMD }
3650,{jjKBASE,      KBASE_CMD,       MODUL_CMD,      MODUL_CMD }
3651,{atKILLATTR1,  KILLATTR_CMD,    NONE,           IDHDL }
3652#ifdef MDEBUG
3653,{jjpHead,      LEAD_CMD,        POLY_CMD,       POLY_CMD }
3654#else
3655,{jjpHead,      LEAD_CMD,        XS(POLY_CMD),   POLY_CMD }
3656#endif
3657,{jjidHead,     LEAD_CMD,        XS(IDEAL_CMD),  IDEAL_CMD }
3658#ifdef MDEBUG
3659,{jjpHead,      LEAD_CMD,        VECTOR_CMD,     VECTOR_CMD }
3660#else
3661,{jjpHead,      LEAD_CMD,        XS(VECTOR_CMD), VECTOR_CMD }
3662#endif
3663,{jjidHead,     LEAD_CMD,        XS(MODUL_CMD),  MODUL_CMD }
3664,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     POLY_CMD }
3665,{jjLEADCOEF,   LEADCOEF_CMD,    NUMBER_CMD,     VECTOR_CMD }
3666,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     POLY_CMD }
3667,{jjLEADEXP,    LEADEXP_CMD,     INTVEC_CMD,     VECTOR_CMD }
3668,{jjLEADMONOM,  LEADMONOM_CMD,   POLY_CMD,       POLY_CMD }
3669,{jjLEADMONOM,  LEADMONOM_CMD,   VECTOR_CMD,     VECTOR_CMD }
3670,{jjLIB,        LIB_CMD,         NONE,           STRING_CMD }
3671,{jjDUMMY,      LINK_CMD,        LINK_CMD,       LINK_CMD}
3672,{jjCALL1MANY,  LIST_CMD,        LIST_CMD,       DEF_CMD }
3673,{jjWRONG,      MAP_CMD,         0,              ANY_TYPE}
3674,{jjDUMMY,      MATRIX_CMD,      MATRIX_CMD,     MATRIX_CMD }
3675,{jjidMaxIdeal, MAXID_CMD,       XS(IDEAL_CMD),  INT_CMD }
3676,{jjMEMORY,     MEMORY_CMD,      INT_CMD,        INT_CMD }
3677,{jjidMinBase,  MINBASE_CMD,     XS(IDEAL_CMD),  IDEAL_CMD }
3678,{jjidMinBase,  MINBASE_CMD,     XS(MODUL_CMD),  MODUL_CMD }
3679,{jjMINRES,     MINRES_CMD,      LIST_CMD,       LIST_CMD }
3680,{jjMINRES_R,   MINRES_CMD,      XS(RESOLUTION_CMD), RESOLUTION_CMD }
3681,{jjDUMMY,      MODUL_CMD,       MODUL_CMD,      MODUL_CMD }
3682,{jjMONITOR1,   MONITOR_CMD,     NONE,           STRING_CMD }
3683,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      IDEAL_CMD }
3684,{jjMULT,       MULTIPLICITY_CMD,  INT_CMD,      MODUL_CMD }
3685,{jjMSTD,       MSTD_CMD,        LIST_CMD,       IDEAL_CMD }
3686,{jjMSTD,       MSTD_CMD,        LIST_CMD,       MODUL_CMD }
3687,{jjNAMEOF,     NAMEOF_CMD,      STRING_CMD,     ANY_TYPE }
3688,{jjNAMES,      NAMES_CMD,       LIST_CMD,       PACKAGE_CMD }
3689,{jjNAMES,      NAMES_CMD,       LIST_CMD,       RING_CMD }
3690,{jjNAMES,      NAMES_CMD,       LIST_CMD,       QRING_CMD }
3691,{jjDUMMY,      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD }
3692,{jjP2N,        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD }
3693,{jjRPAR,       NPARS_CMD,       INT_CMD,        RING_CMD }
3694,{jjRPAR,       NPARS_CMD,       INT_CMD,        QRING_CMD }
3695,{jjNVARS,      NVARS_CMD,       INT_CMD,        RING_CMD }
3696,{jjNVARS,      NVARS_CMD,       INT_CMD,        QRING_CMD }
3697,{jjOpenClose,  OPEN_CMD,        NONE,           LINK_CMD }
3698,{jjORD,        ORD_CMD,         INT_CMD,        POLY_CMD }
3699,{jjORD,        ORD_CMD,         INT_CMD,        VECTOR_CMD }
3700,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), RING_CMD }
3701,{jjrOrdStr,    ORDSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3702,{jjPAR1,       PAR_CMD,         NUMBER_CMD,     INT_CMD }
3703,{jjPARDEG,     PARDEG_CMD,      INT_CMD,        NUMBER_CMD }
3704,{jjPARSTR1,    PARSTR_CMD,      STRING_CMD,     INT_CMD }
3705,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), RING_CMD }
3706,{jjrParStr,    PARSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3707,{jjDUMMY,      POLY_CMD,        POLY_CMD,       POLY_CMD }
3708,{jjPREIMAGE_R, PREIMAGE_CMD,    RING_CMD,       MAP_CMD }
3709,{jjPRIME,      PRIME_CMD,       INT_CMD,        INT_CMD }
3710,{jjPRINT,      PRINT_CMD,       NONE,           LIST_CMD}
3711,{jjPRINT,      PRINT_CMD,       NONE,           DEF_CMD}
3712,{jjPRUNE,      PRUNE_CMD,       MODUL_CMD,      MODUL_CMD }
3713,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     IDEAL_CMD }
3714,{kQHWeight,    QHWEIGHT_CMD,    INTVEC_CMD,     MODUL_CMD }
3715,{jjWRONG,      QRING_CMD,       0,              ANY_TYPE}
3716,{jjREAD,       READ_CMD,        STRING_CMD,     LINK_CMD }
3717,{jjREGULARITY, REGULARITY_CMD,  INT_CMD,        LIST_CMD }
3718,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD,      STRING_CMD }
3719,{jjL2R,        RESOLUTION_CMD,  RESOLUTION_CMD, LIST_CMD }
3720,{jjDUMMY,      RESOLUTION_CMD,  RESOLUTION_CMD, RESOLUTION_CMD }
3721,{jjDUMMY,      RING_CMD,        RING_CMD,       RING_CMD}
3722,{jjWRONG,      ROWS_CMD,        0,              POLY_CMD }
3723,{jjpMaxComp,   ROWS_CMD,        XS(INT_CMD),    VECTOR_CMD }
3724,{jjROWS,       ROWS_CMD,        INT_CMD,        MODUL_CMD }
3725,{jjROWS,       ROWS_CMD,        INT_CMD,        MATRIX_CMD }
3726,{jjROWS_IV,    ROWS_CMD,        INT_CMD,        INTMAT_CMD }
3727,{jjCOUNT_IV,   ROWS_CMD,        INT_CMD,        INTVEC_CMD }
3728,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD }
3729,{jjSort_Id,    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD }
3730,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD }
3731,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD }
3732,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD }
3733,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD }
3734,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD }
3735,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD }
3736,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD }
3737,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD }
3738,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD }
3739,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD }
3740,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD }
3741,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD }
3742,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD }
3743,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD }
3744,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE }
3745,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD }
3746,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD }
3747,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD }
3748,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD }
3749,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD }
3750,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD }
3751,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3752,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD }
3753,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD }
3754,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD }
3755,{loNewtonP,    NEWTONPOLY_CMD,  IDEAL_CMD,      IDEAL_CMD}
3756,{NULL,         0,               0,              0}
3757};
3758#undef s
3759/*=================== operations with 3 args.: static proc =================*/
3760static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
3761{
3762  char *s= (char *)u->Data();
3763  int   r = (int)v->Data();
3764  int   c = (int)w->Data();
3765  int l = strlen(s);
3766
3767  if ( (r<1) || (r>l) || (c<0) )
3768  {
3769    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
3770    return TRUE;
3771  }
3772  res->data = (char *)omAlloc(c+1);
3773  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
3774  return FALSE;
3775}
3776static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
3777{
3778  intvec *iv = (intvec *)u->Data();
3779  int   r = (int)v->Data();
3780  int   c = (int)w->Data();
3781  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
3782  {
3783    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
3784           r,c,u->Fullname(),iv->rows(),iv->cols());
3785    return TRUE;
3786  }
3787  res->data=u->data;
3788  u->data=NULL;
3789  res->rtyp=u->rtyp;
3790  u->rtyp=0;
3791  res->name=u->name;
3792  u->name=NULL;
3793  Subexpr e=jjMakeSub(v);
3794          e->next=jjMakeSub(w);
3795  if (u->e==NULL) res->e=e;
3796  else
3797  {
3798    Subexpr h=u->e;
3799    while (h->next!=NULL) h=h->next;
3800    h->next=e;
3801    res->e=u->e;
3802    u->e=NULL;
3803  }
3804  return FALSE;
3805}
3806static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
3807{
3808  matrix m= (matrix)u->Data();
3809  int   r = (int)v->Data();
3810  int   c = (int)w->Data();
3811  //Print("gen. elem %d, %d\n",r,c);
3812  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
3813  {
3814    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
3815      MATROWS(m),MATCOLS(m));
3816    return TRUE;
3817  }
3818  res->data=u->data;
3819  u->data=NULL;
3820  res->rtyp=u->rtyp;
3821  u->rtyp=0;
3822  res->name=u->name;
3823  u->name=NULL;
3824  Subexpr e=jjMakeSub(v);
3825          e->next=jjMakeSub(w);
3826  if (u->e==NULL)
3827    res->e=e;
3828  else
3829  {
3830    Subexpr h=u->e;
3831    while (h->next!=NULL) h=h->next;
3832    h->next=e;
3833    res->e=u->e;
3834    u->e=NULL;
3835  }
3836  return FALSE;
3837}
3838static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
3839{
3840  sleftv t;
3841  sleftv ut;
3842  leftv p=NULL;
3843  intvec *iv=(intvec *)w->Data();
3844  int l;
3845  BOOLEAN nok;
3846
3847  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3848  {
3849    WerrorS("cannot build expression lists from unnamed objects");
3850    return TRUE;
3851  }
3852  memcpy(&ut,u,sizeof(ut));
3853  memset(&t,0,sizeof(t));
3854  t.rtyp=INT_CMD;
3855  for (l=0;l< iv->length(); l++)
3856  {
3857    t.data=(char *)(*iv)[l];
3858    if (p==NULL)
3859    {
3860      p=res;
3861    }
3862    else
3863    {
3864      p->next=(leftv)omAlloc0Bin(sleftv_bin);
3865      p=p->next;
3866    }
3867    memcpy(u,&ut,sizeof(ut));
3868    if (u->Typ() == MATRIX_CMD)
3869      nok=jjBRACK_Ma(p,u,v,&t);
3870    else /* INTMAT_CMD */
3871      nok=jjBRACK_Im(p,u,v,&t);
3872    if (nok)
3873    {
3874      while (res->next!=NULL)
3875      {
3876        p=res->next->next;
3877        omFreeBin((ADDRESS)res->next, sleftv_bin);
3878        // res->e aufraeumen !!!!
3879        res->next=p;
3880      }
3881      return TRUE;
3882    }
3883  }
3884  return FALSE;
3885}
3886static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
3887{
3888  sleftv t;
3889  sleftv ut;
3890  leftv p=NULL;
3891  intvec *iv=(intvec *)v->Data();
3892  int l;
3893  BOOLEAN nok;
3894
3895  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3896  {
3897    WerrorS("cannot build expression lists from unnamed objects");
3898    return TRUE;
3899  }
3900  memcpy(&ut,u,sizeof(ut));
3901  memset(&t,0,sizeof(t));
3902  t.rtyp=INT_CMD;
3903  for (l=0;l< iv->length(); l++)
3904  {
3905    t.data=(char *)((*iv)[l]);
3906    if (p==NULL)
3907    {
3908      p=res;
3909    }
3910    else
3911    {
3912      p->next=(leftv)omAlloc0Bin(sleftv_bin);
3913      p=p->next;
3914    }
3915    memcpy(u,&ut,sizeof(ut));
3916    if (u->Typ() == MATRIX_CMD)
3917      nok=jjBRACK_Ma(p,u,&t,w);
3918    else /* INTMAT_CMD */
3919      nok=jjBRACK_Im(p,u,&t,w);
3920    if (nok)
3921    {
3922      while (res->next!=NULL)
3923      {
3924        p=res->next->next;
3925        omFreeBin((ADDRESS)res->next, sleftv_bin);
3926        // res->e aufraeumen !!
3927        res->next=p;
3928      }
3929      return TRUE;
3930    }
3931  }
3932  return FALSE;
3933}
3934static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
3935{
3936  sleftv t1,t2,ut;
3937  leftv p=NULL;
3938  intvec *vv=(intvec *)v->Data();
3939  intvec *wv=(intvec *)w->Data();
3940  int vl;
3941  int wl;
3942  BOOLEAN nok;
3943
3944  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3945  {
3946    WerrorS("cannot build expression lists from unnamed objects");
3947    return TRUE;
3948  }
3949  memcpy(&ut,u,sizeof(ut));
3950  memset(&t1,0,sizeof(sleftv));
3951  memset(&t2,0,sizeof(sleftv));
3952  t1.rtyp=INT_CMD;
3953  t2.rtyp=INT_CMD;
3954  for (vl=0;vl< vv->length(); vl++)
3955  {
3956    t1.data=(char *)((*vv)[vl]);
3957    for (wl=0;wl< wv->length(); wl++)
3958    {
3959      t2.data=(char *)((*wv)[wl]);
3960      if (p==NULL)
3961      {
3962        p=res;
3963      }
3964      else
3965      {
3966        p->next=(leftv)omAlloc0Bin(sleftv_bin);
3967        p=p->next;
3968      }
3969      memcpy(u,&ut,sizeof(ut));
3970      if (u->Typ() == MATRIX_CMD)
3971        nok=jjBRACK_Ma(p,u,&t1,&t2);
3972      else /* INTMAT_CMD */
3973        nok=jjBRACK_Im(p,u,&t1,&t2);
3974      if (nok)
3975      {
3976        res->CleanUp();
3977        return TRUE;
3978      }
3979    }
3980  }
3981  return FALSE;
3982}
3983static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
3984{
3985  v->next=(leftv)omAllocBin(sleftv_bin);
3986  memcpy(v->next,w,sizeof(sleftv));
3987  BOOLEAN r=iiExprArith2(res,u,'(',v);
3988  v->rtyp=0; v->data=NULL;
3989  w->rtyp=0; w->data=NULL;
3990  return r;
3991}
3992static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
3993{
3994  u->next=(leftv)omAllocBin(sleftv_bin);
3995  memcpy(u->next,v,sizeof(sleftv));
3996  u->next->next=(leftv)omAllocBin(sleftv_bin);
3997  memcpy(u->next->next,w,sizeof(sleftv));
3998  BOOLEAN r=iiExprArithM(res,u,iiOp);
3999  v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
4000  w->rtyp=0; w->data=NULL;
4001  return r;
4002}
4003static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
4004{
4005  lists l;
4006  int k=(int)w->Data();
4007  if (k>=0)
4008  {
4009    l=smCallNewBareiss((ideal)u->Data(),(int)v->Data(),(int)w->Data());
4010  }
4011  else
4012  {
4013    l=smCallSolv((ideal)u->Data());
4014  }
4015  res->data = (char *)l;
4016  return FALSE;
4017}
4018static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
4019{
4020  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4021  {
4022    WerrorS("3rd argument must be a name of a matrix");
4023    return TRUE;
4024  }
4025  ideal i=(ideal)u->Data();
4026  int rank=(int)i->rank;
4027  BOOLEAN r=jjCOEFFS_Id(res,u,v);
4028  if (r) return TRUE;
4029  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4030  return FALSE;
4031}
4032static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
4033{
4034  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
4035           (ideal)(v->Data()),(poly)(w->Data()));
4036  return FALSE;
4037}
4038static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
4039{
4040  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
4041  {
4042    WerrorS("3rd argument must be a name of a matrix");
4043    return TRUE;
4044  }
4045  // CopyD for POLY_CMD and VECTOR_CMD are identical:
4046  poly p=(poly)u->CopyD(POLY_CMD);
4047  ideal i=idInit(1,1);
4048  i->m[0]=p;
4049  sleftv t;
4050  memset(&t,0,sizeof(t));
4051  t.data=(char *)i;
4052  t.rtyp=IDEAL_CMD;
4053  int rank=1;
4054  if (u->Typ()==VECTOR_CMD)
4055  {
4056    i->rank=rank=pMaxComp(p);
4057    t.rtyp=MODUL_CMD;
4058  }
4059  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
4060  t.CleanUp();
4061  if (r) return TRUE;
4062  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
4063  return FALSE;
4064}
4065static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
4066{
4067  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
4068    (intvec *)w->Data());
4069  setFlag(res,FLAG_STD);
4070  return FALSE;
4071}
4072static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
4073{
4074  /*4
4075  * look for the substring what in the string where
4076  * starting at position n
4077  * return the position of the first char of what in where
4078  * or 0
4079  */
4080  int n=(int)w->Data();
4081  char *where=(char *)u->Data();
4082  char *what=(char *)v->Data();
4083  char *found;
4084  if ((1>n)||(n>(int)strlen(where)))
4085  {
4086    Werror("start position %d out of range",n);
4087    return TRUE;
4088  }
4089  found = strchr(where+n-1,*what);
4090  if (*(what+1)!='\0')
4091  {
4092    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4093    {
4094      found=strchr(found+1,*what);
4095    }
4096  }
4097  if (found != NULL)
4098  {
4099    res->data=(char *)((found-where)+1);
4100  }
4101  return FALSE;
4102}
4103static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4104{
4105  assumeStdFlag(u);
4106  intvec *module_w=(intvec *)atGet(u,"isHomog");
4107  intvec *wdegree=(intvec*)w->Data();
4108  if (wdegree->length()!=pVariables)
4109  {
4110    Werror("weight vector must have size %d, not %d",
4111           pVariables,wdegree->length());
4112    return TRUE;
4113  }
4114  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4115  switch((int)v->Data())
4116  {
4117    case 1:
4118      res->data=(void *)iv;
4119      return FALSE;
4120    case 2:
4121      res->data=(void *)hSecondSeries(iv);
4122      delete iv;
4123      return FALSE;
4124  }
4125  WerrorS(feNotImplemented);
4126  delete iv;
4127  return TRUE;
4128}
4129static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4130{
4131  intvec* im= new intvec((int)v->Data(),(int)w->Data(), 0);
4132  intvec* arg = (intvec*) u->Data();
4133  int i, n = min(im->cols()*im->rows(), arg->cols()*arg->rows());
4134
4135  for (i=0; i<n; i++)
4136  {
4137    (*im)[i] = (*arg)[i];
4138  }
4139
4140  res->data = (char *)im;
4141  return FALSE;
4142}
4143static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4144{
4145  short *iw=iv2array((intvec *)w->Data());
4146  res->data = (char *)pJetW((poly)u->Data(),(int)v->Data(),iw);
4147  omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
4148  return FALSE;
4149}
4150static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4151{
4152  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
4153                             (intvec *)w->Data());
4154  return FALSE;
4155}
4156static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4157{
4158  assumeStdFlag(w);
4159  res->data = (char *)idMinors(
4160                        (matrix)u->Data(),(int)v->Data(),(ideal)w->Data());
4161  return FALSE;
4162}
4163static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4164{
4165  idhdl h;
4166  ring rr;
4167  map mapping;
4168
4169  if ((v->name==NULL) || (w->name==NULL))
4170  {
4171    WerrorS("2nd/3rd arguments must have names");
4172    return TRUE;
4173  }
4174  rr=(ring)u->Data();
4175  const char *ring_name=u->Name();
4176  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4177  {
4178    if (h->typ==MAP_CMD)
4179    {
4180      mapping=IDMAP(h);
4181      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4182      if ((preim_ring==NULL)
4183      || (IDRING(preim_ring)!=currRing))
4184      {
4185        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4186        return TRUE;
4187      }
4188    }
4189    else if (h->typ==IDEAL_CMD)
4190    {
4191      mapping=IDMAP(h);
4192    }
4193    else
4194    {
4195      Werror("`%s` is no map nor ideal",IDID(h));
4196      return TRUE;
4197    }
4198  }
4199  else
4200  {
4201    Werror("`%s` is not defined in `%s`",v->name,ring_name);
4202    return TRUE;
4203  }
4204  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4205  {
4206    if (h->typ==IDEAL_CMD)
4207    {
4208      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4209    }
4210    else
4211    {
4212      Werror("`%s` is no ideal",IDID(h));
4213      return TRUE;
4214    }
4215  }
4216  else
4217  {
4218    Werror("`%s` is not defined in `%s`",w->name,ring_name);
4219    return TRUE;
4220  }
4221  return FALSE;
4222}
4223static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4224{
4225  int di, k;
4226  int i=(int)u->Data();
4227  int r=(int)v->Data();
4228  int c=(int)w->Data();
4229  intvec *iv = new intvec(r, c, 0);
4230  if (iv->rows()==0)
4231  {
4232    delete iv;
4233    return TRUE;
4234  }
4235  if (i!=0)
4236  {
4237    if (i<0) i = -i;
4238    di = 2 * i + 1;
4239    for (k=0; k<iv->length(); k++)
4240    {
4241#ifdef buildin_rand
4242      (*iv)[k] = ((siRand() % di) - i);
4243#else
4244      (*iv)[k] = ((rand() % di) - i);
4245#endif
4246    }
4247  }
4248  res->data = (char *)iv;
4249  return FALSE;
4250}
4251static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4252  int &ringvar, poly &monomexpr)
4253{
4254  monomexpr=(poly)w->Data();
4255  if (pLength(monomexpr)>1)
4256  {
4257    Werror("`%s` substitutes a ringvar only by a term",
4258      Tok2Cmdname(SUBST_CMD));
4259    return TRUE;
4260  }
4261  if (!(ringvar=pVar((poly)v->Data())))
4262  {
4263    WerrorS("ringvar expected");
4264    return TRUE;
4265  }
4266  return FALSE;
4267}
4268static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4269{
4270  int ringvar;
4271  poly monomexpr;
4272  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4273  if (nok) return TRUE;
4274  res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4275  return FALSE;
4276}
4277static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4278{
4279  int ringvar;
4280  poly monomexpr;
4281  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4282  if (nok) return TRUE;
4283  res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4284  return FALSE;
4285}
4286// we do not want to have jjSUBST_Id_X inlined:
4287static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4288                            int input_type);
4289static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4290{
4291  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4292}
4293static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4294{
4295  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4296}
4297static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4298{
4299  sleftv tmp;
4300  memset(&tmp,0,sizeof(tmp));
4301  // do not check the result, conversion from int/number to poly works always
4302  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4303  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4304  tmp.CleanUp();
4305  return b;
4306}
4307static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4308{
4309  matrix m=mpNew((int)v->Data(),(int)w->Data());
4310  ideal I=(ideal)u->CopyD(IDEAL_CMD);
4311  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4312  //for(i=i-1;i>=0;i--)
4313  //{
4314  //  m->m[i]=I->m[i];
4315  //  I->m[i]=NULL;
4316  //}
4317  memcpy4(m->m,I->m,i*sizeof(poly));
4318  memset(I->m,0,i*sizeof(poly));
4319  idDelete(&I);
4320  res->data = (char *)m;
4321  return FALSE;
4322}
4323static BOOLEAN jjSUBST_Par_N(leftv res, leftv u, leftv v,leftv w)
4324{
4325  // u: to change poly
4326  // v: number (parameter)
4327  // w: image of u (number)
4328  int i;
4329  lnumber a=(lnumber)v->Data();
4330  if (naParDeg((number)a)!=1)
4331  {
4332    WerrorS("first argument is not a parameter");
4333    return TRUE;
4334  }
4335  int r=rPar(currRing);
4336  ideal G=idMaxIdeal(1);
4337  ideal F=idInit(r,1);
4338  int par=-1;
4339  for(i=0;i<r;i++)
4340  {
4341    if (a->z->e[i]!=0) { par=i; break;}
4342  }
4343  for(i=0;i<r;i++)
4344  {
4345    if (i==par) F->m[i]=(poly)w->CopyD();
4346    else
4347    {
4348      F->m[i]=pOne();pSetCoeff( F->m[i],naPar(i+1));
4349    }
4350  }
4351  res->data=(poly)maAlgpolyMap(currRing,(poly)u->Data(),F,G);
4352  idDelete(&F);
4353  idDelete(&G);
4354  return FALSE;
4355}
4356static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4357{
4358  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4359           (int)v->Data(),(int)w->Data());
4360  return FALSE;
4361}
4362static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4363{
4364  matrix m=mpNew((int)v->Data(),(int)w->Data());
4365  matrix I=(matrix)u->CopyD(MATRIX_CMD);
4366  int r=min(MATROWS(I),(int)v->Data());
4367  int c=min(MATCOLS(I),(int)w->Data());
4368  int i,j;
4369  for(i=r;i>0;i--)
4370  {
4371    for(j=c;j>0;j--)
4372    {
4373      MATELEM(m,i,j)=MATELEM(I,i,j);
4374      MATELEM(I,i,j)=NULL;
4375    }
4376  }
4377  idDelete((ideal *)&I);
4378  res->data = (char *)m;
4379  return FALSE;
4380}
4381static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4382{
4383  if (w->rtyp!=IDHDL) return TRUE;
4384  BITSET save_test=test;
4385  int ul= IDELEMS((ideal)u->Data());
4386  int vl= IDELEMS((ideal)v->Data());
4387  ideal m
4388    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
4389             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
4390  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4391  test=save_test;
4392  return FALSE;
4393}
4394static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4395{
4396  assumeStdFlag(v);
4397  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4398    0,(int)w->Data());
4399  return FALSE;
4400}
4401static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
4402{
4403  assumeStdFlag(v);
4404  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
4405    0,(int)w->Data());
4406  return FALSE;
4407}
4408#ifdef OLD_RES
4409static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
4410{
4411  int maxl=(int)v->Data();
4412  int l=0;
4413  resolvente r;
4414  intvec **weights=NULL;
4415  int wmaxl=maxl;
4416  maxl--;
4417  if ((maxl==-1) && (iiOp!=MRES_CMD))
4418    maxl = pVariables-1;
4419  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
4420  {
4421    intvec * iv=(intvec*)atGet(u,"isHomog");
4422    if (iv!=NULL)
4423    {
4424      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
4425      weights[0] = ivCopy(iv);
4426      l=1;
4427    }
4428    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
4429  }
4430  else
4431    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
4432  if (r==NULL) return TRUE;
4433  int t3=u->Typ();
4434  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
4435  return FALSE;
4436  return TRUE;
4437}
4438#endif
4439static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
4440{
4441  res->data=(void *)rInit(u,v,w);
4442  return (res->data==NULL);
4443}
4444static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
4445{
4446  int yes;
4447  jjSTATUS2(res, u, v);
4448  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
4449  omFree((ADDRESS) res->data);
4450  res->data = (void *) yes;
4451  return FALSE;
4452}
4453static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
4454{
4455  ideal result;
4456  intvec *ww=(intvec *)atGet(u,"isHomog");
4457  tHomog hom=testHomog;
4458  if (ww!=NULL)
4459  {
4460    ww=ivCopy(ww);
4461    hom=isHomog;
4462  }
4463  result=kStd((ideal)(u->Data()),
4464              currQuotient,
4465              hom,
4466              &ww,                  // module weights
4467              (intvec *)v->Data(),  // hilbert series
4468              0,0,                  // syzComp, newIdeal
4469              (intvec *)w->Data()); // weights of vars
4470  idSkipZeroes(result);
4471  res->data = (char *)result;
4472  setFlag(res,FLAG_STD);
4473  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
4474  return FALSE;
4475}
4476
4477/*=================== operations with 3 args.: table =================*/
4478struct sValCmd3 dArith3[]=
4479{
4480// operations:
4481// proc             cmd          res         arg1        arg2        arg3
4482 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD }
4483,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD }
4484,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD }
4485,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD }
4486,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
4487,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD }
4488,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD }
4489,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD }
4490,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
4491,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD }
4492,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD }
4493,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD }
4494,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD }
4495,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD }
4496,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD }
4497,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD }
4498,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD }
4499,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD }
4500,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
4501,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD }
4502,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
4503,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD }
4504,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4505//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4506,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD }
4507,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD }
4508,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD }
4509,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD }
4510,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
4511,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD }
4512,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD }
4513,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD }
4514,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4515,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD }
4516,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD }
4517,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD }
4518,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD}
4519,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4520#ifdef OLD_RES
4521,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4522,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4523#endif
4524,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD }
4525,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD }
4526,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE }
4527,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE }
4528,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD }
4529,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD }
4530,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD }
4531,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD }
4532,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD }
4533,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD }
4534,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD }
4535#ifdef OLD_RES
4536,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4537,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4538#endif
4539#ifdef HAVE_FACTORY
4540,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4541#else
4542,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4543#endif
4544,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4545#ifdef OLD_RES
4546,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4547,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4548#endif
4549,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD}
4550,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD}
4551,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD}
4552,{jjSUBST_Par_N,    SUBST_CMD,  POLY_CMD,   POLY_CMD,   NUMBER_CMD, POLY_CMD }
4553,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4554,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4555,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD }
4556,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD }
4557,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD }
4558,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD }
4559,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD }
4560,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD }
4561,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD  }
4562,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD  }
4563,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD  }
4564,{NULL,             0,          0,          0,          0,          0 }
4565};
4566/*=================== operations with many arg.: static proc =================*/
4567static BOOLEAN jjBREAK0(leftv res, leftv v)
4568{
4569  sdb_show_bp();
4570  return FALSE;
4571}
4572static BOOLEAN jjBREAK1(leftv res, leftv v)
4573{
4574  if(v->Typ()==PROC_CMD)
4575  {
4576    int lineno=0;
4577    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
4578    {
4579      lineno=(int)v->next->Data();
4580    }
4581    return sdb_set_breakpoint(v->Name(),lineno);
4582  }
4583  return TRUE;
4584}
4585static BOOLEAN jjCALL1ARG(leftv res, leftv v)
4586{
4587  return iiExprArith1(res,v,iiOp);
4588}
4589static BOOLEAN jjCALL2ARG(leftv res, leftv u)
4590{
4591  leftv v=u->next;
4592  u->next=NULL;
4593  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
4594  u->next=v;
4595  return b;
4596}
4597static BOOLEAN jjCALL3ARG(leftv res, leftv u)
4598{
4599  leftv v = u->next;
4600  leftv w = v->next;
4601  u->next = NULL;
4602  v->next = NULL;
4603  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4604  u->next = v;
4605  v->next = w;
4606  return b;
4607}
4608
4609static BOOLEAN jjCOEF_M(leftv res, leftv v)
4610{
4611  if((v->Typ() != VECTOR_CMD)
4612  || (v->next->Typ() != POLY_CMD)
4613  || (v->next->next->Typ() != MATRIX_CMD)
4614  || (v->next->next->next->Typ() != MATRIX_CMD))
4615     return TRUE;
4616  if (v->next->next->rtyp!=IDHDL) return TRUE;
4617  idhdl c=(idhdl)v->next->next->data;
4618  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
4619  idhdl m=(idhdl)v->next->next->next->data;
4620  idDelete((ideal *)&(c->data.uideal));
4621  idDelete((ideal *)&(m->data.uideal));
4622  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
4623    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
4624  return FALSE;
4625}
4626static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
4627{
4628  int s=1;
4629  leftv h=v;
4630  if (h!=NULL) s=exprlist_length(h);
4631  ideal id=idInit(s,1);
4632  int rank=1;
4633  int i=0;
4634  poly p;
4635  while (h!=NULL)
4636  {
4637    switch(h->Typ())
4638    {
4639      case POLY_CMD:
4640      {
4641        p=(poly)h->CopyD(POLY_CMD);
4642        break;
4643      }
4644      case INT_CMD:
4645      {
4646        number n=nInit((int)h->Data());
4647        if (!nIsZero(n))
4648        {
4649          p=pOne();
4650          pSetCoeff(p,n);
4651        }
4652        else
4653        {
4654          p=NULL;
4655          nDelete(&n);
4656        }
4657        break;
4658      }
4659      case NUMBER_CMD:
4660      {
4661        number n=(number)h->CopyD(NUMBER_CMD);
4662        if (!nIsZero(n))
4663        {
4664          p=pOne();
4665          pSetCoeff(p,n);
4666        }
4667        else
4668        {
4669          p=NULL;
4670          nDelete(&n);
4671        }
4672        break;
4673      }
4674      case VECTOR_CMD:
4675      {
4676        p=(poly)h->CopyD(VECTOR_CMD);
4677        if (iiOp!=MODUL_CMD)
4678        {
4679          idDelete(&id);
4680          pDelete(&p);
4681          return TRUE;
4682        }
4683        rank=max(rank,pMaxComp(p));
4684        break;
4685      }
4686      default:
4687      {
4688        idDelete(&id);
4689        return TRUE;
4690      }
4691    }
4692    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4693    {
4694      pSetCompP(p,1);
4695    }
4696    id->m[i]=p;
4697    i++;
4698    h=h->next;
4699  }
4700  id->rank=rank;
4701  res->data=(char *)id;
4702  return FALSE;
4703}
4704static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4705{
4706  leftv h=v;
4707  int l=v->listLength();
4708  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
4709  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
4710  int t=0;
4711  // try to convert to IDEAL_CMD
4712  while (h!=NULL)
4713  {
4714    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4715    {
4716      t=IDEAL_CMD;
4717    }
4718    else break;
4719    h=h->next;
4720  }
4721  // if failure, try MODUL_CMD
4722  if (t==0)
4723  {
4724    h=v;
4725    while (h!=NULL)
4726    {
4727      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4728      {
4729        t=MODUL_CMD;
4730      }
4731      else break;
4732      h=h->next;
4733    }
4734  }
4735  // check for success  in converting
4736  if (t==0)
4737  {
4738    WerrorS("cannot convert to ideal or module");
4739    return TRUE;
4740  }
4741  // call idMultSect
4742  h=v;
4743  int i=0;
4744  sleftv tmp;
4745  while (h!=NULL)
4746  {
4747    if (h->Typ()==t)
4748    {
4749      r[i]=(ideal)h->Data(); /*no copy*/
4750      h=h->next;
4751    }
4752    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4753    {
4754      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
4755      omFreeSize((ADDRESS)r,l*sizeof(ideal));
4756      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4757      return TRUE;
4758    }
4759    else
4760    {
4761      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
4762      copied[i]=TRUE;
4763      h=tmp.next;
4764    }
4765    i++;
4766  }
4767  res->rtyp=t;
4768  res->data=(char *)idMultSect(r,i);
4769  while(i>0)
4770  {
4771    i--;
4772    if (copied[i]) idDelete(&(r[i]));
4773  }
4774  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
4775  omFreeSize((ADDRESS)r,l*sizeof(ideal));
4776  return FALSE;
4777}
4778static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4779{
4780  int i=0;
4781  leftv h=v;
4782  if (h!=NULL) i=exprlist_length(h);
4783  intvec *iv=new intvec(i);
4784  i=0;
4785  while (h!=NULL)
4786  {
4787    if(h->Typ()==INT_CMD)
4788    {
4789      (*iv)[i]=(int)h->Data();
4790    }
4791    else
4792    {
4793      delete iv;
4794      return TRUE;
4795    }
4796    i++;
4797    h=h->next;
4798  }
4799  res->data=(char *)iv;
4800  return FALSE;
4801}
4802static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4803{
4804  if ((yyInRingConstruction)
4805  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
4806  {
4807    memcpy(res,u,sizeof(sleftv));
4808    memset(u,0,sizeof(sleftv));
4809    return FALSE;
4810  }
4811  leftv v=u->next;
4812  BOOLEAN b;
4813  if(v==NULL)
4814    b=iiExprArith1(res,u,iiOp);
4815  else
4816  {
4817    u->next=NULL;
4818    b=iiExprArith2(res,u,iiOp,v);
4819    u->next=v;
4820  }
4821  return b;
4822}
4823static BOOLEAN jjLIST_PL(leftv res, leftv v)
4824{
4825  int sl=0;
4826  if (v!=NULL) sl = v->listLength();
4827  lists L;
4828  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4829  {
4830    L=syConvRes((syStrategy)v->Data());
4831  }
4832  else
4833  {
4834    L=(lists)omAllocBin(slists_bin);
4835    leftv h=NULL;
4836    int i;
4837    int rt;
4838
4839    L->Init(sl);
4840    for (i=0;i<sl;i++)
4841    {
4842      if (h!=NULL) { /* e.g. not in the first step:
4843                     * h is the pointer to the old sleftv,
4844                     * v is the pointer to the next sleftv
4845                     * (in this moment) */
4846                     h->next=v;
4847                   }
4848      h=v;
4849      v=v->next;
4850      h->next=NULL;
4851      rt=h->Typ();
4852      if (rt==0)
4853      {
4854        L->Clean();
4855        Werror("`%s` is undefined",h->Fullname());
4856        return TRUE;
4857      }
4858      if ((rt==RING_CMD)||(rt==QRING_CMD))
4859      {
4860        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
4861        ((ring)L->m[i].data)->ref++;
4862      }
4863      else
4864        L->m[i].Copy(h);
4865    }
4866  }
4867  res->data=(char *)L;
4868  return FALSE;
4869}
4870static BOOLEAN jjNAMES0(leftv res, leftv v)
4871{
4872  res->data=(void *)ipNameList(IDROOT);
4873  return FALSE;
4874}
4875static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4876{
4877  if(v==NULL)
4878  {
4879    res->data=(char *)showOption();
4880    return FALSE;
4881  }
4882  res->rtyp=NONE;
4883  return setOption(res,v);
4884}
4885static BOOLEAN jjREDUCE4(leftv res, leftv v)
4886{
4887  // poly, ideal, deg, weights
4888  leftv u1=v;
4889  leftv u2=v->next;
4890  leftv u3=u2->next; u2->next=NULL;
4891  leftv u4=u3->next;
4892  if ((u3->Typ()!=INT_CMD)||(u4->Typ()!=INTVEC_CMD))
4893  {
4894    Werror("%s(`poly`,`ideal`,`int`,`intvec`) exppected",Tok2Cmdname(iiOp));
4895    return TRUE;
4896  }
4897  int save_d=Kstd1_deg;
4898  Kstd1_deg=(int)u3->Data();
4899  kModW=(intvec *)u4->Data();
4900  BITSET save=verbose;
4901  verbose|=Sy_bit(V_DEG_STOP);
4902  BOOLEAN r=jjCALL2ARG(res,v);
4903  kModW=NULL;
4904  Kstd1_deg=save_d;
4905  verbose=save;
4906  v->next->next=u3;
4907  return r;
4908}
4909static BOOLEAN jjRESERVED0(leftv res, leftv v)
4910{
4911  int i=1;
4912  loop
4913  {
4914    Print("%-20s",cmds[i].name);
4915    i++;
4916    if(cmds[i].name==NULL)
4917      break;
4918    if ((i%3)==1) PrintLn();
4919  }
4920  PrintLn();
4921  return FALSE;
4922}
4923static BOOLEAN jjSTRING_PL(leftv res, leftv v)
4924{
4925  if (v == NULL)
4926  {
4927    res->data = omStrDup("");
4928    return FALSE;
4929  }
4930  int n = v->listLength();
4931  if (n == 1)
4932  {
4933    res->data = v->String();
4934    return FALSE;
4935  }
4936
4937  char** slist = (char**) omAlloc(n*sizeof(char*));
4938  int i, j;
4939
4940  for (i=0, j=0; i<n; i++, v = v ->next)
4941  {
4942    slist[i] = v->String();
4943    assume(slist[i] != NULL);
4944    j+=strlen(slist[i]);
4945  }
4946  char* s = (char*) omAlloc((j+1)*sizeof(char));
4947  *s='\0';
4948  for (i=0;i<n;i++)
4949  {
4950    strcat(s, slist[i]);
4951    omFree(slist[i]);
4952  }
4953  omFreeSize(slist, n*sizeof(char*));
4954  res->data = s;
4955  return FALSE;
4956}
4957static BOOLEAN jjTEST(leftv res, leftv v)
4958{
4959  do
4960  {
4961    if (v->Typ()!=INT_CMD)
4962      return TRUE;
4963    test_cmd((int)v->Data());
4964    v=v->next;
4965  }
4966  while (v!=NULL);
4967  return FALSE;
4968}
4969
4970#ifndef __MWERKS__
4971static BOOLEAN jjSTATUS_M(leftv res, leftv v)
4972{
4973  if ((v->Typ() != LINK_CMD) ||
4974      (v->next->Typ() != STRING_CMD) ||
4975      (v->next->next->Typ() != STRING_CMD) ||
4976      (v->next->next->next->Typ() != INT_CMD))
4977    return TRUE;
4978  jjSTATUS3(res, v, v->next, v->next->next);
4979#if defined(HAVE_USLEEP)
4980  if (((int) res->data) == 0)
4981  {
4982    int i_s = (int) v->next->next->next->Data();
4983    if (i_s > 0)
4984    {
4985      usleep((int) v->next->next->next->Data());
4986      jjSTATUS3(res, v, v->next, v->next->next);
4987    }
4988  }
4989#elif defined(HAVE_SLEEP)
4990  if (((int) res->data) == 0)
4991  {
4992    int i_s = (int) v->next->next->next->Data();
4993    if (i_s > 0)
4994    {
4995      sleep((is - 1)/1000000 + 1);
4996      jjSTATUS3(res, v, v->next, v->next->next);
4997    }
4998  }
4999#endif
5000  return FALSE;
5001}
5002#endif
5003static BOOLEAN jjSUBST_M(leftv res, leftv u)
5004{
5005  leftv v = u->next; // number of args > 0
5006  if (v==NULL) return TRUE;
5007  leftv w = v->next;
5008  if (w==NULL) return TRUE;
5009  leftv rest = w->next;;
5010
5011  u->next = NULL;
5012  v->next = NULL;
5013  w->next = NULL;
5014  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5015  if ((rest!=NULL) && (!b))
5016  {
5017    sleftv tmp_res;
5018    leftv tmp_next=res->next;
5019    res->next=rest;
5020    memset(&tmp_res,0,sizeof(tmp_res));
5021    b = iiExprArithM(&tmp_res,res,iiOp);
5022    memcpy(res,&tmp_res,sizeof(tmp_res));
5023    res->next=tmp_next;
5024  }
5025  u->next = v;
5026  v->next = w;
5027  // rest was w->next, but is already cleaned
5028  return b;
5029}
5030
5031#ifdef HAVE_NAMESPACES
5032static BOOLEAN jjIMPORTFROM(leftv res, leftv v);
5033
5034static BOOLEAN jjEXPORTTO(leftv res, leftv v)
5035{
5036  BOOLEAN nok=TRUE;
5037  leftv u=v;
5038  if(u->rtyp==NSHDL)
5039  {
5040    namehdl ns = (namehdl)(u->data);
5041    idhdl h = namespaceroot->root->get(ns->name, 0, TRUE);
5042    //Print("Export to '%s', lev %d\n", ns->name, ns->myynest);
5043    while(v->next!=NULL)
5044    {
5045      nok = iiInternalExport(v->next, ns->myynest, h);
5046      if(nok) { return nok; }
5047
5048      v = v->next;
5049    }
5050    return FALSE;
5051  }
5052  if(u->Typ()==PACKAGE_CMD)
5053  {
5054    //PrintS("export to package\n");
5055    while(v->next!=NULL)
5056    {
5057      nok = iiInternalExport(v->next, 0, u->data);
5058      if(nok) return nok;
5059      v = v->next;
5060    }
5061    return FALSE;
5062  }
5063  return TRUE;
5064}
5065#endif /* HAVE_NAMESPACES */
5066#ifdef HAVE_NAMESPACES
5067static BOOLEAN jjIMPORTFROM(leftv res, leftv v)
5068{
5069  BOOLEAN nok=FALSE;
5070  PrintS("jjIMPORT_FROM()\n");
5071  if(v->rtyp==NSHDL)
5072  {
5073    PrintS("Import from toplevel\n");
5074//While-schleife!!!
5075    return FALSE;
5076  }
5077  if(v->Typ()==PACKAGE_CMD)
5078  {
5079    Print("Import from package %s\n", v->name);
5080    while(v->next!=NULL)
5081    {
5082      //nok = iiInternalImport(v->next, 0, v->data);
5083      if(nok) return nok;
5084      v = v->next;
5085    }
5086    return FALSE;
5087  }
5088  return TRUE;
5089}
5090#endif
5091#ifdef HAVE_NAMESPACES
5092static BOOLEAN jjUNLOAD(leftv res, leftv v)
5093{
5094  if(v->Typ()==PACKAGE_CMD)
5095  {
5096    char *typ;
5097    idhdl h = (idhdl)v->data;
5098    package d=(package)v->Data();
5099    switch (d->language)
5100    {
5101      case LANG_C:
5102        typ="object";
5103        break;
5104      case LANG_SINGULAR:
5105      case LANG_NONE:
5106      default:
5107        killhdl(h);
5108    }
5109    return FALSE;
5110  }
5111  return TRUE;
5112}
5113#endif
5114/*=================== operations with many arg.: table =================*/
5115/* number_of_args:  -1: any, -2: any >0, .. */
5116struct sValCmdM dArithM[]=
5117{
5118// operations:
5119// proc         cmd               res            number_of_args
5120 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2  }
5121,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0  }
5122,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2  }
5123,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2  }
5124,{jjCOEF_M,    COEF_CMD,        NONE,               4  }
5125,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2 }
5126,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1  }
5127,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1 }
5128,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2  }
5129,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2 }
5130,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1  }
5131,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2 }
5132,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1 }
5133,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1  }
5134,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1 }
5135,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1 }
5136,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0 }
5137,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 }
5138,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          2  }
5139,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          3  }
5140,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          4  }
5141,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1 }
5142,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0 }
5143,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1 }
5144,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3 }
5145,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2 }
5146,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2 }
5147,{jjTEST,      TEST_CMD,        NONE,               -2 }
5148,{iiWRITE,     WRITE_CMD,       NONE,               -2 }
5149,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2 }
5150,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3 }
5151#ifndef __MWERKS__
5152,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4 }
5153#endif
5154#ifdef HAVE_NAMESPACES
5155,{jjIMPORTFROM,IMPORTFROM_CMD,  ANY_TYPE,           -2 }
5156,{jjEXPORTTO,  EXPORTTO_CMD,    NONE,               -2 }
5157,{jjUNLOAD,    UNLOAD_CMD,      NONE,               -2 }
5158#endif /* HAVE_NAMESPACES */
5159,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6 }
5160,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4 }
5161,{NULL,        0,               0,                   0 }
5162};
5163#ifdef MDEBUG
5164static Subexpr jjDBMakeSub(leftv e,char *f, int l)
5165#else
5166static Subexpr jjMakeSub(leftv e)
5167#endif
5168{
5169  assume( e->Typ()==INT_CMD );
5170  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
5171  r->start =(int)e->Data();
5172  return r;
5173}
5174
5175/*================ generating tables ============================*/
5176#ifdef GENTABLE
5177extern struct sValAssign dAssign[];
5178struct sValCmdTab dArithTab1[]={ {0,0}};
5179#define JJTAB1LEN 0
5180struct sValCmdTab dArithTab2[]={ {0,0}};
5181#define JJTAB2LEN 0
5182void ttGen1()
5183{
5184  FILE *outfile = myfopen("iparith.inc","w");
5185  int i,j,l1=0,l2=0;
5186  currRing=(ring)omAllocBin(sip_sring_bin);
5187  fprintf(outfile,
5188  "/****************************************\n"
5189  "*  Computer Algebra System SINGULAR     *\n"
5190  "****************************************/\n\n");
5191/*-------------------------------------------------------------------*/
5192  fprintf(outfile,"// syntax table for Singular\n//\n");
5193  fprintf(outfile,"// - search for an exact match of the argument types\n");
5194  fprintf(outfile,"// - otherwise search for the first possibility\n");
5195  fprintf(outfile,"//   with converted types of the arguments\n");
5196  fprintf(outfile,"// - otherwise report an error\n//\n");
5197
5198  int op;
5199  i=0;
5200  while ((op=dArith1[i].cmd)!=0)
5201  {
5202    if (dArith1[i].p==jjWRONG)
5203      fprintf(outfile,"// DUMMY ");
5204    char *s = iiTwoOps(op);
5205    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
5206          s,
5207          Tok2Cmdname(dArith1[i].arg),
5208          Tok2Cmdname(ABS(dArith1[i].res)));
5209    i++;
5210  }
5211  fprintf(outfile,"/*---------------------------------------------*/\n");
5212  i=0;
5213  while ((op=dArith2[i].cmd)!=0)
5214  {
5215    if (dArith2[i].p==jjWRONG2)
5216      fprintf(outfile,"// DUMMY ");
5217    char *s = iiTwoOps(op);
5218    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
5219          s,
5220          Tok2Cmdname(dArith2[i].arg1),
5221          Tok2Cmdname(dArith2[i].arg2),
5222          Tok2Cmdname(dArith2[i].res));
5223    i++;
5224  }
5225  fprintf(outfile,"/*---------------------------------------------*/\n");
5226  i=0;
5227  while ((op=dArith3[i].cmd)!=0)
5228  {
5229    char *s = iiTwoOps(op);
5230    if (dArith3[i].p==jjWRONG3)
5231      fprintf(outfile,"// DUMMY ");
5232    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
5233          s,
5234          Tok2Cmdname(dArith3[i].arg1),
5235          Tok2Cmdname(dArith3[i].arg2),
5236          Tok2Cmdname(dArith3[i].arg3),
5237          Tok2Cmdname(dArith3[i].res));
5238    i++;
5239  }
5240  fprintf(outfile,"/*---------------------------------------------*/\n");
5241  i=0;
5242  while ((op=dArithM[i].cmd)!=0)
5243  {
5244    char *s = iiTwoOps(op);
5245    fprintf(outfile,"// operation: %s (...)  ->  %s",
5246          s,
5247          Tok2Cmdname(dArithM[i].res));
5248    switch(dArithM[i].number_of_args)
5249    {
5250      case -2:
5251         fprintf(outfile," ( number of arguments >0 )\n");
5252         break;
5253      case -1:
5254         fprintf(outfile," ( any number of arguments )\n");
5255         break;
5256      default:
5257         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
5258         break;
5259    }
5260    i++;
5261  }
5262  fprintf(outfile,"/*---------------------------------------------*/\n");
5263  i=0;
5264  while ((op=dAssign[i].res)!=0)
5265  {
5266    fprintf(outfile,"// assign: %s =  %s\n",
5267          Tok2Cmdname(op/*dAssign[i].res*/),
5268          Tok2Cmdname(dAssign[i].arg));
5269    i++;
5270  }
5271/*-------------------------------------------------------------------*/
5272  fprintf(outfile,"/*---------------------------------------------*/\n");
5273  for (j=257;j<=MAX_TOK+1;j++)
5274  {
5275    for(i=257;i<=MAX_TOK+1;i++)
5276    {
5277      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
5278      && iiTestConvert(i,j))
5279      {
5280        fprintf(outfile,"// convert %s -> %s\n",
5281          Tok2Cmdname(i), Tok2Cmdname(j));
5282        if (j==ANY_TYPE) break;
5283      }
5284    }
5285  }
5286  fprintf(outfile,"/*---------------------------------------------*/\n");
5287  char ops[]="=><+*/[.^,%(;";
5288  for(i=0;ops[i]!='\0';i++)
5289    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
5290  for (i=257;i<=MAX_TOK;i++)
5291  {
5292    char *s=iiTwoOps(i);
5293    if (s[0]!='$')
5294    {
5295      fprintf(outfile,"// token %d : %s\n", i, s);
5296    }
5297  }
5298/*-------------------------------------------------------------------*/
5299  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
5300/*-------------------------------------------------------------------*/
5301  fprintf(outfile,"/*---------------------------------------------*/\n");
5302  fprintf(outfile,
5303  "struct sValCmdTab dArithTab1[]=\n"
5304  "{\n");
5305  for (j=1;j<=MAX_TOK+1;j++)
5306  {
5307    for(i=0;dArith1[i].cmd!=0;i++)
5308    {
5309      if (dArith1[i].cmd==j)
5310      {
5311        fprintf(outfile," { %d,%d },\n",j,i);
5312        l1++;
5313        break;
5314      }
5315    }
5316  }
5317  fprintf(outfile," { 10000,0 }\n};\n");
5318  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
5319/*-------------------------------------------------------------------*/
5320  fprintf(outfile,
5321  "struct sValCmdTab dArithTab2[]=\n"
5322  "{\n");
5323  for (j=1;j<=MAX_TOK+1;j++)
5324  {
5325    for(i=0;dArith2[i].cmd!=0;i++)
5326    {
5327      if (dArith2[i].cmd==j)
5328      {
5329        fprintf(outfile," { %d,%d },\n",j,i);
5330        l2++;
5331        break;
5332      }
5333    }
5334  }
5335  fprintf(outfile," { 10000,0 }\n};\n");
5336  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
5337  fclose(outfile);
5338}
5339/*-------------------------------------------------------------------*/
5340void ttGen2()
5341{
5342  FILE *outfile = myfopen("iparith.inc","a");
5343  fprintf(outfile,
5344  "/****************************************\n"
5345  "*  Computer Algebra System SINGULAR     *\n"
5346  "****************************************/\n\n");
5347/*-------------------------------------------------------------------*/
5348  fprintf(outfile,"// identifier table for Singular\n//\n");
5349
5350  fprintf(outfile,
5351  "cmdnames cmds[] =\n"
5352  "{  // name-string     alias  tokval toktype\n"
5353  "{ \"$INVALID$\",            0,  -1, 0},\n");
5354  int i=1;
5355  int m=-1;
5356  int id_nr=0;
5357  BOOLEAN f=FALSE;
5358  loop
5359  {
5360    while (cmds[i].tokval!=0)
5361    {
5362      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
5363      {
5364        if(m==-1)
5365        {
5366          m=i;
5367          f=TRUE;
5368        }
5369        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5370        {
5371          m=i;
5372          f=TRUE;
5373        }
5374      }
5375      i++;
5376    }
5377    if(f)
5378    {
5379      id_nr++;
5380      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
5381      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
5382                                             20-strlen(cmds[m].name),
5383                                             cmds[m].alias,
5384                                             cmds[m].tokval);
5385      switch(cmds[m].toktype)
5386      {
5387        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
5388        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
5389        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
5390        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
5391        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
5392        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
5393        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
5394        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
5395        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
5396        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
5397        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
5398        case NONE:             fprintf(outfile,"NONE },\n"); break;
5399        default:               if((cmds[m].toktype>' ')
5400                               &&(cmds[m].toktype<127))
5401                               {
5402                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
5403                               }
5404                               else
5405                               {
5406                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
5407                               }
5408                               break;
5409      }
5410      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
5411      cmds[m].name=NULL;
5412      m=-1;
5413      i=1;
5414      f=FALSE;
5415    }
5416    else break;
5417  }
5418  fprintf(outfile,
5419"/* list of scanner identifiers/only for feread/reservedName */\n");
5420  f=FALSE;
5421  i=1;m=-1;
5422  loop
5423  {
5424    while (cmds[i].tokval!=0)
5425    {
5426      if (cmds[i].name!=NULL)
5427      {
5428        if(m==-1)
5429        {
5430          m=i;
5431          f=TRUE;
5432        }
5433        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5434        {
5435          m=i;
5436          f=TRUE;
5437        }
5438      }
5439      i++;
5440    }
5441    if(f)
5442    {
5443      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
5444                                             20-strlen(cmds[m].name),
5445                                             0/*cmds[m].alias*/
5446                                             /*-1 cmds[m].tokval*/
5447                                             /*0 cmds[m].toktype*/);
5448      cmds[m].name=NULL;
5449      m=-1;
5450      i=1;
5451      f=FALSE;
5452    }
5453    else break;
5454  }
5455  fprintf(outfile,
5456"/* end of list marker */\n"
5457"  { NULL, 0, 0, 0}\n"
5458"};\n"
5459"#ifdef HAVE_RTIMER\n"
5460"#define LAST_IDENTIFIER %d\n"
5461"#else\n"
5462"#define LAST_IDENTIFIER %d\n"
5463"#endif\n",id_nr,id_nr-1);
5464  fclose(outfile);
5465}
5466/*-------------------------------------------------------------------*/
5467#if 0
5468void ttGen3()
5469{
5470  FILE *outfile = myfopen("mpsr_tok.inc","w");
5471  fprintf(outfile,
5472  "/****************************************\n"
5473  "*  Computer Algebra System SINGULAR     *\n"
5474  "****************************************/\n\n");
5475/*-------------------------------------------------------------------*/
5476  fprintf(outfile,"// token table for Singular\n//\n");
5477
5478  fprintf(outfile,
5479  "short vtok[] =\n"
5480  "{\n");
5481  // operations with 1 arg: ===========================================
5482  int i=0;
5483  while (dArith1[i].cmd!=0)
5484  {
5485    if ((dArith1[i].p!=jjWRONG)
5486    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
5487    {
5488      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
5489    }
5490    i++;
5491  }
5492  // operations with 2 args: ===========================================
5493  i=0;
5494  while (dArith2[i].cmd!=0)
5495  {
5496    if ((dArith2[i].p!=jjWRONG2)
5497    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
5498    {
5499      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
5500    }
5501    i++;
5502  }
5503  // operations with 3 args: ===========================================
5504  i=0;
5505  while (dArith3[i].cmd!=0)
5506  {
5507    if (
5508    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
5509    {
5510      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
5511    }
5512    i++;
5513  }
5514  // operations with many args: ===========================================
5515  i=0;
5516  while (dArithM[i].cmd!=0)
5517  {
5518    if (
5519    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
5520    {
5521      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
5522    }
5523    i++;
5524  }
5525  // ====================================================================
5526  fprintf(outfile,
5527  "/* end of list marker */\n"
5528  " %d };\n",MAX_TOK);
5529  fclose(outfile);
5530}
5531#endif
5532/*-------------------------------------------------------------------*/
5533#else
5534#include "iparith.inc"
5535#endif
5536
5537/*=================== operations with 2 args. ============================*/
5538
5539BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
5540{
5541#ifndef GENTABLE
5542  memset(res,0,sizeof(sleftv));
5543
5544  if (!errorreported)
5545  {
5546#ifdef SIQ
5547    if (siq>0)
5548    {
5549      //Print("siq:%d\n",siq);
5550      command d=(command)omAlloc0Bin(ip_command_bin);
5551      memcpy(&d->arg1,a,sizeof(sleftv));
5552      memcpy(&d->arg2,b,sizeof(sleftv));
5553      d->argc=2;
5554      d->op=op;
5555      res->data=(char *)d;
5556      res->rtyp=COMMAND;
5557      return FALSE;
5558    }
5559#endif
5560    int at=a->Typ();
5561    int bt=b->Typ();
5562    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
5563    int index=i;
5564
5565    iiOp=op;
5566    while (dArith2[i].cmd==op)
5567    {
5568      if ((at==dArith2[i].arg1)
5569      && (bt==dArith2[i].arg2))
5570      {
5571        res->rtyp=dArith2[i].res;
5572        if (dArith2[i].p(res,a,b))
5573        {
5574          break;// leave loop, goto error handling
5575        }
5576        a->CleanUp();
5577        b->CleanUp();
5578        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5579        return FALSE;
5580      }
5581      i++;
5582    }
5583    // implicite type conversion ----------------------------------------------
5584    if (dArith2[i].cmd!=op)
5585    {
5586      int ai,bi;
5587      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
5588      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
5589      BOOLEAN failed=FALSE;
5590      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5591      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
5592      while (dArith2[i].cmd==op)
5593      {
5594        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5595        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
5596        {
5597          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
5598          {
5599            res->rtyp=dArith2[i].res;
5600            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
5601            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
5602            || (dArith2[i].p(res,an,bn)));
5603            // everything done, clean up temp. variables
5604            if (failed)
5605            {
5606              // leave loop, goto error handling
5607              break;
5608            }
5609            else
5610            {
5611              // everything ok, clean up and return
5612              an->CleanUp();
5613              bn->CleanUp();
5614              omFreeBin((ADDRESS)an, sleftv_bin);
5615              omFreeBin((ADDRESS)bn, sleftv_bin);
5616              a->CleanUp();
5617              b->CleanUp();
5618              return FALSE;
5619            }
5620          }
5621        }
5622        i++;
5623      }
5624      an->CleanUp();
5625      bn->CleanUp();
5626      omFreeBin((ADDRESS)an, sleftv_bin);
5627      omFreeBin((ADDRESS)bn, sleftv_bin);
5628    }
5629    // error handling ---------------------------------------------------
5630    const char *s=NULL;
5631    if (!errorreported)
5632    {
5633      if ((at==0) && (a->Fullname()!=sNoName))
5634      {
5635        s=a->Fullname();
5636      }
5637      else if ((bt==0) && (b->Fullname()!=sNoName))
5638      {
5639        s=b->Fullname();
5640      }
5641      if (s!=NULL)
5642        Werror("`%s` is not defined",s);
5643      else
5644      {
5645        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5646        s = iiTwoOps(op);
5647        if (proccall)
5648        {
5649          Werror("%s(`%s`,`%s`) is not supported"
5650                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
5651        }
5652        else
5653        {
5654          Werror("`%s` %s `%s` is not supported"
5655                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
5656        }
5657        if (BVERBOSE(V_SHOW_USE))
5658        {
5659          while (dArith2[i].cmd==op)
5660          {
5661            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
5662            && (dArith2[i].res!=0)
5663            && (dArith2[i].p!=jjWRONG2))
5664            {
5665              if (proccall)
5666                Werror("expected %s(`%s`,`%s`)"
5667                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5668              else
5669                Werror("expected `%s` %s `%s`"
5670                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
5671            }
5672            i++;
5673          }
5674        }
5675      }
5676    }
5677    res->rtyp = UNKNOWN;
5678  }
5679  a->CleanUp();
5680  b->CleanUp();
5681#endif
5682  return TRUE;
5683}
5684
5685/*==================== operations with 1 arg. ===============================*/
5686
5687BOOLEAN iiExprArith1(leftv res, leftv a, int op)
5688{
5689#ifndef GENTABLE
5690  memset(res,0,sizeof(sleftv));
5691
5692  if (!errorreported)
5693  {
5694#ifdef SIQ
5695    if (siq>0)
5696    {
5697      //Print("siq:%d\n",siq);
5698      command d=(command)omAlloc0Bin(ip_command_bin);
5699      memcpy(&d->arg1,a,sizeof(sleftv));
5700      d->op=op;
5701      d->argc=1;
5702      res->data=(char *)d;
5703      res->rtyp=COMMAND;
5704      return FALSE;
5705    }
5706#endif
5707    int at=a->Typ();
5708    BOOLEAN failed=FALSE;
5709
5710    iiOp=op;
5711    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
5712    int ti = i;
5713    while (dArith1[i].cmd==op)
5714    {
5715      if (at==dArith1[i].arg)
5716      {
5717        int r=res->rtyp=dArith1[i].res;
5718        if (r<0)
5719        {
5720          res->rtyp=-r;
5721          #ifdef PROC_BUG
5722          dArith1[i].p(res,a);
5723          #else
5724          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
5725          #endif
5726        }
5727        else if (dArith1[i].p(res,a))
5728        {
5729          break;// leave loop, goto error handling
5730        }
5731        if (a->Next()!=NULL)
5732        {
5733          res->next=(leftv)omAllocBin(sleftv_bin);
5734          failed=iiExprArith1(res->next,a->next,op);
5735        }
5736        a->CleanUp();
5737        return failed;
5738      }
5739      i++;
5740    }
5741    // implicite type conversion --------------------------------------------
5742    if (dArith1[i].cmd!=op)
5743    {
5744      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
5745      i=ti;
5746      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
5747      while (dArith1[i].cmd==op)
5748      {
5749        int ai;
5750        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
5751        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
5752        {
5753          int r=res->rtyp=dArith1[i].res;
5754          if (r<0)
5755          {
5756            res->rtyp=-r;
5757            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
5758            if (!failed)
5759            {
5760              #ifdef PROC_BUG
5761              dArith1[i].p(res,a);
5762              #else
5763              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
5764              #endif
5765            }
5766          }
5767          else
5768          {
5769            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
5770            || (dArith1[i].p(res,an)));
5771          }
5772          // everything done, clean up temp. variables
5773          if (failed)
5774          {
5775            // leave loop, goto error handling
5776            break;
5777          }
5778          else
5779          {
5780            if (an->Next() != NULL)
5781            {
5782              res->next = (leftv)omAllocBin(sleftv_bin);
5783              failed=iiExprArith1(res->next,an->next,op);
5784            }
5785            // everything ok, clean up and return
5786            an->CleanUp();
5787            omFreeBin((ADDRESS)an, sleftv_bin);
5788            a->CleanUp();
5789            return failed;
5790          }
5791        }
5792        i++;
5793      }
5794      an->CleanUp();
5795      omFreeBin((ADDRESS)an, sleftv_bin);
5796    }
5797    // error handling
5798    if (!errorreported)
5799    {
5800      if ((at==0) && (a->Fullname()!=sNoName))
5801      {
5802        Werror("`%s` is not defined",a->Fullname());
5803      }
5804      else
5805      {
5806        i=ti;
5807        char *s = iiTwoOps(op);
5808        Werror("%s(`%s`) is not supported"
5809                ,s,Tok2Cmdname(at));
5810        if (BVERBOSE(V_SHOW_USE))
5811        {
5812          while (dArith1[i].cmd==op)
5813          {
5814            if ((dArith1[i].res!=0)
5815            && (dArith1[i].p!=jjWRONG))
5816              Werror("expected %s(`%s`)"
5817                ,s,Tok2Cmdname(dArith1[i].arg));
5818            i++;
5819          }
5820        }
5821      }
5822    }
5823    res->rtyp = UNKNOWN;
5824  }
5825  a->CleanUp();
5826#endif
5827  return TRUE;
5828}
5829
5830/*=================== operations with 3 args. ============================*/
5831
5832BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
5833{
5834#ifndef GENTABLE
5835  memset(res,0,sizeof(sleftv));
5836
5837  if (!errorreported)
5838  {
5839#ifdef SIQ
5840    if (siq>0)
5841    {
5842      //Print("siq:%d\n",siq);
5843      command d=(command)omAlloc0Bin(ip_command_bin);
5844      memcpy(&d->arg1,a,sizeof(sleftv));
5845      memcpy(&d->arg2,b,sizeof(sleftv));
5846      memcpy(&d->arg3,c,sizeof(sleftv));
5847      d->op=op;
5848      d->argc=3;
5849      res->data=(char *)d;
5850      res->rtyp=COMMAND;
5851      return FALSE;
5852    }
5853#endif
5854    int at=a->Typ();
5855    int bt=b->Typ();
5856    int ct=c->Typ();
5857
5858    iiOp=op;
5859    int i=0;
5860    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5861    while (dArith3[i].cmd==op)
5862    {
5863      if ((at==dArith3[i].arg1)
5864      && (bt==dArith3[i].arg2)
5865      && (ct==dArith3[i].arg3))
5866      {
5867        res->rtyp=dArith3[i].res;
5868        if (dArith3[i].p(res,a,b,c))
5869        {
5870          break;// leave loop, goto error handling
5871        }
5872        a->CleanUp();
5873        b->CleanUp();
5874        c->CleanUp();
5875        return FALSE;
5876      }
5877      i++;
5878    }
5879    // implicite type conversion ----------------------------------------------
5880    if (dArith3[i].cmd!=op)
5881    {
5882      int ai,bi,ci;
5883      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
5884      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
5885      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
5886      BOOLEAN failed=FALSE;
5887      i=0;
5888      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5889      while (dArith3[i].cmd==op)
5890      {
5891        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
5892        {
5893          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
5894          {
5895            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
5896            {
5897              res->rtyp=dArith3[i].res;
5898              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
5899                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
5900                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
5901                || (dArith3[i].p(res,an,bn,cn)));
5902              // everything done, clean up temp. variables
5903              if (failed)
5904              {
5905                // leave loop, goto error handling
5906                break;
5907              }
5908              else
5909              {
5910                // everything ok, clean up and return
5911                an->CleanUp();
5912                bn->CleanUp();
5913                cn->CleanUp();
5914                omFreeBin((ADDRESS)an, sleftv_bin);
5915                omFreeBin((ADDRESS)bn, sleftv_bin);
5916                omFreeBin((ADDRESS)cn, sleftv_bin);
5917                a->CleanUp();
5918                b->CleanUp();
5919                c->CleanUp();
5920        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5921                return FALSE;
5922              }
5923            }
5924          }
5925        }
5926        i++;
5927      }
5928      an->CleanUp();
5929      bn->CleanUp();
5930      cn->CleanUp();
5931      omFreeBin((ADDRESS)an, sleftv_bin);
5932      omFreeBin((ADDRESS)bn, sleftv_bin);
5933      omFreeBin((ADDRESS)cn, sleftv_bin);
5934    }
5935    // error handling ---------------------------------------------------
5936    if (!errorreported)
5937    {
5938      const char *s=NULL;
5939      if ((at==0) && (a->Fullname()!=sNoName))
5940      {
5941        s=a->Fullname();
5942      }
5943      else if ((bt==0) && (b->Fullname()!=sNoName))
5944      {
5945        s=b->Fullname();
5946      }
5947      else if ((ct==0) && (c->Fullname()!=sNoName))
5948      {
5949        s=c->Fullname();
5950      }
5951      if (s!=NULL)
5952        Werror("`%s` is not defined",s);
5953      else
5954      {
5955        i=0;
5956        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5957        char *s = iiTwoOps(op);
5958        Werror("%s(`%s`,`%s`,`%s`) is not supported"
5959                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
5960        if (BVERBOSE(V_SHOW_USE))
5961        {
5962          while (dArith3[i].cmd==op)
5963          {
5964            if(((at==dArith3[i].arg1)
5965            ||(bt==dArith3[i].arg2)
5966            ||(ct==dArith3[i].arg3))
5967            && (dArith3[i].res!=0))
5968            {
5969              Werror("expected %s(`%s`,`%s`,`%s`)"
5970                  ,s,Tok2Cmdname(dArith3[i].arg1)
5971                  ,Tok2Cmdname(dArith3[i].arg2)
5972                  ,Tok2Cmdname(dArith3[i].arg3));
5973            }
5974            i++;
5975          }
5976        }
5977      }
5978    }
5979    res->rtyp = UNKNOWN;
5980  }
5981  a->CleanUp();
5982  b->CleanUp();
5983  c->CleanUp();
5984        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5985#endif
5986  return TRUE;
5987}
5988/*==================== operations with many arg. ===============================*/
5989
5990BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
5991{
5992  // cnt = 0: all
5993  // cnt = 1: only first one
5994  leftv next;
5995  BOOLEAN failed = TRUE;
5996  if(v==NULL) return failed;
5997  res->rtyp = LIST_CMD;
5998  if(cnt) v->next = NULL;
5999  next = v->next;             // saving next-pointer
6000  failed = jjLIST_PL(res, v);
6001  v->next = next;             // writeback next-pointer
6002  return failed;
6003}
6004
6005BOOLEAN iiExprArithM(leftv res, leftv a, int op)
6006{
6007#ifndef GENTABLE
6008  memset(res,0,sizeof(sleftv));
6009
6010  if (!errorreported)
6011  {
6012#ifdef SIQ
6013    if (siq>0)
6014    {
6015      //Print("siq:%d\n",siq);
6016      command d=(command)omAlloc0Bin(ip_command_bin);
6017      d->op=op;
6018      res->data=(char *)d;
6019      if (a!=NULL)
6020      {
6021        d->argc=a->listLength();
6022        // else : d->argc=0;
6023        memcpy(&d->arg1,a,sizeof(sleftv));
6024        switch(d->argc)
6025        {
6026          case 3:
6027            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
6028            a->next->next->rtyp=0;
6029            a->next->next->data=NULL;
6030            a->next->next->name=NULL;
6031            a->next->next->attribute=NULL;
6032          case 2:
6033            memcpy(&d->arg2,a->next,sizeof(sleftv));
6034            a->next->rtyp=0;
6035            a->next->name=NULL;
6036            a->next->data=NULL;
6037            a->next->attribute=NULL;
6038            d->arg2.next=NULL;
6039          case 1:
6040            d->arg1.next=NULL;
6041        }
6042        if (d->argc>3) a->next=NULL;
6043        a->rtyp=0;
6044        a->data=NULL;
6045        a->name=NULL;
6046        a->CleanUp();
6047      }
6048      res->rtyp=COMMAND;
6049      return FALSE;
6050    }
6051#endif
6052    BOOLEAN failed=FALSE;
6053    int args=0;
6054    if (a!=NULL) args=a->listLength();
6055
6056    iiOp=op;
6057    int i=0;
6058    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
6059    int ii=i;
6060    while (dArithM[i].cmd==op)
6061    {
6062      if ((args==dArithM[i].number_of_args)
6063      || (dArithM[i].number_of_args==-1)
6064      || ((dArithM[i].number_of_args==-2)&&(args>0)))
6065      {
6066        res->rtyp=dArithM[i].res;
6067        if (dArithM[i].p(res,a))
6068        {
6069          break;// leave loop, goto error handling
6070        }
6071        if (a!=NULL) a->CleanUp();
6072        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6073        return failed;
6074      }
6075      i++;
6076    }
6077    // error handling
6078    if (!errorreported)
6079    {
6080      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
6081      {
6082        Werror("`%s` is not defined",a->Fullname());
6083      }
6084      else
6085      {
6086        char *s = iiTwoOps(op);
6087        Werror("%s(...) is not supported",s);
6088      }
6089    }
6090    res->rtyp = UNKNOWN;
6091  }
6092  if (a!=NULL) a->CleanUp();
6093        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6094#endif
6095  return TRUE;
6096}
6097
6098/*=================== general utilities ============================*/
6099int IsCmd(char *n, int & tok)
6100{
6101  int an=1;
6102  int i,v;
6103#ifndef GENTABLE
6104  int en=LAST_IDENTIFIER;
6105
6106  loop
6107  {
6108    if(an>=en-1)
6109    {
6110      if (strcmp(n, cmds[an].name) == 0)
6111      {
6112        i=an;
6113        break;
6114      }
6115      else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
6116      {
6117        i=en;
6118        break;
6119      }
6120      else
6121      {
6122        return 0;
6123      }
6124    }
6125    i=(an+en)/2;
6126    if (*n < *(cmds[i].name))
6127    {
6128      en=i-1;
6129    }
6130    else if (*n > *(cmds[i].name))
6131    {
6132      an=i+1;
6133    }
6134    else
6135    {
6136      v=strcmp(n,cmds[i].name);
6137      if(v<0)
6138      {
6139        en=i-1;
6140      }
6141      else if(v>0)
6142      {
6143        an=i+1;
6144      }
6145      else /*v==0*/
6146      {
6147        break;
6148      }
6149    }
6150  }
6151  lastreserved=cmds[i].name;
6152  tok=cmds[i].tokval;
6153  if(cmds[i].alias==2)
6154  {
6155    Warn("outdated identifier `%s` used - please change your code",
6156    cmds[i].name);
6157    cmds[i].alias=1;
6158  }
6159  if (currRingHdl==NULL)
6160  {
6161    #ifdef SIQ
6162    if (siq<=0)
6163    {
6164    #endif
6165      if ((tok>=BEGIN_RING) && (tok<=END_RING))
6166      {
6167        WerrorS("no ring active");
6168        return 0;
6169      }
6170    #ifdef SIQ
6171    }
6172    #endif
6173  }
6174  if (!expected_parms)
6175  {
6176    switch (tok)
6177    {
6178      case IDEAL_CMD:
6179      case INT_CMD:
6180      case INTVEC_CMD:
6181      case MAP_CMD:
6182      case MATRIX_CMD:
6183      case MODUL_CMD:
6184      case POLY_CMD:
6185      case PROC_CMD:
6186      case RING_CMD:
6187      case STRING_CMD:
6188        cmdtok = tok;
6189        break;
6190    }
6191  }
6192#endif
6193  return cmds[i].toktype;
6194}
6195static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
6196{
6197#ifndef GENTABLE
6198  int a=0;
6199  int e=len;
6200  int p=len/2;
6201  do
6202  {
6203     if (op==dArithTab[p].cmd) return dArithTab[p].start;
6204     if (op<dArithTab[p].cmd) e=p-1;
6205     else   a = p+1;
6206     p=a+(e-a)/2;
6207  }
6208  while ( a <= e);
6209
6210#endif
6211  assume(0);
6212  return 0;
6213}
6214
Note: See TracBrowser for help on using the repository browser.