source: git/Singular/iparith.cc @ d2b2a7

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