source: git/Singular/iparith.cc @ 0936ad

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