source: git/Singular/iparith.cc @ 50cbdc

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