source: git/Singular/iparith.cc @ d5f35ac

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