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

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