source: git/Singular/iparith.cc @ c813c9

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