source: git/Singular/iparith.cc @ f2dff02

spielwiese
Last change on this file since f2dff02 was f2dff02, checked in by Hans Schönemann <hannes@…>, 23 years ago
*hannes: CleanUp does a memset git-svn-id: file:///usr/local/Singular/svn/trunk@5342 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 182.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.261 2001-03-26 19:30:20 Singular Exp $ */
5
6/*
7* ABSTRACT: table driven kernel interface, used by interpreter
8*/
9
10#include <stdlib.h>
11#include <string.h>
12#include <ctype.h>
13#include <stdio.h>
14#include <time.h>
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "omalloc.h"
22#include "polys.h"
23#include "febase.h"
24#include "sdb.h"
25#include "longalg.h"
26#include "ideals.h"
27#include "matpol.h"
28#include "kstd1.h"
29#include "timer.h"
30#include "ring.h"
31#include "subexpr.h"
32#include "lists.h"
33#include "longalg.h"
34#include "numbers.h"
35#include "stairc.h"
36#include "maps.h"
37#include "syz.h"
38#include "weight.h"
39#include "ipconv.h"
40#include "ipprint.h"
41#include "sing_dld.h"
42#include "attrib.h"
43#include "silink.h"
44#include "sparsmat.h"
45#include "algmap.h"
46#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_M},
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  // 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  // 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  if (!pIsUnit((poly)v->Data()))
4164  {
4165    WerrorS("2nd argument must be a unit");
4166    return TRUE;
4167  }
4168  res->data = (char *)pSeries((int)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
4169  return FALSE;
4170}
4171static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4172{
4173  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
4174                             (intvec *)w->Data());
4175  return FALSE;
4176}
4177static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
4178{
4179  if (!mpIsDiagUnit((matrix)v->Data()))
4180  {
4181    WerrorS("2nd argument must be a diagonal matrix of units");
4182    return TRUE;
4183  }
4184  res->data = (char *)idSeries((int)w->Data(),(ideal)u->CopyD(),
4185                               (matrix)v->CopyD());
4186  return FALSE;
4187}
4188static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4189{
4190  assumeStdFlag(w);
4191  res->data = (char *)idMinors(
4192                        (matrix)u->Data(),(int)v->Data(),(ideal)w->Data());
4193  return FALSE;
4194}
4195static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4196{
4197  idhdl h;
4198  ring rr;
4199  map mapping;
4200
4201  if ((v->name==NULL) || (w->name==NULL))
4202  {
4203    WerrorS("2nd/3rd arguments must have names");
4204    return TRUE;
4205  }
4206  rr=(ring)u->Data();
4207  const char *ring_name=u->Name();
4208  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4209  {
4210    if (h->typ==MAP_CMD)
4211    {
4212      mapping=IDMAP(h);
4213      idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4214      if ((preim_ring==NULL)
4215      || (IDRING(preim_ring)!=currRing))
4216      {
4217        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4218        return TRUE;
4219      }
4220    }
4221    else if (h->typ==IDEAL_CMD)
4222    {
4223      mapping=IDMAP(h);
4224    }
4225    else
4226    {
4227      Werror("`%s` is no map nor ideal",IDID(h));
4228      return TRUE;
4229    }
4230  }
4231  else
4232  {
4233    Werror("`%s` is not defined in `%s`",v->name,ring_name);
4234    return TRUE;
4235  }
4236  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4237  {
4238    if (h->typ==IDEAL_CMD)
4239    {
4240      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4241    }
4242    else
4243    {
4244      Werror("`%s` is no ideal",IDID(h));
4245      return TRUE;
4246    }
4247  }
4248  else
4249  {
4250    Werror("`%s` is not defined in `%s`",w->name,ring_name);
4251    return TRUE;
4252  }
4253  return FALSE;
4254}
4255static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4256{
4257  int di, k;
4258  int i=(int)u->Data();
4259  int r=(int)v->Data();
4260  int c=(int)w->Data();
4261  intvec *iv = new intvec(r, c, 0);
4262  if (iv->rows()==0)
4263  {
4264    delete iv;
4265    return TRUE;
4266  }
4267  if (i!=0)
4268  {
4269    if (i<0) i = -i;
4270    di = 2 * i + 1;
4271    for (k=0; k<iv->length(); k++)
4272    {
4273#ifdef buildin_rand
4274      (*iv)[k] = ((siRand() % di) - i);
4275#else
4276      (*iv)[k] = ((rand() % di) - i);
4277#endif
4278    }
4279  }
4280  res->data = (char *)iv;
4281  return FALSE;
4282}
4283static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4284  int &ringvar, poly &monomexpr)
4285{
4286  monomexpr=(poly)w->Data();
4287  if (pLength(monomexpr)>1)
4288  {
4289    Werror("`%s` substitutes a ringvar only by a term",
4290      Tok2Cmdname(SUBST_CMD));
4291    return TRUE;
4292  }
4293  if (!(ringvar=pVar((poly)v->Data())))
4294  {
4295    WerrorS("ringvar expected");
4296    return TRUE;
4297  }
4298  return FALSE;
4299}
4300static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4301{
4302  int ringvar;
4303  poly monomexpr;
4304  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4305  if (nok) return TRUE;
4306  res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4307  return FALSE;
4308}
4309static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4310{
4311  int ringvar;
4312  poly monomexpr;
4313  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4314  if (nok) return TRUE;
4315  res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4316  return FALSE;
4317}
4318// we do not want to have jjSUBST_Id_X inlined:
4319static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4320                            int input_type);
4321static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4322{
4323  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4324}
4325static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4326{
4327  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4328}
4329static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4330{
4331  sleftv tmp;
4332  memset(&tmp,0,sizeof(tmp));
4333  // do not check the result, conversion from int/number to poly works always
4334  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4335  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4336  tmp.CleanUp();
4337  return b;
4338}
4339static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4340{
4341  matrix m=mpNew((int)v->Data(),(int)w->Data());
4342  ideal I=(ideal)u->CopyD(IDEAL_CMD);
4343  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4344  //for(i=i-1;i>=0;i--)
4345  //{
4346  //  m->m[i]=I->m[i];
4347  //  I->m[i]=NULL;
4348  //}
4349  memcpy4(m->m,I->m,i*sizeof(poly));
4350  memset(I->m,0,i*sizeof(poly));
4351  idDelete(&I);
4352  res->data = (char *)m;
4353  return FALSE;
4354}
4355static BOOLEAN jjSUBST_Par_N(leftv res, leftv u, leftv v,leftv w)
4356{
4357  // u: to change poly
4358  // v: number (parameter)
4359  // w: image of u (number)
4360  int i;
4361  lnumber a=(lnumber)v->Data();
4362  if (naParDeg((number)a)!=1)
4363  {
4364    WerrorS("first argument is not a parameter");
4365    return TRUE;
4366  }
4367  int r=rPar(currRing);
4368  ideal G=idMaxIdeal(1);
4369  ideal F=idInit(r,1);
4370  int par=-1;
4371  for(i=1;i<=r;i++)
4372  {
4373    if (napGetExp(a->z,i)!=0) { par=i; break;}
4374  }
4375  for(i=0;i<r;i++)
4376  {
4377    if (i==par) F->m[i]=(poly)w->CopyD();
4378    else
4379    {
4380      F->m[i]=pOne();pSetCoeff( F->m[i],naPar(i+1));
4381    }
4382  }
4383  res->data=(poly)maAlgpolyMap(currRing,(poly)u->Data(),F,G);
4384  idDelete(&F);
4385  idDelete(&G);
4386  return FALSE;
4387}
4388static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4389{
4390  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4391           (int)v->Data(),(int)w->Data());
4392  return FALSE;
4393}
4394static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4395{
4396  matrix m=mpNew((int)v->Data(),(int)w->Data());
4397  matrix I=(matrix)u->CopyD(MATRIX_CMD);
4398  int r=min(MATROWS(I),(int)v->Data());
4399  int c=min(MATCOLS(I),(int)w->Data());
4400  int i,j;
4401  for(i=r;i>0;i--)
4402  {
4403    for(j=c;j>0;j--)
4404    {
4405      MATELEM(m,i,j)=MATELEM(I,i,j);
4406      MATELEM(I,i,j)=NULL;
4407    }
4408  }
4409  idDelete((ideal *)&I);
4410  res->data = (char *)m;
4411  return FALSE;
4412}
4413static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4414{
4415  if (w->rtyp!=IDHDL) return TRUE;
4416  BITSET save_test=test;
4417  int ul= IDELEMS((ideal)u->Data());
4418  int vl= IDELEMS((ideal)v->Data());
4419  ideal m
4420    = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
4421             FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
4422  res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4423  test=save_test;
4424  return FALSE;
4425}
4426static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
4427{
4428  assumeStdFlag(w);
4429  if (!idIsZeroDim((ideal)w->Data()))
4430  {
4431    Werror("`%s` must be 0-dimensional",v->Name());
4432    return TRUE;
4433  }
4434  res->data = (char *)redNF((ideal)w->CopyD(),(poly)u->CopyD(),
4435    (poly)v->CopyD());
4436  return FALSE;
4437}
4438static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
4439{
4440  assumeStdFlag(w);
4441  if (!idIsZeroDim((ideal)w->Data()))
4442  {
4443    Werror("`%s` must be 0-dimensional",v->Name());
4444    return TRUE;
4445  }
4446  res->data = (char *)redNF((ideal)w->CopyD(),(ideal)u->CopyD(),
4447    (matrix)v->CopyD());
4448  return FALSE;
4449}
4450static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4451{
4452  assumeStdFlag(v);
4453  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4454    0,(int)w->Data());
4455  return FALSE;
4456}
4457static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
4458{
4459  assumeStdFlag(v);
4460  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
4461    0,(int)w->Data());
4462  return FALSE;
4463}
4464#ifdef OLD_RES
4465static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
4466{
4467  int maxl=(int)v->Data();
4468  int l=0;
4469  resolvente r;
4470  intvec **weights=NULL;
4471  int wmaxl=maxl;
4472  maxl--;
4473  if ((maxl==-1) && (iiOp!=MRES_CMD))
4474    maxl = pVariables-1;
4475  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
4476  {
4477    intvec * iv=(intvec*)atGet(u,"isHomog");
4478    if (iv!=NULL)
4479    {
4480      weights = (intvec**)omAlloc0Bin(void_ptr_bin);
4481      weights[0] = ivCopy(iv);
4482      l=1;
4483    }
4484    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
4485  }
4486  else
4487    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
4488  if (r==NULL) return TRUE;
4489  int t3=u->Typ();
4490  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
4491  return FALSE;
4492  return TRUE;
4493}
4494#endif
4495static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
4496{
4497  res->data=(void *)rInit(u,v,w);
4498  return (res->data==NULL);
4499}
4500static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
4501{
4502  int yes;
4503  jjSTATUS2(res, u, v);
4504  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
4505  omFree((ADDRESS) res->data);
4506  res->data = (void *) yes;
4507  return FALSE;
4508}
4509static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
4510{
4511  ideal result;
4512  intvec *ww=(intvec *)atGet(u,"isHomog");
4513  tHomog hom=testHomog;
4514  if (ww!=NULL)
4515  {
4516    ww=ivCopy(ww);
4517    hom=isHomog;
4518  }
4519  result=kStd((ideal)(u->Data()),
4520              currQuotient,
4521              hom,
4522              &ww,                  // module weights
4523              (intvec *)v->Data(),  // hilbert series
4524              0,0,                  // syzComp, newIdeal
4525              (intvec *)w->Data()); // weights of vars
4526  idSkipZeroes(result);
4527  res->data = (char *)result;
4528  setFlag(res,FLAG_STD);
4529  if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
4530  return FALSE;
4531}
4532
4533/*=================== operations with 3 args.: table =================*/
4534struct sValCmd3 dArith3[]=
4535{
4536// operations:
4537// proc             cmd          res         arg1        arg2        arg3
4538 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD }
4539,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD }
4540,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD }
4541,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD }
4542,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
4543,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD }
4544,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD }
4545,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD }
4546,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
4547,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD }
4548,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD }
4549,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD }
4550,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD }
4551,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD }
4552,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD }
4553,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD }
4554,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD }
4555,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD }
4556,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
4557,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD }
4558,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
4559,{jjHILBERT3,       HILBERT_CMD,INTVEC_CMD, MODUL_CMD,  INT_CMD,    INTVEC_CMD }
4560,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4561//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4562,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD }
4563,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD }
4564,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD }
4565,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD }
4566,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
4567,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD }
4568,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD }
4569,{jjJET_P_P,        JET_CMD,    POLY_CMD,   POLY_CMD,   POLY_CMD,   INT_CMD }
4570,{jjJET_P_P,        JET_CMD,    VECTOR_CMD, VECTOR_CMD, POLY_CMD,   INT_CMD }
4571,{jjJET_ID_M,       JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD }
4572,{jjJET_ID_M,       JET_CMD,    MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, INT_CMD }
4573,{jjWRONG3,         JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INT_CMD }
4574,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD }
4575,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4576,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD }
4577,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD }
4578,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD }
4579,{jjMINOR3,         MINOR_CMD,  IDEAL_CMD,  MATRIX_CMD, INT_CMD,    IDEAL_CMD}
4580,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4581#ifdef OLD_RES
4582,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4583,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4584#endif
4585,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD }
4586,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD }
4587,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE }
4588,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE }
4589,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD }
4590,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD }
4591,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD }
4592,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD }
4593,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD }
4594,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD }
4595,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD }
4596,{jjREDUCE3_CP,     REDUCE_CMD, POLY_CMD,   POLY_CMD,   POLY_CMD,   IDEAL_CMD }
4597,{jjREDUCE3_CP,     REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD,   MODUL_CMD }
4598,{jjREDUCE3_CID,    REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  MATRIX_CMD, IDEAL_CMD }
4599,{jjREDUCE3_CID,    REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MATRIX_CMD, MODUL_CMD }
4600#ifdef OLD_RES
4601,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4602,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4603#endif
4604#ifdef HAVE_FACTORY
4605,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4606#else
4607,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4608#endif
4609,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4610#ifdef OLD_RES
4611,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4612,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4613#endif
4614,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD}
4615,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD}
4616,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD}
4617,{jjSUBST_Par_N,    SUBST_CMD,  POLY_CMD,   POLY_CMD,   NUMBER_CMD, POLY_CMD }
4618,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4619,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4620,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD }
4621,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD }
4622,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD }
4623,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD }
4624,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD }
4625,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD }
4626,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD  }
4627,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD  }
4628,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD  }
4629,{NULL,             0,          0,          0,          0,          0 }
4630};
4631/*=================== operations with many arg.: static proc =================*/
4632static BOOLEAN jjBREAK0(leftv res, leftv v)
4633{
4634  sdb_show_bp();
4635  return FALSE;
4636}
4637static BOOLEAN jjBREAK1(leftv res, leftv v)
4638{
4639  if(v->Typ()==PROC_CMD)
4640  {
4641    int lineno=0;
4642    if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
4643    {
4644      lineno=(int)v->next->Data();
4645    }
4646    return sdb_set_breakpoint(v->Name(),lineno);
4647  }
4648  return TRUE;
4649}
4650static BOOLEAN jjCALL1ARG(leftv res, leftv v)
4651{
4652  return iiExprArith1(res,v,iiOp);
4653}
4654static BOOLEAN jjCALL2ARG(leftv res, leftv u)
4655{
4656  leftv v=u->next;
4657  u->next=NULL;
4658  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
4659  u->next=v;
4660  return b;
4661}
4662static BOOLEAN jjCALL3ARG(leftv res, leftv u)
4663{
4664  leftv v = u->next;
4665  leftv w = v->next;
4666  u->next = NULL;
4667  v->next = NULL;
4668  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4669  u->next = v;
4670  v->next = w;
4671  return b;
4672}
4673
4674static BOOLEAN jjCOEF_M(leftv res, leftv v)
4675{
4676  if((v->Typ() != VECTOR_CMD)
4677  || (v->next->Typ() != POLY_CMD)
4678  || (v->next->next->Typ() != MATRIX_CMD)
4679  || (v->next->next->next->Typ() != MATRIX_CMD))
4680     return TRUE;
4681  if (v->next->next->rtyp!=IDHDL) return TRUE;
4682  idhdl c=(idhdl)v->next->next->data;
4683  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
4684  idhdl m=(idhdl)v->next->next->next->data;
4685  idDelete((ideal *)&(c->data.uideal));
4686  idDelete((ideal *)&(m->data.uideal));
4687  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
4688    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
4689  return FALSE;
4690}
4691static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
4692{
4693  int s=1;
4694  leftv h=v;
4695  if (h!=NULL) s=exprlist_length(h);
4696  ideal id=idInit(s,1);
4697  int rank=1;
4698  int i=0;
4699  poly p;
4700  while (h!=NULL)
4701  {
4702    switch(h->Typ())
4703    {
4704      case POLY_CMD:
4705      {
4706        p=(poly)h->CopyD(POLY_CMD);
4707        break;
4708      }
4709      case INT_CMD:
4710      {
4711        number n=nInit((int)h->Data());
4712        if (!nIsZero(n))
4713        {
4714          p=pOne();
4715          pSetCoeff(p,n);
4716        }
4717        else
4718        {
4719          p=NULL;
4720          nDelete(&n);
4721        }
4722        break;
4723      }
4724      case NUMBER_CMD:
4725      {
4726        number n=(number)h->CopyD(NUMBER_CMD);
4727        if (!nIsZero(n))
4728        {
4729          p=pOne();
4730          pSetCoeff(p,n);
4731        }
4732        else
4733        {
4734          p=NULL;
4735          nDelete(&n);
4736        }
4737        break;
4738      }
4739      case VECTOR_CMD:
4740      {
4741        p=(poly)h->CopyD(VECTOR_CMD);
4742        if (iiOp!=MODUL_CMD)
4743        {
4744          idDelete(&id);
4745          pDelete(&p);
4746          return TRUE;
4747        }
4748        rank=max(rank,pMaxComp(p));
4749        break;
4750      }
4751      default:
4752      {
4753        idDelete(&id);
4754        return TRUE;
4755      }
4756    }
4757    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4758    {
4759      pSetCompP(p,1);
4760    }
4761    id->m[i]=p;
4762    i++;
4763    h=h->next;
4764  }
4765  id->rank=rank;
4766  res->data=(char *)id;
4767  return FALSE;
4768}
4769static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4770{
4771  leftv h=v;
4772  int l=v->listLength();
4773  resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
4774  BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
4775  int t=0;
4776  // try to convert to IDEAL_CMD
4777  while (h!=NULL)
4778  {
4779    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4780    {
4781      t=IDEAL_CMD;
4782    }
4783    else break;
4784    h=h->next;
4785  }
4786  // if failure, try MODUL_CMD
4787  if (t==0)
4788  {
4789    h=v;
4790    while (h!=NULL)
4791    {
4792      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4793      {
4794        t=MODUL_CMD;
4795      }
4796      else break;
4797      h=h->next;
4798    }
4799  }
4800  // check for success  in converting
4801  if (t==0)
4802  {
4803    WerrorS("cannot convert to ideal or module");
4804    return TRUE;
4805  }
4806  // call idMultSect
4807  h=v;
4808  int i=0;
4809  sleftv tmp;
4810  while (h!=NULL)
4811  {
4812    if (h->Typ()==t)
4813    {
4814      r[i]=(ideal)h->Data(); /*no copy*/
4815      h=h->next;
4816    }
4817    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4818    {
4819      omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
4820      omFreeSize((ADDRESS)r,l*sizeof(ideal));
4821      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4822      return TRUE;
4823    }
4824    else
4825    {
4826      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
4827      copied[i]=TRUE;
4828      h=tmp.next;
4829    }
4830    i++;
4831  }
4832  res->rtyp=t;
4833  res->data=(char *)idMultSect(r,i);
4834  while(i>0)
4835  {
4836    i--;
4837    if (copied[i]) idDelete(&(r[i]));
4838  }
4839  omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
4840  omFreeSize((ADDRESS)r,l*sizeof(ideal));
4841  return FALSE;
4842}
4843static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4844{
4845  int i=0;
4846  leftv h=v;
4847  if (h!=NULL) i=exprlist_length(h);
4848  intvec *iv=new intvec(i);
4849  i=0;
4850  while (h!=NULL)
4851  {
4852    if(h->Typ()==INT_CMD)
4853    {
4854      (*iv)[i]=(int)h->Data();
4855    }
4856    else
4857    {
4858      delete iv;
4859      return TRUE;
4860    }
4861    i++;
4862    h=h->next;
4863  }
4864  res->data=(char *)iv;
4865  return FALSE;
4866}
4867static BOOLEAN jjJET4(leftv res, leftv u)
4868{
4869  leftv u1=u;
4870  leftv u2=u1->next;
4871  leftv u3=u2->next;
4872  leftv u4=u3->next;
4873  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
4874     (u4->Typ()==INTVEC_CMD)||
4875     (u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
4876     (u4->Typ()==INTVEC_CMD))
4877  {
4878    if(!pIsUnit((poly)u2->Data()))
4879    {
4880      Werror("2nd argument must be a unit");
4881      return TRUE;
4882    }
4883    res->rtyp=u1->Typ();
4884    res->data=(char*)pSeries((int)u3->Data(),pCopy((poly)u1->Data()),
4885                             pCopy((poly)u2->Data()),(intvec*)u4->Data());
4886    return FALSE;
4887  }
4888  else
4889  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
4890     (u4->Typ()==INTVEC_CMD)||
4891     (u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
4892     (u4->Typ()==INTVEC_CMD))
4893  {
4894    if(!mpIsDiagUnit((matrix)u2->Data()))
4895    {
4896      Werror("2nd argument must be a diagonal matrix of units");
4897      return TRUE;
4898    }
4899    res->rtyp=u1->Typ();
4900    res->data=(char*)idSeries((int)u3->Data(),idCopy((ideal)u1->Data()),
4901                              mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
4902    return FALSE;
4903  }
4904  else
4905  {
4906    Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
4907           Tok2Cmdname(iiOp));
4908    return TRUE;
4909  }
4910}
4911static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4912{
4913  if ((yyInRingConstruction)
4914  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
4915  {
4916    memcpy(res,u,sizeof(sleftv));
4917    memset(u,0,sizeof(sleftv));
4918    return FALSE;
4919  }
4920  leftv v=u->next;
4921  BOOLEAN b;
4922  if(v==NULL)
4923    b=iiExprArith1(res,u,iiOp);
4924  else
4925  {
4926    u->next=NULL;
4927    b=iiExprArith2(res,u,iiOp,v);
4928    u->next=v;
4929  }
4930  return b;
4931}
4932static BOOLEAN jjLIST_PL(leftv res, leftv v)
4933{
4934  int sl=0;
4935  if (v!=NULL) sl = v->listLength();
4936  lists L;
4937  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4938  {
4939    L=syConvRes((syStrategy)v->Data());
4940  }
4941  else
4942  {
4943    L=(lists)omAllocBin(slists_bin);
4944    leftv h=NULL;
4945    int i;
4946    int rt;
4947
4948    L->Init(sl);
4949    for (i=0;i<sl;i++)
4950    {
4951      if (h!=NULL) { /* e.g. not in the first step:
4952                     * h is the pointer to the old sleftv,
4953                     * v is the pointer to the next sleftv
4954                     * (in this moment) */
4955                     h->next=v;
4956                   }
4957      h=v;
4958      v=v->next;
4959      h->next=NULL;
4960      rt=h->Typ();
4961      if (rt==0)
4962      {
4963        L->Clean();
4964        Werror("`%s` is undefined",h->Fullname());
4965        return TRUE;
4966      }
4967      if ((rt==RING_CMD)||(rt==QRING_CMD))
4968      {
4969        L->m[i].rtyp=rt;  L->m[i].data=h->Data();
4970        ((ring)L->m[i].data)->ref++;
4971      }
4972      else
4973        L->m[i].Copy(h);
4974    }
4975  }
4976  res->data=(char *)L;
4977  return FALSE;
4978}
4979static BOOLEAN jjNAMES0(leftv res, leftv v)
4980{
4981  res->data=(void *)ipNameList(IDROOT);
4982  return FALSE;
4983}
4984static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4985{
4986  if(v==NULL)
4987  {
4988    res->data=(char *)showOption();
4989    return FALSE;
4990  }
4991  res->rtyp=NONE;
4992  return setOption(res,v);
4993}
4994static BOOLEAN jjREDUCE4(leftv res, leftv u)
4995{
4996  leftv u1=u;
4997  leftv u2=u1->next;
4998  leftv u3=u2->next;
4999  leftv u4=u3->next;
5000  if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
5001  {
5002    int save_d=Kstd1_deg;
5003    Kstd1_deg=(int)u3->Data();
5004    kModW=(intvec *)u4->Data();
5005    BITSET save=verbose;
5006    verbose|=Sy_bit(V_DEG_STOP);
5007    u2->next=NULL;
5008    BOOLEAN r=jjCALL2ARG(res,u);
5009    kModW=NULL;
5010    Kstd1_deg=save_d;
5011    verbose=save;
5012    u->next->next=u3;
5013    return r;
5014  }
5015  else
5016  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5017     (u4->Typ()==INT_CMD))
5018  {
5019    assumeStdFlag(u3);
5020    if(!mpIsDiagUnit((matrix)u2->Data()))
5021    {
5022      Werror("2nd argument must be a diagonal matrix of units");
5023      return TRUE;
5024    }
5025    res->rtyp=IDEAL_CMD;
5026    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5027                           mpCopy((matrix)u2->Data()),(int)u4->Data());
5028    return FALSE;
5029  }
5030  else
5031  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5032     (u4->Typ()==INT_CMD))
5033  {
5034    assumeStdFlag(u3);
5035    if(!pIsUnit((poly)u2->Data()))
5036    {
5037      Werror("2nd argument must be a unit");
5038      return TRUE;
5039    }
5040    res->rtyp=POLY_CMD;
5041    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5042                           pCopy((poly)u2->Data()),(int)u4->Data());
5043    return FALSE;
5044  }
5045  else
5046  {
5047    Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
5048    return TRUE;
5049  }
5050}
5051static BOOLEAN jjREDUCE5(leftv res, leftv u)
5052{
5053  leftv u1=u;
5054  leftv u2=u1->next;
5055  leftv u3=u2->next;
5056  leftv u4=u3->next;
5057  leftv u5=u4->next;
5058  if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5059     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5060  {
5061    assumeStdFlag(u3);
5062    if(!mpIsDiagUnit((matrix)u2->Data()))
5063    {
5064      Werror("2nd argument must be a diagonal matrix of units");
5065      return TRUE;
5066    }
5067    res->rtyp=IDEAL_CMD;
5068    res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
5069                           mpCopy((matrix)u2->Data()),
5070                           (int)u4->Data(),(intvec*)u5->Data());
5071    return FALSE;
5072  }
5073  else
5074  if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
5075     (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
5076  {
5077    assumeStdFlag(u3);
5078    if(!pIsUnit((poly)u2->Data()))
5079    {
5080      Werror("2nd argument must be a unit");
5081      return TRUE;
5082    }
5083    res->rtyp=POLY_CMD;
5084    res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
5085                           pCopy((poly)u2->Data()),
5086                           (int)u4->Data(),(intvec*)u5->Data());
5087    return FALSE;
5088  }
5089  else
5090  {
5091    Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
5092           Tok2Cmdname(iiOp));
5093    return TRUE;
5094  }
5095}
5096static BOOLEAN jjRESERVED0(leftv res, leftv v)
5097{
5098  int i=1;
5099  loop
5100  {
5101    Print("%-20s",cmds[i].name);
5102    i++;
5103    if(cmds[i].name==NULL)
5104      break;
5105    if ((i%3)==1) PrintLn();
5106  }
5107  PrintLn();
5108  return FALSE;
5109}
5110static BOOLEAN jjSTRING_PL(leftv res, leftv v)
5111{
5112  if (v == NULL)
5113  {
5114    res->data = omStrDup("");
5115    return FALSE;
5116  }
5117  int n = v->listLength();
5118  if (n == 1)
5119  {
5120    res->data = v->String();
5121    return FALSE;
5122  }
5123
5124  char** slist = (char**) omAlloc(n*sizeof(char*));
5125  int i, j;
5126
5127  for (i=0, j=0; i<n; i++, v = v ->next)
5128  {
5129    slist[i] = v->String();
5130    assume(slist[i] != NULL);
5131    j+=strlen(slist[i]);
5132  }
5133  char* s = (char*) omAlloc((j+1)*sizeof(char));
5134  *s='\0';
5135  for (i=0;i<n;i++)
5136  {
5137    strcat(s, slist[i]);
5138    omFree(slist[i]);
5139  }
5140  omFreeSize(slist, n*sizeof(char*));
5141  res->data = s;
5142  return FALSE;
5143}
5144static BOOLEAN jjTEST(leftv res, leftv v)
5145{
5146  do
5147  {
5148    if (v->Typ()!=INT_CMD)
5149      return TRUE;
5150    test_cmd((int)v->Data());
5151    v=v->next;
5152  }
5153  while (v!=NULL);
5154  return FALSE;
5155}
5156
5157#ifndef __MWERKS__
5158#if defined(__alpha) && !defined(linux)
5159extern "C"
5160{
5161  void usleep(unsigned long usec);
5162};
5163#endif
5164
5165static BOOLEAN jjSTATUS_M(leftv res, leftv v)
5166{
5167  if ((v->Typ() != LINK_CMD) ||
5168      (v->next->Typ() != STRING_CMD) ||
5169      (v->next->next->Typ() != STRING_CMD) ||
5170      (v->next->next->next->Typ() != INT_CMD))
5171    return TRUE;
5172  jjSTATUS3(res, v, v->next, v->next->next);
5173#if defined(HAVE_USLEEP)
5174  if (((int) res->data) == 0)
5175  {
5176    int i_s = (int) v->next->next->next->Data();
5177    if (i_s > 0)
5178    {
5179      usleep((int) v->next->next->next->Data());
5180      jjSTATUS3(res, v, v->next, v->next->next);
5181    }
5182  }
5183#elif defined(HAVE_SLEEP)
5184  if (((int) res->data) == 0)
5185  {
5186    int i_s = (int) v->next->next->next->Data();
5187    if (i_s > 0)
5188    {
5189      sleep((is - 1)/1000000 + 1);
5190      jjSTATUS3(res, v, v->next, v->next->next);
5191    }
5192  }
5193#endif
5194  return FALSE;
5195}
5196#endif
5197static BOOLEAN jjSUBST_M(leftv res, leftv u)
5198{
5199  leftv v = u->next; // number of args > 0
5200  if (v==NULL) return TRUE;
5201  leftv w = v->next;
5202  if (w==NULL) return TRUE;
5203  leftv rest = w->next;;
5204
5205  u->next = NULL;
5206  v->next = NULL;
5207  w->next = NULL;
5208  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5209  if ((rest!=NULL) && (!b))
5210  {
5211    sleftv tmp_res;
5212    leftv tmp_next=res->next;
5213    res->next=rest;
5214    memset(&tmp_res,0,sizeof(tmp_res));
5215    b = iiExprArithM(&tmp_res,res,iiOp);
5216    memcpy(res,&tmp_res,sizeof(tmp_res));
5217    res->next=tmp_next;
5218  }
5219  u->next = v;
5220  v->next = w;
5221  // rest was w->next, but is already cleaned
5222  return b;
5223}
5224
5225#ifdef HAVE_NAMESPACES
5226static BOOLEAN jjIMPORTFROM(leftv res, leftv v);
5227
5228static BOOLEAN jjEXPORTTO(leftv res, leftv v)
5229{
5230  BOOLEAN nok=TRUE;
5231  leftv u=v;
5232  if(u->rtyp==NSHDL)
5233  {
5234    namehdl ns = (namehdl)(u->data);
5235    idhdl h = namespaceroot->root->get(ns->name, 0, TRUE);
5236    //Print("Export to '%s', lev %d\n", ns->name, ns->myynest);
5237    while(v->next!=NULL)
5238    {
5239      nok = iiInternalExport(v->next, ns->myynest, h);
5240      if(nok) { return nok; }
5241
5242      v = v->next;
5243    }
5244    return FALSE;
5245  }
5246  if(u->Typ()==PACKAGE_CMD)
5247  {
5248    //PrintS("export to package\n");
5249    while(v->next!=NULL)
5250    {
5251      nok = iiInternalExport(v->next, 0, u->data);
5252      if(nok) return nok;
5253      v = v->next;
5254    }
5255    return FALSE;
5256  }
5257  return TRUE;
5258}
5259#endif /* HAVE_NAMESPACES */
5260#ifdef HAVE_NAMESPACES
5261static BOOLEAN jjIMPORTFROM(leftv res, leftv v)
5262{
5263  BOOLEAN nok=FALSE;
5264  PrintS("jjIMPORT_FROM()\n");
5265  if(v->rtyp==NSHDL)
5266  {
5267    PrintS("Import from toplevel\n");
5268//While-schleife!!!
5269    return FALSE;
5270  }
5271  if(v->Typ()==PACKAGE_CMD)
5272  {
5273    Print("Import from package %s\n", v->name);
5274    while(v->next!=NULL)
5275    {
5276      //nok = iiInternalImport(v->next, 0, v->data);
5277      if(nok) return nok;
5278      v = v->next;
5279    }
5280    return FALSE;
5281  }
5282  return TRUE;
5283}
5284#endif
5285#ifdef HAVE_NAMESPACES
5286static BOOLEAN jjUNLOAD(leftv res, leftv v)
5287{
5288  if(v->Typ()==PACKAGE_CMD)
5289  {
5290    char *typ;
5291    idhdl h = (idhdl)v->data;
5292    package d=(package)v->Data();
5293    switch (d->language)
5294    {
5295      case LANG_C:
5296        typ="object";
5297        break;
5298      case LANG_SINGULAR:
5299      case LANG_NONE:
5300      default:
5301        killhdl(h);
5302    }
5303    return FALSE;
5304  }
5305  return TRUE;
5306}
5307#endif
5308/*=================== operations with many arg.: table =================*/
5309/* number_of_args:  -1: any, -2: any >0, .. */
5310struct sValCmdM dArithM[]=
5311{
5312// operations:
5313// proc         cmd               res            number_of_args
5314 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2  }
5315,{jjBREAK0,    BREAKPOINT_CMD,  NONE,               0  }
5316,{jjBREAK1,    BREAKPOINT_CMD,  NONE,               -2  }
5317,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2  }
5318,{jjCOEF_M,    COEF_CMD,        NONE,               4  }
5319,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2 }
5320,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1  }
5321,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1 }
5322,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2  }
5323,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2 }
5324,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1  }
5325,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -2 }
5326,{jjCALL2ARG,  JET_CMD,         POLY_CMD,/*or set by p*/           2  }
5327,{jjCALL3ARG,  JET_CMD,         POLY_CMD,/*or set by p*/           3  }
5328,{jjJET4,      JET_CMD,         POLY_CMD,/*or set by p*/           4  }
5329,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1 }
5330,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1  }
5331,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1 }
5332,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1 }
5333,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0 }
5334,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 }
5335,{jjCALL2ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          2  }
5336,{jjCALL3ARG,  REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          3  }
5337,{jjREDUCE4,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          4  }
5338,{jjREDUCE5,   REDUCE_CMD,      IDEAL_CMD/*or set by p*/,          5  }
5339,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1 }
5340,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0 }
5341,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1 }
5342,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3 }
5343,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2 }
5344,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2 }
5345,{jjTEST,      TEST_CMD,        NONE,               -2 }
5346,{iiWRITE,     WRITE_CMD,       NONE,               -2 }
5347,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2 }
5348,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3 }
5349#ifndef __MWERKS__
5350,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4 }
5351#endif
5352#ifdef HAVE_NAMESPACES
5353,{jjIMPORTFROM,IMPORTFROM_CMD,  ANY_TYPE,           -2 }
5354,{jjEXPORTTO,  EXPORTTO_CMD,    NONE,               -2 }
5355,{jjUNLOAD,    UNLOAD_CMD,      NONE,               -2 }
5356#endif /* HAVE_NAMESPACES */
5357,{loSimplex,   SIMPLEX_CMD,     LIST_CMD,            6 }
5358,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4 }
5359,{NULL,        0,               0,                   0 }
5360};
5361#ifdef MDEBUG
5362static Subexpr jjDBMakeSub(leftv e,char *f, int l)
5363#else
5364static Subexpr jjMakeSub(leftv e)
5365#endif
5366{
5367  assume( e->Typ()==INT_CMD );
5368  Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
5369  r->start =(int)e->Data();
5370  return r;
5371}
5372
5373/*================ generating tables ============================*/
5374#ifdef GENTABLE
5375extern struct sValAssign dAssign[];
5376struct sValCmdTab dArithTab1[]={ {0,0}};
5377#define JJTAB1LEN 0
5378struct sValCmdTab dArithTab2[]={ {0,0}};
5379#define JJTAB2LEN 0
5380void ttGen1()
5381{
5382  FILE *outfile = myfopen("iparith.inc","w");
5383  int i,j,l1=0,l2=0;
5384  currRing=(ring)omAllocBin(sip_sring_bin);
5385  fprintf(outfile,
5386  "/****************************************\n"
5387  "*  Computer Algebra System SINGULAR     *\n"
5388  "****************************************/\n\n");
5389/*-------------------------------------------------------------------*/
5390  fprintf(outfile,"// syntax table for Singular\n//\n");
5391  fprintf(outfile,"// - search for an exact match of the argument types\n");
5392  fprintf(outfile,"// - otherwise search for the first possibility\n");
5393  fprintf(outfile,"//   with converted types of the arguments\n");
5394  fprintf(outfile,"// - otherwise report an error\n//\n");
5395
5396  int op;
5397  i=0;
5398  while ((op=dArith1[i].cmd)!=0)
5399  {
5400    if (dArith1[i].p==jjWRONG)
5401      fprintf(outfile,"// DUMMY ");
5402    char *s = iiTwoOps(op);
5403    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
5404          s,
5405          Tok2Cmdname(dArith1[i].arg),
5406          Tok2Cmdname(ABS(dArith1[i].res)));
5407    i++;
5408  }
5409  fprintf(outfile,"/*---------------------------------------------*/\n");
5410  i=0;
5411  while ((op=dArith2[i].cmd)!=0)
5412  {
5413    if (dArith2[i].p==jjWRONG2)
5414      fprintf(outfile,"// DUMMY ");
5415    char *s = iiTwoOps(op);
5416    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
5417          s,
5418          Tok2Cmdname(dArith2[i].arg1),
5419          Tok2Cmdname(dArith2[i].arg2),
5420          Tok2Cmdname(dArith2[i].res));
5421    i++;
5422  }
5423  fprintf(outfile,"/*---------------------------------------------*/\n");
5424  i=0;
5425  while ((op=dArith3[i].cmd)!=0)
5426  {
5427    char *s = iiTwoOps(op);
5428    if (dArith3[i].p==jjWRONG3)
5429      fprintf(outfile,"// DUMMY ");
5430    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
5431          s,
5432          Tok2Cmdname(dArith3[i].arg1),
5433          Tok2Cmdname(dArith3[i].arg2),
5434          Tok2Cmdname(dArith3[i].arg3),
5435          Tok2Cmdname(dArith3[i].res));
5436    i++;
5437  }
5438  fprintf(outfile,"/*---------------------------------------------*/\n");
5439  i=0;
5440  while ((op=dArithM[i].cmd)!=0)
5441  {
5442    char *s = iiTwoOps(op);
5443    fprintf(outfile,"// operation: %s (...)  ->  %s",
5444          s,
5445          Tok2Cmdname(dArithM[i].res));
5446    switch(dArithM[i].number_of_args)
5447    {
5448      case -2:
5449         fprintf(outfile," ( number of arguments >0 )\n");
5450         break;
5451      case -1:
5452         fprintf(outfile," ( any number of arguments )\n");
5453         break;
5454      default:
5455         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
5456         break;
5457    }
5458    i++;
5459  }
5460  fprintf(outfile,"/*---------------------------------------------*/\n");
5461  i=0;
5462  while ((op=dAssign[i].res)!=0)
5463  {
5464    fprintf(outfile,"// assign: %s =  %s\n",
5465          Tok2Cmdname(op/*dAssign[i].res*/),
5466          Tok2Cmdname(dAssign[i].arg));
5467    i++;
5468  }
5469/*-------------------------------------------------------------------*/
5470  fprintf(outfile,"/*---------------------------------------------*/\n");
5471  for (j=257;j<=MAX_TOK+1;j++)
5472  {
5473    for(i=257;i<=MAX_TOK+1;i++)
5474    {
5475      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
5476      && iiTestConvert(i,j))
5477      {
5478        fprintf(outfile,"// convert %s -> %s\n",
5479          Tok2Cmdname(i), Tok2Cmdname(j));
5480        if (j==ANY_TYPE) break;
5481      }
5482    }
5483  }
5484  fprintf(outfile,"/*---------------------------------------------*/\n");
5485  char ops[]="=><+*/[.^,%(;";
5486  for(i=0;ops[i]!='\0';i++)
5487    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
5488  for (i=257;i<=MAX_TOK;i++)
5489  {
5490    char *s=iiTwoOps(i);
5491    if (s[0]!='$')
5492    {
5493      fprintf(outfile,"// token %d : %s\n", i, s);
5494    }
5495  }
5496/*-------------------------------------------------------------------*/
5497  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
5498/*-------------------------------------------------------------------*/
5499  fprintf(outfile,"/*---------------------------------------------*/\n");
5500  fprintf(outfile,
5501  "struct sValCmdTab dArithTab1[]=\n"
5502  "{\n");
5503  for (j=1;j<=MAX_TOK+1;j++)
5504  {
5505    for(i=0;dArith1[i].cmd!=0;i++)
5506    {
5507      if (dArith1[i].cmd==j)
5508      {
5509        fprintf(outfile," { %d,%d },\n",j,i);
5510        l1++;
5511        break;
5512      }
5513    }
5514  }
5515  fprintf(outfile," { 10000,0 }\n};\n");
5516  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
5517/*-------------------------------------------------------------------*/
5518  fprintf(outfile,
5519  "struct sValCmdTab dArithTab2[]=\n"
5520  "{\n");
5521  for (j=1;j<=MAX_TOK+1;j++)
5522  {
5523    for(i=0;dArith2[i].cmd!=0;i++)
5524    {
5525      if (dArith2[i].cmd==j)
5526      {
5527        fprintf(outfile," { %d,%d },\n",j,i);
5528        l2++;
5529        break;
5530      }
5531    }
5532  }
5533  fprintf(outfile," { 10000,0 }\n};\n");
5534  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
5535  fclose(outfile);
5536}
5537/*-------------------------------------------------------------------*/
5538void ttGen2()
5539{
5540  FILE *outfile = myfopen("iparith.inc","a");
5541  fprintf(outfile,
5542  "/****************************************\n"
5543  "*  Computer Algebra System SINGULAR     *\n"
5544  "****************************************/\n\n");
5545/*-------------------------------------------------------------------*/
5546  fprintf(outfile,"// identifier table for Singular\n//\n");
5547
5548  fprintf(outfile,
5549  "cmdnames cmds[] =\n"
5550  "{  // name-string     alias  tokval toktype\n"
5551  "{ \"$INVALID$\",            0,  -1, 0},\n");
5552  int i=1;
5553  int m=-1;
5554  int id_nr=0;
5555  BOOLEAN f=FALSE;
5556  loop
5557  {
5558    while (cmds[i].tokval!=0)
5559    {
5560      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
5561      {
5562        if(m==-1)
5563        {
5564          m=i;
5565          f=TRUE;
5566        }
5567        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5568        {
5569          m=i;
5570          f=TRUE;
5571        }
5572      }
5573      i++;
5574    }
5575    if(f)
5576    {
5577      id_nr++;
5578      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
5579      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
5580                                             20-strlen(cmds[m].name),
5581                                             cmds[m].alias,
5582                                             cmds[m].tokval);
5583      switch(cmds[m].toktype)
5584      {
5585        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
5586        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
5587        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
5588        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
5589        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
5590        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
5591        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
5592        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
5593        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
5594        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
5595        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
5596        case NONE:             fprintf(outfile,"NONE },\n"); break;
5597        default:               if((cmds[m].toktype>' ')
5598                               &&(cmds[m].toktype<127))
5599                               {
5600                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
5601                               }
5602                               else
5603                               {
5604                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
5605                               }
5606                               break;
5607      }
5608      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
5609      cmds[m].name=NULL;
5610      m=-1;
5611      i=1;
5612      f=FALSE;
5613    }
5614    else break;
5615  }
5616  fprintf(outfile,
5617"/* list of scanner identifiers/only for feread/reservedName */\n");
5618  f=FALSE;
5619  i=1;m=-1;
5620  loop
5621  {
5622    while (cmds[i].tokval!=0)
5623    {
5624      if (cmds[i].name!=NULL)
5625      {
5626        if(m==-1)
5627        {
5628          m=i;
5629          f=TRUE;
5630        }
5631        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5632        {
5633          m=i;
5634          f=TRUE;
5635        }
5636      }
5637      i++;
5638    }
5639    if(f)
5640    {
5641      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
5642                                             20-strlen(cmds[m].name),
5643                                             0/*cmds[m].alias*/
5644                                             /*-1 cmds[m].tokval*/
5645                                             /*0 cmds[m].toktype*/);
5646      cmds[m].name=NULL;
5647      m=-1;
5648      i=1;
5649      f=FALSE;
5650    }
5651    else break;
5652  }
5653  fprintf(outfile,
5654"/* end of list marker */\n"
5655"  { NULL, 0, 0, 0}\n"
5656"};\n"
5657"#ifdef HAVE_RTIMER\n"
5658"#define LAST_IDENTIFIER %d\n"
5659"#else\n"
5660"#define LAST_IDENTIFIER %d\n"
5661"#endif\n",id_nr,id_nr-1);
5662  fclose(outfile);
5663}
5664/*-------------------------------------------------------------------*/
5665#if 0
5666void ttGen3()
5667{
5668  FILE *outfile = myfopen("mpsr_tok.inc","w");
5669  fprintf(outfile,
5670  "/****************************************\n"
5671  "*  Computer Algebra System SINGULAR     *\n"
5672  "****************************************/\n\n");
5673/*-------------------------------------------------------------------*/
5674  fprintf(outfile,"// token table for Singular\n//\n");
5675
5676  fprintf(outfile,
5677  "short vtok[] =\n"
5678  "{\n");
5679  // operations with 1 arg: ===========================================
5680  int i=0;
5681  while (dArith1[i].cmd!=0)
5682  {
5683    if ((dArith1[i].p!=jjWRONG)
5684    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
5685    {
5686      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
5687    }
5688    i++;
5689  }
5690  // operations with 2 args: ===========================================
5691  i=0;
5692  while (dArith2[i].cmd!=0)
5693  {
5694    if ((dArith2[i].p!=jjWRONG2)
5695    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
5696    {
5697      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
5698    }
5699    i++;
5700  }
5701  // operations with 3 args: ===========================================
5702  i=0;
5703  while (dArith3[i].cmd!=0)
5704  {
5705    if (
5706    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
5707    {
5708      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
5709    }
5710    i++;
5711  }
5712  // operations with many args: ===========================================
5713  i=0;
5714  while (dArithM[i].cmd!=0)
5715  {
5716    if (
5717    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
5718    {
5719      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
5720    }
5721    i++;
5722  }
5723  // ====================================================================
5724  fprintf(outfile,
5725  "/* end of list marker */\n"
5726  " %d };\n",MAX_TOK);
5727  fclose(outfile);
5728}
5729#endif
5730/*-------------------------------------------------------------------*/
5731#else
5732#include "iparith.inc"
5733#endif
5734
5735/*=================== operations with 2 args. ============================*/
5736
5737BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
5738{
5739#ifndef GENTABLE
5740  memset(res,0,sizeof(sleftv));
5741
5742  if (!errorreported)
5743  {
5744#ifdef SIQ
5745    if (siq>0)
5746    {
5747      //Print("siq:%d\n",siq);
5748      command d=(command)omAlloc0Bin(ip_command_bin);
5749      memcpy(&d->arg1,a,sizeof(sleftv));
5750      memcpy(&d->arg2,b,sizeof(sleftv));
5751      d->argc=2;
5752      d->op=op;
5753      res->data=(char *)d;
5754      res->rtyp=COMMAND;
5755      return FALSE;
5756    }
5757#endif
5758    int at=a->Typ();
5759    int bt=b->Typ();
5760    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
5761    int index=i;
5762
5763    iiOp=op;
5764    while (dArith2[i].cmd==op)
5765    {
5766      if ((at==dArith2[i].arg1)
5767      && (bt==dArith2[i].arg2))
5768      {
5769        res->rtyp=dArith2[i].res;
5770        if (dArith2[i].p(res,a,b))
5771        {
5772          break;// leave loop, goto error handling
5773        }
5774        a->CleanUp();
5775        b->CleanUp();
5776        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5777        return FALSE;
5778      }
5779      i++;
5780    }
5781    // implicite type conversion ----------------------------------------------
5782    if (dArith2[i].cmd!=op)
5783    {
5784      int ai,bi;
5785      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
5786      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
5787      BOOLEAN failed=FALSE;
5788      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5789      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
5790      while (dArith2[i].cmd==op)
5791      {
5792        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5793        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
5794        {
5795          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
5796          {
5797            res->rtyp=dArith2[i].res;
5798            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
5799            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
5800            || (dArith2[i].p(res,an,bn)));
5801            // everything done, clean up temp. variables
5802            if (failed)
5803            {
5804              // leave loop, goto error handling
5805              break;
5806            }
5807            else
5808            {
5809              // everything ok, clean up and return
5810              an->CleanUp();
5811              bn->CleanUp();
5812              omFreeBin((ADDRESS)an, sleftv_bin);
5813              omFreeBin((ADDRESS)bn, sleftv_bin);
5814              a->CleanUp();
5815              b->CleanUp();
5816              return FALSE;
5817            }
5818          }
5819        }
5820        i++;
5821      }
5822      an->CleanUp();
5823      bn->CleanUp();
5824      omFreeBin((ADDRESS)an, sleftv_bin);
5825      omFreeBin((ADDRESS)bn, sleftv_bin);
5826    }
5827    // error handling ---------------------------------------------------
5828    const char *s=NULL;
5829    if (!errorreported)
5830    {
5831      if ((at==0) && (a->Fullname()!=sNoName))
5832      {
5833        s=a->Fullname();
5834      }
5835      else if ((bt==0) && (b->Fullname()!=sNoName))
5836      {
5837        s=b->Fullname();
5838      }
5839      if (s!=NULL)
5840        Werror("`%s` is not defined",s);
5841      else
5842      {
5843        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5844        s = iiTwoOps(op);
5845        if (proccall)
5846        {
5847          Werror("%s(`%s`,`%s`) is not supported"
5848                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
5849        }
5850        else
5851        {
5852          Werror("`%s` %s `%s` is not supported"
5853                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
5854        }
5855        if (BVERBOSE(V_SHOW_USE))
5856        {
5857          while (dArith2[i].cmd==op)
5858          {
5859            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
5860            && (dArith2[i].res!=0)
5861            && (dArith2[i].p!=jjWRONG2))
5862            {
5863              if (proccall)
5864                Werror("expected %s(`%s`,`%s`)"
5865                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5866              else
5867                Werror("expected `%s` %s `%s`"
5868                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
5869            }
5870            i++;
5871          }
5872        }
5873      }
5874    }
5875    res->rtyp = UNKNOWN;
5876  }
5877  a->CleanUp();
5878  b->CleanUp();
5879#endif
5880  return TRUE;
5881}
5882
5883/*==================== operations with 1 arg. ===============================*/
5884
5885BOOLEAN iiExprArith1(leftv res, leftv a, int op)
5886{
5887#ifndef GENTABLE
5888  memset(res,0,sizeof(sleftv));
5889
5890  if (!errorreported)
5891  {
5892#ifdef SIQ
5893    if (siq>0)
5894    {
5895      //Print("siq:%d\n",siq);
5896      command d=(command)omAlloc0Bin(ip_command_bin);
5897      memcpy(&d->arg1,a,sizeof(sleftv));
5898      d->op=op;
5899      d->argc=1;
5900      res->data=(char *)d;
5901      res->rtyp=COMMAND;
5902      return FALSE;
5903    }
5904#endif
5905    int at=a->Typ();
5906    BOOLEAN failed=FALSE;
5907
5908    iiOp=op;
5909    int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
5910    int ti = i;
5911    while (dArith1[i].cmd==op)
5912    {
5913      if (at==dArith1[i].arg)
5914      {
5915        int r=res->rtyp=dArith1[i].res;
5916        if (r<0)
5917        {
5918          res->rtyp=-r;
5919          #ifdef PROC_BUG
5920          dArith1[i].p(res,a);
5921          #else
5922          res->data=(char *)((Proc1)dArith1[i].p)((char *)a->Data());
5923          #endif
5924        }
5925        else if (dArith1[i].p(res,a))
5926        {
5927          break;// leave loop, goto error handling
5928        }
5929        if (a->Next()!=NULL)
5930        {
5931          res->next=(leftv)omAllocBin(sleftv_bin);
5932          failed=iiExprArith1(res->next,a->next,op);
5933        }
5934        a->CleanUp();
5935        return failed;
5936      }
5937      i++;
5938    }
5939    // implicite type conversion --------------------------------------------
5940    if (dArith1[i].cmd!=op)
5941    {
5942      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
5943      i=ti;
5944      //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
5945      while (dArith1[i].cmd==op)
5946      {
5947        int ai;
5948        //Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
5949        if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
5950        {
5951          int r=res->rtyp=dArith1[i].res;
5952          if (r<0)
5953          {
5954            res->rtyp=-r;
5955            failed= iiConvert(at,dArith1[i].arg,ai,a,an);
5956            if (!failed)
5957            {
5958              #ifdef PROC_BUG
5959              dArith1[i].p(res,a);
5960              #else
5961              res->data=(char *)((Proc1)dArith1[i].p)((char *)an->Data());
5962              #endif
5963            }
5964          }
5965          else
5966          {
5967            failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
5968            || (dArith1[i].p(res,an)));
5969          }
5970          // everything done, clean up temp. variables
5971          if (failed)
5972          {
5973            // leave loop, goto error handling
5974            break;
5975          }
5976          else
5977          {
5978            if (an->Next() != NULL)
5979            {
5980              res->next = (leftv)omAllocBin(sleftv_bin);
5981              failed=iiExprArith1(res->next,an->next,op);
5982            }
5983            // everything ok, clean up and return
5984            an->CleanUp();
5985            omFreeBin((ADDRESS)an, sleftv_bin);
5986            a->CleanUp();
5987            return failed;
5988          }
5989        }
5990        i++;
5991      }
5992      an->CleanUp();
5993      omFreeBin((ADDRESS)an, sleftv_bin);
5994    }
5995    // error handling
5996    if (!errorreported)
5997    {
5998      if ((at==0) && (a->Fullname()!=sNoName))
5999      {
6000        Werror("`%s` is not defined",a->Fullname());
6001      }
6002      else
6003      {
6004        i=ti;
6005        char *s = iiTwoOps(op);
6006        Werror("%s(`%s`) is not supported"
6007                ,s,Tok2Cmdname(at));
6008        if (BVERBOSE(V_SHOW_USE))
6009        {
6010          while (dArith1[i].cmd==op)
6011          {
6012            if ((dArith1[i].res!=0)
6013            && (dArith1[i].p!=jjWRONG))
6014              Werror("expected %s(`%s`)"
6015                ,s,Tok2Cmdname(dArith1[i].arg));
6016            i++;
6017          }
6018        }
6019      }
6020    }
6021    res->rtyp = UNKNOWN;
6022  }
6023  a->CleanUp();
6024#endif
6025  return TRUE;
6026}
6027
6028/*=================== operations with 3 args. ============================*/
6029
6030BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
6031{
6032#ifndef GENTABLE
6033  memset(res,0,sizeof(sleftv));
6034
6035  if (!errorreported)
6036  {
6037#ifdef SIQ
6038    if (siq>0)
6039    {
6040      //Print("siq:%d\n",siq);
6041      command d=(command)omAlloc0Bin(ip_command_bin);
6042      memcpy(&d->arg1,a,sizeof(sleftv));
6043      memcpy(&d->arg2,b,sizeof(sleftv));
6044      memcpy(&d->arg3,c,sizeof(sleftv));
6045      d->op=op;
6046      d->argc=3;
6047      res->data=(char *)d;
6048      res->rtyp=COMMAND;
6049      return FALSE;
6050    }
6051#endif
6052    int at=a->Typ();
6053    int bt=b->Typ();
6054    int ct=c->Typ();
6055
6056    iiOp=op;
6057    int i=0;
6058    while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
6059    while (dArith3[i].cmd==op)
6060    {
6061      if ((at==dArith3[i].arg1)
6062      && (bt==dArith3[i].arg2)
6063      && (ct==dArith3[i].arg3))
6064      {
6065        res->rtyp=dArith3[i].res;
6066        if (dArith3[i].p(res,a,b,c))
6067        {
6068          break;// leave loop, goto error handling
6069        }
6070        a->CleanUp();
6071        b->CleanUp();
6072        c->CleanUp();
6073        return FALSE;
6074      }
6075      i++;
6076    }
6077    // implicite type conversion ----------------------------------------------
6078    if (dArith3[i].cmd!=op)
6079    {
6080      int ai,bi,ci;
6081      leftv an = (leftv)omAlloc0Bin(sleftv_bin);
6082      leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
6083      leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
6084      BOOLEAN failed=FALSE;
6085      i=0;
6086      while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
6087      while (dArith3[i].cmd==op)
6088      {
6089        if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
6090        {
6091          if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
6092          {
6093            if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
6094            {
6095              res->rtyp=dArith3[i].res;
6096              failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
6097                || (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
6098                || (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
6099                || (dArith3[i].p(res,an,bn,cn)));
6100              // everything done, clean up temp. variables
6101              if (failed)
6102              {
6103                // leave loop, goto error handling
6104                break;
6105              }
6106              else
6107              {
6108                // everything ok, clean up and return
6109                an->CleanUp();
6110                bn->CleanUp();
6111                cn->CleanUp();
6112                omFreeBin((ADDRESS)an, sleftv_bin);
6113                omFreeBin((ADDRESS)bn, sleftv_bin);
6114                omFreeBin((ADDRESS)cn, sleftv_bin);
6115                a->CleanUp();
6116                b->CleanUp();
6117                c->CleanUp();
6118        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6119                return FALSE;
6120              }
6121            }
6122          }
6123        }
6124        i++;
6125      }
6126      an->CleanUp();
6127      bn->CleanUp();
6128      cn->CleanUp();
6129      omFreeBin((ADDRESS)an, sleftv_bin);
6130      omFreeBin((ADDRESS)bn, sleftv_bin);
6131      omFreeBin((ADDRESS)cn, sleftv_bin);
6132    }
6133    // error handling ---------------------------------------------------
6134    if (!errorreported)
6135    {
6136      const char *s=NULL;
6137      if ((at==0) && (a->Fullname()!=sNoName))
6138      {
6139        s=a->Fullname();
6140      }
6141      else if ((bt==0) && (b->Fullname()!=sNoName))
6142      {
6143        s=b->Fullname();
6144      }
6145      else if ((ct==0) && (c->Fullname()!=sNoName))
6146      {
6147        s=c->Fullname();
6148      }
6149      if (s!=NULL)
6150        Werror("`%s` is not defined",s);
6151      else
6152      {
6153        i=0;
6154        while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
6155        char *s = iiTwoOps(op);
6156        Werror("%s(`%s`,`%s`,`%s`) is not supported"
6157                ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
6158        if (BVERBOSE(V_SHOW_USE))
6159        {
6160          while (dArith3[i].cmd==op)
6161          {
6162            if(((at==dArith3[i].arg1)
6163            ||(bt==dArith3[i].arg2)
6164            ||(ct==dArith3[i].arg3))
6165            && (dArith3[i].res!=0))
6166            {
6167              Werror("expected %s(`%s`,`%s`,`%s`)"
6168                  ,s,Tok2Cmdname(dArith3[i].arg1)
6169                  ,Tok2Cmdname(dArith3[i].arg2)
6170                  ,Tok2Cmdname(dArith3[i].arg3));
6171            }
6172            i++;
6173          }
6174        }
6175      }
6176    }
6177    res->rtyp = UNKNOWN;
6178  }
6179  a->CleanUp();
6180  b->CleanUp();
6181  c->CleanUp();
6182        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6183#endif
6184  return TRUE;
6185}
6186/*==================== operations with many arg. ===============================*/
6187
6188BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
6189{
6190  // cnt = 0: all
6191  // cnt = 1: only first one
6192  leftv next;
6193  BOOLEAN failed = TRUE;
6194  if(v==NULL) return failed;
6195  res->rtyp = LIST_CMD;
6196  if(cnt) v->next = NULL;
6197  next = v->next;             // saving next-pointer
6198  failed = jjLIST_PL(res, v);
6199  v->next = next;             // writeback next-pointer
6200  return failed;
6201}
6202
6203BOOLEAN iiExprArithM(leftv res, leftv a, int op)
6204{
6205#ifndef GENTABLE
6206  memset(res,0,sizeof(sleftv));
6207
6208  if (!errorreported)
6209  {
6210#ifdef SIQ
6211    if (siq>0)
6212    {
6213      //Print("siq:%d\n",siq);
6214      command d=(command)omAlloc0Bin(ip_command_bin);
6215      d->op=op;
6216      res->data=(char *)d;
6217      if (a!=NULL)
6218      {
6219        d->argc=a->listLength();
6220        // else : d->argc=0;
6221        memcpy(&d->arg1,a,sizeof(sleftv));
6222        switch(d->argc)
6223        {
6224          case 3:
6225            memcpy(&d->arg3,a->next->next,sizeof(sleftv));
6226            a->next->next->rtyp=0;
6227            a->next->next->data=NULL;
6228            a->next->next->name=NULL;
6229            a->next->next->attribute=NULL;
6230          case 2:
6231            memcpy(&d->arg2,a->next,sizeof(sleftv));
6232            a->next->rtyp=0;
6233            a->next->name=NULL;
6234            a->next->data=NULL;
6235            a->next->attribute=NULL;
6236            d->arg2.next=NULL;
6237          case 1:
6238            d->arg1.next=NULL;
6239        }
6240        if (d->argc>3) a->next=NULL;
6241        a->rtyp=0;
6242        a->data=NULL;
6243        a->name=NULL;
6244        a->CleanUp();
6245      }
6246      res->rtyp=COMMAND;
6247      return FALSE;
6248    }
6249#endif
6250    BOOLEAN failed=FALSE;
6251    int args=0;
6252    if (a!=NULL) args=a->listLength();
6253
6254    iiOp=op;
6255    int i=0;
6256    while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
6257    int ii=i;
6258    while (dArithM[i].cmd==op)
6259    {
6260      if ((args==dArithM[i].number_of_args)
6261      || (dArithM[i].number_of_args==-1)
6262      || ((dArithM[i].number_of_args==-2)&&(args>0)))
6263      {
6264        res->rtyp=dArithM[i].res;
6265        if (dArithM[i].p(res,a))
6266        {
6267          break;// leave loop, goto error handling
6268        }
6269        if (a!=NULL) a->CleanUp();
6270        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6271        return failed;
6272      }
6273      i++;
6274    }
6275    // error handling
6276    if (!errorreported)
6277    {
6278      if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
6279      {
6280        Werror("`%s` is not defined",a->Fullname());
6281      }
6282      else
6283      {
6284        char *s = iiTwoOps(op);
6285        Werror("%s(...) is not supported",s);
6286      }
6287    }
6288    res->rtyp = UNKNOWN;
6289  }
6290  if (a!=NULL) a->CleanUp();
6291        //Print("op: %d,result typ:%d\n",op,res->rtyp);
6292#endif
6293  return TRUE;
6294}
6295
6296/*=================== general utilities ============================*/
6297int IsCmd(char *n, int & tok)
6298{
6299  int an=1;
6300  int i,v;
6301#ifndef GENTABLE
6302  int en=LAST_IDENTIFIER;
6303
6304  loop
6305  {
6306    if(an>=en-1)
6307    {
6308      if (strcmp(n, cmds[an].name) == 0)
6309      {
6310        i=an;
6311        break;
6312      }
6313      else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
6314      {
6315        i=en;
6316        break;
6317      }
6318      else
6319      {
6320        return 0;
6321      }
6322    }
6323    i=(an+en)/2;
6324    if (*n < *(cmds[i].name))
6325    {
6326      en=i-1;
6327    }
6328    else if (*n > *(cmds[i].name))
6329    {
6330      an=i+1;
6331    }
6332    else
6333    {
6334      v=strcmp(n,cmds[i].name);
6335      if(v<0)
6336      {
6337        en=i-1;
6338      }
6339      else if(v>0)
6340      {
6341        an=i+1;
6342      }
6343      else /*v==0*/
6344      {
6345        break;
6346      }
6347    }
6348  }
6349  lastreserved=cmds[i].name;
6350  tok=cmds[i].tokval;
6351  if(cmds[i].alias==2)
6352  {
6353    Warn("outdated identifier `%s` used - please change your code",
6354    cmds[i].name);
6355    cmds[i].alias=1;
6356  }
6357  if (currRingHdl==NULL)
6358  {
6359    #ifdef SIQ
6360    if (siq<=0)
6361    {
6362    #endif
6363      if ((tok>=BEGIN_RING) && (tok<=END_RING))
6364      {
6365        WerrorS("no ring active");
6366        return 0;
6367      }
6368    #ifdef SIQ
6369    }
6370    #endif
6371  }
6372  if (!expected_parms)
6373  {
6374    switch (tok)
6375    {
6376      case IDEAL_CMD:
6377      case INT_CMD:
6378      case INTVEC_CMD:
6379      case MAP_CMD:
6380      case MATRIX_CMD:
6381      case MODUL_CMD:
6382      case POLY_CMD:
6383      case PROC_CMD:
6384      case RING_CMD:
6385      case STRING_CMD:
6386        cmdtok = tok;
6387        break;
6388    }
6389  }
6390#endif
6391  return cmds[i].toktype;
6392}
6393static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
6394{
6395#ifndef GENTABLE
6396  int a=0;
6397  int e=len;
6398  int p=len/2;
6399  do
6400  {
6401     if (op==dArithTab[p].cmd) return dArithTab[p].start;
6402     if (op<dArithTab[p].cmd) e=p-1;
6403     else   a = p+1;
6404     p=a+(e-a)/2;
6405  }
6406  while ( a <= e);
6407
6408#endif
6409  assume(0);
6410  return 0;
6411}
6412
Note: See TracBrowser for help on using the repository browser.