source: git/Singular/iparith.cc @ f907fc

fieker-DuValspielwiese
Last change on this file since f907fc was f907fc, checked in by Olaf Bachmann <obachman@…>, 25 years ago
* fixed prun/idMinEmbedding git-svn-id: file:///usr/local/Singular/svn/trunk@3913 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 169.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: iparith.cc,v 1.189 1999-11-24 14:07:22 obachman Exp $ */
5
6/*
7* ABSTRACT: table driven kernel interface, used by interpreter
8*/
9
10#include <stdlib.h>
11#include <string.h>
12#include <ctype.h>
13#include <stdio.h>
14#include <time.h>
15#include <unistd.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "ipid.h"
20#include "intvec.h"
21#include "mmemory.h"
22#include "febase.h"
23#include "longalg.h"
24#include "polys.h"
25#include "ideals.h"
26#include "matpol.h"
27#include "kstd1.h"
28#include "timer.h"
29#include "ring.h"
30#include "subexpr.h"
31#include "lists.h"
32#include "numbers.h"
33#include "stairc.h"
34#include "maps.h"
35#include "syz.h"
36#include "weight.h"
37#include "ipconv.h"
38#include "ipprint.h"
39#include "sing_dld.h"
40#include "attrib.h"
41#include "silink.h"
42#include "sparsmat.h"
43#ifdef HAVE_FACTORY
44#include "clapsing.h"
45#include "kstdfac.h"
46#endif
47#ifdef HAVE_FGLM
48#include "fglm.h"
49#endif
50#ifdef HAVE_SPECTRUM
51#include "spectrum.h"
52#endif
53
54#include "ipshell.h"
55
56#include "mpr_inout.h"
57
58/*=============== types =====================*/
59struct sValCmdTab
60{
61  short cmd;
62  short start;
63};
64
65typedef sValCmdTab jjValCmdTab[];
66
67/* ifdef GENTABLE: definitions are in ipshell.h */
68#ifndef GENTABLE
69typedef char * (*Proc1)(char *);
70struct sValCmd1
71{
72  proc1 p;
73  short cmd;
74  short res;
75  short arg;
76};
77
78typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
79struct sValCmd2
80{
81  proc2 p;
82  short cmd;
83  short res;
84  short arg1;
85  short arg2;
86};
87
88typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
89struct sValCmd3
90{
91  proc3 p;
92  short cmd;
93  short res;
94  short arg1;
95  short arg2;
96  short arg3;
97};
98struct sValCmdM
99{
100  proc1 p;
101  short cmd;
102  short res;
103  short number_of_args; /* -1: any, -2: any >0, .. */
104};
105#endif
106
107/*============= proc =======================*/
108static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
109static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
110#ifdef MDEBUG
111#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
112static Subexpr jjDBMakeSub(leftv e,char *f, int l);
113#else
114static Subexpr jjMakeSub(leftv e);
115#endif
116
117/*============= vars ======================*/
118extern int cmdtok;
119extern BOOLEAN expected_parms;
120
121int iiOp; /* the current operation*/
122
123#ifdef GENTABLE
124cmdnames cmds[] =
125{  // name-string alias tokval          toktype
126  { "$INVALID$",   0, -1,                 0},
127  { "and",         0, '&' ,               '&'},
128  { "attrib",      0, ATTRIB_CMD ,        CMD_123},
129  { "bareiss",     0, BAREISS_CMD ,       CMD_123},
130  { "betti",       0, BETTI_CMD ,         CMD_12},
131  { "break",       0, BREAK_CMD ,         BREAK_CMD},
132  { "char",        0, CHARACTERISTIC_CMD ,CMD_1},
133  { "char_series", 0, CHAR_SERIES_CMD ,   CMD_1},
134  { "charstr",     0, CHARSTR_CMD ,       CMD_1},
135  { "cleardenom",  0, CONTENT_CMD ,       CMD_1},
136  { "close",       0, CLOSE_CMD ,         CMD_1},
137  { "coef",        0, COEF_CMD ,          CMD_M},
138  { "coeffs",      0, COEFFS_CMD ,        CMD_23},
139  { "continue",    0, CONTINUE_CMD ,      CONTINUE_CMD},
140  { "contract",    0, CONTRACT_CMD ,      CMD_2},
141  { "dbprint",     0, DBPRINT_CMD ,       CMD_M},
142  { "def",         0, DEF_CMD ,           ROOT_DECL},
143  { "defined",     0, DEFINED_CMD ,       CMD_1},
144  { "deg",         0, DEG_CMD ,           CMD_12},
145  { "degree",      0, DEGREE_CMD ,        CMD_1},
146  { "delete",      0, DELETE_CMD ,        CMD_2},
147  { "det",         0, DET_CMD ,           CMD_1},
148  { "diff",        0, DIFF_CMD ,          CMD_2},
149  { "dim",         0, DIM_CMD ,           CMD_1},
150  { "div",         0, INTDIV ,            INTDIV},
151#ifdef DRING
152  { "dring",       0, DRING_CMD ,         DRING_CMD},
153#endif
154  { "dump",        0, DUMP_CMD,           CMD_1},
155  { "extgcd",      0, EXTGCD_CMD ,        CMD_2},
156  { "EXTGCD",      2, EXTGCD_CMD ,        CMD_2},
157  { "ERROR",       0, ERROR_CMD ,         CMD_1},
158  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
159  { "else",        0, ELSE_CMD ,          ELSE_CMD},
160  { "eval",        0, EVAL ,              EVAL},
161  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
162  { "execute",     0, EXECUTE_CMD ,       EXECUTE_CMD},
163  { "export",      0, EXPORT_CMD ,        EXPORT_CMD},
164#ifdef HAVE_NAMESPACES
165  { "exportto",    0, EXPORTTO_CMD ,      CMD_M},
166#endif
167  { "factorize",   0, FAC_CMD ,           CMD_12},
168  { "fetch",       0, FETCH_CMD ,         CMD_2},
169  { "fglm",        0, FGLM_CMD ,          CMD_2},
170  { "fglmquot",    0, FGLMQUOT_CMD,       CMD_2},
171  { "find",        0, FIND_CMD ,          CMD_23},
172  { "finduni",     0, FINDUNI_CMD,        CMD_1},
173  { "forif",       0, IF_CMD ,            IF_CMD},
174  { "freemodule",  0, FREEMODULE_CMD ,    CMD_1},
175  { "facstd",      0, FACSTD_CMD ,        CMD_12},
176  { "gen",         0, E_CMD ,             CMD_1},
177  { "getdump",     0, GETDUMP_CMD,        CMD_1},
178  { "gcd",         0, GCD_CMD ,           CMD_2},
179  { "GCD",         2, GCD_CMD ,           CMD_2},
180  { "hilb",        0, HILBERT_CMD ,       CMD_12},
181  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
182  { "homog",       0, HOMOG_CMD ,         CMD_12},
183  { "hres",        0, HRES_CMD ,          CMD_2},
184  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
185  { "if",          0, IF_CMD ,            IF_CMD},
186  { "imap",        0, IMAP_CMD ,          CMD_2},
187#ifdef HAVE_NAMESPACES
188  { "importfrom",  0, IMPORTFROM_CMD ,    CMD_M},
189#endif
190  { "indepSet",    0, INDEPSET_CMD ,      CMD_12},
191  { "insert",      0, INSERT_CMD ,        CMD_23},
192  { "int",         0, INT_CMD ,           ROOT_DECL},
193  { "interred",    0, INTERRED_CMD ,      CMD_1},
194  { "intersect",   0, INTERSECT_CMD ,     CMD_M},
195  { "intmat",      0, INTMAT_CMD ,        INTMAT_CMD},
196  { "intvec",      0, INTVEC_CMD ,        ROOT_DECL_LIST},
197  { "jacob",       0, JACOB_CMD ,         CMD_1},
198  { "jet",         0, JET_CMD ,           CMD_23},
199  { "kbase",       0, KBASE_CMD ,         CMD_12},
200  { "keepring",    0, KEEPRING_CMD ,      KEEPRING_CMD},
201  { "kill",        0, KILL_CMD ,          KILL_CMD},
202  { "killattrib",  0, KILLATTR_CMD ,      CMD_12},
203  { "koszul",      0, KOSZUL_CMD ,        CMD_23},
204  { "laguerre",    0, LAGSOLVE_CMD,       CMD_3},
205  { "lead",        0, LEAD_CMD ,          CMD_1},
206  { "leadcoef",    0, LEADCOEF_CMD ,      CMD_1},
207  { "leadexp",     0, LEADEXP_CMD ,       CMD_1},
208  { "leadmonom",   0, LEADMONOM_CMD ,     CMD_1},
209  { "LIB",         0, LIB_CMD ,           SYSVAR},
210  { "lift",        0, LIFT_CMD ,          CMD_23},
211  { "liftstd",     0, LIFTSTD_CMD ,       CMD_2},
212  { "link",        0, LINK_CMD ,          ROOT_DECL},
213  { "listvar",     0, LISTVAR_CMD ,       LISTVAR_CMD},
214  { "list",        0, LIST_CMD ,          ROOT_DECL_LIST},
215  { "load",        0, LOAD_CMD ,          CMD_12},
216  { "lres",        0, LRES_CMD ,          CMD_2},
217  { "map",         0, MAP_CMD ,           RING_DECL},
218  { "matrix",      0, MATRIX_CMD ,        MATRIX_CMD},
219  { "maxideal",    0, MAXID_CMD ,         CMD_1},
220  { "memory",      0, MEMORY_CMD ,        CMD_1},
221  { "minbase",     0, MINBASE_CMD ,       CMD_1},
222  { "minor",       0, MINOR_CMD ,         CMD_2},
223  { "minres",      0, MINRES_CMD ,        CMD_1},
224  { "mod",         0, '%',                '%'},
225  { "module",      0, MODUL_CMD ,         MODUL_CMD},
226  { "modulo",      0, MODULO_CMD ,        CMD_2},
227  { "monitor",     0, MONITOR_CMD ,       CMD_12},
228  { "mpresmat",    0, MPRES_CMD,          CMD_2},
229  { "mult",        0, MULTIPLICITY_CMD ,  CMD_1},
230  #ifdef OLD_RES
231  { "mres",        0, MRES_CMD ,          CMD_23},
232  #else
233  { "mres",        0, MRES_CMD ,          CMD_2},
234  #endif
235  { "mstd",        0, MSTD_CMD ,          CMD_1},
236  { "nameof",      0, NAMEOF_CMD ,        CMD_1},
237  { "names",       0, NAMES_CMD ,         CMD_M},
238  { "ncols",       0, COLS_CMD ,          CMD_1},
239  { "not",         0, NOT ,               NOT},
240  { "npars",       0, NPARS_CMD ,         CMD_1},
241  #ifdef OLD_RES
242  { "nres",        0, RES_CMD ,           CMD_23},
243  #else
244  { "nres",        0, RES_CMD ,           CMD_2},
245  #endif
246  { "nrows",       0, ROWS_CMD ,          CMD_1},
247  { "number",      0, NUMBER_CMD ,        RING_DECL},
248  { "nvars",       0, NVARS_CMD ,         CMD_1},
249  { "open",        0, OPEN_CMD ,          CMD_1},
250  { "option",      0, OPTION_CMD ,        CMD_M},
251  { "or",          0, '|' ,               '|'},
252  { "ord",         0, ORD_CMD ,           CMD_1},
253  { "ordstr",      0, ORDSTR_CMD ,        CMD_1},
254  { "package",     0, PACKAGE_CMD ,       ROOT_DECL},
255  { "par",         0, PAR_CMD ,           CMD_1},
256  { "parameter",   0, PARAMETER ,         PARAMETER},
257  { "pardeg",      0, PARDEG_CMD ,        CMD_1},
258  { "parstr",      0, PARSTR_CMD ,        CMD_12},
259  { "poly",        0, POLY_CMD ,          RING_DECL},
260  { "preimage",    0, PREIMAGE_CMD ,      CMD_13},
261  { "prime",       0, PRIME_CMD ,         CMD_1},
262  { "print",       0, PRINT_CMD ,         CMD_12},
263  { "prune",       0, PRUNE_CMD ,         CMD_1},
264  { "proc",        0, PROC_CMD ,          PROC_CMD},
265  { "qhweight",    0, QHWEIGHT_CMD ,      CMD_1},
266  { "qring",       0, QRING_CMD ,         ROOT_DECL},
267  { "quote",       0, QUOTE ,             QUOTE},
268  { "quotient",    0, QUOTIENT_CMD ,      CMD_2},
269  { "random",      0, RANDOM_CMD ,        CMD_23},
270  { "read",        0, READ_CMD ,          CMD_12},
271  { "reduce",      0, REDUCE_CMD ,        CMD_23},
272  { "regularity",  0, REGULARITY_CMD ,    CMD_1},
273  { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
274  { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},
275  { "resultant",   0, RESULTANT_CMD,      CMD_3},
276  { "return",      0, RETURN ,            RETURN},
277  { "RETURN",      0, END_GRAMMAR ,       RETURN},
278  { "ring",        0, RING_CMD ,          RING_CMD},
279  { "rvar",        0, IS_RINGVAR ,        CMD_1},
280  { "setring",     0, SETRING_CMD ,       SETRING_CMD},
281  { "simplify",    0, SIMPLIFY_CMD ,      CMD_2},
282  { "size",        0, COUNT_CMD ,         CMD_1},
283  { "sortvec",     0, SORTVEC_CMD ,       CMD_1},
284  #ifdef HAVE_SPECTRUM
285  { "spectrum",    0, SPECTRUM_CMD ,      CMD_123},
286  { "semic",       0, SEMIC_CMD ,         CMD_23},
287  #endif
288  #ifdef OLD_RES
289  { "sres",        0, SRES_CMD ,          CMD_23},
290  #else
291  { "sres",        0, SRES_CMD ,          CMD_2},
292  #endif
293  { "status",      0, STATUS_CMD,         CMD_M},
294  { "std",         0, STD_CMD ,           CMD_123},
295  { "string",      0, STRING_CMD ,        ROOT_DECL_LIST},
296  { "subst",       0, SUBST_CMD ,         CMD_M},
297  { "system",      0, SYSTEM_CMD,         CMD_M},
298  { "syz",         0, SYZYGY_CMD ,        CMD_1},
299  { "test",        0, TEST_CMD ,          CMD_M},
300  { "trace",       0, TRACE_CMD ,         CMD_1},
301  { "transpose",   0, TRANSPOSE_CMD ,     CMD_1},
302  { "type",        0, TYPE_CMD ,          TYPE_CMD},
303  { "typeof",      0, TYPEOF_CMD ,        CMD_1},
304#ifdef HAVE_NAMESPACES
305  { "unload",      0, UNLOAD_CMD ,        CMD_M},
306#endif
307  { "uressolve",   0, URSOLVE_CMD,        CMD_M},
308  { "vandermonde", 0, VANDER_CMD,         CMD_3},
309  { "var",         0, VAR_CMD ,           CMD_1},
310  { "varstr",      0, VARSTR_CMD ,        CMD_12},
311  { "vdim",        0, VDIM_CMD ,          CMD_1},
312  { "vector",      0, VECTOR_CMD ,        RING_DECL},
313  { "wedge",       0, WEDGE_CMD ,         CMD_2},
314  { "weight",      0, WEIGHT_CMD ,        CMD_1},
315  { "whileif",     0, IF_CMD ,            IF_CMD},
316  { "write",       0, WRITE_CMD ,         CMD_M},
317/* delete for next version:*/
318  { "IN",          1, LEAD_CMD ,          CMD_1},
319  { "NF",          1, REDUCE_CMD ,        CMD_23},
320  { "multiplicity",1, MULTIPLICITY_CMD ,  CMD_1},
321  { "verbose",     2, OPTION_CMD ,        CMD_M},
322//  { "rank",        1, ROWS_CMD ,          CMD_1},
323//  { "Current",     0, -1 ,                SYSVAR},
324//  { "Top",         0, -1 ,                SYSVAR},
325//  { "Up",          0, -1 ,                SYSVAR},
326
327/* set sys vars*/
328//#ifdef SRING
329  { "alternating", 0, VALTVARS ,          SYSVAR},
330//#endif
331  { "degBound",    0, VMAXDEG ,           SYSVAR},
332  { "echo",        0, VECHO ,             SYSVAR},
333  { "minpoly",     0, VMINPOLY ,          SYSVAR},
334  { "multBound",   0, VMAXMULT ,          SYSVAR},
335  { "noether",     0, VNOETHER ,          SYSVAR},
336  { "pagelength",  0, VPAGELENGTH ,       SYSVAR},
337  { "pagewidth",   0, VCOLMAX ,           SYSVAR},
338  { "printlevel",  0, VPRINTLEVEL ,       SYSVAR},
339  { "short",       0, VSHORTOUT ,         SYSVAR},
340  { "timer",       0, VTIMER ,            SYSVAR},
341  { "rtimer",      0, VRTIMER,            SYSVAR},
342  { "TRACE",       0, TRACE ,             SYSVAR},
343  { "voice",       0, VOICE ,             SYSVAR},
344
345/* other reserved words:scanner.l */
346  { "pause",       2, -1 ,             0},
347  { "while",       0, -1 ,             0},
348  { "for",         0, -1 ,             0},
349  { "help",        0, -1 ,             0},
350  { "newline",     0, -1 ,             0},
351  { "exit",        0, -1 ,             0},
352  { "quit",        0, -1 ,             0},
353/* end of list marker */
354  { NULL, 0, 0, 0}
355};
356#endif
357
358/*=================== operations with 2 args.: static proc =================*/
359static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
360{
361  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
362  int bb = (int)(v->Data());
363  if (errorreported) return TRUE;
364  switch (iiOp)
365  {
366    case '+': (*aa) += bb; break;
367    case '-': (*aa) -= bb; break;
368    case '*': (*aa) *= bb; break;
369    case '/':
370    case INTDIV: (*aa) /= bb; break;
371    case '%': (*aa) %= bb; break;
372  }
373  res->data=(char *)aa;
374  return FALSE;
375}
376static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
377{
378  return jjOP_IV_I(res,v,u);
379}
380static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
381{
382  intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
383  int bb = (int)(v->Data());
384  int i=min(aa->rows(),aa->cols());
385  switch (iiOp)
386  {
387    case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
388              break;
389    case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
390              break;
391  }
392  res->data=(char *)aa;
393  return FALSE;
394}
395static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
396{
397  return jjOP_IM_I(res,v,u);
398}
399static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
400{
401  res->data=(char *)NewIntvec2((int)u->Data(),(int)v->Data());
402  return FALSE;
403}
404static void jjEQUAL_REST(leftv res,leftv u,leftv v)
405{
406  if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
407  {
408    int save_iiOp=iiOp;
409    if (iiOp==NOTEQUAL)
410      iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
411    else
412      iiExprArith2(res,u->next,iiOp,v->next);
413    iiOp=save_iiOp;
414  }
415  if (iiOp==NOTEQUAL) res->data=(char *)(!(int)res->data);
416}
417static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
418{
419  intvec*    a = (intvec * )(u->Data());
420  intvec*    b = (intvec * )(v->Data());
421  int r=a->compare(b);
422  switch  (iiOp)
423  {
424    case '<':
425      res->data  = (char *) (r<0);
426      break;
427    case '>':
428      res->data  = (char *) (r>0);
429      break;
430    case LE:
431      res->data  = (char *) (r<=0);
432      break;
433    case GE:
434      res->data  = (char *) (r>=0);
435      break;
436    case EQUAL_EQUAL:
437    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
438      res->data  = (char *) (r==0);
439      break;
440  }
441  jjEQUAL_REST(res,u,v);
442  return r==-2;
443}
444static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
445{
446  intvec* a = (intvec * )(u->Data());
447  int     b = (int )     (v->Data());
448  int r=a->compare(b);
449  switch  (iiOp)
450  {
451    case '<':
452      res->data  = (char *) (r<0);
453      break;
454    case '>':
455      res->data  = (char *) (r>0);
456      break;
457    case LE:
458      res->data  = (char *) (r<=0);
459      break;
460    case GE:
461      res->data  = (char *) (r>=0);
462      break;
463    case EQUAL_EQUAL:
464    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
465      res->data  = (char *) (r==0);
466      break;
467  }
468  jjEQUAL_REST(res,u,v);
469  return FALSE;
470}
471static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
472{
473  poly p=(poly)u->Data();
474  poly q=(poly)v->Data();
475  int r=pComp(p,q);
476  if (r==0)
477  {
478    /* compare lead coeffs */
479    number h=nSub(pGetCoeff(p),pGetCoeff(q));
480    r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
481    nDelete(&h);
482  }
483  else if (p==NULL)
484  {
485    if (q==NULL)
486    {
487      /* compare 0, 0 */
488      r=0;
489    }
490    else if(pIsConstant(q))
491    {
492      /* compare 0, const */
493      r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
494    }
495  }
496  else if (q==NULL)
497  {
498    if (pIsConstant(p))
499    {
500      /* compare const, 0 */
501      r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
502    }
503  }
504  switch  (iiOp)
505  {
506    case '<':
507      res->data  = (char *) (r < 0);
508      break;
509    case '>':
510      res->data  = (char *) (r > 0);
511      break;
512    case LE:
513      res->data  = (char *) (r <= 0);
514      break;
515    case GE:
516      res->data  = (char *) (r >= 0);
517      break;
518    //case EQUAL_EQUAL:
519    //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
520    //  res->data  = (char *) (r == 0);
521    //  break;
522  }
523  jjEQUAL_REST(res,u,v);
524  return FALSE;
525}
526static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
527{
528  char*    a = (char * )(u->Data());
529  char*    b = (char * )(v->Data());
530  int result = strcmp(a,b);
531  switch  (iiOp)
532  {
533    case '<':
534      res->data  = (char *) (result  < 0);
535      break;
536    case '>':
537      res->data  = (char *) (result  > 0);
538      break;
539    case LE:
540      res->data  = (char *) (result  <= 0);
541      break;
542    case GE:
543      res->data  = (char *) (result  >= 0);
544      break;
545    case EQUAL_EQUAL:
546    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
547      res->data  = (char *) (result  == 0);
548      break;
549  }
550  jjEQUAL_REST(res,u,v);
551  return FALSE;
552}
553static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
554{
555  if (u->Next()!=NULL)
556  {
557    u=u->next;
558    res->next = (leftv)AllocSizeOf(sleftv);
559    return iiExprArith2(res->next,u,iiOp,v);
560  }
561  else if (v->Next()!=NULL)
562  {
563    v=v->next;
564    res->next = (leftv)AllocSizeOf(sleftv);
565    return iiExprArith2(res->next,u,iiOp,v);
566  }
567  return FALSE;
568}
569static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
570{
571  int b=(int)u->Data();
572  int e=(int)v->Data();
573  int rc = 1;
574  BOOLEAN overflow=FALSE;
575  if ((e >= 0)&&(b!=0))
576  {
577    int oldrc;
578    while ((e--)!=0)
579    {
580      oldrc=rc;
581      rc *= b;
582      if (!overflow)
583      {
584        if(rc/b!=oldrc) overflow=TRUE;
585      }
586    }
587    if (overflow)
588      Warn("int overflow(^), result may be wrong");
589    res->data = (char *)rc;
590    if (u!=NULL) return jjOP_REST(res,u,v);
591    return FALSE;
592  }
593  else
594  {
595    WerrorS("exponent must be non-negative");
596    return TRUE;
597  }
598}
599static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
600{
601  int e=(int)v->Data();
602  number n=(number)u->CopyD(NUMBER_CMD);
603  if (e<0)
604  {
605    number m=nInvers(n);
606    nDelete(&n);
607    n=m;
608    e=-e;
609  }
610  nPower(n,e,(number*)&res->data);
611  nDelete(&n);
612  if (u!=NULL) return jjOP_REST(res,u,v);
613  return FALSE;
614}
615static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
616{
617  res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)v->Data());
618  if (u!=NULL) return jjOP_REST(res,u,v);
619  return FALSE;
620}
621static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
622{
623  res->data = (char *)idPower((ideal)(u->Data()),(int)(v->Data()));
624  if (u!=NULL) return jjOP_REST(res,u,v);
625  return FALSE;
626}
627static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
628{
629  u=u->next;
630  v=v->next;
631  if (u==NULL)
632  {
633    if (v==NULL) return FALSE;      /* u==NULL, v==NULL */
634    if (iiOp=='-')                  /* u==NULL, v<>NULL, iiOp=='-'*/
635    {
636      do
637      {
638        if (res->next==NULL)
639          res->next = (leftv)Alloc0SizeOf(sleftv);
640        leftv tmp_v=v->next;
641        v->next=NULL;
642        BOOLEAN b=iiExprArith1(res->next,v,'-');
643        v->next=tmp_v;
644        if (b)
645          return TRUE;
646        v=tmp_v;
647        res=res->next;
648      } while (v!=NULL);
649      return FALSE;
650    }
651    loop                            /* u==NULL, v<>NULL, iiOp=='+' */
652    {
653      res->next = (leftv)Alloc0SizeOf(sleftv);
654      res=res->next;
655      res->data = v->CopyD();
656      res->rtyp = v->Typ();
657      v=v->next;
658      if (v==NULL) return FALSE;
659    }
660  }
661  if (v!=NULL)                     /* u<>NULL, v<>NULL */
662  {
663    do
664    {
665      res->next = (leftv)Alloc0SizeOf(sleftv);
666      leftv tmp_u=u->next; u->next=NULL;
667      leftv tmp_v=v->next; v->next=NULL;
668      BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
669      u->next=tmp_u;
670      v->next=tmp_v;
671      if (b)
672        return TRUE;
673      u=tmp_u;
674      v=tmp_v;
675      res=res->next;
676    } while ((u!=NULL) && (v!=NULL));
677    return FALSE;
678  }
679  loop                             /* u<>NULL, v==NULL */
680  {
681    res->next = (leftv)Alloc0SizeOf(sleftv);
682    res=res->next;
683    res->data = u->CopyD();
684    res->rtyp = u->Typ();
685    u=u->next;
686    if (u==NULL) return FALSE;
687  }
688}
689static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
690{
691#ifdef HAVE_NAMESPACES
692  BOOLEAN iiReLoadLib(idhdl packhdl);
693  BOOLEAN iiTryLoadLib(leftv v, char *id);
694  idhdl packhdl;
695
696  switch(u->Typ())
697  {
698      case 0:
699        //Print("%s of type 'ANY'. Trying load.\n", v->name);
700        if(iiTryLoadLib(u, u->name))
701        {
702          Werror("'%s' no such package", u->name);
703          return TRUE;
704        }
705        // else: use next case !!! no break !!!
706
707      case PACKAGE_CMD:
708        packhdl = (idhdl)u->data;
709        if(!IDPACKAGE(packhdl)->loaded)
710        {
711          //if(iiReLoadLib(packhdl))
712          //  Werror("unable to reload package '%s'", IDID(packhdl));
713        }
714        if(v->rtyp == IDHDL)
715        {
716          v->name = mstrdup(v->name);
717        }
718        namespaceroot->push( IDPACKAGE(packhdl), IDID(packhdl));
719        syMake(v, v->name, packhdl);
720        memcpy(res, v, sizeof(sleftv));
721        memset(v, 0, sizeof(sleftv));
722        namespaceroot->pop();
723        break;
724
725      case DEF_CMD:
726        break;
727
728      default:
729        WerrorS("<package>::<id> expected");
730        return TRUE;
731  }
732#else /* HAVE_NAMESPACES */
733  WerrorS("package is not supported in this version");
734#endif /* HAVE_NAMESPACES */
735  return FALSE;
736}
737static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
738{
739  unsigned int a=(unsigned int)u->Data();
740  unsigned int b=(unsigned int)v->Data();
741  unsigned int c=a+b;
742  res->data = (char *)c;
743  if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
744  {
745    Warn("int overflow(+), result may be wrong");
746  }
747  return jjPLUSMINUS_Gen(res,u,v);
748}
749static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
750{
751  res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
752  return jjPLUSMINUS_Gen(res,u,v);
753}
754static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
755{
756  res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
757  return jjPLUSMINUS_Gen(res,u,v);
758}
759static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
760{
761  res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
762  if (res->data==NULL)
763  {
764     WerrorS("intmat size not compatible");
765     return TRUE;
766  }
767  return jjPLUSMINUS_Gen(res,u,v);
768}
769static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
770{
771  res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
772  if (res->data==NULL)
773  {
774     WerrorS("matrix size not compatible");
775     return TRUE;
776  }
777  return jjPLUSMINUS_Gen(res,u,v);
778}
779static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
780{
781  matrix m=(matrix)u->Data();
782  matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
783  if (iiOp=='+')
784    res->data = (char *)mpAdd(m , p);
785  else
786    res->data = (char *)mpSub(m , p);
787  idDelete((ideal *)&p);
788  return jjPLUSMINUS_Gen(res,u,v);
789}
790static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
791{
792  return jjPLUS_MA_P(res,v,u);
793}
794static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
795{
796  char*    a = (char * )(u->Data());
797  char*    b = (char * )(v->Data());
798  char*    r = (char * )AllocL(strlen(a) + strlen(b) + 1);
799  strcpy(r,a);
800  strcat(r,b);
801  res->data=r;
802  return jjPLUSMINUS_Gen(res,u,v);
803}
804static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
805{
806  res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
807  return jjPLUSMINUS_Gen(res,u,v);
808}
809static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
810{
811  unsigned int a=(unsigned int)u->Data();
812  unsigned int b=(unsigned int)v->Data();
813  unsigned int c=a-b;
814  if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
815  {
816    Warn("int overflow(-), result may be wrong");
817  }
818  res->data = (char *)c;
819  return jjPLUSMINUS_Gen(res,u,v);
820}
821static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
822{
823  res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
824  return jjPLUSMINUS_Gen(res,u,v);
825}
826static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
827{
828  res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
829  return jjPLUSMINUS_Gen(res,u,v);
830}
831static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
832{
833  res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
834  if (res->data==NULL)
835  {
836     WerrorS("intmat size not compatible");
837     return TRUE;
838  }
839  return jjPLUSMINUS_Gen(res,u,v);
840}
841static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
842{
843  res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
844  if (res->data==NULL)
845  {
846     WerrorS("matrix size not compatible");
847     return TRUE;
848  }
849  return jjPLUSMINUS_Gen(res,u,v);
850}
851static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
852{
853  int a=(int)u->Data();
854  int b=(int)v->Data();
855  int c=a * b;
856  if ((b!=0) && (c/b !=a))
857    Warn("int overflow(*), result may be wrong");
858  res->data = (char *)c;
859  if ((u->Next()!=NULL) || (v->Next()!=NULL))
860    return jjOP_REST(res,u,v);
861  return FALSE;
862}
863static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
864{
865  res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
866  if ((v->next!=NULL) || (u->next!=NULL))
867    return jjOP_REST(res,u,v);
868  return FALSE;
869}
870static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
871{
872  poly a;
873  poly b;
874
875  if (v->next==NULL)
876  {
877    a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
878    if (u->next==NULL)
879    {
880      b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
881      res->data = (char *)(pMult( a, b));
882      return FALSE;
883    }
884    // u->next exists: copy v
885    b=pCopy((poly)v->Data());
886    res->data = (char *)(pMult( a, b));
887    return jjOP_REST(res,u,v);
888  }
889  // v->next exists: copy u
890  a=pCopy((poly)u->Data());
891  b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
892  res->data = (char *)(pMult( a, b));
893  return jjOP_REST(res,u,v);
894}
895static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
896{
897  res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
898  if ((v->next!=NULL) || (u->next!=NULL))
899    return jjOP_REST(res,u,v);
900  return FALSE;
901}
902static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
903{
904  res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
905  if (res->data==NULL)
906  {
907     WerrorS("intmat size not compatible");
908     return TRUE;
909  }
910  if ((v->next!=NULL) || (u->next!=NULL))
911    return jjOP_REST(res,u,v);
912  return FALSE;
913}
914static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
915{
916  poly p=(poly)v->CopyD(POLY_CMD);
917  int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
918  ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
919  if (r>0) I->rank=r;
920  res->data = (char *)I;
921  return FALSE;
922}
923static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
924{
925  return jjTIMES_MA_P1(res,v,u);
926}
927static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
928{
929  number n=(number)v->CopyD(NUMBER_CMD);
930  poly p=pOne();
931  pSetCoeff(p,n);
932  res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
933  return FALSE;
934}
935static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
936{
937  return jjTIMES_MA_N1(res,v,u);
938}
939static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
940{
941  res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)v->Data());
942  return FALSE;
943}
944static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
945{
946  return jjTIMES_MA_I1(res,v,u);
947}
948static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
949{
950  res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
951  if (res->data==NULL)
952  {
953     WerrorS("matrix size not compatible");
954     return TRUE;
955  }
956  if ((v->next!=NULL) || (u->next!=NULL))
957    return jjOP_REST(res,u,v);
958  return FALSE;
959}
960static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
961{
962  res->data = (char *)((int)u->Data() >= (int)v->Data());
963  return FALSE;
964}
965static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
966{
967  number h=nSub((number)u->Data(),(number)v->Data());
968  res->data = (char *) (nGreaterZero(h)||(nIsZero(h)));
969  nDelete(&h);
970  return FALSE;
971}
972static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
973{
974  res->data = (char *)((int)u->Data()>(int)v->Data());
975  return FALSE;
976}
977static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
978{
979  number h=nSub((number)u->Data(),(number)v->Data());
980  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
981  nDelete(&h);
982  return FALSE;
983}
984static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
985{
986  res->data = (char *)((int)u->Data() <= (int)v->Data());
987  return FALSE;
988}
989static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
990{
991  number h=nSub((number)v->Data(),(number)u->Data());
992  res->data = (char *) (nGreaterZero(h)||nIsZero(h));
993  nDelete(&h);
994  return FALSE;
995}
996static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
997{
998  res->data = (char *)((int)u->Data() < (int)v->Data());
999  return FALSE;
1000}
1001static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1002{
1003  number h=nSub((number)v->Data(),(number)u->Data());
1004  res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1005  nDelete(&h);
1006  return FALSE;
1007}
1008static BOOLEAN jjDIV_I(leftv res, leftv u, leftv v)
1009{
1010  int a= (int) u->Data();
1011  int b= (int) v->Data();
1012  if (b==0)
1013  {
1014    WerrorS("div. by 0");
1015    return TRUE;
1016  }
1017  //int c=a%ABS(b);
1018  //if(c<0) c+=ABS(b);
1019  //res->data = (char *)((a-c) / b);
1020  res->data = (char *)(a / b);
1021  return FALSE;
1022}
1023static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1024{
1025  number q=(number)v->Data();
1026  if (nIsZero(q))
1027  {
1028    WerrorS("div. by 0");
1029    return TRUE;
1030  }
1031  q = nDiv((number)u->Data(),q);
1032  nNormalize(q);
1033  res->data = (char *)q;
1034  return FALSE;
1035}
1036static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1037{
1038  poly q=(poly)v->Data();
1039  if (q==NULL)
1040  {
1041    WerrorS("div. by 0");
1042    return TRUE;
1043  }
1044  if (pNext(q)!=NULL)
1045  {
1046#ifdef HAVE_FACTORY
1047    res->data=(void*)(singclap_pdivide((poly)(u->Data()),
1048                                       (poly)(v->Data())));
1049#else
1050    WerrorS("division only by a monomial");
1051    return TRUE;
1052#endif
1053  }
1054  else
1055  {
1056    res->data = (char *)pDivideM((poly)u->CopyD(POLY_CMD),pHead(q));
1057  }
1058  return FALSE;
1059}
1060static BOOLEAN jjMOD_I(leftv res, leftv u, leftv v)
1061{
1062  int a=(int)u->Data();
1063  int b=ABS((int)v->Data());
1064  if (errorreported) return TRUE;
1065  if (b==0)
1066  {
1067    WerrorS("div. by 0");
1068    return TRUE;
1069  }
1070  int c=a%b;
1071  if(c<0) c+=b;
1072  res->data = (char *)c;
1073  return FALSE;
1074}
1075static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1076{
1077  res->data = (char *)((int)u->Data() == (int)v->Data());
1078  jjEQUAL_REST(res,u,v);
1079  return FALSE;
1080}
1081static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1082{
1083  res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
1084  jjEQUAL_REST(res,u,v);
1085  return FALSE;
1086}
1087static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1088{
1089  res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
1090  jjEQUAL_REST(res,u,v);
1091  return FALSE;
1092}
1093static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1094{
1095  poly p=(poly)u->Data();
1096  poly q=(poly)v->Data();
1097  if (p==NULL)
1098  {
1099    res->data=(char *)(q==NULL);
1100  }
1101  else
1102  {
1103    if (q==NULL) res->data=(char *)FALSE;
1104    else
1105    {
1106      int r=pComp(p,q);
1107      if (r==0)
1108      {
1109        p=pSub(pCopy(p),pCopy(q));
1110        res->data = (char *) (p==NULL);
1111        pDelete(&p);
1112      }
1113      else
1114        res->data = (char *) FALSE;
1115    }
1116  }
1117  jjEQUAL_REST(res,u,v);
1118  return FALSE;
1119}
1120static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1121{
1122  res->data = (char *)((int)u->Data() && (int)v->Data());
1123  return FALSE;
1124}
1125static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1126{
1127  res->data = (char *)((int)u->Data() || (int)v->Data());
1128  return FALSE;
1129}
1130static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1131{
1132  res->rtyp=u->rtyp; u->rtyp=0;
1133  res->data=u->data; u->data=NULL;
1134  res->name=u->name; u->name=NULL;
1135#ifdef HAVE_NAMESPACES
1136  res->packhdl=u->packhdl; u->packhdl=NULL;
1137  res->req_packhdl=u->req_packhdl; u->req_packhdl=NULL;
1138#endif /* HAVE_NAMESPACES */
1139  res->e=u->e;       u->e=NULL;
1140  if (res->e==NULL) res->e=jjMakeSub(v);
1141  else
1142  {
1143    Subexpr sh=res->e;
1144    while (sh->next != NULL) sh=sh->next;
1145    sh->next=jjMakeSub(v);
1146  }
1147  return FALSE;
1148}
1149static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1150{
1151  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1152  {
1153    WerrorS("indexed object must have a name");
1154    return TRUE;
1155  }
1156  intvec * iv=(intvec *)v->Data();
1157  leftv p=NULL;
1158  int i;
1159  sleftv t;
1160
1161  memset(&t,0,sizeof(t));
1162  t.rtyp=INT_CMD;
1163  for (i=0;i<iv->length(); i++)
1164  {
1165    t.data=(char *)(*iv)[i];
1166    if (p==NULL)
1167    {
1168      p=res;
1169    }
1170    else
1171    {
1172      p->next=(leftv)Alloc0SizeOf(sleftv);
1173      p=p->next;
1174    }
1175    p->rtyp=IDHDL;
1176    p->data=u->data;
1177    p->name=u->name;
1178#ifdef HAVE_NAMESPACES
1179    p->packhdl=u->packhdl;
1180#endif /* HAVE_NAMESPACES */
1181    p->flag|=u->flag;
1182    p->e=jjMakeSub(&t);
1183  }
1184  u->rtyp=0;
1185  u->data=NULL;
1186  u->name=NULL;
1187  return FALSE;
1188}
1189static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1190{
1191  poly p=(poly)u->Data();
1192  int i=(int)v->Data();
1193  int j=0;
1194  while (p!=NULL)
1195  {
1196    j++;
1197    if (j==i)
1198    {
1199      res->data=(char *)pHead(p);
1200      return FALSE;
1201    }
1202    pIter(p);
1203  }
1204  return FALSE;
1205}
1206static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1207{
1208  poly p=(poly)u->Data();
1209  poly r=NULL;
1210  intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1211  int i;
1212  int sum=0;
1213  for(i=iv->length()-1;i>=0;i--)
1214    sum+=(*iv)[i];
1215  int j=0;
1216  while ((p!=NULL) && (sum>0))
1217  {
1218    j++;
1219    for(i=iv->length()-1;i>=0;i--)
1220    {
1221      if (j==(*iv)[i])
1222      {
1223        r=pAdd(r,pHead(p));
1224        sum-=j;
1225        (*iv)[i]=0;
1226        break;
1227      }
1228    }
1229    pIter(p);
1230  }
1231  delete iv;
1232  res->data=(char *)r;
1233  return FALSE;
1234}
1235static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1236{
1237  poly p=(poly)u->CopyD(VECTOR_CMD);
1238  poly r=p; // pointer to the beginning of component i
1239  poly o=NULL;
1240  int i=(int)v->Data();
1241  while (p!=NULL)
1242  {
1243    if (pGetComp(p)!=i)
1244    {
1245      if (r==p) r=pNext(p);
1246      if (o!=NULL)
1247      {
1248        pDelete1(&pNext(o));
1249        p=pNext(o);
1250      }
1251      else
1252        pDelete1(&p);
1253    }
1254    else
1255    {
1256      pSetComp(p, 0);
1257      o=p;
1258      p=pNext(o);
1259    }
1260  }
1261  res->data=(char *)r;
1262  return FALSE;
1263}
1264static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1265{
1266  poly p=(poly)u->CopyD(VECTOR_CMD);
1267  if (p!=NULL)
1268  {
1269    poly r=pOne();
1270    poly hp=r;
1271    intvec *iv=(intvec *)v->Data();
1272    int i;
1273    loop
1274    {
1275      for(i=0;i<iv->length();i++)
1276      {
1277        if (pGetComp(p)==(*iv)[i])
1278        {
1279          poly h;
1280          pSplit(p,&h);
1281          pNext(hp)=p;
1282          p=h;
1283          pIter(hp);
1284          break;
1285        }
1286      }
1287      if (p==NULL) break;
1288      if (i==iv->length())
1289      {
1290        pDelete1(&p);
1291        if (p==NULL) break;
1292      }
1293    }
1294    pDelete1(&r);
1295    res->data=(char *)r;
1296  }
1297  return FALSE;
1298}
1299static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1300{
1301  if(u->name==NULL) return TRUE;
1302  char * nn = (char *)AllocL(strlen(u->name) + 14);
1303  sprintf(nn,"%s(%d)",u->name,(int)v->Data());
1304  FreeL((ADDRESS)u->name);
1305  u->name=NULL;
1306  char *n=mstrdup(nn);
1307  FreeL((ADDRESS)nn);
1308#ifdef HAVE_NAMESPACES
1309  if(u->req_packhdl != NULL)
1310  {
1311    namespaceroot->push( IDPACKAGE(u->req_packhdl), IDID(u->req_packhdl));
1312    syMake(res,n);
1313    namespaceroot->pop();
1314  }
1315  else
1316#endif /* HAVE_NAMESPACES */
1317    syMake(res,n);
1318  return FALSE;
1319}
1320static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1321{
1322  intvec * iv=(intvec *)v->Data();
1323  leftv p=NULL;
1324  int i;
1325  int slen = strlen(u->name) + 14;
1326  char *n = (char*) Alloc(slen);
1327#ifdef HAVE_NAMESPACES
1328  BOOLEAN needpop=FALSE;
1329
1330  if(u->req_packhdl != NULL)
1331  {
1332    namespaceroot->push( IDPACKAGE(u->req_packhdl), IDID(u->req_packhdl));
1333    needpop = TRUE;
1334  }
1335#endif /* HAVE_NAMESPACES */
1336
1337  for (i=0;i<iv->length(); i++)
1338  {
1339    if (p==NULL)
1340    {
1341      p=res;
1342    }
1343    else
1344    {
1345      p->next=(leftv)Alloc0SizeOf(sleftv);
1346      p=p->next;
1347    }
1348    sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1349    syMake(p,mstrdup(n));
1350  }
1351  FreeL((ADDRESS)u->name);
1352  u->name = NULL;
1353  Free(n, slen);
1354#ifdef HAVE_NAMESPACES
1355  if(needpop) namespaceroot->pop();
1356#endif /* HAVE_NAMESPACES */
1357  return FALSE;
1358}
1359static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1360{
1361#ifdef HAVE_NAMESPACES
1362  leftv sl = iiMake_proc((idhdl)u->data,u,v);
1363#else /* HAVE_NAMESPACES */
1364  leftv sl = iiMake_proc((idhdl)u->data,v);
1365#endif /* HAVE_NAMESPACES */
1366  if (sl==NULL)
1367  {
1368    return TRUE;
1369  }
1370  else
1371  {
1372    memcpy(res,sl,sizeof(sleftv));
1373  }
1374  return FALSE;
1375}
1376static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1377{
1378  //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1379  leftv sl=NULL;
1380  if ((v->e==NULL)&&(v->name!=NULL))
1381  {
1382    map m=(map)u->Data();
1383    sl=iiMap(m,v->name);
1384  }
1385  else
1386  {
1387    Werror("%s(<name>) expected",u->Name());
1388  }
1389  if (sl==NULL) return TRUE;
1390  memcpy(res,sl,sizeof(sleftv));
1391  FreeSizeOf((ADDRESS)sl,sleftv);
1392  return FALSE;
1393}
1394static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1395{
1396  u->next=(leftv)AllocSizeOf(sleftv);
1397  memcpy(u->next,v,sizeof(sleftv));
1398  BOOLEAN r=iiExprArithM(res,u,iiOp);
1399  v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
1400  return r;
1401}
1402static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1403{
1404  res->data=(char *)mpCoeffProc((poly)u->Data(),(poly)v->Data());
1405  return FALSE;
1406}
1407static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1408{
1409  int i=pVar((poly)v->Data());
1410  if (i==0)
1411  {
1412    WerrorS("ringvar expected");
1413    return TRUE;
1414  }
1415  res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1416  return FALSE;
1417}
1418static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1419{
1420  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1421  return FALSE;
1422}
1423static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1424{
1425  short *iv=iv2array((intvec *)v->Data());
1426  res->data = (char *)pDegW((poly)u->Data(),iv);
1427  Free((ADDRESS)iv,(pVariables+1)*sizeof(short));
1428  return FALSE;
1429}
1430static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1431{
1432  int i=pVar((poly)v->Data());
1433  if (i==0)
1434  {
1435    WerrorS("ringvar expected");
1436    return TRUE;
1437  }
1438  res->data=(char *)pDiff((poly)(u->Data()),i);
1439  return FALSE;
1440}
1441static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1442{
1443  int i=pVar((poly)v->Data());
1444  if (i==0)
1445  {
1446    WerrorS("ringvar expected");
1447    return TRUE;
1448  }
1449  res->data=(char *)idDiff((matrix)(u->Data()),i);
1450  return FALSE;
1451}
1452static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1453{
1454  res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1455  return FALSE;
1456}
1457
1458static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1459{
1460  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1461  setFlag(res,FLAG_STD);
1462  return FALSE;
1463}
1464static BOOLEAN jjERROR(leftv res, leftv u)
1465{
1466  WerrorS((char *)u->Data());
1467  return TRUE;
1468}
1469static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1470{
1471  assumeStdFlag(v);
1472  if(currQuotient==NULL)
1473    res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1474  else
1475  {
1476    ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1477    res->data = (char *)scDimInt((ideal)(v->Data()),q);
1478    idDelete(&q);
1479  }
1480  return FALSE;
1481}
1482static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1483{
1484  int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1485  int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1486
1487  while ( p1!=0 )
1488  {
1489    q=p0 / p1;
1490    r=p0 % p1;
1491    p0 = p1; p1 = r;
1492    r = g0 - g1 * q;
1493    g0 = g1; g1 = r;
1494    r = f0 - f1 * q;
1495    f0 = f1; f1 = r;
1496  }
1497  int a = f0;
1498  int b = g0;
1499  if ( (int)u->Data() < 0 ) a=-a;
1500  if ( (int)v->Data() < 0 ) b=-b;
1501  lists L=(lists)AllocSizeOf(slists);
1502  L->Init(3);
1503  L->m[0].rtyp=INT_CMD;
1504  L->m[0].data=(void *)p0;
1505  L->m[1].rtyp=INT_CMD;
1506  L->m[1].data=(void *)a;
1507  L->m[2].rtyp=INT_CMD;
1508  L->m[2].data=(void *)b;
1509  res->rtyp=LIST_CMD;
1510  res->data=(char *)L;
1511  return FALSE;
1512}
1513#ifdef HAVE_FACTORY
1514static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1515{
1516  res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL,
1517           (ideal)w->Data());
1518  setFlag(res,FLAG_STD);
1519  return FALSE;
1520}
1521#endif
1522static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1523{
1524  ring r=(ring)u->Data();
1525  idhdl w;
1526  int op=iiOp;
1527
1528  if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1529  {
1530    int *perm=NULL;
1531    int *par_perm=NULL;
1532    int par_perm_size=0;
1533    BOOLEAN bo;
1534    //if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1535    if (!nSetMap(r))
1536    {
1537      if (rEqual(r,currRing))
1538      {
1539        nMap=nCopy;
1540      }
1541      else
1542      // Allow imap/fetch to be make an exception only for:
1543      if ( (rField_is_Q_a(r) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
1544            (rField_is_Q() || rField_is_Q_a() ||
1545             (rField_is_Zp() || rField_is_Zp_a())))
1546           ||
1547           (rField_is_Zp_a(r) &&  // Zp(a..) -> Zp(a..) || Zp
1548            (rField_is_Zp(currRing, rInternalChar(r)) ||
1549             rField_is_Zp_a(currRing, rInternalChar(r)))) )
1550      {
1551        par_perm_size=rPar(r);
1552        BITSET save_test=test;
1553        naSetChar(rInternalChar(r),TRUE,r->parameter,rPar(r));
1554        nSetChar(currRing,TRUE);
1555        test=save_test;
1556      }
1557      else
1558      {
1559        goto err_fetch;
1560      }
1561    }
1562    if ((iiOp!=FETCH_CMD) || (r->N!=pVariables) || (rPar(r)!=rPar(currRing)))
1563    {
1564      perm=(int *)Alloc0((r->N+1)*sizeof(int));
1565      if (par_perm_size!=0)
1566        par_perm=(int *)Alloc0(par_perm_size*sizeof(int));
1567      op=IMAP_CMD;
1568      if (iiOp==IMAP_CMD)
1569      {
1570        maFindPerm(r->names,       r->N,       r->parameter,        r->P,
1571                   currRing->names,currRing->N,currRing->parameter, currRing->P,
1572                   perm,par_perm, currRing->ch);
1573      }
1574      else
1575      {
1576        int i;
1577        if (par_perm_size!=0)
1578          for(i=0;i<min(rPar(r),rPar(currRing));i++) par_perm[i]=-(i+1);
1579        for(i=1;i<=min(r->N,pVariables);i++) perm[i]=i;
1580      }
1581    }
1582    sleftv tmpW;
1583    memset(&tmpW,0,sizeof(sleftv));
1584    tmpW.rtyp=IDTYP(w);
1585    tmpW.data=IDDATA(w);
1586    if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1587                         perm,par_perm,par_perm_size)))
1588    {
1589      Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1590    }
1591    if (perm!=NULL)
1592      Free((ADDRESS)perm,(r->N+1)*sizeof(int));
1593    if (par_perm!=NULL)
1594      Free((ADDRESS)par_perm,par_perm_size*sizeof(int));
1595    return bo;
1596  }
1597  else
1598  {
1599    Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1600  }
1601  return TRUE;
1602err_fetch:
1603  Werror("no identity map from %s",u->Fullname());
1604  return TRUE;
1605}
1606static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1607{
1608  /*4
1609  * look for the substring what in the string where
1610  * return the position of the first char of what in where
1611  * or 0
1612  */
1613  char *where=(char *)u->Data();
1614  char *what=(char *)v->Data();
1615  char *found = strstr(where,what);
1616  if (found != NULL)
1617  {
1618    res->data=(char *)((found-where)+1);
1619  }
1620  /*else res->data=NULL;*/
1621  return FALSE;
1622}
1623static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1624{
1625  int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1626  int r;
1627
1628  while ( p1!=0 )
1629  {
1630    r=p0 % p1;
1631    p0 = p1; p1 = r;
1632  }
1633  res->rtyp=INT_CMD;
1634  res->data=(char *)p0;
1635  return FALSE;
1636}
1637static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1638{
1639  assumeStdFlag(u);
1640  intvec *module_w=(intvec*)atGet(u,"isHomog");
1641  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1642  switch((int)v->Data())
1643  {
1644    case 1:
1645      res->data=(void *)iv;
1646      return FALSE;
1647    case 2:
1648      res->data=(void *)hSecondSeries(iv);
1649      delete iv;
1650      return FALSE;
1651  }
1652  WerrorS(feNotImplemented);
1653  delete iv;
1654  return TRUE;
1655}
1656static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1657{
1658  int i=pVar((poly)v->Data());
1659  if (i==0)
1660  {
1661    WerrorS("ringvar expected");
1662    return TRUE;
1663  }
1664  res->data = (char *)pHomogen((poly)u->Data(),i);
1665  return FALSE;
1666}
1667static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1668{
1669  int i=pVar((poly)v->Data());
1670  if (i==0)
1671  {
1672    WerrorS("ringvar expected");
1673    return TRUE;
1674  }
1675  res->data = (char *)idHomogen((ideal)u->Data(),i);
1676  return FALSE;
1677}
1678static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1679{
1680  assumeStdFlag(u);
1681  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(v->Data()),
1682                    currQuotient);
1683  return FALSE;
1684}
1685static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1686{
1687  res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1688  setFlag(res,FLAG_STD);
1689  return FALSE;
1690}
1691static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1692{
1693  res->data = (char *)pJet((poly)u->Data(),(int)v->Data());
1694  return FALSE;
1695}
1696static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1697{
1698  res->data = (char *)idJet((ideal)u->Data(),(int)v->Data());
1699  return FALSE;
1700}
1701static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1702{
1703  assumeStdFlag(u);
1704  res->data = (char *)scKBase((int)v->Data(),
1705                              (ideal)(u->Data()),currQuotient);
1706  return FALSE;
1707}
1708static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1709{
1710  return mpKoszul(res, u,v);
1711}
1712static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1713{
1714  sleftv h;
1715  memset(&h,0,sizeof(sleftv));
1716  h.rtyp=INT_CMD;
1717  h.data=(void *)IDELEMS((ideal)v->Data());
1718  return mpKoszul(res, &h, u, v);
1719}
1720static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1721{
1722  ideal m;
1723  int ul= IDELEMS((ideal)u->Data());
1724  int vl= IDELEMS((ideal)v->Data());
1725  if (hasFlag(u,FLAG_STD))
1726  {
1727    m = idLift((ideal)u->Data(),(ideal)v->Data());
1728    res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1729  }
1730  else
1731  {
1732    // matrix ma=mpNew(1,1);
1733    // ideal mo=idLiftStd((ideal)u->CopyD(),currQuotient,&ma,testHomog);
1734    // m = idLift(mo,(ideal)v->Data());
1735    // matrix r=idModule2formatedMatrix(m, IDELEMS(mo),vl);
1736    // idDelete(&mo);
1737    // // idDelete(&m); already done by idModule2formatedMatrix
1738    // res->data=(char *)mpMult(ma,r);
1739    // idDelete((ideal *)&ma);
1740    // idDelete((ideal *)&r);
1741    m = idLiftNonStB((ideal)u->Data(),(ideal)v->Data());
1742    res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1743  }
1744  return FALSE;
1745}
1746static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
1747{
1748  if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
1749  idhdl h=(idhdl)v->data;
1750  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
1751  res->data = (char *)idLiftStd((ideal)u->Data(),
1752                                &(h->data.umatrix),testHomog);
1753  setFlag(res,FLAG_STD);
1754  return FALSE;
1755}
1756static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
1757{
1758  res->data = (char *)idMinors((matrix)u->Data(),(int)v->Data());
1759  return FALSE;
1760}
1761static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
1762{
1763  res->data = (char *)idModulo((ideal)u->Data(),(ideal)v->Data());
1764  return FALSE;
1765}
1766static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
1767{
1768  char *opt=(char *)v->Data();
1769  int mode=0;
1770  while(*opt!='\0')
1771  {
1772    if (*opt=='i') mode |= PROT_I;
1773    else if (*opt=='o') mode |= PROT_O;
1774    opt++;
1775  }
1776  monitor((char *)(u->Data()),mode);
1777  return FALSE;
1778}
1779static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
1780{
1781  idhdl h=(idhdl)u->data;
1782  int i=(int)v->Data();
1783  int p=0;
1784  if ((0<i)
1785  && (IDRING(h)->parameter!=NULL)
1786  && (i<=(p=rPar(IDRING(h)))))
1787    res->data=mstrdup(IDRING(h)->parameter[i-1]);
1788  else
1789  {
1790    Werror("par number %d out of range 1..%d",i,p);
1791    return TRUE;
1792  }
1793  return FALSE;
1794}
1795static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
1796{
1797  res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
1798    hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
1799  idDelMultiples((ideal)(res->data));
1800  return FALSE;
1801}
1802static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
1803{
1804  int i=(int)u->Data();
1805  int j=(int)v->Data();
1806#ifdef buildin_rand
1807  res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
1808#else
1809  res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
1810#endif
1811  return FALSE;
1812}
1813static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
1814{
1815  si_link l=(si_link)u->Data();
1816  leftv r=slRead(l,v);
1817  if (r==NULL)
1818  {
1819    const char *s;
1820    if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
1821    else                            s=sNoName;
1822    Werror("cannot read from `%s`",s);
1823    return TRUE;
1824  }
1825  memcpy(res,r,sizeof(sleftv));
1826  FreeSizeOf((ADDRESS)r,sleftv);
1827  return FALSE;
1828}
1829static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
1830{
1831  assumeStdFlag(v);
1832  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
1833  return FALSE;
1834}
1835static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
1836{
1837  assumeStdFlag(v);
1838  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data());
1839  return FALSE;
1840}
1841static BOOLEAN jjRES(leftv res, leftv u, leftv v)
1842{
1843  int maxl=(int)v->Data();
1844  if (maxl<0)
1845  {
1846    WerrorS("length for res must not be negative");
1847    return TRUE;
1848  }
1849  int l=0;
1850  //resolvente r;
1851  syStrategy r;
1852  intvec **weights=NULL;
1853  int wmaxl=maxl;
1854  ideal u_id=(ideal)u->Data();
1855
1856  maxl--;
1857  if ((maxl==-1) && (iiOp!=MRES_CMD))
1858    maxl = pVariables-1;
1859  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
1860  {
1861    intvec * iv=(intvec*)atGet(u,"isHomog");
1862    r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
1863  }
1864  else if (iiOp==SRES_CMD)
1865  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
1866    r=sySchreyer(u_id,maxl+1);
1867  else if (iiOp == LRES_CMD)
1868  {
1869    int dummy;
1870    if((currQuotient!=NULL)||
1871    (!idHomIdeal (u_id,NULL)))
1872    {
1873       WerrorS
1874       ("`lres` not implemented for inhomogeneous input or qring");
1875       return TRUE;
1876    }
1877    r=syLaScala3(u_id,&dummy);
1878  }
1879  else
1880  {
1881    int dummy;
1882    if((currQuotient!=NULL)||
1883    (!idHomIdeal (u_id,NULL)))
1884    {
1885       WerrorS
1886       ("`hres` not implemented for inhomogeneous input or qring");
1887       return TRUE;
1888    }
1889    r=syHilb(u_id,&dummy);
1890  }
1891  if (r==NULL) return TRUE;
1892  //res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
1893  r->list_length=wmaxl;
1894  res->data=(void *)r;
1895  return FALSE;
1896}
1897static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
1898{
1899  ring r;
1900  int i=rSum((ring)u->Data(),(ring)v->Data(),r);
1901  res->data = (char *)r;
1902  return (i==-1);
1903}
1904#define SIMPL_LMDIV 32
1905#define SIMPL_LMEQ  16
1906#define SIMPL_MULT 8
1907#define SIMPL_EQU  4
1908#define SIMPL_NULL 2
1909#define SIMPL_NORM 1
1910static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
1911{
1912  int sw = (int)v->Data();
1913  // CopyD for IDEAL_CMD and MODUL_CMD are identical:
1914  ideal id = (ideal)u->CopyD(IDEAL_CMD);
1915  if (sw & SIMPL_LMDIV)
1916  {
1917    idDelDiv(id);
1918  }
1919  if (sw & SIMPL_LMEQ)
1920  {
1921    idDelLmEquals(id);
1922  }
1923  if (sw & SIMPL_NULL)
1924  {
1925    idSkipZeroes(id);
1926  }
1927  if (sw & SIMPL_NORM)
1928  {
1929    idNorm(id);
1930  }
1931  if (sw & SIMPL_MULT)
1932  {
1933    idDelMultiples(id);
1934  }
1935  else if(sw & SIMPL_EQU)
1936  {
1937    idDelEquals(id);
1938  }
1939  res->data = (char * )id;
1940  return FALSE;
1941}
1942static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
1943{
1944  res->data = mstrdup(slStatus((si_link) u->Data(), (char *) v->Data()));
1945  return FALSE;
1946}
1947static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
1948{
1949  int sw = (int)v->Data();
1950  // CopyD for POLY_CMD and VECTOR_CMD are identical:
1951  poly p = (poly)u->CopyD(POLY_CMD);
1952  if (sw & SIMPL_NORM)
1953  {
1954    pNorm(p);
1955  }
1956  res->data = (char * )p;
1957  return FALSE;
1958}
1959static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
1960{
1961  ideal result;
1962  intvec *w=(intvec *)atGet(u,"isHomog");
1963  tHomog hom=testHomog;
1964  if (w!=NULL)
1965  {
1966    w=ivCopy(w);
1967    hom=isHomog;
1968  }
1969  result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
1970  idSkipZeroes(result);
1971  res->data = (char *)result;
1972  setFlag(res,FLAG_STD);
1973  if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
1974  return FALSE;
1975}
1976static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
1977{
1978  ideal result;
1979  intvec *w=(intvec *)atGet(u,"isHomog");
1980  tHomog hom=testHomog;
1981  if (w!=NULL)
1982  {
1983    w=ivCopy(w);
1984    hom=isHomog;
1985  }
1986  ideal i1=(ideal)u->Data();
1987  ideal i0=idInit(1,i1->rank);
1988  i0->m[0]=(poly)v->Data();
1989  i1=idSimpleAdd(i1,i0);
1990  i0->m[0]=NULL;
1991  idDelete(&i0);
1992  BITSET save_test=test;
1993  test|=Sy_bit(OPT_SB_1);
1994  result=kStd(i1,currQuotient,hom,&w);
1995  test=save_test;
1996  idDelete(&i1);
1997  idSkipZeroes(result);
1998  res->data = (char *)result;
1999  setFlag(res,FLAG_STD);
2000  if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
2001  return FALSE;
2002}
2003static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2004{
2005  idhdl h=(idhdl)u->data;
2006  int i=(int)v->Data();
2007  if ((0<i) && (i<=IDRING(h)->N))
2008    res->data=mstrdup(IDRING(h)->names[i-1]);
2009  else
2010  {
2011    Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2012    return TRUE;
2013  }
2014  return FALSE;
2015}
2016static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2017{
2018  res->data = (char *)mpWedge((matrix)u->Data(),(int)v->Data());
2019  return FALSE;
2020}
2021#define jjWRONG2 (proc2)jjWRONG
2022#define jjWRONG3 (proc3)jjWRONG
2023static BOOLEAN jjWRONG(leftv res, leftv u)
2024{
2025  return TRUE;
2026}
2027
2028static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2029{
2030  char * s=(char *)u->Data();
2031  if(strcmp(s, "with")==0)
2032    return jjLOAD(res, v, TRUE);
2033  WerrorS("invalid second argument");
2034  WerrorS("load(\"libname\" [,\"with\"]);");
2035  return TRUE;
2036}
2037
2038/*=================== operations with 2 args.: table =================*/
2039
2040struct sValCmd2 dArith2[]=
2041{
2042// operations:
2043// proc        cmd              res             arg1        arg2
2044 {jjCOLCOL,    COLONCOLON,     ANY_TYPE,       DEF_CMD,    DEF_CMD      PROFILER}
2045,{jjPLUS_I,    '+',            INT_CMD,        INT_CMD,    INT_CMD        PROFILER}
2046,{jjPLUS_N,    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD     PROFILER}
2047,{jjPLUS_P,    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2048,{jjPLUS_P,    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD PROFILER}
2049,{jjPLUS_ID,   '+',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2050,{jjPLUS_ID,   '+',            MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2051,{jjPLUS_P_MA, '+',            MATRIX_CMD,     POLY_CMD,   MATRIX_CMD PROFILER}
2052,{jjPLUS_MA_P, '+',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
2053,{jjPLUS_MA,   '+',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
2054,{jjPLUS_S,    '+',            STRING_CMD,     STRING_CMD, STRING_CMD PROFILER}
2055,{jjOP_IV_I,   '+',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2056,{jjOP_I_IV,   '+',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD PROFILER}
2057,{jjOP_IM_I,   '+',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2058,{jjOP_I_IM,   '+',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD PROFILER}
2059,{jjPLUS_IV,   '+',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD PROFILER}
2060,{jjPLUS_IV,   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
2061,{lAdd,        '+',            LIST_CMD,       LIST_CMD,   LIST_CMD PROFILER}
2062,{jjRSUM,      '+',            RING_CMD,       RING_CMD,   RING_CMD PROFILER}
2063,{jjMINUS_I,   '-',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2064,{jjMINUS_N,   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
2065,{jjMINUS_P,   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2066,{jjMINUS_P,   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD PROFILER}
2067,{jjPLUS_MA_P, '-',            MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
2068,{jjMINUS_MA,  '-',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
2069,{jjOP_IV_I,   '-',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2070,{jjOP_IM_I,   '-',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2071,{jjMINUS_IV,  '-',            INTVEC_CMD,     INTVEC_CMD, INTVEC_CMD PROFILER}
2072,{jjMINUS_IV,  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
2073,{jjTIMES_I,   '*',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2074,{jjTIMES_N,   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
2075,{jjTIMES_P,   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2076,{jjTIMES_P,   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD PROFILER}
2077,{jjTIMES_P,   '*',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2078,{jjTIMES_MA_P1,'*',           IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2079,{jjTIMES_MA_P2,'*',           IDEAL_CMD,      POLY_CMD,   IDEAL_CMD PROFILER}
2080,{jjTIMES_ID,  '*',            IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2081,{jjTIMES_MA_P1,'*',           MODUL_CMD,      IDEAL_CMD,  VECTOR_CMD PROFILER}
2082,{jjTIMES_MA_P2,'*',           MODUL_CMD,      VECTOR_CMD, IDEAL_CMD PROFILER}
2083,{jjTIMES_ID,  '*',            MODUL_CMD,      IDEAL_CMD,  MODUL_CMD PROFILER}
2084,{jjTIMES_ID,  '*',            MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
2085,{jjTIMES_MA_P1,'*',           MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
2086,{jjTIMES_MA_P2,'*',           MATRIX_CMD,     POLY_CMD,   MATRIX_CMD PROFILER}
2087,{jjTIMES_MA_N1,'*',           MATRIX_CMD,     MATRIX_CMD, NUMBER_CMD PROFILER}
2088,{jjTIMES_MA_N2,'*',           MATRIX_CMD,     NUMBER_CMD, MATRIX_CMD PROFILER}
2089,{jjTIMES_MA_I1,'*',           MATRIX_CMD,     MATRIX_CMD, INT_CMD PROFILER}
2090,{jjTIMES_MA_I2,'*',           MATRIX_CMD,     INT_CMD,    MATRIX_CMD PROFILER}
2091,{jjTIMES_MA,  '*',            MATRIX_CMD,     MATRIX_CMD, MATRIX_CMD PROFILER}
2092,{jjOP_IV_I,   '*',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2093,{jjOP_I_IV,   '*',            INTVEC_CMD,     INT_CMD,    INTVEC_CMD PROFILER}
2094,{jjOP_IV_I,   '*',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2095,{jjOP_I_IV,   '*',            INTMAT_CMD,     INT_CMD,    INTMAT_CMD PROFILER}
2096,{jjTIMES_IV,  '*',            INTVEC_CMD,     INTMAT_CMD, INTVEC_CMD PROFILER}
2097,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD PROFILER}
2098,{jjTIMES_IV,  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD PROFILER}
2099,{jjDIV_N,     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD PROFILER}
2100,{jjDIV_P,     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2101,{jjDIV_P,     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2102,{jjDIV_I,     '/',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2103,{jjOP_IV_I,   '/',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2104,{jjOP_IV_I,   '/',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2105,{jjDIV_I,     INTDIV,         INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2106,{jjOP_IV_I,   INTDIV,         INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2107,{jjOP_IV_I,   INTDIV,         INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2108,{jjMOD_I,     '%',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2109,{jjOP_IV_I,   '%',            INTVEC_CMD,     INTVEC_CMD, INT_CMD PROFILER}
2110,{jjOP_IV_I,   '%',            INTMAT_CMD,     INTMAT_CMD, INT_CMD PROFILER}
2111,{jjPOWER_I,   '^',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2112,{jjPOWER_N,   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD PROFILER}
2113,{jjPOWER_P,   '^',            POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2114,{jjPOWER_ID,  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2115,{jjLE_I,      LE,             INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2116,{jjLE_N,      LE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2117,{jjCOMPARE_S, LE,             INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2118,{jjCOMPARE_IV_I,LE,           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2119,{jjCOMPARE_IV,LE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2120,{jjCOMPARE_P, LE,             INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2121,{jjCOMPARE_P, LE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2122,{jjLT_I,      '<',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2123,{jjLT_N,      '<',            INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2124,{jjCOMPARE_IV_I,'<',           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2125,{jjCOMPARE_IV,'<',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2126,{jjCOMPARE_S, '<',            INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2127,{jjCOMPARE_P, '<',            INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2128,{jjCOMPARE_P, '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2129,{jjGE_I,      GE,             INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2130,{jjGE_N,      GE,             INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2131,{jjCOMPARE_S, GE,             INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2132,{jjCOMPARE_IV_I,GE,           INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2133,{jjCOMPARE_IV,GE,             INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2134,{jjCOMPARE_P, GE,             INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2135,{jjCOMPARE_P, GE,             INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2136,{jjGT_I,      '>',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2137,{jjGT_N,      '>',            INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2138,{jjCOMPARE_S, '>',            INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2139,{jjCOMPARE_IV_I,'>',          INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2140,{jjCOMPARE_IV,'>',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2141,{jjCOMPARE_P, '>',            INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2142,{jjCOMPARE_P, '>',            INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2143,{jjAND_I,     '&',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2144,{jjOR_I,      '|',            INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2145,{jjEQUAL_I,   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2146,{jjEQUAL_N,   EQUAL_EQUAL,    INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2147,{jjCOMPARE_S, EQUAL_EQUAL,    INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2148,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2149,{jjEQUAL_P,   EQUAL_EQUAL,    INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2150,{jjCOMPARE_IV_I,EQUAL_EQUAL,  INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2151,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2152,{jjCOMPARE_IV,EQUAL_EQUAL,    INT_CMD,        INTMAT_CMD, INTMAT_CMD PROFILER}
2153,{jjEQUAL_Ma,  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD PROFILER}
2154,{jjWRONG2,    EQUAL_EQUAL,    0,              IDEAL_CMD,  IDEAL_CMD PROFILER}
2155,{jjWRONG2,    EQUAL_EQUAL,    0,              MODUL_CMD,  MODUL_CMD PROFILER}
2156,{jjEQUAL_I,   NOTEQUAL,       INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2157,{jjEQUAL_N,   NOTEQUAL,       INT_CMD,        NUMBER_CMD, NUMBER_CMD PROFILER}
2158,{jjCOMPARE_S, NOTEQUAL,       INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2159,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        POLY_CMD,   POLY_CMD PROFILER}
2160,{jjEQUAL_P,   NOTEQUAL,       INT_CMD,        VECTOR_CMD, VECTOR_CMD PROFILER}
2161,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2162,{jjCOMPARE_IV,NOTEQUAL,       INT_CMD,        INTMAT_CMD, INTMAT_CMD PROFILER}
2163,{jjEQUAL_Ma,  NOTEQUAL,       INT_CMD,        MATRIX_CMD, MATRIX_CMD PROFILER}
2164,{jjWRONG2,    NOTEQUAL,       0,              IDEAL_CMD,  IDEAL_CMD PROFILER}
2165,{jjWRONG2,    NOTEQUAL,       0,              MODUL_CMD,  MODUL_CMD PROFILER}
2166,{jjDOTDOT,    DOTDOT,         INTVEC_CMD,     INT_CMD,    INT_CMD PROFILER}
2167,{jjINDEX_I,   '[',            INT_CMD,        INTVEC_CMD, INT_CMD PROFILER}
2168,{jjINDEX_IV,  '[',            INT_CMD,        INTVEC_CMD, INTVEC_CMD PROFILER}
2169,{jjINDEX_I,   '[',            POLY_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2170,{jjINDEX_I,   '[',            POLY_CMD,       MAP_CMD,    INT_CMD PROFILER}
2171,{jjINDEX_IV,  '[',            POLY_CMD,       IDEAL_CMD,  INTVEC_CMD PROFILER}
2172,{jjINDEX_I,   '[',            VECTOR_CMD,     MODUL_CMD,  INT_CMD PROFILER}
2173,{jjINDEX_IV,  '[',            VECTOR_CMD,     MODUL_CMD,  INTVEC_CMD PROFILER}
2174,{jjINDEX_I,   '[',            STRING_CMD,     STRING_CMD, INT_CMD PROFILER}
2175,{jjINDEX_IV,  '[',            STRING_CMD,     STRING_CMD, INTVEC_CMD PROFILER}
2176,{jjINDEX_I,   '[',            ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD PROFILER}
2177,{jjINDEX_IV,  '[',            ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD PROFILER}
2178,{jjINDEX_P,   '[',            POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2179,{jjINDEX_P_IV,'[',            POLY_CMD,       POLY_CMD,   INTVEC_CMD PROFILER}
2180,{jjINDEX_V,   '[',            POLY_CMD,       VECTOR_CMD, INT_CMD PROFILER}
2181,{jjINDEX_V_IV,'[',            VECTOR_CMD,     VECTOR_CMD, INTVEC_CMD PROFILER}
2182,{jjPROC,      '(',            ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD PROFILER}
2183,{jjMAP,       '(',            ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD PROFILER}
2184,{jjKLAMMER,   '(',            ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD PROFILER}
2185,{jjKLAMMER_IV,'(',            ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD PROFILER}
2186// and the procedures with 2 arguments:
2187,{atATTRIB2,   ATTRIB_CMD,     NONE/*set by p*/,DEF_CMD,   STRING_CMD PROFILER}
2188,{jjWRONG2,    BAREISS_CMD,    0,              DEF_CMD,    DEF_CMD PROFILER}
2189,{syBetti2,    BETTI_CMD,      INTMAT_CMD,     RESOLUTION_CMD, INT_CMD PROFILER}
2190,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD PROFILER}
2191,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD PROFILER}
2192,{jjCOEFFS_Id, COEFFS_CMD,     MATRIX_CMD,     MODUL_CMD,  POLY_CMD PROFILER}
2193,{jjCONTRACT,  CONTRACT_CMD,   MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2194,{jjDEG_IV,    DEG_CMD,        INT_CMD,        POLY_CMD,   INTVEC_CMD PROFILER}
2195,{lDelete,     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD PROFILER}
2196,{jjDIFF_P,    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2197,{jjDIFF_P,    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2198,{jjDIFF_ID,   DIFF_CMD,       IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2199,{jjDIFF_ID_ID,DIFF_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2200,{jjDIFF_ID,   DIFF_CMD,       MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2201,{jjDIFF_ID,   DIFF_CMD,       MATRIX_CMD,     MATRIX_CMD, POLY_CMD PROFILER}
2202,{jjDIM2,      DIM_CMD,        INT_CMD,        IDEAL_CMD,  IDEAL_CMD PROFILER}
2203,{jjDIM2,      DIM_CMD,        INT_CMD,        MODUL_CMD,  IDEAL_CMD PROFILER}
2204,{jjELIMIN,    ELIMINATION_CMD,IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2205,{jjELIMIN,    ELIMINATION_CMD,MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2206,{jjEXTGCD_I,  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD PROFILER}
2207#ifdef HAVE_FACTORY
2208,{jjEXTGCD_P,  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2209,{jjSQR_FREE_DEC,FAC_CMD,      IDEAL_CMD,      POLY_CMD,   INT_CMD PROFILER}
2210,{jjFACSTD2,    FACSTD_CMD,    LIST_CMD,       IDEAL_CMD,  IDEAL_CMD PROFILER}
2211#else
2212,{jjWRONG2,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2213,{jjWRONG2,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD PROFILER}
2214,{jjWRONG2,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD PROFILER}
2215#endif
2216,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE PROFILER}
2217,{jjFETCH,     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE PROFILER}
2218#ifdef HAVE_FGLM
2219,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD PROFILER}
2220,{fglmProc,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD PROFILER}
2221,{fglmQuotProc,FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2222#else
2223,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD PROFILER}
2224,{jjWRONG2,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD PROFILER}
2225,{jjWRONG2,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD PROFILER}
2226#endif
2227,{jjFIND2,     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD PROFILER}
2228,{jjGCD_I,     GCD_CMD,        INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2229#ifdef HAVE_FACTORY
2230,{jjGCD_P,     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2231#else
2232,{jjWRONG2,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2233#endif
2234,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD PROFILER}
2235,{jjHILBERT2,  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD PROFILER}
2236,{jjHOMOG_P,   HOMOG_CMD,      POLY_CMD,       POLY_CMD,   POLY_CMD PROFILER}
2237,{jjHOMOG_P,   HOMOG_CMD,      VECTOR_CMD,     VECTOR_CMD, POLY_CMD PROFILER}
2238,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
2239,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
2240,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2241,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD PROFILER}
2242,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE PROFILER}
2243,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE PROFILER}
2244,{jjINDEPSET2, INDEPSET_CMD,   LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2245,{lInsert,     INSERT_CMD,     LIST_CMD,       LIST_CMD,   DEF_CMD PROFILER}
2246,{jjINTERSECT, INTERSECT_CMD,  IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2247,{jjINTERSECT, INTERSECT_CMD,  MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2248,{jjJET_P,     JET_CMD,        POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2249,{jjJET_ID,    JET_CMD,        IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2250,{jjJET_P,     JET_CMD,        VECTOR_CMD,     VECTOR_CMD, INT_CMD PROFILER}
2251,{jjJET_ID,    JET_CMD,        MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2252,{jjJET_ID,    JET_CMD,        MATRIX_CMD,     MATRIX_CMD,  INT_CMD PROFILER}
2253,{jjKBASE2,    KBASE_CMD,      IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2254,{jjKBASE2,    KBASE_CMD,      MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2255,{atKILLATTR2, KILLATTR_CMD,   NONE,           IDHDL,      STRING_CMD PROFILER}
2256,{jjKoszul,    KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    INT_CMD PROFILER}
2257,{jjKoszul_Id, KOSZUL_CMD,     MATRIX_CMD,     INT_CMD,    IDEAL_CMD PROFILER}
2258,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     IDEAL_CMD,  IDEAL_CMD PROFILER}
2259,{jjLIFT,      LIFT_CMD,       MATRIX_CMD,     MODUL_CMD,  MODUL_CMD PROFILER}
2260,{jjLIFTSTD,   LIFTSTD_CMD,    IDEAL_CMD,      IDEAL_CMD,  MATRIX_CMD PROFILER}
2261,{jjLIFTSTD,   LIFTSTD_CMD,    MODUL_CMD,      MODUL_CMD,  MATRIX_CMD PROFILER}
2262,{jjCALL2MANY, LIST_CMD,       LIST_CMD,       DEF_CMD,    DEF_CMD PROFILER}
2263,{jjRES,       LRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2264,{jjMINOR,     MINOR_CMD,      IDEAL_CMD,      MATRIX_CMD, INT_CMD PROFILER}
2265,{jjCALL2MANY, MODUL_CMD,      MODUL_CMD,      DEF_CMD,    DEF_CMD PROFILER}
2266,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2267,{jjMODULO,    MODULO_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2268,{jjMONITOR2,  MONITOR_CMD,    NONE,           STRING_CMD, STRING_CMD PROFILER}
2269//,{jjRES,       MRES_CMD,       LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2270//,{jjRES,       MRES_CMD,       LIST_CMD,       MODUL_CMD,  INT_CMD PROFILER}
2271,{jjRES,       MRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2272,{jjRES,       MRES_CMD,       RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2273,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     RING_CMD,   INT_CMD PROFILER}
2274,{jjPARSTR2,   PARSTR_CMD,     STRING_CMD,     QRING_CMD,  INT_CMD PROFILER}
2275,{jjPRINT_FORMAT, PRINT_CMD,   ANY_TYPE,       DEF_CMD,    STRING_CMD PROFILER}
2276,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2277,{jjQUOT,      QUOTIENT_CMD,   MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
2278,{jjQUOT,      QUOTIENT_CMD,   IDEAL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2279,{jjRANDOM,    RANDOM_CMD,     INT_CMD,        INT_CMD,    INT_CMD PROFILER}
2280,{jjREAD2,     READ_CMD,       STRING_CMD,     LINK_CMD,   STRING_CMD PROFILER}
2281,{jjREDUCE_P,  REDUCE_CMD,     POLY_CMD,       POLY_CMD,   IDEAL_CMD PROFILER}
2282,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, IDEAL_CMD PROFILER}
2283,{jjREDUCE_P,  REDUCE_CMD,     VECTOR_CMD,     VECTOR_CMD, MODUL_CMD PROFILER}
2284,{jjREDUCE_ID, REDUCE_CMD,     IDEAL_CMD,      IDEAL_CMD,  IDEAL_CMD PROFILER}
2285,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  MODUL_CMD PROFILER}
2286,{jjREDUCE_ID, REDUCE_CMD,     MODUL_CMD,      MODUL_CMD,  IDEAL_CMD PROFILER}
2287//,{jjRES,       RES_CMD,        LIST_CMD,       IDEAL_CMD,  INT_CMD PROFILER}
2288//,{jjRES,       RES_CMD,        LIST_CMD,       MODUL_CMD,  INT_CMD PROFILER}
2289,{jjRES,       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
2290,{jjRES,       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD PROFILER}
2291,{jjSTATUS2,   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD PROFILER}
2292,{jjSIMPL_P,   SIMPLIFY_CMD,   POLY_CMD,       POLY_CMD,   INT_CMD PROFILER}
2293,{jjSIMPL_P,   SIMPLIFY_CMD,   VECTOR_CMD,     VECTOR_CMD, INT_CMD PROFILER}
2294,{jjSIMPL_ID,  SIMPLIFY_CMD,   IDEAL_CMD,      IDEAL_CMD,  INT_CMD PROFILER}
2295,{jjSIMPL_ID,  SIMPLIFY_CMD,   MODUL_CMD,      MODUL_CMD,  INT_CMD PROFILER}
2296#ifdef HAVE_SPECTRUM
2297,{spectrumProc2,SPECTRUM_CMD,  LIST_CMD,       POLY_CMD,   INT_CMD PROFILER}
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#ifdef HAVE_SPECTRUM
3599,{spectrumProc, SPECTRUM_CMD,    LIST_CMD,       POLY_CMD }
3600#endif
3601,{jjSTD,        STD_CMD,         IDEAL_CMD,      IDEAL_CMD }
3602,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD }
3603,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD }
3604,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD }
3605,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD }
3606,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD }
3607,{jjWRONG,      TRACE_CMD,       0,              INTVEC_CMD }
3608,{jjWRONG,      TRACE_CMD,       0,              IDEAL_CMD }
3609,{jjTRACE_IV,   TRACE_CMD,       INT_CMD,        INTMAT_CMD }
3610,{jjmpTrace,    TRACE_CMD,       XS(POLY_CMD),   MATRIX_CMD }
3611,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTVEC_CMD }
3612,{jjTRANSP_IV,  TRANSPOSE_CMD,   INTMAT_CMD,     INTMAT_CMD }
3613,{jjmpTransp,   TRANSPOSE_CMD,   XS(MATRIX_CMD), MATRIX_CMD }
3614,{jjidTransp,   TRANSPOSE_CMD,   XS(MODUL_CMD),  MODUL_CMD }
3615,{jjTYPEOF,     TYPEOF_CMD,      STRING_CMD,     ANY_TYPE }
3616,{jjDUMMY,      VECTOR_CMD,      VECTOR_CMD,     VECTOR_CMD }
3617,{jjVDIM,       VDIM_CMD,        INT_CMD,        IDEAL_CMD }
3618,{jjVDIM,       VDIM_CMD,        INT_CMD,        MODUL_CMD }
3619,{jjVAR1,       VAR_CMD,         POLY_CMD,       INT_CMD }
3620,{jjVARSTR1,    VARSTR_CMD,      STRING_CMD,     INT_CMD }
3621,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), RING_CMD }
3622,{jjrVarStr,    VARSTR_CMD,      XS(STRING_CMD), QRING_CMD }
3623,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     IDEAL_CMD }
3624,{kWeight,      WEIGHT_CMD,      INTVEC_CMD,     MODUL_CMD }
3625,{jjLOAD1,      LOAD_CMD,        NONE,           STRING_CMD }
3626,{NULL,         0,               0,              0}
3627};
3628#undef s
3629/*=================== operations with 3 args.: static proc =================*/
3630static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
3631{
3632  char *s= (char *)u->Data();
3633  int   r = (int)v->Data();
3634  int   c = (int)w->Data();
3635  int l = strlen(s);
3636
3637  if ( (r<1) || (r>l) || (c<0) )
3638  {
3639    Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
3640    return TRUE;
3641  }
3642  res->data = (char *)AllocL(c+1);
3643  sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
3644  return FALSE;
3645}
3646static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
3647{
3648  intvec *iv = (intvec *)u->Data();
3649  int   r = (int)v->Data();
3650  int   c = (int)w->Data();
3651  if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
3652  {
3653    Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
3654           r,c,u->Fullname(),iv->rows(),iv->cols());
3655    return TRUE;
3656  }
3657  res->data=u->data;
3658  u->data=NULL;
3659  res->rtyp=u->rtyp;
3660  u->rtyp=0;
3661  res->name=u->name;
3662  u->name=NULL;
3663  Subexpr e=jjMakeSub(v);
3664          e->next=jjMakeSub(w);
3665  if (u->e==NULL) res->e=e;
3666  else
3667  {
3668    Subexpr h=u->e;
3669    while (h->next!=NULL) h=h->next;
3670    h->next=e;
3671    res->e=u->e;
3672    u->e=NULL;
3673  }
3674  return FALSE;
3675}
3676static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
3677{
3678  matrix m= (matrix)u->Data();
3679  int   r = (int)v->Data();
3680  int   c = (int)w->Data();
3681  //Print("gen. elem %d, %d\n",r,c);
3682  if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
3683  {
3684    Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
3685      MATROWS(m),MATCOLS(m));
3686    return TRUE;
3687  }
3688  res->data=u->data;
3689  u->data=NULL;
3690  res->rtyp=u->rtyp;
3691  u->rtyp=0;
3692  res->name=u->name;
3693  u->name=NULL;
3694  Subexpr e=jjMakeSub(v);
3695          e->next=jjMakeSub(w);
3696  if (u->e==NULL)
3697    res->e=e;
3698  else
3699  {
3700    Subexpr h=u->e;
3701    while (h->next!=NULL) h=h->next;
3702    h->next=e;
3703    res->e=u->e;
3704    u->e=NULL;
3705  }
3706  return FALSE;
3707}
3708static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
3709{
3710  sleftv t;
3711  sleftv ut;
3712  leftv p=NULL;
3713  intvec *iv=(intvec *)w->Data();
3714  int l;
3715  BOOLEAN nok;
3716
3717  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3718  {
3719    WerrorS("cannot build expression lists from unnamed objects");
3720    return TRUE;
3721  }
3722  memcpy(&ut,u,sizeof(ut));
3723  memset(&t,0,sizeof(t));
3724  t.rtyp=INT_CMD;
3725  for (l=0;l< iv->length(); l++)
3726  {
3727    t.data=(char *)(*iv)[l];
3728    if (p==NULL)
3729    {
3730      p=res;
3731    }
3732    else
3733    {
3734      p->next=(leftv)Alloc0SizeOf(sleftv);
3735      p=p->next;
3736    }
3737    memcpy(u,&ut,sizeof(ut));
3738    if (u->Typ() == MATRIX_CMD)
3739      nok=jjBRACK_Ma(p,u,v,&t);
3740    else /* INTMAT_CMD */
3741      nok=jjBRACK_Im(p,u,v,&t);
3742    if (nok)
3743    {
3744      while (res->next!=NULL)
3745      {
3746        p=res->next->next;
3747        FreeSizeOf((ADDRESS)res->next,sleftv);
3748        // res->e aufraeumen !!!!
3749        res->next=p;
3750      }
3751      return TRUE;
3752    }
3753  }
3754  return FALSE;
3755}
3756static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
3757{
3758  sleftv t;
3759  sleftv ut;
3760  leftv p=NULL;
3761  intvec *iv=(intvec *)v->Data();
3762  int l;
3763  BOOLEAN nok;
3764
3765  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3766  {
3767    WerrorS("cannot build expression lists from unnamed objects");
3768    return TRUE;
3769  }
3770  memcpy(&ut,u,sizeof(ut));
3771  memset(&t,0,sizeof(t));
3772  t.rtyp=INT_CMD;
3773  for (l=0;l< iv->length(); l++)
3774  {
3775    t.data=(char *)((*iv)[l]);
3776    if (p==NULL)
3777    {
3778      p=res;
3779    }
3780    else
3781    {
3782      p->next=(leftv)Alloc0SizeOf(sleftv);
3783      p=p->next;
3784    }
3785    memcpy(u,&ut,sizeof(ut));
3786    if (u->Typ() == MATRIX_CMD)
3787      nok=jjBRACK_Ma(p,u,&t,w);
3788    else /* INTMAT_CMD */
3789      nok=jjBRACK_Im(p,u,&t,w);
3790    if (nok)
3791    {
3792      while (res->next!=NULL)
3793      {
3794        p=res->next->next;
3795        FreeSizeOf((ADDRESS)res->next,sleftv);
3796        // res->e aufraeumen !!
3797        res->next=p;
3798      }
3799      return TRUE;
3800    }
3801  }
3802  return FALSE;
3803}
3804static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
3805{
3806  sleftv t1,t2,ut;
3807  leftv p=NULL;
3808  intvec *vv=(intvec *)v->Data();
3809  intvec *wv=(intvec *)w->Data();
3810  int vl;
3811  int wl;
3812  BOOLEAN nok;
3813
3814  if ((u->rtyp!=IDHDL)||(u->e!=NULL))
3815  {
3816    WerrorS("cannot build expression lists from unnamed objects");
3817    return TRUE;
3818  }
3819  memcpy(&ut,u,sizeof(ut));
3820  memset(&t1,0,sizeof(sleftv));
3821  memset(&t2,0,sizeof(sleftv));
3822  t1.rtyp=INT_CMD;
3823  t2.rtyp=INT_CMD;
3824  for (vl=0;vl< vv->length(); vl++)
3825  {
3826    t1.data=(char *)((*vv)[vl]);
3827    for (wl=0;wl< wv->length(); wl++)
3828    {
3829      t2.data=(char *)((*wv)[wl]);
3830      if (p==NULL)
3831      {
3832        p=res;
3833      }
3834      else
3835      {
3836        p->next=(leftv)Alloc0SizeOf(sleftv);
3837        p=p->next;
3838      }
3839      memcpy(u,&ut,sizeof(ut));
3840      if (u->Typ() == MATRIX_CMD)
3841        nok=jjBRACK_Ma(p,u,&t1,&t2);
3842      else /* INTMAT_CMD */
3843        nok=jjBRACK_Im(p,u,&t1,&t2);
3844      if (nok)
3845      {
3846        res->CleanUp();
3847        return TRUE;
3848      }
3849    }
3850  }
3851  return FALSE;
3852}
3853static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
3854{
3855  v->next=(leftv)AllocSizeOf(sleftv);
3856  memcpy(v->next,w,sizeof(sleftv));
3857  BOOLEAN r=iiExprArith2(res,u,'(',v);
3858  v->rtyp=0; v->data=NULL;
3859  w->rtyp=0; w->data=NULL;
3860  return r;
3861}
3862static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
3863{
3864  u->next=(leftv)AllocSizeOf(sleftv);
3865  memcpy(u->next,v,sizeof(sleftv));
3866  u->next->next=(leftv)AllocSizeOf(sleftv);
3867  memcpy(u->next->next,w,sizeof(sleftv));
3868  BOOLEAN r=iiExprArithM(res,u,iiOp);
3869  v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
3870  w->rtyp=0; w->data=NULL;
3871  return r;
3872}
3873static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
3874{
3875  lists l=smCallNewBareiss((ideal)u->Data(),(int)v->Data(),(int)w->Data());
3876  res->data = (char *)l;
3877  return FALSE;
3878}
3879static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
3880{
3881  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
3882  {
3883    WerrorS("3rd argument must be a name of a matrix");
3884    return TRUE;
3885  }
3886  ideal i=(ideal)u->Data();
3887  int rank=(int)i->rank;
3888  BOOLEAN r=jjCOEFFS_Id(res,u,v);
3889  if (r) return TRUE;
3890  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3891  return FALSE;
3892}
3893static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
3894{
3895  res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
3896           (ideal)(v->Data()),(poly)(w->Data()));
3897  return FALSE;
3898}
3899static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
3900{
3901  if ((w->rtyp!=IDHDL)||(w->e!=NULL))
3902  {
3903    WerrorS("3rd argument must be a name of a matrix");
3904    return TRUE;
3905  }
3906  // CopyD for POLY_CMD and VECTOR_CMD are identical:
3907  poly p=(poly)u->CopyD(POLY_CMD);
3908  ideal i=idInit(1,1);
3909  i->m[0]=p;
3910  sleftv t;
3911  memset(&t,0,sizeof(t));
3912  t.data=(char *)i;
3913  t.rtyp=IDEAL_CMD;
3914  int rank=1;
3915  if (u->Typ()==VECTOR_CMD)
3916  {
3917    i->rank=rank=pMaxComp(p);
3918    t.rtyp=MODUL_CMD;
3919  }
3920  BOOLEAN r=jjCOEFFS_Id(res,&t,v);
3921  t.CleanUp();
3922  if (r) return TRUE;
3923  mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3924  return FALSE;
3925}
3926static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
3927{
3928  res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
3929    (intvec *)w->Data());
3930  setFlag(res,FLAG_STD);
3931  return FALSE;
3932}
3933static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
3934{
3935  /*4
3936  * look for the substring what in the string where
3937  * starting at position n
3938  * return the position of the first char of what in where
3939  * or 0
3940  */
3941  int n=(int)w->Data();
3942  char *where=(char *)u->Data();
3943  char *what=(char *)v->Data();
3944  char *found;
3945  if ((1>n)||(n>(int)strlen(where)))
3946  {
3947    Werror("start position %d out of range",n);
3948    return TRUE;
3949  }
3950  found = strchr(where+n-1,*what);
3951  if (*(what+1)!='\0')
3952  {
3953    while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
3954    {
3955      found=strchr(found+1,*what);
3956    }
3957  }
3958  if (found != NULL)
3959  {
3960    res->data=(char *)((found-where)+1);
3961  }
3962  return FALSE;
3963}
3964static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
3965{
3966  intvec* im= NewIntvec3((int)v->Data(),(int)w->Data(), 0);
3967  intvec* arg = (intvec*) u->Data();
3968  int i, n = min(im->cols()*im->rows(), arg->cols()*arg->rows());
3969
3970  for (i=0; i<n; i++)
3971  {
3972    (*im)[i] = (*arg)[i];
3973  }
3974
3975  res->data = (char *)im;
3976  return FALSE;
3977}
3978static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
3979{
3980  short *iw=iv2array((intvec *)w->Data());
3981  res->data = (char *)pJetW((poly)u->Data(),(int)v->Data(),iw);
3982  Free((ADDRESS)iw,(pVariables+1)*sizeof(short));
3983  return FALSE;
3984}
3985static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
3986{
3987  res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
3988                             (intvec *)w->Data());
3989  return FALSE;
3990}
3991static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
3992{
3993  idhdl h;
3994  ring rr;
3995  map mapping;
3996
3997  if ((v->name==NULL) || (w->name==NULL))
3998  {
3999    WerrorS("2nd/3rd arguments must have names");
4000    return TRUE;
4001  }
4002  rr=(ring)u->Data();
4003  const char *ring_name=u->Name();
4004  if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4005  {
4006    if (h->typ==MAP_CMD)
4007    {
4008      mapping=IDMAP(h);
4009      idhdl preim_ring=idroot->get(mapping->preimage,myynest);
4010      if ((preim_ring==NULL)
4011      || (IDRING(preim_ring)!=currRing))
4012      {
4013        Werror("preimage ring `%s` is not the basering",mapping->preimage);
4014        return TRUE;
4015      }
4016    }
4017    else if (h->typ==IDEAL_CMD)
4018    {
4019      mapping=IDMAP(h);
4020    }
4021    else
4022    {
4023      Werror("`%s` is no map nor ideal",IDID(h));
4024      return TRUE;
4025    }
4026  }
4027  else
4028  {
4029    Werror("`%s` is not defined in `%s`",v->name,ring_name);
4030    return TRUE;
4031  }
4032  if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4033  {
4034    if (h->typ==IDEAL_CMD)
4035    {
4036      res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4037    }
4038    else
4039    {
4040      Werror("`%s` is no ideal",IDID(h));
4041      return TRUE;
4042    }
4043  }
4044  else
4045  {
4046    Werror("`%s` is not defined in `%s`",w->name,ring_name);
4047    return TRUE;
4048  }
4049  return FALSE;
4050}
4051static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4052{
4053  int di, k;
4054  int i=(int)u->Data();
4055  int r=(int)v->Data();
4056  int c=(int)w->Data();
4057  intvec *iv = NewIntvec3(r, c, 0);
4058  if (iv->rows()==0)
4059  {
4060    delete iv;
4061    return TRUE;
4062  }
4063  if (i!=0)
4064  {
4065    if (i<0) i = -i;
4066    di = 2 * i + 1;
4067    for (k=0; k<iv->length(); k++)
4068    {
4069#ifdef buildin_rand
4070      (*iv)[k] = ((siRand() % di) - i);
4071#else
4072      (*iv)[k] = ((rand() % di) - i);
4073#endif
4074    }
4075  }
4076  res->data = (char *)iv;
4077  return FALSE;
4078}
4079static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4080  int &ringvar, poly &monomexpr)
4081{
4082  monomexpr=(poly)w->Data();
4083  if (pLength(monomexpr)>1)
4084  {
4085    Werror("`%s` substitutes a ringvar only by a term",
4086      Tok2Cmdname(SUBST_CMD));
4087    return TRUE;
4088  }
4089  if (!(ringvar=pVar((poly)v->Data())))
4090  {
4091    WerrorS("ringvar expected");
4092    return TRUE;
4093  }
4094  return FALSE;
4095}
4096static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4097{
4098  int ringvar;
4099  poly monomexpr;
4100  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4101  if (nok) return TRUE;
4102  res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4103  return FALSE;
4104}
4105static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4106{
4107  int ringvar;
4108  poly monomexpr;
4109  BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4110  if (nok) return TRUE;
4111  res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4112  return FALSE;
4113}
4114// we do not want to have jjSUBST_Id_X inlined:
4115static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4116                            int input_type);
4117static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4118{
4119  return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4120}
4121static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4122{
4123  return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4124}
4125static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4126{
4127  sleftv tmp;
4128  memset(&tmp,0,sizeof(tmp));
4129  // do not check the result, conversion form int/number to poly works always
4130  iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4131  BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4132  tmp.CleanUp();
4133  return b;
4134}
4135static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4136{
4137  matrix m=mpNew((int)v->Data(),(int)w->Data());
4138  ideal I=(ideal)u->CopyD(IDEAL_CMD);
4139  int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4140  //for(i=i-1;i>=0;i--)
4141  //{
4142  //  m->m[i]=I->m[i];
4143  //  I->m[i]=NULL;
4144  //}
4145  memcpy4(m->m,I->m,i*sizeof(poly));
4146  memset(I->m,0,i*sizeof(poly));
4147  idDelete(&I);
4148  res->data = (char *)m;
4149  return FALSE;
4150}
4151static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4152{
4153  res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4154           (int)v->Data(),(int)w->Data());
4155  return FALSE;
4156}
4157static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4158{
4159  matrix m=mpNew((int)v->Data(),(int)w->Data());
4160  matrix I=(matrix)u->CopyD(MATRIX_CMD);
4161  int r=min(MATROWS(I),(int)v->Data());
4162  int c=min(MATCOLS(I),(int)w->Data());
4163  int i,j;
4164  for(i=r;i>0;i--)
4165  {
4166    for(j=c;j>0;j--)
4167    {
4168      MATELEM(m,i,j)=MATELEM(I,i,j);
4169      MATELEM(I,i,j)=NULL;
4170    }
4171  }
4172  idDelete((ideal *)&I);
4173  res->data = (char *)m;
4174  return FALSE;
4175}
4176static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4177{
4178  int sw=(int)w->Data();
4179  if (sw==0)
4180  {
4181    return jjLIFT(res,u,v);
4182  }
4183  else
4184  {
4185    ideal m;
4186    ideal ui=(ideal)u->Data();
4187    ideal vi=(ideal)v->Data();
4188    int ul= IDELEMS(ui);
4189    int vl= IDELEMS(vi);
4190    m = idLiftNonStB(ui,vi, sw);
4191    res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4192  }
4193  return FALSE;
4194}
4195static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4196{
4197  assumeStdFlag(v);
4198  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4199    0,(int)w->Data());
4200  return FALSE;
4201}
4202static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
4203{
4204  assumeStdFlag(v);
4205  res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
4206    0,(int)w->Data());
4207  return FALSE;
4208}
4209#ifdef OLD_RES
4210static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
4211{
4212  int maxl=(int)v->Data();
4213  int l=0;
4214  resolvente r;
4215  intvec **weights=NULL;
4216  int wmaxl=maxl;
4217  maxl--;
4218  if ((maxl==-1) && (iiOp!=MRES_CMD))
4219    maxl = pVariables-1;
4220  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
4221  {
4222    intvec * iv=(intvec*)atGet(u,"isHomog");
4223    if (iv!=NULL)
4224    {
4225      weights = (intvec**)Alloc0SizeOf(void_ptr);
4226      weights[0] = ivCopy(iv);
4227      l=1;
4228    }
4229    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
4230  }
4231  else
4232    r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
4233  if (r==NULL) return TRUE;
4234  int t3=u->Typ();
4235  iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
4236  return FALSE;
4237  return TRUE;
4238}
4239#endif
4240static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
4241{
4242  res->data=(void *)rInit(u,v,w);
4243  return (res->data==NULL);
4244}
4245static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
4246{
4247  int yes;
4248  jjSTATUS2(res, u, v);
4249  yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
4250  FreeL((ADDRESS) res->data);
4251  res->data = (void *) yes;
4252  return FALSE;
4253}
4254static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
4255{
4256  ideal result;
4257  intvec *ww=(intvec *)atGet(u,"isHomog");
4258  tHomog hom=testHomog;
4259  if (ww!=NULL)
4260  {
4261    ww=ivCopy(ww);
4262    hom=isHomog;
4263  }
4264  result=kStd((ideal)(u->Data()),
4265              currQuotient,
4266              hom,
4267              &ww,                  // module weights
4268              (intvec *)v->Data(),  // hilbert series
4269              0,0,                  // syzComp, newIdeal
4270              (intvec *)w->Data()); // weights of vars
4271  idSkipZeroes(result);
4272  res->data = (char *)result;
4273  setFlag(res,FLAG_STD);
4274  if (ww!=NULL) atSet(res,mstrdup("isHomog"),ww,INTVEC_CMD);
4275  return FALSE;
4276}
4277
4278/*=================== operations with 3 args.: table =================*/
4279struct sValCmd3 dArith3[]=
4280{
4281// operations:
4282// proc             cmd          res         arg1        arg2        arg3
4283 {jjBRACK_S,        '[',        STRING_CMD, STRING_CMD, INT_CMD,    INT_CMD }
4284,{jjBRACK_Im,       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD }
4285,{jjBRACK_Ma_I_IV,  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD }
4286,{jjBRACK_Ma_IV_I,  '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INT_CMD }
4287,{jjBRACK_Ma_IV_IV, '[',        INT_CMD,    INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
4288,{jjBRACK_Ma,       '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INT_CMD }
4289,{jjBRACK_Ma_I_IV,  '[',        POLY_CMD,   MATRIX_CMD, INT_CMD,    INTVEC_CMD }
4290,{jjBRACK_Ma_IV_I,  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD }
4291,{jjBRACK_Ma_IV_IV, '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
4292,{jjPROC3,          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD }
4293,{atATTRIB3,        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD }
4294,{jjBAREISS3,       BAREISS_CMD,LIST_CMD,   MODUL_CMD,  INT_CMD,    INT_CMD }
4295,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD,   MATRIX_CMD }
4296,{jjCOEFFS3_P,      COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD,   MATRIX_CMD }
4297,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  POLY_CMD,   MATRIX_CMD }
4298,{jjCOEFFS3_Id,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  POLY_CMD,   MATRIX_CMD }
4299,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  POLY_CMD }
4300,{jjCOEFFS3_KB,     COEFFS_CMD, MATRIX_CMD, MODUL_CMD,  MODUL_CMD,  POLY_CMD }
4301,{jjELIMIN_HILB,    ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
4302,{jjFIND3,          FIND_CMD,   INT_CMD,    STRING_CMD, STRING_CMD, INT_CMD }
4303,{jjCALL3MANY,      IDEAL_CMD,  IDEAL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4304//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4305,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD }
4306,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD }
4307,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD }
4308,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD }
4309,{jjJET_ID_IV,      JET_CMD,    IDEAL_CMD,  IDEAL_CMD,  INT_CMD,    INTVEC_CMD }
4310,{jjJET_P_IV,       JET_CMD,    VECTOR_CMD, VECTOR_CMD, INT_CMD,    INTVEC_CMD }
4311,{jjJET_ID_IV,      JET_CMD,    MODUL_CMD,  MODUL_CMD,  INT_CMD,    INTVEC_CMD }
4312,{mpKoszul,         KOSZUL_CMD, MATRIX_CMD, INT_CMD,    INT_CMD,    IDEAL_CMD }
4313,{jjCALL3MANY,      LIST_CMD,   LIST_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4314,{jjMATRIX_Id,      MATRIX_CMD, MATRIX_CMD, IDEAL_CMD,  INT_CMD,    INT_CMD }
4315,{jjMATRIX_Mo,      MATRIX_CMD, MATRIX_CMD, MODUL_CMD,  INT_CMD,    INT_CMD }
4316,{jjMATRIX_Ma,      MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD,    INT_CMD }
4317,{jjCALL3MANY,      MODUL_CMD,  MODUL_CMD,  DEF_CMD,    DEF_CMD,    DEF_CMD }
4318#ifdef OLD_RES
4319,{jjRES3,           MRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4320,{jjRES3,           MRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4321#endif
4322,{jjLIFT3,          LIFT_CMD,   MATRIX_CMD, IDEAL_CMD,  IDEAL_CMD,  INT_CMD }
4323,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, RING_CMD,  ANY_TYPE,   ANY_TYPE }
4324,{jjPREIMAGE,       PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE,   ANY_TYPE }
4325,{jjRANDOM_Im,      RANDOM_CMD, INTMAT_CMD, INT_CMD,    INT_CMD,    INT_CMD }
4326,{jjREDUCE3_P,      REDUCE_CMD, POLY_CMD,   POLY_CMD,   IDEAL_CMD,  INT_CMD }
4327,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD,  INT_CMD }
4328,{jjREDUCE3_P,      REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD,  INT_CMD }
4329,{jjREDUCE3_ID,     REDUCE_CMD, IDEAL_CMD,  IDEAL_CMD,  IDEAL_CMD,  INT_CMD }
4330,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  MODUL_CMD,  INT_CMD }
4331,{jjREDUCE3_ID,     REDUCE_CMD, MODUL_CMD,  MODUL_CMD,  IDEAL_CMD,  INT_CMD }
4332#ifdef OLD_RES
4333,{jjRES3,           RES_CMD,    NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4334,{jjRES3,           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4335#endif
4336#ifdef HAVE_FACTORY
4337,{jjRESULTANT,      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4338#else
4339,{jjWRONG3,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD }
4340#endif
4341,{jjRING3,          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD }
4342#ifdef HAVE_SPECTRUM
4343,{semicProc3,       SEMIC_CMD,  INT_CMD,    LIST_CMD,   LIST_CMD,   INT_CMD }
4344,{spectrumOp3,      SPECTRUM_CMD, LIST_CMD, LIST_CMD,   STRING_CMD, INT_CMD }
4345,{spectrumOp3,      SPECTRUM_CMD, LIST_CMD, LIST_CMD,   STRING_CMD, LIST_CMD }
4346#endif
4347#ifdef OLD_RES
4348,{jjRES3,           SRES_CMD,   NONE,       IDEAL_CMD,  INT_CMD,    ANY_TYPE }
4349,{jjRES3,           SRES_CMD,   NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE }
4350#endif
4351,{jjSTATUS3,        STATUS_CMD, INT_CMD,    LINK_CMD,   STRING_CMD, STRING_CMD}
4352,{jjSTD_HILB_W,     STD_CMD,    IDEAL_CMD,  IDEAL_CMD,  INTVEC_CMD, INTVEC_CMD}
4353,{jjSTD_HILB_W,     STD_CMD,    MODUL_CMD,  MODUL_CMD,  INTVEC_CMD, INTVEC_CMD}
4354,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4355,{jjSUBST_P,        SUBST_CMD,  POLY_CMD,   POLY_CMD,   POLY_CMD,   POLY_CMD }
4356,{jjSUBST_P,        SUBST_CMD,  VECTOR_CMD, VECTOR_CMD, POLY_CMD,   POLY_CMD }
4357,{jjSUBST_Id,       SUBST_CMD,  IDEAL_CMD,  IDEAL_CMD,  POLY_CMD,   POLY_CMD }
4358,{jjSUBST_Id,       SUBST_CMD,  MODUL_CMD,  MODUL_CMD,  POLY_CMD,   POLY_CMD }
4359,{jjSUBST_Id,       SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   POLY_CMD }
4360,{jjSUBST_Id_I,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   INT_CMD }
4361,{jjSUBST_Id_N,     SUBST_CMD,  MATRIX_CMD, MATRIX_CMD, POLY_CMD,   NUMBER_CMD }
4362,{jjCALL3MANY,      SYSTEM_CMD, NONE,       STRING_CMD, DEF_CMD,    DEF_CMD  }
4363,{nuLagSolve,       LAGSOLVE_CMD,LIST_CMD,  POLY_CMD,   INT_CMD,    INT_CMD  }
4364,{nuVanderSys,      VANDER_CMD, POLY_CMD,   IDEAL_CMD,  IDEAL_CMD,  INT_CMD  }
4365,{NULL,             0,          0,          0,          0,          0 }
4366};
4367/*=================== operations with many arg.: static proc =================*/
4368static BOOLEAN jjCALL1ARG(leftv res, leftv v)
4369{
4370  return iiExprArith1(res,v,iiOp);
4371}
4372static BOOLEAN jjCALL2ARG(leftv res, leftv u)
4373{
4374  leftv v=u->next;
4375  u->next=NULL;
4376  BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
4377  u->next=v;
4378  return b;
4379}
4380static BOOLEAN jjCALL3ARG(leftv res, leftv u)
4381{
4382  leftv v = u->next;
4383  leftv w = v->next;
4384  u->next = NULL;
4385  v->next = NULL;
4386  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4387  u->next = v;
4388  v->next = w;
4389  return b;
4390}
4391
4392static BOOLEAN jjCOEF_M(leftv res, leftv v)
4393{
4394  if((v->Typ() != VECTOR_CMD)
4395  || (v->next->Typ() != POLY_CMD)
4396  || (v->next->next->Typ() != MATRIX_CMD)
4397  || (v->next->next->next->Typ() != MATRIX_CMD))
4398     return TRUE;
4399  if (v->next->next->rtyp!=IDHDL) return TRUE;
4400  idhdl c=(idhdl)v->next->next->data;
4401  if (v->next->next->next->rtyp!=IDHDL) return TRUE;
4402  idhdl m=(idhdl)v->next->next->next->data;
4403  idDelete((ideal *)&(c->data.uideal));
4404  idDelete((ideal *)&(m->data.uideal));
4405  mpCoef2((poly)v->Data(),(poly)v->next->Data(),
4406    (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix));
4407  return FALSE;
4408}
4409static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
4410{
4411  int s=1;
4412  leftv h=v;
4413  if (h!=NULL) s=exprlist_length(h);
4414  ideal id=idInit(s,1);
4415  int rank=1;
4416  int i=0;
4417  poly p;
4418  while (h!=NULL)
4419  {
4420    switch(h->Typ())
4421    {
4422      case POLY_CMD:
4423      {
4424        p=(poly)h->CopyD(POLY_CMD);
4425        break;
4426      }
4427      case INT_CMD:
4428      {
4429        number n=nInit((int)h->Data());
4430        if (!nIsZero(n))
4431        {
4432          p=pOne();
4433          pSetCoeff(p,n);
4434        }
4435        else
4436        {
4437          p=NULL;
4438          nDelete(&n);
4439        }
4440        break;
4441      }
4442      case NUMBER_CMD:
4443      {
4444        number n=(number)h->CopyD(NUMBER_CMD);
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 VECTOR_CMD:
4458      {
4459        p=(poly)h->CopyD(VECTOR_CMD);
4460        if (iiOp!=MODUL_CMD)
4461        {
4462          idDelete(&id);
4463          pDelete(&p);
4464          return TRUE;
4465        }
4466        rank=max(rank,pMaxComp(p));
4467        break;
4468      }
4469      default:
4470      {
4471        idDelete(&id);
4472        return TRUE;
4473      }
4474    }
4475    if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4476    {
4477      pSetCompP(p,1);
4478    }
4479    id->m[i]=p;
4480    i++;
4481    h=h->next;
4482  }
4483  id->rank=rank;
4484  res->data=(char *)id;
4485  return FALSE;
4486}
4487static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4488{
4489  leftv h=v;
4490  int l=v->listLength();
4491  resolvente r=(resolvente)Alloc0(l*sizeof(ideal));
4492  BOOLEAN *copied=(BOOLEAN *)Alloc0(l*sizeof(BOOLEAN));
4493  int t=0;
4494  // try to convert to IDEAL_CMD
4495  while (h!=NULL)
4496  {
4497    if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4498    {
4499      t=IDEAL_CMD;
4500    }
4501    else break;
4502    h=h->next;
4503  }
4504  // if failure, try MODUL_CMD
4505  if (t==0)
4506  {
4507    h=v;
4508    while (h!=NULL)
4509    {
4510      if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4511      {
4512        t=MODUL_CMD;
4513      }
4514      else break;
4515      h=h->next;
4516    }
4517  }
4518  // check for success  in converting
4519  if (t==0)
4520  {
4521    WerrorS("cannot convert to ideal or module");
4522    return TRUE;
4523  }
4524  // call idMultSect
4525  h=v;
4526  int i=0;
4527  sleftv tmp;
4528  while (h!=NULL)
4529  {
4530    if (h->Typ()==t)
4531    {
4532      r[i]=(ideal)h->Data(); /*no copy*/
4533      h=h->next;
4534    }
4535    else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4536    {
4537      Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4538      Free((ADDRESS)r,l*sizeof(ideal));
4539      Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4540      return TRUE;
4541    }
4542    else
4543    {
4544      r[i]=(ideal)tmp.Data(); /*now it's a copy*/
4545      copied[i]=TRUE;
4546      h=tmp.next;
4547    }
4548    i++;
4549  }
4550  res->rtyp=t;
4551  res->data=(char *)idMultSect(r,i);
4552  while(i>0)
4553  {
4554    i--;
4555    if (copied[i]) idDelete(&(r[i]));
4556  }
4557  Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4558  Free((ADDRESS)r,l*sizeof(ideal));
4559  return FALSE;
4560}
4561static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4562{
4563  int i=0;
4564  leftv h=v;
4565  if (h!=NULL) i=exprlist_length(h);
4566  intvec *iv=NewIntvec1(i);
4567  i=0;
4568  while (h!=NULL)
4569  {
4570    if(h->Typ()==INT_CMD)
4571    {
4572      (*iv)[i]=(int)h->Data();
4573    }
4574    else
4575    {
4576      delete iv;
4577      return TRUE;
4578    }
4579    i++;
4580    h=h->next;
4581  }
4582  res->data=(char *)iv;
4583  return FALSE;
4584}
4585static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4586{
4587  if ((yyInRingConstruction)
4588  && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
4589  {
4590    memcpy(res,u,sizeof(sleftv));
4591    memset(u,0,sizeof(sleftv));
4592    return FALSE;
4593  }
4594  leftv v=u->next;
4595  BOOLEAN b;
4596  if(v==NULL)
4597    b=iiExprArith1(res,u,iiOp);
4598  else
4599  {
4600    u->next=NULL;
4601    b=iiExprArith2(res,u,iiOp,v);
4602    u->next=v;
4603  }
4604  return b;
4605}
4606static BOOLEAN jjLIST_PL(leftv res, leftv v)
4607{
4608  int sl=0;
4609  if (v!=NULL) sl = v->listLength();
4610  lists L;
4611  if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4612  {
4613    L=syConvRes((syStrategy)v->Data());
4614  }
4615  else
4616  {
4617    L=(lists)AllocSizeOf(slists);
4618    leftv h=NULL;
4619    int i;
4620    int rt;
4621
4622    L->Init(sl);
4623    for (i=0;i<sl;i++)
4624    {
4625      if (h!=NULL) { /* e.g. not in the first step:
4626                     * h is the pointer to the old sleftv,
4627                     * v is the pointer to the next sleftv
4628                     * (in this moment) */
4629                     h->next=v;
4630                   }
4631      h=v;
4632      v=v->next;
4633      h->next=NULL;
4634      rt=h->Typ();
4635      if (rt==0)
4636      {
4637        L->Clean();
4638        Werror("`%s` is undefined",h->Fullname());
4639        return TRUE;
4640      }
4641      if ((rt==RING_CMD)||(rt==QRING_CMD))
4642      {
4643        L->m[i].rtyp=rt;
4644        L->m[i].data=h->Data();
4645        ((ring)L->m[i].data)->ref++;
4646      }
4647      else
4648        L->m[i].Copy(h);
4649    }
4650  }
4651  res->data=(char *)L;
4652  return FALSE;
4653}
4654static BOOLEAN jjNAMES0(leftv res, leftv v)
4655{
4656  res->data=(void *)ipNameList(IDROOT);
4657  return FALSE;
4658}
4659static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4660{
4661  if(v==NULL)
4662  {
4663    res->data=(char *)showOption();
4664    return FALSE;
4665  }
4666  res->rtyp=NONE;
4667  return setOption(res,v);
4668}
4669static BOOLEAN jjRESERVED0(leftv res, leftv v)
4670{
4671  int i=1;
4672  loop
4673  {
4674    Print("%-20s",cmds[i].name);
4675    i++;
4676    if(cmds[i].name==NULL)
4677      break;
4678    if ((i%3)==1) PrintLn();
4679  }
4680  PrintLn();
4681  return FALSE;
4682}
4683static BOOLEAN jjSTRING_PL(leftv res, leftv v)
4684{
4685  if (v == NULL)
4686  {
4687    res->data = mstrdup("");
4688    return FALSE;
4689  }
4690  int n = v->listLength();
4691  if (n == 1)
4692  {
4693    res->data = v->String();
4694    return FALSE;
4695  }
4696
4697  char** slist = (char**) Alloc(n*sizeof(char*));
4698  int i, j;
4699
4700  for (i=0, j=0; i<n; i++, v = v ->next)
4701  {
4702    slist[i] = v->String();
4703    assume(slist[i] != NULL);
4704    j+=strlen(slist[i]);
4705  }
4706  char* s = (char*) AllocL((j+1)*sizeof(char));
4707  *s='\0';
4708  for (i=0;i<n;i++)
4709  {
4710    strcat(s, slist[i]);
4711    FreeL(slist[i]);
4712  }
4713  Free(slist, n*sizeof(char*));
4714  res->data = s;
4715  return FALSE;
4716}
4717static BOOLEAN jjTEST(leftv res, leftv v)
4718{
4719  do
4720  {
4721    if (v->Typ()!=INT_CMD)
4722      return TRUE;
4723    test_cmd((int)v->Data());
4724    v=v->next;
4725  }
4726  while (v!=NULL);
4727  return FALSE;
4728}
4729
4730#ifndef __MWERKS__
4731static BOOLEAN jjSTATUS_M(leftv res, leftv v)
4732{
4733  if ((v->Typ() != LINK_CMD) ||
4734      (v->next->Typ() != STRING_CMD) ||
4735      (v->next->next->Typ() != STRING_CMD) ||
4736      (v->next->next->next->Typ() != INT_CMD))
4737    return TRUE;
4738  jjSTATUS3(res, v, v->next, v->next->next);
4739#if defined(HAVE_USLEEP)
4740  if (((int) res->data) == 0)
4741  {
4742    int i_s = (int) v->next->next->next->Data();
4743    if (i_s > 0)
4744    {
4745      usleep((int) v->next->next->next->Data());
4746      jjSTATUS3(res, v, v->next, v->next->next);
4747    }
4748  }
4749#elif defined(HAVE_SLEEP)
4750  if (((int) res->data) == 0)
4751  {
4752    int i_s = (int) v->next->next->next->Data();
4753    if (i_s > 0)
4754    {
4755      sleep((is - 1)/1000000 + 1);
4756      jjSTATUS3(res, v, v->next, v->next->next);
4757    }
4758  }
4759#endif
4760  return FALSE;
4761}
4762#endif
4763static BOOLEAN jjSUBST_M(leftv res, leftv u)
4764{
4765  leftv v = u->next;
4766  leftv w = v->next;
4767  leftv rest = w->next;
4768
4769  u->next = NULL;
4770  v->next = NULL;
4771  w->next = NULL;
4772  BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4773  if ((rest!=NULL) && (!b))
4774  {
4775    sleftv tmp_res;
4776    leftv tmp_next=res->next;
4777    res->next=rest;
4778    memset(&tmp_res,0,sizeof(tmp_res));
4779    b = iiExprArithM(&tmp_res,res,iiOp);
4780    memcpy(res,&tmp_res,sizeof(tmp_res));
4781    res->next=tmp_next;
4782  }
4783  u->next = v;
4784  v->next = w;
4785  // rest was w->next, but is already cleaned
4786  return b;
4787}
4788
4789#ifdef HAVE_NAMESPACES
4790static BOOLEAN jjIMPORTFROM(leftv res, leftv v);
4791
4792static BOOLEAN jjEXPORTTO(leftv res, leftv v)
4793{
4794  BOOLEAN nok=TRUE;
4795  leftv u=v;
4796  if(u->rtyp==NSHDL)
4797  {
4798    namehdl ns = (namehdl)(u->data);
4799    idhdl h = namespaceroot->root->get(ns->name, 0, TRUE);
4800    //Print("Export to '%s', lev %d\n", ns->name, ns->myynest);
4801    while(v->next!=NULL)
4802    {
4803      nok = iiInternalExport(v->next, ns->myynest, h);
4804      if(nok) { return nok; }
4805
4806      v = v->next;
4807    }
4808    return FALSE;
4809  }
4810  if(u->Typ()==PACKAGE_CMD)
4811  {
4812    //PrintS("export to package\n");
4813    while(v->next!=NULL)
4814    {
4815      nok = iiInternalExport(v->next, 0, u->data);
4816      if(nok) return nok;
4817      v = v->next;
4818    }
4819    return FALSE;
4820  }
4821  return TRUE;
4822}
4823#endif /* HAVE_NAMESPACES */
4824#ifdef HAVE_NAMESPACES
4825static BOOLEAN jjIMPORTFROM(leftv res, leftv v)
4826{
4827  BOOLEAN nok=FALSE;
4828  PrintS("jjIMPORT_FROM()\n");
4829  if(v->rtyp==NSHDL)
4830  {
4831    PrintS("Import from toplevel\n");
4832//While-schleife!!!
4833    return FALSE;
4834  }
4835  if(v->Typ()==PACKAGE_CMD)
4836  {
4837    Print("Import from package %s\n", v->name);
4838    while(v->next!=NULL)
4839    {
4840      //nok = iiInternalImport(v->next, 0, v->data);
4841      if(nok) return nok;
4842      v = v->next;
4843    }
4844    return FALSE;
4845  }
4846  return TRUE;
4847}
4848#endif
4849#ifdef HAVE_NAMESPACES
4850static BOOLEAN jjUNLOAD(leftv res, leftv v)
4851{
4852  if(v->Typ()==PACKAGE_CMD)
4853  {
4854    char *typ;
4855    idhdl h = (idhdl)v->data;
4856    package d=(package)v->Data();
4857    switch (d->language)
4858    {
4859      case LANG_C:
4860        typ="object";
4861        break;
4862      case LANG_SINGULAR:
4863      case LANG_NONE:
4864      default:
4865        killhdl(h);
4866    }
4867    return FALSE;
4868  }
4869  return TRUE;
4870}
4871#endif
4872/*=================== operations with many arg.: table =================*/
4873/* number_of_args:  -1: any, -2: any >0, .. */
4874struct sValCmdM dArithM[]=
4875{
4876// operations:
4877// proc         cmd               res            number_of_args
4878 {jjKLAMMER_PL,  '(',           ANY_TYPE,           -2  }
4879,{jjCALL2ARG,  COEF_CMD,        MATRIX_CMD,         2  }
4880,{jjCOEF_M,    COEF_CMD,        NONE,               4  }
4881,{jjDBPRINT,   DBPRINT_CMD,     NONE,               -2 }
4882,{jjCALL1ARG,  IDEAL_CMD,       IDEAL_CMD,          1  }
4883,{jjIDEAL_PL,  IDEAL_CMD,       IDEAL_CMD,          -1 }
4884,{jjCALL2ARG,  INTERSECT_CMD,   IDEAL_CMD,          2  }
4885,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD,          -2 }
4886,{jjCALL1ARG,  INTVEC_CMD,      INTVEC_CMD,         1  }
4887,{jjINTVEC_PL, INTVEC_CMD,      INTVEC_CMD,         -1 }
4888,{jjLIST_PL,   LIST_CMD,        LIST_CMD,           -1 }
4889,{jjCALL1ARG,  MODUL_CMD,       MODUL_CMD,          1  }
4890,{jjIDEAL_PL,  MODUL_CMD,       MODUL_CMD,          -1 }
4891,{jjCALL1ARG,  NAMES_CMD,       LIST_CMD,            1 }
4892,{jjNAMES0,    NAMES_CMD,       LIST_CMD,            0 }
4893,{jjOPTION_PL, OPTION_CMD,      STRING_CMD/*or set by p*/,-1 }
4894,{jjCALL1ARG,  RESERVEDNAME_CMD, INT_CMD,            1 }
4895,{jjRESERVED0, RESERVEDNAME_CMD, NONE,               0 }
4896,{jjSTRING_PL, STRING_CMD,      STRING_CMD,         -1 }
4897,{jjCALL3ARG,  SUBST_CMD,       NONE/*set by p*/,   3 }
4898,{jjSUBST_M,   SUBST_CMD,       NONE/*set by p*/,   -2 }
4899,{jjSYSTEM,    SYSTEM_CMD,      NONE/*or set by p*/,-2 }
4900,{jjTEST,      TEST_CMD,        NONE,               -2 }
4901,{iiWRITE,     WRITE_CMD,       NONE,               -2 }
4902,{jjCALL2ARG,  STATUS_CMD,      STRING_CMD,          2 }
4903,{jjCALL3ARG,  STATUS_CMD,      INT_CMD,             3 }
4904#ifndef __MWERKS__
4905,{jjSTATUS_M,  STATUS_CMD,      INT_CMD,             4 }
4906#endif
4907#ifdef HAVE_NAMESPACES
4908,{jjIMPORTFROM,IMPORTFROM_CMD,  ANY_TYPE,           -2 }
4909,{jjEXPORTTO,  EXPORTTO_CMD,    NONE,               -2 }
4910,{jjUNLOAD,    UNLOAD_CMD,      NONE,               -2 }
4911#endif /* HAVE_NAMESPACES */
4912,{nuUResSolve, URSOLVE_CMD,     LIST_CMD,            4 }
4913,{NULL,        0,               0,                   0 }
4914};
4915#ifdef MDEBUG
4916static Subexpr jjDBMakeSub(leftv e,char *f, int l)
4917#else
4918static Subexpr jjMakeSub(leftv e)
4919#endif
4920{
4921  // assume: e->Typ()==INT_CMD
4922#ifdef MDEBUG
4923  Subexpr r=(Subexpr)mmDBAllocBlock0(sizeof(*r),f,l);
4924#else
4925  Subexpr r=(Subexpr)Alloc0SizeOf(sSubexpr);
4926#endif
4927  r->start =(int)e->Data();
4928  return r;
4929}
4930
4931/*================ generating tables ============================*/
4932#ifdef GENTABLE
4933extern struct sValAssign dAssign[];
4934struct sValCmdTab dArithTab1[]={ {0,0}};
4935#define JJTAB1LEN 0
4936struct sValCmdTab dArithTab2[]={ {0,0}};
4937#define JJTAB2LEN 0
4938void ttGen1()
4939{
4940  FILE *outfile = myfopen("iparith.inc","w");
4941  int i,j,l1=0,l2=0;
4942  currRing=(ring)AllocSizeOf(sip_sring);
4943  fprintf(outfile,
4944  "/****************************************\n"
4945  "*  Computer Algebra System SINGULAR     *\n"
4946  "****************************************/\n\n");
4947/*-------------------------------------------------------------------*/
4948  fprintf(outfile,"// syntax table for Singular\n//\n");
4949  fprintf(outfile,"// - search for an exact match of the argument types\n");
4950  fprintf(outfile,"// - otherwise search for the first possibility\n");
4951  fprintf(outfile,"//   with converted types of the arguments\n");
4952  fprintf(outfile,"// - otherwise report an error\n//\n");
4953
4954  int op;
4955  i=0;
4956  while ((op=dArith1[i].cmd)!=0)
4957  {
4958    if (dArith1[i].p==jjWRONG)
4959      fprintf(outfile,"// DUMMY ");
4960    char *s = iiTwoOps(op);
4961    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
4962          s,
4963          Tok2Cmdname(dArith1[i].arg),
4964          Tok2Cmdname(ABS(dArith1[i].res)));
4965    i++;
4966  }
4967  fprintf(outfile,"/*---------------------------------------------*/\n");
4968  i=0;
4969  while ((op=dArith2[i].cmd)!=0)
4970  {
4971    if (dArith2[i].p==jjWRONG2)
4972      fprintf(outfile,"// DUMMY ");
4973    char *s = iiTwoOps(op);
4974    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
4975          s,
4976          Tok2Cmdname(dArith2[i].arg1),
4977          Tok2Cmdname(dArith2[i].arg2),
4978          Tok2Cmdname(dArith2[i].res));
4979    i++;
4980  }
4981  fprintf(outfile,"/*---------------------------------------------*/\n");
4982  i=0;
4983  while ((op=dArith3[i].cmd)!=0)
4984  {
4985    char *s = iiTwoOps(op);
4986    if (dArith3[i].p==jjWRONG3)
4987      fprintf(outfile,"// DUMMY ");
4988    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
4989          s,
4990          Tok2Cmdname(dArith3[i].arg1),
4991          Tok2Cmdname(dArith3[i].arg2),
4992          Tok2Cmdname(dArith3[i].arg3),
4993          Tok2Cmdname(dArith3[i].res));
4994    i++;
4995  }
4996  fprintf(outfile,"/*---------------------------------------------*/\n");
4997  i=0;
4998  while ((op=dArithM[i].cmd)!=0)
4999  {
5000    char *s = iiTwoOps(op);
5001    fprintf(outfile,"// operation: %s (...)  ->  %s",
5002          s,
5003          Tok2Cmdname(dArithM[i].res));
5004    switch(dArithM[i].number_of_args)
5005    {
5006      case -2:
5007         fprintf(outfile," ( number of arguments >0 )\n");
5008         break;
5009      case -1:
5010         fprintf(outfile," ( any number of arguments )\n");
5011         break;
5012      default:
5013         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
5014         break;
5015    }
5016    i++;
5017  }
5018  fprintf(outfile,"/*---------------------------------------------*/\n");
5019  i=0;
5020  while ((op=dAssign[i].res)!=0)
5021  {
5022    fprintf(outfile,"// assign: %s =  %s\n",
5023          Tok2Cmdname(op/*dAssign[i].res*/),
5024          Tok2Cmdname(dAssign[i].arg));
5025    i++;
5026  }
5027/*-------------------------------------------------------------------*/
5028  fprintf(outfile,"/*---------------------------------------------*/\n");
5029  for (j=257;j<=MAX_TOK+1;j++)
5030  {
5031    for(i=257;i<=MAX_TOK+1;i++)
5032    {
5033      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
5034      && iiTestConvert(i,j))
5035      {
5036        fprintf(outfile,"// convert %s -> %s\n",
5037          Tok2Cmdname(i), Tok2Cmdname(j));
5038        if (j==ANY_TYPE) break;
5039      }
5040    }
5041  }
5042  fprintf(outfile,"/*---------------------------------------------*/\n");
5043  char ops[]="=><+*/[.^,%(;";
5044  for(i=0;ops[i]!='\0';i++)
5045    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
5046  for (i=257;i<=MAX_TOK;i++)
5047  {
5048    char *s=iiTwoOps(i);
5049    if (s[0]!='$')
5050    {
5051      fprintf(outfile,"// token %d : %s\n", i, s);
5052    }
5053  }
5054/*-------------------------------------------------------------------*/
5055  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
5056/*-------------------------------------------------------------------*/
5057  fprintf(outfile,"/*---------------------------------------------*/\n");
5058  fprintf(outfile,
5059  "struct sValCmdTab dArithTab1[]=\n"
5060  "{\n");
5061  for (j=1;j<=MAX_TOK+1;j++)
5062  {
5063    for(i=0;dArith1[i].cmd!=0;i++)
5064    {
5065      if (dArith1[i].cmd==j)
5066      {
5067        fprintf(outfile," { %d,%d },\n",j,i);
5068        l1++;
5069        break;
5070      }
5071    }
5072  }
5073  fprintf(outfile," { 10000,0 }\n};\n");
5074  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
5075/*-------------------------------------------------------------------*/
5076  fprintf(outfile,
5077  "struct sValCmdTab dArithTab2[]=\n"
5078  "{\n");
5079  for (j=1;j<=MAX_TOK+1;j++)
5080  {
5081    for(i=0;dArith2[i].cmd!=0;i++)
5082    {
5083      if (dArith2[i].cmd==j)
5084      {
5085        fprintf(outfile," { %d,%d },\n",j,i);
5086        l2++;
5087        break;
5088      }
5089    }
5090  }
5091  fprintf(outfile," { 10000,0 }\n};\n");
5092  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
5093  fclose(outfile);
5094}
5095/*-------------------------------------------------------------------*/
5096void ttGen2()
5097{
5098  FILE *outfile = myfopen("iparith.inc","a");
5099  fprintf(outfile,
5100  "/****************************************\n"
5101  "*  Computer Algebra System SINGULAR     *\n"
5102  "****************************************/\n\n");
5103/*-------------------------------------------------------------------*/
5104  fprintf(outfile,"// identifier table for Singular\n//\n");
5105
5106  fprintf(outfile,
5107  "cmdnames cmds[] =\n"
5108  "{  // name-string     alias  tokval toktype\n"
5109  "{ \"$INVALID$\",            0,  -1, 0},\n");
5110  int i=1;
5111  int m=-1;
5112  int id_nr=0;
5113  BOOLEAN f=FALSE;
5114  loop
5115  {
5116    while (cmds[i].tokval!=0)
5117    {
5118      if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
5119      {
5120        if(m==-1)
5121        {
5122          m=i;
5123          f=TRUE;
5124        }
5125        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5126        {
5127          m=i;
5128          f=TRUE;
5129        }
5130      }
5131      i++;
5132    }
5133    if(f)
5134    {
5135      id_nr++;
5136      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
5137      fprintf(outfile,"  {\"%s\", %*d, %3d, ",cmds[m].name,
5138                                             20-strlen(cmds[m].name),
5139                                             cmds[m].alias,
5140                                             cmds[m].tokval);
5141      switch(cmds[m].toktype)
5142      {
5143        case CMD_1:            fprintf(outfile,"CMD_1 },\n"); break;
5144        case CMD_2:            fprintf(outfile,"CMD_2 },\n"); break;
5145        case CMD_3:            fprintf(outfile,"CMD_3 },\n"); break;
5146        case CMD_12:           fprintf(outfile,"CMD_12 },\n"); break;
5147        case CMD_123 :         fprintf(outfile,"CMD_123 },\n"); break;
5148        case CMD_23:           fprintf(outfile,"CMD_23 },\n"); break;
5149        case CMD_M:            fprintf(outfile,"CMD_M },\n"); break;
5150        case SYSVAR:           fprintf(outfile,"SYSVAR },\n"); break;
5151        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL },\n"); break;
5152        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
5153        case RING_DECL:        fprintf(outfile,"RING_DECL },\n"); break;
5154        case NONE:             fprintf(outfile,"NONE },\n"); break;
5155        default:               if((cmds[m].toktype>' ')
5156                               &&(cmds[m].toktype<127))
5157                               {
5158                                 fprintf(outfile,"'%c' },\n",cmds[m].toktype);
5159                               }
5160                               else
5161                               {
5162                                 fprintf(outfile,"%d },\n",cmds[m].toktype);
5163                               }
5164                               break;
5165      }
5166      if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
5167      cmds[m].name=NULL;
5168      m=-1;
5169      i=1;
5170      f=FALSE;
5171    }
5172    else break;
5173  }
5174  fprintf(outfile,
5175"/* list of scanner identifiers/only for feread/reservedName */\n");
5176  f=FALSE;
5177  i=1;m=-1;
5178  loop
5179  {
5180    while (cmds[i].tokval!=0)
5181    {
5182      if (cmds[i].name!=NULL)
5183      {
5184        if(m==-1)
5185        {
5186          m=i;
5187          f=TRUE;
5188        }
5189        else if(strcmp(cmds[m].name,cmds[i].name)>0)
5190        {
5191          m=i;
5192          f=TRUE;
5193        }
5194      }
5195      i++;
5196    }
5197    if(f)
5198    {
5199      fprintf(outfile,"  {\"%s\", %*d,  -1, 0 },\n",cmds[m].name,
5200                                             20-strlen(cmds[m].name),
5201                                             0/*cmds[m].alias*/
5202                                             /*-1 cmds[m].tokval*/
5203                                             /*0 cmds[m].toktype*/);
5204      cmds[m].name=NULL;
5205      m=-1;
5206      i=1;
5207      f=FALSE;
5208    }
5209    else break;
5210  }
5211  fprintf(outfile,
5212"/* end of list marker */\n"
5213"  { NULL, 0, 0, 0}\n"
5214"};\n"
5215"#ifdef HAVE_RTIMER\n"
5216"#define LAST_IDENTIFIER %d\n"
5217"#else\n"
5218"#define LAST_IDENTIFIER %d\n"
5219"#endif\n",id_nr,id_nr-1);
5220  fclose(outfile);
5221}
5222/*-------------------------------------------------------------------*/
5223#if 0
5224void ttGen3()
5225{
5226  FILE *outfile = myfopen("mpsr_tok.inc","w");
5227  fprintf(outfile,
5228  "/****************************************\n"
5229  "*  Computer Algebra System SINGULAR     *\n"
5230  "****************************************/\n\n");
5231/*-------------------------------------------------------------------*/
5232  fprintf(outfile,"// token table for Singular\n//\n");
5233
5234  fprintf(outfile,
5235  "short vtok[] =\n"
5236  "{\n");
5237  // operations with 1 arg: ===========================================
5238  int i=0;
5239  while (dArith1[i].cmd!=0)
5240  {
5241    if ((dArith1[i].p!=jjWRONG)
5242    &&((i==0)||(dArith1[i].cmd!=dArith1[i-1].cmd)))
5243    {
5244      fprintf(outfile,"  %d,\n",dArith1[i].cmd);
5245    }
5246    i++;
5247  }
5248  // operations with 2 args: ===========================================
5249  i=0;
5250  while (dArith2[i].cmd!=0)
5251  {
5252    if ((dArith2[i].p!=jjWRONG2)
5253    &&((i==0)||(dArith2[i].cmd!=dArith2[i-1].cmd)))
5254    {
5255      fprintf(outfile,"  %d,\n",dArith2[i].cmd);
5256    }
5257    i++;
5258  }
5259  // operations with 3 args: ===========================================
5260  i=0;
5261  while (dArith3[i].cmd!=0)
5262  {
5263    if (
5264    ((i==0)||(dArith3[i].cmd!=dArith3[i-1].cmd)))
5265    {
5266      fprintf(outfile,"  %d,\n",dArith3[i].cmd);
5267    }
5268    i++;
5269  }
5270  // operations with many args: ===========================================
5271  i=0;
5272  while (dArithM[i].cmd!=0)
5273  {
5274    if (
5275    ((i==0)||(dArithM[i].cmd!=dArithM[i-1].cmd)))
5276    {
5277      fprintf(outfile,"  %d,\n",dArithM[i].cmd);
5278    }
5279    i++;
5280  }
5281  // ====================================================================
5282  fprintf(outfile,
5283  "/* end of list marker */\n"
5284  " %d };\n",MAX_TOK);
5285  fclose(outfile);
5286}
5287#endif
5288/*-------------------------------------------------------------------*/
5289#else
5290#include "iparith.inc"
5291#endif
5292
5293/*=================== operations with 2 args. ============================*/
5294
5295BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
5296{
5297#ifndef GENTABLE
5298  memset(res,0,sizeof(sleftv));
5299
5300  if (!errorreported)
5301  {
5302#ifdef SIQ
5303    if (siq>0)
5304    {
5305      //Print("siq:%d\n",siq);
5306      command d=(command)Alloc0SizeOf(ip_command);
5307      memcpy(&d->arg1,a,sizeof(sleftv));
5308      memcpy(&d->arg2,b,sizeof(sleftv));
5309      d->argc=2;
5310      d->op=op;
5311      res->data=(char *)d;
5312      res->rtyp=COMMAND;
5313      return FALSE;
5314    }
5315#endif
5316    int at=a->Typ();
5317    int bt=b->Typ();
5318    int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
5319    int index=i;
5320
5321    iiOp=op;
5322    while (dArith2[i].cmd==op)
5323    {
5324      if ((at==dArith2[i].arg1)
5325      && (bt==dArith2[i].arg2))
5326      {
5327        res->rtyp=dArith2[i].res;
5328        if (dArith2[i].p(res,a,b))
5329        {
5330          break;// leave loop, goto error handling
5331        }
5332        a->CleanUp();
5333        b->CleanUp();
5334        //Print("op: %d,result typ:%d\n",op,res->rtyp);
5335        return FALSE;
5336      }
5337      i++;
5338    }
5339    // implicite type conversion ----------------------------------------------
5340    if (dArith2[i].cmd!=op)
5341    {
5342      int ai,bi;
5343      leftv an = (leftv)Alloc0SizeOf(sleftv);
5344      leftv bn = (leftv)Alloc0SizeOf(sleftv);
5345      BOOLEAN failed=FALSE;
5346      i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5347      //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
5348      while (dArith2[i].cmd==op)
5349      {
5350        //Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5351        if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
5352        {
5353          if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
5354          {
5355            res->rtyp=dArith2[i].res;
5356            failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
5357            || (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
5358            || (dArith2[i].p(res,an,bn)));
5359            // everything done, clean up temp. variables
5360            if (failed)
5361            {
5362              // leave loop, goto error handling
5363              break;
5364            }
5365            else
5366            {
5367              // everything ok, clean up and return
5368              an->CleanUp();
5369              bn->CleanUp();
5370              FreeSizeOf((ADDRESS)an,sleftv);
5371              FreeSizeOf((ADDRESS)bn,sleftv);
5372              a->CleanUp();
5373              b->CleanUp();
5374              return FALSE;
5375            }
5376          }
5377        }
5378        i++;
5379      }
5380      an->CleanUp();
5381      bn->CleanUp();
5382      FreeSizeOf((ADDRESS)an,sleftv);
5383      FreeSizeOf((ADDRESS)bn,sleftv);
5384    }
5385    // error handling ---------------------------------------------------
5386    const char *s=NULL;
5387    if (!errorreported)
5388    {
5389      if ((at==0) && (a->Fullname()!=sNoName))
5390      {
5391        s=a->Fullname();
5392      }
5393      else if ((bt==0) && (b->Fullname()!=sNoName))
5394      {
5395        s=b->Fullname();
5396      }
5397      if (s!=NULL)
5398        Werror("`%s` is not defined",s);
5399      else
5400      {
5401        i=index; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
5402        s = iiTwoOps(op);
5403        if (proccall)
5404        {
5405          Werror("%s(`%s`,`%s`) is not supported"
5406                ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
5407        }
5408        else
5409        {
5410          Werror("`%s` %s `%s` is not supported"
5411                ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
5412        }
5413        if (BVERBOSE(V_SHOW_USE))
5414        {
5415          while (dArith2[i].cmd==op)
5416          {
5417            if(((at==dArith2[i].arg1)||(bt==dArith2[i].arg2))
5418            && (dArith2[i].res!=0)
5419            && (dArith2[i].p!=jjWRONG2))
5420            {
5421              if (proccall)
5422                Werror("expected %s(`%s`,`%s`)"
5423                  ,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5424              else
5425                Werror("expected `%s` %s `%s`"
5426                  ,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
5427            }
5428            i++;
5429          }
5430        }
5431      }
5432    }
5433    res->rtyp = UNKNOWN;
5434  }
5435  a->CleanUp();
5436  b->CleanUp();
5437#endif
5438  return TRUE;
5439}
5440
5441/*==================== operations with 1 arg. ===============================*/
5442
5443BOOLEAN iiExprArith1(leftv res, leftv a, int op)
5444{
5445#ifndef GENTABLE
5446  memset(res,0,sizeof(sleftv));
5447