source: git/Singular/iparith.cc @ fca547

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