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

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