source: git/Singular/iparith.cc @ 9d72fe

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