Context Navigation

source: git/Singular/iparith.cc @ 5d12cc

spielwiese

Last change on this file since 5d12cc was 5d12cc, checked in by Hans Schönemann <hannes@…>, 17 years ago
*hannes: opt. git-svn-id: file:///usr/local/Singular/svn/trunk@9696 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 237.6 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/* $Id: iparith.cc,v 1.429 2007-01-11 12:47:50 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 "omalloc.h"
22	#include "polys.h"
23	#include "febase.h"
24	#include "sdb.h"
25	#include "longalg.h"
26	#include "ideals.h"
27	#include "matpol.h"
28	#include "kstd1.h"
29	#include "timer.h"
30	#include "ring.h"
31	#include "subexpr.h"
32	#include "lists.h"
33	#include "longalg.h"
34	#include "numbers.h"
35	#include "stairc.h"
36	#include "maps.h"
37	#include "maps_ip.h"
38	#include "syz.h"
39	#include "weight.h"
40	#include "ipconv.h"
41	#include "ipprint.h"
42	#include "sing_dld.h"
43	#include "attrib.h"
44	#include "silink.h"
45	#include "sparsmat.h"
46	#include "units.h"
47	#include "janet.h"
48	#include "GMPrat.h"
49	#include "tgb.h"
50	#include "walkProc.h"
51	#include "mod_raw.h"
52	#ifdef HAVE_FACTORY
53	#include "clapsing.h"
54	#include "kstdfac.h"
55	#endif /* HAVE_FACTORY */
56	#ifdef HAVE_FGLM
57	#include "fglm.h"
58	#endif /* HAVE_FGLM */
59	#define HAVE_INTERPOLATION
60	#ifdef HAVE_INTERPOLATION
61	#include "interpolation.h"
62	#endif
63
64
65	#include "ipshell.h"
66
67	#include "mpr_inout.h"
68
69	#ifdef HAVE_PLURAL
70	#include "gring.h"
71	#define ALLOW_PLURAL ,1
72	#define ALLOW_PLURAL_N 1
73	#define NO_PLURAL ,0
74	#define NO_PLURAL_N 0
75	#define COMM_PLURAL ,2
76	#define COMM_PLURAL_N 2
77	#else /* HAVE_PLURAL */
78	#define ALLOW_PLURAL
79	#define NO_PLURAL
80	#define COMM_PLURAL
81	#endif /* HAVE_PLURAL */
82
83	/=============== types =====================/
84	struct sValCmdTab
85	{
86	short cmd;
87	short start;
88	};
89
90	typedef sValCmdTab jjValCmdTab[];
91
92	/* ifdef GENTABLE: definitions are in ipshell.h */
93	#ifndef GENTABLE
94	typedef char * (Proc1)(char );
95	struct sValCmd1
96	{
97	proc1 p;
98	short cmd;
99	short res;
100	short arg;
101	#ifdef HAVE_PLURAL
102	short valid_for_plural;
103	# endif /* HAVE_PLURAL */
104	};
105
106	typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
107	struct sValCmd2
108	{
109	proc2 p;
110	short cmd;
111	short res;
112	short arg1;
113	short arg2;
114	#ifdef HAVE_PLURAL
115	short valid_for_plural;
116	# endif /* HAVE_PLURAL */
117	};
118
119	typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
120	struct sValCmd3
121	{
122	proc3 p;
123	short cmd;
124	short res;
125	short arg1;
126	short arg2;
127	short arg3;
128	#ifdef HAVE_PLURAL
129	short valid_for_plural;
130	# endif /* HAVE_PLURAL */
131	};
132	struct sValCmdM
133	{
134	proc1 p;
135	short cmd;
136	short res;
137	short number_of_args; /* -1: any, -2: any >0, .. */
138	#ifdef HAVE_PLURAL
139	short valid_for_plural;
140	# endif /* HAVE_PLURAL */
141	};
142	#endif /* GENTABLE */
143
144	typedef struct
145	{
146	cmdnames sCmds; /< array of existing commands /
147
148	#ifndef GENTABLE
149	struct sValCmd1 *psValCmd1;
150	struct sValCmd2 *psValCmd2;
151	struct sValCmd3 *psValCmd3;
152	struct sValCmdM *psValCmdM;
153	#endif /* GENTABLE */
154
155	int nCmdUsed; /*< number of commands used /
156	int nCmdAllocated; /*< number of commands-slots allocated /
157	int nLastIdentifier; /*< valid indentifieres are slot 1..nLastIdentifier /
158	} SArithBase;
159
160	/---------------------------------------------------------------------
161	* File scope Variables (Variables share by several functions in
162	* the same file )
163	*
164	---------------------------------------------------------------------/
165	static SArithBase sArithBase; /*< Base entry for arithmetic /
166
167	/---------------------------------------------------------------------
168	* Extern Functions declarations
169	*
170	---------------------------------------------------------------------/
171	static int _gentable_sort_cmds(const void a, const void b);
172	extern int iiArithRemoveCmd(char *szName);
173	extern int iiArithAddCmd(char *szName, short nAlias, short nTokval,
174	short nToktype, short nPos=-1);
175
176	/============= proc =======================/
177	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
178	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
179	#ifdef MDEBUG
180	#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
181	static Subexpr jjDBMakeSub(leftv e,char *f, int l);
182	#else
183	static Subexpr jjMakeSub(leftv e);
184	#endif
185
186	/============= vars ======================/
187	extern int cmdtok;
188	extern BOOLEAN expected_parms;
189
190	#define ii_div_by_0 "div. by 0"
191	#define ii_not_for_plural "not implemented for non-commutative rings"
192
193	int iiOp; /* the current operation*/
194
195	#ifdef GENTABLE
196	cmdnames cmds[] =
197	{ // name-string alias tokval toktype
198	{ "$INVALID$", 0, -1, 0},
199	{ "and", 0, '&' , LOGIC_OP},
200	{ "attrib", 0, ATTRIB_CMD , CMD_123},
201	{ "bareiss", 0, BAREISS_CMD , CMD_123},
202	{ "betti", 0, BETTI_CMD , CMD_12},
203	{ "bigint", 0, BIGINT_CMD , ROOT_DECL},
204	#ifdef HAVE_PLURAL
205	{ "bracket", 0, BRACKET_CMD , CMD_2},
206	#endif
207	{ "break", 0, BREAK_CMD , BREAK_CMD},
208	{ "breakpoint", 0, BREAKPOINT_CMD , CMD_M},
209	{ "char", 0, CHARACTERISTIC_CMD ,CMD_1},
210	{ "char_series", 0, CHAR_SERIES_CMD , CMD_1},
211	{ "charstr", 0, CHARSTR_CMD , CMD_1},
212	{ "cleardenom", 0, CONTENT_CMD , CMD_1},
213	{ "close", 0, CLOSE_CMD , CMD_1},
214	{ "coef", 0, COEF_CMD , CMD_M},
215	{ "coeffs", 0, COEFFS_CMD , CMD_23},
216	{ "continue", 0, CONTINUE_CMD , CONTINUE_CMD},
217	{ "contract", 0, CONTRACT_CMD , CMD_2},
218	{ "convhull", 0, NEWTONPOLY_CMD, CMD_1},
219	{ "dbprint", 0, DBPRINT_CMD , CMD_M},
220	{ "def", 0, DEF_CMD , ROOT_DECL},
221	{ "defined", 0, DEFINED_CMD , CMD_1},
222	{ "deg", 0, DEG_CMD , CMD_12},
223	{ "degree", 0, DEGREE_CMD , CMD_1},
224	{ "delete", 0, DELETE_CMD , CMD_2},
225	{ "det", 0, DET_CMD , CMD_1},
226	{ "diff", 0, DIFF_CMD , CMD_2},
227	{ "dim", 0, DIM_CMD , CMD_1},
228	{ "div", 0, INTDIV_CMD , MULDIV_OP},
229	{ "division", 0, DIVISION_CMD , CMD_M},
230	{ "dump", 0, DUMP_CMD, CMD_1},
231	{ "extgcd", 0, EXTGCD_CMD , CMD_2},
232	{ "EXTGCD", 2, EXTGCD_CMD , CMD_2},
233	{ "ERROR", 0, ERROR_CMD , CMD_1},
234	{ "eliminate", 0, ELIMINATION_CMD, CMD_23},
235	{ "else", 0, ELSE_CMD , ELSE_CMD},
236	#ifdef HAVE_PLURAL
237	{ "envelope", 0, ENVELOPE_CMD , CMD_1},
238	#endif
239	{ "eval", 0, EVAL , EVAL},
240	{ "example", 0, EXAMPLE_CMD , EXAMPLE_CMD},
241	{ "execute", 0, EXECUTE_CMD , CMD_1},
242	{ "export", 0, EXPORT_CMD , EXPORT_CMD},
243	{ "exportto", 0, EXPORTTO_CMD , CMD_2},
244	{ "factorize", 0, FAC_CMD , CMD_12},
245	{ "fetch", 0, FETCH_CMD , CMD_2},
246	{ "fglm", 0, FGLM_CMD , CMD_2},
247	{ "fglmquot", 0, FGLMQUOT_CMD, CMD_2},
248	{ "find", 0, FIND_CMD , CMD_23},
249	{ "finduni", 0, FINDUNI_CMD, CMD_1},
250	{ "forif", 0, IF_CMD , IF_CMD},
251	{ "freemodule", 0, FREEMODULE_CMD , CMD_1},
252	{ "facstd", 0, FACSTD_CMD , CMD_12},
253	{ "frwalk", 0, FWALK_CMD , CMD_23},
254	{ "gen", 0, E_CMD , CMD_1},
255	{ "getdump", 0, GETDUMP_CMD, CMD_1},
256	{ "gcd", 0, GCD_CMD , CMD_2},
257	{ "GCD", 2, GCD_CMD , CMD_2},
258	{ "hilb", 0, HILBERT_CMD , CMD_123},
259	{ "highcorner", 0, HIGHCORNER_CMD, CMD_1},
260	{ "homog", 0, HOMOG_CMD , CMD_12},
261	{ "hres", 0, HRES_CMD , CMD_2},
262	{ "ideal", 0, IDEAL_CMD , IDEAL_CMD},
263	{ "if", 0, IF_CMD , IF_CMD},
264	{ "imap", 0, IMAP_CMD , CMD_2},
265	{ "impart", 0, IMPART_CMD , CMD_1},
266	{ "importfrom", 0, IMPORTFROM_CMD , CMD_2},
267	{ "indepSet", 0, INDEPSET_CMD , CMD_12},
268	{ "insert", 0, INSERT_CMD , CMD_23},
269	{ "int", 0, INT_CMD , ROOT_DECL},
270	#ifdef HAVE_INTERPOLATION
271	{ "interpolation",0,INTERPOLATE_CMD , CMD_2},
272	#endif
273	{ "interred", 0, INTERRED_CMD , CMD_1},
274	{ "intersect", 0, INTERSECT_CMD , CMD_M},
275	{ "intmat", 0, INTMAT_CMD , INTMAT_CMD},
276	{ "intvec", 0, INTVEC_CMD , ROOT_DECL_LIST},
277	{ "jacob", 0, JACOB_CMD , CMD_1},
278	{ "janet", 0, JANET_CMD , CMD_12},
279	{ "jet", 0, JET_CMD , CMD_M},
280	{ "kbase", 0, KBASE_CMD , CMD_12},
281	{ "keepring", 0, KEEPRING_CMD , KEEPRING_CMD},
282	{ "kill", 0, KILL_CMD , KILL_CMD},
283	{ "killattrib", 0, KILLATTR_CMD , CMD_12},
284	{ "koszul", 0, KOSZUL_CMD , CMD_23},
285	{ "kres", 0, KRES_CMD , CMD_2},
286	{ "laguerre", 0, LAGSOLVE_CMD, CMD_3},
287	{ "lead", 0, LEAD_CMD , CMD_1},
288	{ "leadcoef", 0, LEADCOEF_CMD , CMD_1},
289	{ "leadexp", 0, LEADEXP_CMD , CMD_1},
290	{ "leadmonom", 0, LEADMONOM_CMD , CMD_1},
291	{ "LIB", 0, LIB_CMD , SYSVAR},
292	{ "lift", 0, LIFT_CMD , CMD_23},
293	{ "liftstd", 0, LIFTSTD_CMD , CMD_2},
294	{ "link", 0, LINK_CMD , ROOT_DECL},
295	{ "listvar", 0, LISTVAR_CMD , LISTVAR_CMD},
296	{ "list", 0, LIST_CMD , ROOT_DECL_LIST},
297	{ "load", 0, LOAD_CMD , CMD_12},
298	{ "lres", 0, LRES_CMD , CMD_2},
299	{ "map", 0, MAP_CMD , RING_DECL},
300	{ "matrix", 0, MATRIX_CMD , MATRIX_CMD},
301	{ "maxideal", 0, MAXID_CMD , CMD_1},
302	{ "memory", 0, MEMORY_CMD , CMD_1},
303	{ "minbase", 0, MINBASE_CMD , CMD_1},
304	{ "minor", 0, MINOR_CMD , CMD_23},
305	{ "minres", 0, MINRES_CMD , CMD_1},
306	{ "mod", 0, INTMOD_CMD , MULDIV_OP},
307	{ "module", 0, MODUL_CMD , MODUL_CMD},
308	{ "modulo", 0, MODULO_CMD , CMD_2},
309	{ "monitor", 0, MONITOR_CMD , CMD_12},
310	{ "mpresmat", 0, MPRES_CMD, CMD_2},
311	{ "mult", 0, MULTIPLICITY_CMD , CMD_1},
312	#ifdef OLD_RES
313	{ "mres", 0, MRES_CMD , CMD_23},
314	#else
315	{ "mres", 0, MRES_CMD , CMD_2},
316	#endif
317	{ "mstd", 0, MSTD_CMD , CMD_1},
318	{ "nameof", 0, NAMEOF_CMD , CMD_1},
319	{ "names", 0, NAMES_CMD , CMD_M},
320	#ifdef HAVE_PLURAL
321	{ "ncalgebra", 0, NCALGEBRA_CMD , CMD_2},
322	#endif
323	{ "ncols", 0, COLS_CMD , CMD_1},
324	{ "not", 0, NOT , NOT},
325	{ "npars", 0, NPARS_CMD , CMD_1},
326	#ifdef OLD_RES
327	{ "nres", 0, RES_CMD , CMD_23},
328	#else
329	{ "nres", 0, RES_CMD , CMD_2},
330	#endif
331	{ "nrows", 0, ROWS_CMD , CMD_1},
332	{ "number", 0, NUMBER_CMD , RING_DECL},
333	{ "nvars", 0, NVARS_CMD , CMD_1},
334	{ "open", 0, OPEN_CMD , CMD_1},
335	#ifdef HAVE_PLURAL
336	{ "oppose", 0, OPPOSE_CMD , CMD_2},
337	{ "opposite", 0, OPPOSITE_CMD , CMD_1},
338	#endif
339	{ "option", 0, OPTION_CMD , CMD_M},
340	{ "or", 0, '\|' , LOGIC_OP},
341	{ "ord", 0, ORD_CMD , CMD_1},
342	{ "ordstr", 0, ORDSTR_CMD , CMD_1},
343	{ "package", 0, PACKAGE_CMD , ROOT_DECL},
344	{ "par", 0, PAR_CMD , CMD_1},
345	{ "parameter", 0, PARAMETER , PARAMETER},
346	{ "pardeg", 0, PARDEG_CMD , CMD_1},
347	{ "parstr", 0, PARSTR_CMD , CMD_12},
348	{ "poly", 0, POLY_CMD , RING_DECL},
349	{ "preimage", 0, PREIMAGE_CMD , CMD_13},
350	{ "prime", 0, PRIME_CMD , CMD_1},
351	{ "print", 0, PRINT_CMD , CMD_12},
352	{ "prune", 0, PRUNE_CMD , CMD_1},
353	{ "proc", 0, PROC_CMD , PROC_CMD},
354	{ "qhweight", 0, QHWEIGHT_CMD , CMD_1},
355	{ "qring", 0, QRING_CMD , ROOT_DECL},
356	{ "quote", 0, QUOTE , QUOTE},
357	{ "quotient", 0, QUOTIENT_CMD , CMD_2},
358	{ "random", 0, RANDOM_CMD , CMD_23},
359	{ "read", 0, READ_CMD , CMD_12},
360	{ "reduce", 0, REDUCE_CMD , CMD_M},
361	{ "regularity", 0, REGULARITY_CMD , CMD_1},
362	{ "repart", 0, REPART_CMD , CMD_1},
363	{ "reservedName",0, RESERVEDNAME_CMD , CMD_M},
364	{ "resolution", 0, RESOLUTION_CMD , RING_DECL},
365	{ "resultant", 0, RESULTANT_CMD, CMD_3},
366	{ "return", 0, RETURN , RETURN},
367	{ "RETURN", 0, END_GRAMMAR , RETURN},
368	{ "ring", 0, RING_CMD , RING_CMD},
369	{ "ringlist", 0, RINGLIST_CMD , CMD_1},
370	{ "rvar", 0, IS_RINGVAR , CMD_1},
371	{ "setring", 0, SETRING_CMD , SETRING_CMD},
372	{ "simplex", 0, SIMPLEX_CMD, CMD_M},
373	{ "simplify", 0, SIMPLIFY_CMD , CMD_2},
374	{ "size", 0, COUNT_CMD , CMD_1},
375	{ "slimgb", 0, SLIM_GB_CMD , CMD_1},
376	{ "sortvec", 0, SORTVEC_CMD , CMD_1},
377	#ifdef OLD_RES
378	{ "sres", 0, SRES_CMD , CMD_23},
379	#else /* OLD_RES */
380	{ "sres", 0, SRES_CMD , CMD_2},
381	#endif /* OLD_RES */
382	{ "status", 0, STATUS_CMD, CMD_M},
383	{ "std", 0, STD_CMD , CMD_123},
384	{ "string", 0, STRING_CMD , ROOT_DECL_LIST},
385	{ "subst", 0, SUBST_CMD , CMD_M},
386	{ "system", 0, SYSTEM_CMD, CMD_M},
387	{ "syz", 0, SYZYGY_CMD , CMD_1},
388	{ "test", 0, TEST_CMD , CMD_M},
389	{ "trace", 0, TRACE_CMD , CMD_1},
390	{ "transpose", 0, TRANSPOSE_CMD , CMD_1},
391	#ifdef HAVE_PLURAL
392	{ "twostd", 0, TWOSTD_CMD , CMD_1},
393	#endif /* HAVE_PLURAL */
394	{ "type", 0, TYPE_CMD , TYPE_CMD},
395	{ "typeof", 0, TYPEOF_CMD , CMD_1},
396	{ "uressolve", 0, URSOLVE_CMD, CMD_M},
397	{ "vandermonde", 0, VANDER_CMD, CMD_3},
398	{ "var", 0, VAR_CMD , CMD_1},
399	{ "varstr", 0, VARSTR_CMD , CMD_12},
400	{ "vdim", 0, VDIM_CMD , CMD_1},
401	{ "vector", 0, VECTOR_CMD , RING_DECL},
402	{ "wedge", 0, WEDGE_CMD , CMD_2},
403	{ "weight", 0, WEIGHT_CMD , CMD_1},
404	{ "whileif", 0, IF_CMD , IF_CMD},
405	{ "write", 0, WRITE_CMD , CMD_M},
406	/* delete for next version:*/
407	{ "IN", 1, LEAD_CMD , CMD_1},
408	{ "NF", 1, REDUCE_CMD , CMD_M},
409	{ "multiplicity",1, MULTIPLICITY_CMD , CMD_1},
410	{ "verbose", 2, OPTION_CMD , CMD_M},
411	// { "rank", 1, ROWS_CMD , CMD_1},
412	// { "Current", 0, -1 , SYSVAR},
413	// { "Top", 0, -1 , SYSVAR},
414	// { "Up", 0, -1 , SYSVAR},
415
416	/* set sys vars*/
417	{ "degBound", 0, VMAXDEG , SYSVAR},
418	{ "echo", 0, VECHO , SYSVAR},
419	{ "minpoly", 0, VMINPOLY , SYSVAR},
420	{ "multBound", 0, VMAXMULT , SYSVAR},
421	{ "noether", 0, VNOETHER , SYSVAR},
422	{ "pagelength", 0, VPAGELENGTH , SYSVAR},
423	{ "pagewidth", 0, VCOLMAX , SYSVAR},
424	{ "printlevel", 0, VPRINTLEVEL , SYSVAR},
425	{ "short", 0, VSHORTOUT , SYSVAR},
426	{ "timer", 0, VTIMER , SYSVAR},
427	{ "rtimer", 0, VRTIMER, SYSVAR},
428	{ "TRACE", 0, TRACE , SYSVAR},
429	{ "voice", 0, VOICE , SYSVAR},
430
431	/* other reserved words:scanner.l */
432	{ "pause", 2, -1 , 0},
433	{ "while", 0, -1 , 0},
434	{ "for", 0, -1 , 0},
435	{ "help", 0, -1 , 0},
436	{ "newline", 0, -1 , 0},
437	{ "exit", 0, -1 , 0},
438	{ "quit", 0, -1 , 0},
439	/* end of list marker */
440	{ NULL, 0, 0, 0}
441	};
442	#endif /* GENTABLE */
443
444	/=================== operations with 2 args.: static proc =================/
445	static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
446	{
447	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
448	int bb = (int)(long)(v->Data());
449	if (errorreported) return TRUE;
450	switch (iiOp)
451	{
452	case '+': (*aa) += bb; break;
453	case '-': (*aa) -= bb; break;
454	case '': (aa) *= bb; break;
455	case '/':
456	case INTDIV_CMD: (*aa) /= bb; break;
457	case '%':
458	case INTMOD_CMD: (*aa) %= bb; break;
459	}
460	res->data=(char *)aa;
461	return FALSE;
462	}
463	static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
464	{
465	return jjOP_IV_I(res,v,u);
466	}
467	static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
468	{
469	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
470	int bb = (int)(long)(v->Data());
471	int i=si_min(aa->rows(),aa->cols());
472	switch (iiOp)
473	{
474	case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
475	break;
476	case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
477	break;
478	}
479	res->data=(char *)aa;
480	return FALSE;
481	}
482	static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
483	{
484	return jjOP_IM_I(res,v,u);
485	}
486	static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
487	{
488	res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
489	return FALSE;
490	}
491	static void jjEQUAL_REST(leftv res,leftv u,leftv v);
492	static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
493	{
494	intvec* a = (intvec * )(u->Data());
495	intvec* b = (intvec * )(v->Data());
496	int r=a->compare(b);
497	switch (iiOp)
498	{
499	case '<':
500	res->data = (char *) (r<0);
501	break;
502	case '>':
503	res->data = (char *) (r>0);
504	break;
505	case LE:
506	res->data = (char *) (r<=0);
507	break;
508	case GE:
509	res->data = (char *) (r>=0);
510	break;
511	case EQUAL_EQUAL:
512	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
513	res->data = (char *) (r==0);
514	break;
515	}
516	jjEQUAL_REST(res,u,v);
517	return r==-2;
518	}
519	static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
520	{
521	intvec* a = (intvec * )(u->Data());
522	int b = (int)(long)(v->Data());
523	int r=a->compare(b);
524	switch (iiOp)
525	{
526	case '<':
527	res->data = (char *) (r<0);
528	break;
529	case '>':
530	res->data = (char *) (r>0);
531	break;
532	case LE:
533	res->data = (char *) (r<=0);
534	break;
535	case GE:
536	res->data = (char *) (r>=0);
537	break;
538	case EQUAL_EQUAL:
539	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
540	res->data = (char *) (r==0);
541	break;
542	}
543	jjEQUAL_REST(res,u,v);
544	return FALSE;
545	}
546	static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
547	{
548	poly p=(poly)u->Data();
549	poly q=(poly)v->Data();
550	int r=pCmp(p,q);
551	if (r==0)
552	{
553	number h=nSub(pGetCoeff(p),pGetCoeff(q));
554	/* compare lead coeffs */
555	r = -1+nIsZero(h)+2nGreaterZero(h); / -1: <, 0:==, 1: > */
556	nDelete(&h);
557	}
558	else if (p==NULL)
559	{
560	if (q==NULL)
561	{
562	/* compare 0, 0 */
563	r=0;
564	}
565	else if(pIsConstant(q))
566	{
567	/* compare 0, const */
568	r = 1-2nGreaterZero(pGetCoeff(q)); / -1: <, 1: > */
569	}
570	}
571	else if (q==NULL)
572	{
573	if (pIsConstant(p))
574	{
575	/* compare const, 0 */
576	r = -1+2nGreaterZero(pGetCoeff(p)); / -1: <, 1: > */
577	}
578	}
579	switch (iiOp)
580	{
581	case '<':
582	res->data = (char *) (r < 0);
583	break;
584	case '>':
585	res->data = (char *) (r > 0);
586	break;
587	case LE:
588	res->data = (char *) (r <= 0);
589	break;
590	case GE:
591	res->data = (char *) (r >= 0);
592	break;
593	//case EQUAL_EQUAL:
594	//case NOTEQUAL: /* negation handled by jjEQUAL_REST */
595	// res->data = (char *) (r == 0);
596	// break;
597	}
598	jjEQUAL_REST(res,u,v);
599	return FALSE;
600	}
601	static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
602	{
603	char* a = (char * )(u->Data());
604	char* b = (char * )(v->Data());
605	int result = strcmp(a,b);
606	switch (iiOp)
607	{
608	case '<':
609	res->data = (char *) (result < 0);
610	break;
611	case '>':
612	res->data = (char *) (result > 0);
613	break;
614	case LE:
615	res->data = (char *) (result <= 0);
616	break;
617	case GE:
618	res->data = (char *) (result >= 0);
619	break;
620	case EQUAL_EQUAL:
621	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
622	res->data = (char *) (result == 0);
623	break;
624	}
625	jjEQUAL_REST(res,u,v);
626	return FALSE;
627	}
628	static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
629	{
630	if (u->Next()!=NULL)
631	{
632	u=u->next;
633	res->next = (leftv)omAllocBin(sleftv_bin);
634	return iiExprArith2(res->next,u,iiOp,v);
635	}
636	else if (v->Next()!=NULL)
637	{
638	v=v->next;
639	res->next = (leftv)omAllocBin(sleftv_bin);
640	return iiExprArith2(res->next,u,iiOp,v);
641	}
642	return FALSE;
643	}
644	static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
645	{
646	int b=(int)(long)u->Data();
647	int e=(int)(long)v->Data();
648	int rc = 1;
649	BOOLEAN overflow=FALSE;
650	if (e >= 0)
651	{
652	if (b==0)
653	{
654	rc=0;
655	}
656	else
657	{
658	int oldrc;
659	while ((e--)!=0)
660	{
661	oldrc=rc;
662	rc *= b;
663	if (!overflow)
664	{
665	if(rc/b!=oldrc) overflow=TRUE;
666	}
667	}
668	if (overflow)
669	WarnS("int overflow(^), result may be wrong");
670	}
671	res->data = (char *)((long)rc);
672	if (u!=NULL) return jjOP_REST(res,u,v);
673	return FALSE;
674	}
675	else
676	{
677	WerrorS("exponent must be non-negative");
678	return TRUE;
679	}
680	}
681	static BOOLEAN jjPOWER_BI(leftv res, leftv u, leftv v)
682	{
683	int e=(int)(long)v->Data();
684	number n=(number)u->Data();
685	if (e>=0)
686	{
687	nlPower(n,e,(number*)&res->data);
688	}
689	else
690	{
691	WerrorS("exponent must be non-negative");
692	return TRUE;
693	}
694	if (u!=NULL) return jjOP_REST(res,u,v);
695	return FALSE;
696	}
697	static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
698	{
699	int e=(int)(long)v->Data();
700	number n=(number)u->Data();
701	int d=0;
702	if (e<0)
703	{
704	n=nInvers(n);
705	e=-e;
706	d=1;
707	}
708	nPower(n,e,(number*)&res->data);
709	if (d) nDelete(&n);
710	if (u!=NULL) return jjOP_REST(res,u,v);
711	return FALSE;
712	}
713	static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
714	{
715	res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)(long)v->Data());
716	if (u!=NULL) return jjOP_REST(res,u,v);
717	return errorreported; /* pPower may set errorreported via Werror */
718	}
719	static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
720	{
721	res->data = (char *)idPower((ideal)(u->Data()),(int)(long)(v->Data()));
722	if (u!=NULL) return jjOP_REST(res,u,v);
723	return FALSE;
724	}
725	static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
726	{
727	u=u->next;
728	v=v->next;
729	if (u==NULL)
730	{
731	if (v==NULL) return FALSE; /* u==NULL, v==NULL */
732	if (iiOp=='-') /* u==NULL, v<>NULL, iiOp=='-'*/
733	{
734	do
735	{
736	if (res->next==NULL)
737	res->next = (leftv)omAlloc0Bin(sleftv_bin);
738	leftv tmp_v=v->next;
739	v->next=NULL;
740	BOOLEAN b=iiExprArith1(res->next,v,'-');
741	v->next=tmp_v;
742	if (b)
743	return TRUE;
744	v=tmp_v;
745	res=res->next;
746	} while (v!=NULL);
747	return FALSE;
748	}
749	loop /* u==NULL, v<>NULL, iiOp=='+' */
750	{
751	res->next = (leftv)omAlloc0Bin(sleftv_bin);
752	res=res->next;
753	res->data = v->CopyD();
754	res->rtyp = v->Typ();
755	v=v->next;
756	if (v==NULL) return FALSE;
757	}
758	}
759	if (v!=NULL) /* u<>NULL, v<>NULL */
760	{
761	do
762	{
763	res->next = (leftv)omAlloc0Bin(sleftv_bin);
764	leftv tmp_u=u->next; u->next=NULL;
765	leftv tmp_v=v->next; v->next=NULL;
766	BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
767	u->next=tmp_u;
768	v->next=tmp_v;
769	if (b)
770	return TRUE;
771	u=tmp_u;
772	v=tmp_v;
773	res=res->next;
774	} while ((u!=NULL) && (v!=NULL));
775	return FALSE;
776	}
777	loop /* u<>NULL, v==NULL */
778	{
779	res->next = (leftv)omAlloc0Bin(sleftv_bin);
780	res=res->next;
781	res->data = u->CopyD();
782	res->rtyp = u->Typ();
783	u=u->next;
784	if (u==NULL) return FALSE;
785	}
786	}
787	static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
788	{
789	#ifdef HAVE_NS
790	idhdl packhdl;
791
792	switch(u->Typ())
793	{
794	case 0:
795	Print("%s of type 'ANY'. Trying load.\n", v->name);
796	if(iiTryLoadLib(u, u->name))
797	{
798	Werror("'%s' no such package", u->name);
799	return TRUE;
800	}
801	syMake(u,u->name,NULL);
802	// else: use next case !!! no break !!!
803
804	case PACKAGE_CMD:
805	packhdl = (idhdl)u->data;
806	if((!IDPACKAGE(packhdl)->loaded)
807	&& (IDPACKAGE(packhdl)->language > LANG_TOP))
808	{
809	//if(iiReLoadLib(packhdl))
810	// Werror("unable to reload package '%s'", IDID(packhdl));
811	Werror("'%s' not loaded", u->name);
812	return TRUE;
813	}
814	if(v->rtyp == IDHDL)
815	{
816	v->name = omStrDup(v->name);
817	}
818	v->req_packhdl=IDPACKAGE(packhdl);
819	v->packhdl=IDPACKAGE(packhdl);
820	syMake(v, v->name, packhdl);
821	memcpy(res, v, sizeof(sleftv));
822	memset(v, 0, sizeof(sleftv));
823	break;
824
825	case DEF_CMD:
826	break;
827
828	default:
829	WerrorS("<package>::<id> expected");
830	return TRUE;
831	}
832	#else /* HAVE_NS */
833	WerrorS("package is not supported in this version");
834	#endif /* HAVE_NS */
835	return FALSE;
836	}
837	static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
838	{
839	unsigned int a=(unsigned int)(unsigned long)u->Data();
840	unsigned int b=(unsigned int)(unsigned long)v->Data();
841	unsigned int c=a+b;
842	res->data = (char *)((long)c);
843	if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
844	{
845	WarnS("int overflow(+), result may be wrong");
846	}
847	return jjPLUSMINUS_Gen(res,u,v);
848	}
849	static BOOLEAN jjPLUS_BI(leftv res, leftv u, leftv v)
850	{
851	res->data = (char *)(nlAdd((number)u->Data(), (number)v->Data()));
852	return jjPLUSMINUS_Gen(res,u,v);
853	}
854	static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
855	{
856	res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
857	return jjPLUSMINUS_Gen(res,u,v);
858	}
859	static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
860	{
861	res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
862	return jjPLUSMINUS_Gen(res,u,v);
863	}
864	static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
865	{
866	res->data = (char )ivAdd((intvec)(u->Data()), (intvec*)(v->Data()));
867	if (res->data==NULL)
868	{
869	WerrorS("intmat size not compatible");
870	return TRUE;
871	}
872	return jjPLUSMINUS_Gen(res,u,v);
873	return FALSE;
874	}
875	static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
876	{
877	res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
878	if (res->data==NULL)
879	{
880	WerrorS("matrix size not compatible");
881	return TRUE;
882	}
883	return jjPLUSMINUS_Gen(res,u,v);
884	}
885	static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
886	{
887	matrix m=(matrix)u->Data();
888	matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
889	if (iiOp=='+')
890	res->data = (char *)mpAdd(m , p);
891	else
892	res->data = (char *)mpSub(m , p);
893	idDelete((ideal *)&p);
894	return jjPLUSMINUS_Gen(res,u,v);
895	}
896	static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
897	{
898	return jjPLUS_MA_P(res,v,u);
899	}
900	static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
901	{
902	char* a = (char * )(u->Data());
903	char* b = (char * )(v->Data());
904	char* r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
905	strcpy(r,a);
906	strcat(r,b);
907	res->data=r;
908	return jjPLUSMINUS_Gen(res,u,v);
909	}
910	static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
911	{
912	res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
913	return jjPLUSMINUS_Gen(res,u,v);
914	}
915	static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
916	{
917	unsigned int a=(unsigned int)(unsigned long)u->Data();
918	unsigned int b=(unsigned int)(unsigned long)v->Data();
919	unsigned int c=a-b;
920	if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
921	{
922	WarnS("int overflow(-), result may be wrong");
923	}
924	res->data = (char *)((long)c);
925	return jjPLUSMINUS_Gen(res,u,v);
926	}
927	static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
928	{
929	res->data = (char *)(nlSub((number)u->Data(), (number)v->Data()));
930	return jjPLUSMINUS_Gen(res,u,v);
931	}
932	static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
933	{
934	res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
935	return jjPLUSMINUS_Gen(res,u,v);
936	}
937	static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
938	{
939	res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
940	return jjPLUSMINUS_Gen(res,u,v);
941	}
942	static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
943	{
944	res->data = (char )ivSub((intvec)(u->Data()), (intvec*)(v->Data()));
945	if (res->data==NULL)
946	{
947	WerrorS("intmat size not compatible");
948	return TRUE;
949	}
950	return jjPLUSMINUS_Gen(res,u,v);
951	}
952	static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
953	{
954	res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
955	if (res->data==NULL)
956	{
957	WerrorS("matrix size not compatible");
958	return TRUE;
959	}
960	return jjPLUSMINUS_Gen(res,u,v);
961	return FALSE;
962	}
963	static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
964	{
965	int a=(int)(long)u->Data();
966	int b=(int)(long)v->Data();
967	int c=a * b;
968	if ((b!=0) && (c/b !=a))
969	WarnS("int overflow(*), result may be wrong");
970	res->data = (char *)((long)c);
971	if ((u->Next()!=NULL) \|\| (v->Next()!=NULL))
972	return jjOP_REST(res,u,v);
973	return FALSE;
974	}
975	static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
976	{
977	res->data = (char *)(nlMult( (number)u->Data(), (number)v->Data()));
978	if ((v->next!=NULL) \|\| (u->next!=NULL))
979	return jjOP_REST(res,u,v);
980	return FALSE;
981	}
982	static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
983	{
984	res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
985	if ((v->next!=NULL) \|\| (u->next!=NULL))
986	return jjOP_REST(res,u,v);
987	return FALSE;
988	}
989	static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
990	{
991	poly a;
992	poly b;
993
994	if (v->next==NULL)
995	{
996	a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
997	if (u->next==NULL)
998	{
999	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
1000	res->data = (char *)(pMult( a, b));
1001	return FALSE;
1002	}
1003	// u->next exists: copy v
1004	b=pCopy((poly)v->Data());
1005	res->data = (char *)(pMult( a, b));
1006	return jjOP_REST(res,u,v);
1007	}
1008	// v->next exists: copy u
1009	a=pCopy((poly)u->Data());
1010	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
1011	res->data = (char *)(pMult( a, b));
1012	return jjOP_REST(res,u,v);
1013	}
1014	static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
1015	{
1016	res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
1017	if ((v->next!=NULL) \|\| (u->next!=NULL))
1018	return jjOP_REST(res,u,v);
1019	return FALSE;
1020	}
1021	static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
1022	{
1023	res->data = (char )ivMult((intvec)(u->Data()), (intvec*)(v->Data()));
1024	if (res->data==NULL)
1025	{
1026	WerrorS("intmat size not compatible");
1027	return TRUE;
1028	}
1029	if ((v->next!=NULL) \|\| (u->next!=NULL))
1030	return jjOP_REST(res,u,v);
1031	return FALSE;
1032	}
1033	static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
1034	{
1035	poly p=(poly)v->CopyD(POLY_CMD);
1036	int r=pMaxComp(p);/* recompute the rank for the case idealvector/
1037	ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1038	if (r>0) I->rank=r;
1039	res->data = (char *)I;
1040	return FALSE;
1041	}
1042	static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
1043	{
1044	return jjTIMES_MA_P1(res,v,u);
1045	}
1046	static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
1047	{
1048	number n=(number)v->CopyD(NUMBER_CMD);
1049	poly p=pOne();
1050	pSetCoeff(p,n);
1051	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1052	return FALSE;
1053	}
1054	static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
1055	{
1056	return jjTIMES_MA_N1(res,v,u);
1057	}
1058	static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
1059	{
1060	res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data());
1061	return FALSE;
1062	}
1063	static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1064	{
1065	return jjTIMES_MA_I1(res,v,u);
1066	}
1067	static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1068	{
1069	res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
1070	if (res->data==NULL)
1071	{
1072	WerrorS("matrix size not compatible");
1073	return TRUE;
1074	}
1075	if ((v->next!=NULL) \|\| (u->next!=NULL))
1076	return jjOP_REST(res,u,v);
1077	return FALSE;
1078	}
1079	static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1080	{
1081	res->data = (char *)((int)((long)u->Data()) >= (int)((long)v->Data()));
1082	return FALSE;
1083	}
1084	static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1085	{
1086	number h=nSub((number)u->Data(),(number)v->Data());
1087	res->data = (char *) (nGreaterZero(h)\|\|(nIsZero(h)));
1088	nDelete(&h);
1089	return FALSE;
1090	}
1091	static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1092	{
1093	res->data = (char *)((int)((long)u->Data()) > (int)((long)v->Data()));
1094	return FALSE;
1095	}
1096	static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1097	{
1098	number h=nSub((number)u->Data(),(number)v->Data());
1099	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1100	nDelete(&h);
1101	return FALSE;
1102	}
1103	static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1104	{
1105	res->data = (char *)((int)((long)u->Data()) <= (int)((long)v->Data()));
1106	return FALSE;
1107	}
1108	static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1109	{
1110	number h=nSub((number)v->Data(),(number)u->Data());
1111	res->data = (char *) (nGreaterZero(h)\|\|nIsZero(h));
1112	nDelete(&h);
1113	return FALSE;
1114	}
1115	static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1116	{
1117	res->data = (char *)((int)((long)u->Data()) < (int)((long)v->Data()));
1118	return FALSE;
1119	}
1120	static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1121	{
1122	number h=nSub((number)v->Data(),(number)u->Data());
1123	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1124	nDelete(&h);
1125	return FALSE;
1126	}
1127	static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1128	{
1129	int a= (int)(long)u->Data();
1130	int b= (int)(long)v->Data();
1131	if (b==0)
1132	{
1133	WerrorS(ii_div_by_0);
1134	return TRUE;
1135	}
1136	int bb=ABS(b);
1137	int c=a%bb;
1138	if(c<0) c+=bb;
1139	int r=0;
1140	switch (iiOp)
1141	{
1142	case INTMOD_CMD:
1143	r=c; break;
1144	case '%':
1145	r= (a % b); break;
1146	case INTDIV_CMD:
1147	r=((a-c) /b); break;
1148	case '/':
1149	r= (a / b); break;
1150	}
1151	res->data=(void *)((long)r);
1152	return FALSE;
1153	}
1154	static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
1155	{
1156	number q=(number)v->Data();
1157	if (nlIsZero(q))
1158	{
1159	WerrorS(ii_div_by_0);
1160	return TRUE;
1161	}
1162	q = nlIntDiv((number)u->Data(),q);
1163	nlNormalize(q);
1164	res->data = (char *)q;
1165	return FALSE;
1166	}
1167	static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1168	{
1169	number q=(number)v->Data();
1170	if (nIsZero(q))
1171	{
1172	WerrorS(ii_div_by_0);
1173	return TRUE;
1174	}
1175	q = nDiv((number)u->Data(),q);
1176	nNormalize(q);
1177	res->data = (char *)q;
1178	return FALSE;
1179	}
1180	static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1181	{
1182	poly q=(poly)v->Data();
1183	if (q==NULL)
1184	{
1185	WerrorS(ii_div_by_0);
1186	return TRUE;
1187	}
1188	poly p=(poly)(u->Data());
1189	if (p==NULL)
1190	{
1191	res->data=NULL;
1192	return FALSE;
1193	}
1194	if (pNext(q)!=NULL)
1195	{
1196	#ifdef HAVE_FACTORY
1197	if(pGetComp(p)==0)
1198	{
1199	res->data=(void)(singclap_pdivide(p /(poly)(u->Data())*/ ,
1200	q /(poly)(v->Data())/ ));
1201	}
1202	else
1203	{
1204	int comps=pMaxComp(p);
1205	ideal I=idInit(comps,1);
1206	p=pCopy(p);
1207	poly h;
1208	int i;
1209	// conversion to a list of polys:
1210	while (p!=NULL)
1211	{
1212	i=pGetComp(p)-1;
1213	h=pNext(p);
1214	pNext(p)=NULL;
1215	pSetComp(p,0);
1216	I->m[i]=pAdd(I->m[i],p);
1217	p=h;
1218	}
1219	// division and conversion to vector:
1220	h=NULL;
1221	p=NULL;
1222	for(i=comps-1;i>=0;i--)
1223	{
1224	if (I->m[i]!=NULL)
1225	{
1226	h=singclap_pdivide(I->m[i],q);
1227	pSetCompP(h,i+1);
1228	p=pAdd(p,h);
1229	}
1230	}
1231	idDelete(&I);
1232	res->data=(void *)p;
1233	}
1234	#else /* HAVE_FACTORY */
1235	WerrorS("division only by a monomial");
1236	return TRUE;
1237	#endif /* HAVE_FACTORY */
1238	}
1239	else
1240	{
1241	res->data = (char *)pDivideM(pCopy(p),pHead(q));
1242	}
1243	return FALSE;
1244	}
1245	static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1246	{
1247	poly q=(poly)v->Data();
1248	if (q==NULL)
1249	{
1250	WerrorS(ii_div_by_0);
1251	return TRUE;
1252	}
1253	matrix m=(matrix)(u->Data());
1254	int r=m->rows();
1255	int c=m->cols();
1256	matrix mm=mpNew(r,c);
1257	int i,j;
1258	for(i=r;i>0;i--)
1259	{
1260	for(j=c;j>0;j--)
1261	{
1262	if (pNext(q)!=NULL)
1263	{
1264	#ifdef HAVE_FACTORY
1265	MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1266	q /(poly)(v->Data())/ );
1267	#else /* HAVE_FACTORY */
1268	WerrorS("division only by a monomial");
1269	return TRUE;
1270	#endif /* HAVE_FACTORY */
1271	}
1272	else
1273	MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1274	}
1275	}
1276	res->data=(char *)mm;
1277	return FALSE;
1278	}
1279	static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1280	{
1281	res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1282	jjEQUAL_REST(res,u,v);
1283	return FALSE;
1284	}
1285	static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1286	{
1287	res->data = (char *)((long)mpEqual((matrix)u->Data(),(matrix)v->Data()));
1288	jjEQUAL_REST(res,u,v);
1289	return FALSE;
1290	}
1291	static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1292	{
1293	res->data = (char *)((long)nEqual((number)u->Data(),(number)v->Data()));
1294	jjEQUAL_REST(res,u,v);
1295	return FALSE;
1296	}
1297	static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1298	{
1299	poly p=(poly)u->Data();
1300	poly q=(poly)v->Data();
1301	res->data = (char *) ((long)pEqualPolys(p,q));
1302	jjEQUAL_REST(res,u,v);
1303	return FALSE;
1304	}
1305	static void jjEQUAL_REST(leftv res,leftv u,leftv v)
1306	{
1307	if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1308	{
1309	int save_iiOp=iiOp;
1310	if (iiOp==NOTEQUAL)
1311	iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
1312	else
1313	iiExprArith2(res,u->next,iiOp,v->next);
1314	iiOp=save_iiOp;
1315	}
1316	if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1317	}
1318	static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1319	{
1320	res->data = (char *)((long)u->Data() && (long)v->Data());
1321	return FALSE;
1322	}
1323	static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1324	{
1325	res->data = (char *)((long)u->Data() \|\| (long)v->Data());
1326	return FALSE;
1327	}
1328	static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1329	{
1330	res->rtyp=u->rtyp; u->rtyp=0;
1331	res->data=u->data; u->data=NULL;
1332	res->name=u->name; u->name=NULL;
1333	res->attribute=u->attribute; u->attribute=NULL;
1334	res->e=u->e; u->e=NULL;
1335	if (res->e==NULL) res->e=jjMakeSub(v);
1336	else
1337	{
1338	Subexpr sh=res->e;
1339	while (sh->next != NULL) sh=sh->next;
1340	sh->next=jjMakeSub(v);
1341	}
1342	return FALSE;
1343	}
1344	static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1345	{
1346	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
1347	{
1348	WerrorS("indexed object must have a name");
1349	return TRUE;
1350	}
1351	intvec * iv=(intvec *)v->Data();
1352	leftv p=NULL;
1353	int i;
1354	sleftv t;
1355
1356	memset(&t,0,sizeof(t));
1357	t.rtyp=INT_CMD;
1358	for (i=0;i<iv->length(); i++)
1359	{
1360	t.data=(char )((long)(iv)[i]);
1361	if (p==NULL)
1362	{
1363	p=res;
1364	}
1365	else
1366	{
1367	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1368	p=p->next;
1369	}
1370	p->rtyp=IDHDL;
1371	p->data=u->data;
1372	p->name=u->name;
1373	p->flag=u->flag;
1374	p->attribute=u->attribute;
1375	p->e=jjMakeSub(&t);
1376	}
1377	u->rtyp=0;
1378	u->data=NULL;
1379	u->name=NULL;
1380	return FALSE;
1381	}
1382	static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1383	{
1384	poly p=(poly)u->Data();
1385	int i=(int)(long)v->Data();
1386	int j=0;
1387	while (p!=NULL)
1388	{
1389	j++;
1390	if (j==i)
1391	{
1392	res->data=(char *)pHead(p);
1393	return FALSE;
1394	}
1395	pIter(p);
1396	}
1397	return FALSE;
1398	}
1399	static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1400	{
1401	poly p=(poly)u->Data();
1402	poly r=NULL;
1403	intvec iv=(intvec )v->CopyD(INTVEC_CMD);
1404	int i;
1405	int sum=0;
1406	for(i=iv->length()-1;i>=0;i--)
1407	sum+=(*iv)[i];
1408	int j=0;
1409	while ((p!=NULL) && (sum>0))
1410	{
1411	j++;
1412	for(i=iv->length()-1;i>=0;i--)
1413	{
1414	if (j==(*iv)[i])
1415	{
1416	r=pAdd(r,pHead(p));
1417	sum-=j;
1418	(*iv)[i]=0;
1419	break;
1420	}
1421	}
1422	pIter(p);
1423	}
1424	delete iv;
1425	res->data=(char *)r;
1426	return FALSE;
1427	}
1428	static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1429	{
1430	poly p=(poly)u->CopyD(VECTOR_CMD);
1431	poly r=p; // pointer to the beginning of component i
1432	poly o=NULL;
1433	int i=(int)(long)v->Data();
1434	while (p!=NULL)
1435	{
1436	if (pGetComp(p)!=i)
1437	{
1438	if (r==p) r=pNext(p);
1439	if (o!=NULL)
1440	{
1441	pDeleteLm(&pNext(o));
1442	p=pNext(o);
1443	}
1444	else
1445	pDeleteLm(&p);
1446	}
1447	else
1448	{
1449	pSetComp(p, 0);
1450	o=p;
1451	p=pNext(o);
1452	}
1453	}
1454	res->data=(char *)r;
1455	return FALSE;
1456	}
1457	static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1458	{
1459	poly p=(poly)u->CopyD(VECTOR_CMD);
1460	if (p!=NULL)
1461	{
1462	poly r=pOne();
1463	poly hp=r;
1464	intvec iv=(intvec )v->Data();
1465	int i;
1466	loop
1467	{
1468	for(i=0;i<iv->length();i++)
1469	{
1470	if (pGetComp(p)==(*iv)[i])
1471	{
1472	poly h;
1473	pSplit(p,&h);
1474	pNext(hp)=p;
1475	p=h;
1476	pIter(hp);
1477	break;
1478	}
1479	}
1480	if (p==NULL) break;
1481	if (i==iv->length())
1482	{
1483	pDeleteLm(&p);
1484	if (p==NULL) break;
1485	}
1486	}
1487	pDeleteLm(&r);
1488	res->data=(char *)r;
1489	}
1490	return FALSE;
1491	}
1492	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v);
1493	static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1494	{
1495	if(u->name==NULL) return TRUE;
1496	char * nn = (char *)omAlloc(strlen(u->name) + 14);
1497	sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1498	omFree((ADDRESS)u->name);
1499	u->name=NULL;
1500	char *n=omStrDup(nn);
1501	omFree((ADDRESS)nn);
1502	syMake(res,n);
1503	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1504	return FALSE;
1505	}
1506	static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1507	{
1508	intvec * iv=(intvec *)v->Data();
1509	leftv p=NULL;
1510	int i;
1511	long slen = strlen(u->name) + 14;
1512	char n = (char) omAlloc(slen);
1513
1514	for (i=0;i<iv->length(); i++)
1515	{
1516	if (p==NULL)
1517	{
1518	p=res;
1519	}
1520	else
1521	{
1522	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1523	p=p->next;
1524	}
1525	sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1526	syMake(p,omStrDup(n));
1527	}
1528	omFree((ADDRESS)u->name);
1529	u->name = NULL;
1530	omFreeSize(n, slen);
1531	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1532	return FALSE;
1533	}
1534	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
1535	{
1536	leftv tmp=(leftv)omAllocBin(sleftv_bin);
1537	memset(tmp,0,sizeof(sleftv));
1538	BOOLEAN b;
1539	if (v->Typ()==INTVEC_CMD)
1540	b=jjKLAMMER_IV(tmp,u,v);
1541	else
1542	b=jjKLAMMER(tmp,u,v);
1543	if (b)
1544	{
1545	omFreeBin(tmp,sleftv_bin);
1546	return TRUE;
1547	}
1548	leftv h=res;
1549	while (h->next!=NULL) h=h->next;
1550	h->next=tmp;
1551	return FALSE;
1552	}
1553	static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1554	{
1555	idrec tmp_proc;
1556	Subexpr e;
1557	void *d;
1558	int typ;
1559	BOOLEAN t=FALSE;
1560	if (u->rtyp!=IDHDL)
1561	{
1562	tmp_proc.id="_auto";
1563	tmp_proc.typ=PROC_CMD;
1564	tmp_proc.data.pinf=(procinfo *)u->Data();
1565	tmp_proc.ref=1;
1566	d=u->data; u->data=(void *)&tmp_proc;
1567	e=u->e; u->e=NULL;
1568	t=TRUE;
1569	typ=u->rtyp; u->rtyp=IDHDL;
1570	}
1571	#ifdef HAVE_NS
1572	leftv sl;
1573	if (u->req_packhdl==currPack)
1574	sl = iiMake_proc((idhdl)u->data,NULL,v);
1575	else
1576	sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1577	#else /* HAVE_NS */
1578	leftv sl = iiMake_proc((idhdl)u->data,v);
1579	#endif /* HAVE_NS */
1580	if (t)
1581	{
1582	u->rtyp=typ;
1583	u->data=d;
1584	u->e=e;
1585	}
1586	if (sl==NULL)
1587	{
1588	return TRUE;
1589	}
1590	else
1591	{
1592	memcpy(res,sl,sizeof(sleftv));
1593	}
1594	return FALSE;
1595	}
1596	static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1597	{
1598	//Print("try to map %s with %s\n",$3.Name(),$1.Name());
1599	leftv sl=NULL;
1600	if ((v->e==NULL)&&(v->name!=NULL))
1601	{
1602	map m=(map)u->Data();
1603	sl=iiMap(m,v->name);
1604	}
1605	else
1606	{
1607	Werror("%s(<name>) expected",u->Name());
1608	}
1609	if (sl==NULL) return TRUE;
1610	memcpy(res,sl,sizeof(sleftv));
1611	omFreeBin((ADDRESS)sl, sleftv_bin);
1612	return FALSE;
1613	}
1614	static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1615	{
1616	u->next=(leftv)omAllocBin(sleftv_bin);
1617	memcpy(u->next,v,sizeof(sleftv));
1618	BOOLEAN r=iiExprArithM(res,u,iiOp);
1619	v->Init();
1620	// iiExprArithM did the CleanUp
1621	return r;
1622	}
1623	static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1624	{
1625	poly p=(poly)v->Data();
1626	if ((p==NULL)\|\|(pNext(p)!=NULL)) return TRUE;
1627	res->data=(char )mpCoeffProc((poly)u->Data(),p /(poly)v->Data()*/);
1628	return FALSE;
1629	}
1630	static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1631	{
1632	int i=pVar((poly)v->Data());
1633	if (i==0)
1634	{
1635	WerrorS("ringvar expected");
1636	return TRUE;
1637	}
1638	res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1639	return FALSE;
1640	}
1641	static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1642	{
1643	poly p = pInit();
1644	int i;
1645
1646	for (i=1; i<=pVariables; i++)
1647	{
1648	pSetExp(p, i, 1);
1649	}
1650	pSetm(p);
1651	res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1652	(ideal)(v->Data()), p);
1653	pDelete(&p);
1654	return FALSE;
1655	}
1656	static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1657	{
1658	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1659	return FALSE;
1660	}
1661	static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1662	{
1663	short iv=iv2array((intvec )v->Data());
1664	ideal I=(ideal)u->Data();
1665	int d=-1;
1666	int i;
1667	for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)pDegW(I->m[i],iv));
1668	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1669	res->data = (char *)((long)d);
1670	return FALSE;
1671	}
1672	static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1673	{
1674	short iv=iv2array((intvec )v->Data());
1675	res->data = (char *)pDegW((poly)u->Data(),iv);
1676	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1677	return FALSE;
1678	}
1679	static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1680	{
1681	int i=pVar((poly)v->Data());
1682	if (i==0)
1683	{
1684	WerrorS("ringvar expected");
1685	return TRUE;
1686	}
1687	res->data=(char *)pDiff((poly)(u->Data()),i);
1688	return FALSE;
1689	}
1690	static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1691	{
1692	int i=pVar((poly)v->Data());
1693	if (i==0)
1694	{
1695	WerrorS("ringvar expected");
1696	return TRUE;
1697	}
1698	res->data=(char *)idDiff((matrix)(u->Data()),i);
1699	return FALSE;
1700	}
1701	static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1702	{
1703	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1704	return FALSE;
1705	}
1706	static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1707	{
1708	assumeStdFlag(v);
1709	if(currQuotient==NULL)
1710	res->data = (char *)((long)scDimInt((ideal)(v->Data()),(ideal)w->Data()));
1711	else
1712	{
1713	ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1714	res->data = (char *)((long)scDimInt((ideal)(v->Data()),q));
1715	idDelete(&q);
1716	}
1717	return FALSE;
1718	}
1719	static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1720	{
1721	ideal vi=(ideal)v->Data();
1722	int vl= IDELEMS(vi);
1723	ideal ui=(ideal)u->Data();
1724	int ul= IDELEMS(ui);
1725	ideal R; matrix U;
1726	ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1727	// now make sure that all matices have the corect size:
1728	matrix T = idModule2formatedMatrix(m,vl,ul);
1729	if (MATCOLS(U) != ul)
1730	{
1731	int mul=si_min(ul,MATCOLS(U));
1732	matrix UU=mpNew(ul,ul);
1733	int i,j;
1734	for(i=mul;i>0;i--)
1735	{
1736	for(j=mul;j>0;j--)
1737	{
1738	MATELEM(UU,i,j)=MATELEM(U,i,j);
1739	MATELEM(U,i,j)=NULL;
1740	}
1741	}
1742	idDelete((ideal *)&U);
1743	U=UU;
1744	}
1745	lists L=(lists)omAllocBin(slists_bin);
1746	L->Init(3);
1747	L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)T;
1748	L->m[1].rtyp=u->Typ(); L->m[1].data=(void *)R;
1749	L->m[2].rtyp=MATRIX_CMD; L->m[2].data=(void *)U;
1750	res->data=(char *)L;
1751	return FALSE;
1752	}
1753	static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1754	{
1755	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1756	setFlag(res,FLAG_STD);
1757	return FALSE;
1758	}
1759	static BOOLEAN jjEXPORTTO(leftv res, leftv u, leftv v)
1760	{
1761	#ifdef HAVE_NS
1762	//Print("exportto %s -> %s\n",v->Name(),u->Name() );
1763	return iiExport(v,0,(idhdl)u->data);
1764	#else /* HAVE_NS */
1765	return TRUE;
1766	#endif /* HAVE_NS */
1767	}
1768	static BOOLEAN jjERROR(leftv res, leftv u)
1769	{
1770	WerrorS((char *)u->Data());
1771	return TRUE;
1772	}
1773	static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1774	{
1775	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1776	int p0=ABS(uu),p1=ABS(vv);
1777	int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1778
1779	while ( p1!=0 )
1780	{
1781	q=p0 / p1;
1782	r=p0 % p1;
1783	p0 = p1; p1 = r;
1784	r = g0 - g1 * q;
1785	g0 = g1; g1 = r;
1786	r = f0 - f1 * q;
1787	f0 = f1; f1 = r;
1788	}
1789	int a = f0;
1790	int b = g0;
1791	if ( uu /(int)(long)u->Data()/ < 0 ) a=-a;
1792	if ( vv /(int)(long)v->Data()/ < 0 ) b=-b;
1793	lists L=(lists)omAllocBin(slists_bin);
1794	L->Init(3);
1795	L->m[0].rtyp=INT_CMD; L->m[0].data=(void *)(long)p0;
1796	L->m[1].rtyp=INT_CMD; L->m[1].data=(void *)(long)a;
1797	L->m[2].rtyp=INT_CMD; L->m[2].data=(void *)(long)b;
1798	res->rtyp=LIST_CMD;
1799	res->data=(char *)L;
1800	return FALSE;
1801	}
1802	#ifdef HAVE_FACTORY
1803	static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1804	{
1805	poly r,pa,pb;
1806	BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1807	if (ret) return TRUE;
1808	lists L=(lists)omAllocBin(slists_bin);
1809	L->Init(3);
1810	res->data=(char *)L;
1811	L->m[0].data=(void *)r;
1812	L->m[0].rtyp=POLY_CMD;
1813	L->m[1].data=(void *)pa;
1814	L->m[1].rtyp=POLY_CMD;
1815	L->m[2].data=(void *)pb;
1816	L->m[2].rtyp=POLY_CMD;
1817	return FALSE;
1818	}
1819	static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1820	{
1821	ideal_list p,h;
1822	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
1823	p=h;
1824	int l=0;
1825	while (p!=NULL) { p=p->next;l++; }
1826	lists L=(lists)omAllocBin(slists_bin);
1827	L->Init(l);
1828	l=0;
1829	while(h!=NULL)
1830	{
1831	L->m[l].data=(char *)h->d;
1832	L->m[l].rtyp=IDEAL_CMD;
1833	p=h->next;
1834	omFreeSize(h,sizeof(*h));
1835	h=p;
1836	l++;
1837	}
1838	res->data=(void *)L;
1839	return FALSE;
1840	}
1841	#endif /* HAVE_FACTORY */
1842	static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1843	{
1844	ring r=(ring)u->Data();
1845	idhdl w;
1846	int op=iiOp;
1847	nMapFunc nMap;
1848
1849	if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1850	{
1851	int *perm=NULL;
1852	int *par_perm=NULL;
1853	int par_perm_size=0;
1854	BOOLEAN bo;
1855	//if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1856	if ((nMap=nSetMap(r))==NULL)
1857	{
1858	if (rEqual(r,currRing))
1859	{
1860	nMap=nCopy;
1861	}
1862	else
1863	// Allow imap/fetch to be make an exception only for:
1864	if ( (rField_is_Q_a(r) && // Q(a..) -> Q(a..) \|\| Q \|\| Zp \|\| Zp(a)
1865	(rField_is_Q() \|\| rField_is_Q_a() \|\|
1866	(rField_is_Zp() \|\| rField_is_Zp_a())))
1867	\|\|
1868	(rField_is_Zp_a(r) && // Zp(a..) -> Zp(a..) \|\| Zp
1869	(rField_is_Zp(currRing, rInternalChar(r)) \|\|
1870	rField_is_Zp_a(currRing, rInternalChar(r)))) )
1871	{
1872	par_perm_size=rPar(r);
1873	BITSET save_test=test;
1874	naSetChar(rInternalChar(r),r);
1875	nSetChar(currRing);
1876	test=save_test;
1877	}
1878	else
1879	{
1880	goto err_fetch;
1881	}
1882	}
1883	if ((iiOp!=FETCH_CMD) \|\| (r->N!=pVariables) \|\| (rPar(r)!=rPar(currRing)))
1884	{
1885	perm=(int )omAlloc0((r->N+1)sizeof(int));
1886	if (par_perm_size!=0)
1887	par_perm=(int )omAlloc0(par_perm_sizesizeof(int));
1888	op=IMAP_CMD;
1889	if (iiOp==IMAP_CMD)
1890	{
1891	maFindPerm(r->names, r->N, r->parameter, r->P,
1892	currRing->names,currRing->N,currRing->parameter, currRing->P,
1893	perm,par_perm, currRing->ch);
1894	}
1895	else
1896	{
1897	int i;
1898	if (par_perm_size!=0)
1899	for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
1900	for(i=si_min(r->N,pVariables);i>0;i--) perm[i]=i;
1901	}
1902	}
1903	if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1904	{
1905	int i;
1906	for(i=0;i<si_min(r->N,pVariables);i++)
1907	{
1908	Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
1909	}
1910	for(i=0;i<si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
1911	{
1912	Print("// par nr %d: %s -> %s\n",
1913	i,r->parameter[i],currRing->parameter[i]);
1914	}
1915	}
1916	sleftv tmpW;
1917	memset(&tmpW,0,sizeof(sleftv));
1918	tmpW.rtyp=IDTYP(w);
1919	tmpW.data=IDDATA(w);
1920	if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1921	perm,par_perm,par_perm_size,nMap)))
1922	{
1923	Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1924	}
1925	if (perm!=NULL)
1926	omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
1927	if (par_perm!=NULL)
1928	omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
1929	return bo;
1930	}
1931	else
1932	{
1933	Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1934	}
1935	return TRUE;
1936	err_fetch:
1937	Werror("no identity map from %s",u->Fullname());
1938	return TRUE;
1939	}
1940	static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1941	{
1942	/*4
1943	* look for the substring what in the string where
1944	* return the position of the first char of what in where
1945	* or 0
1946	*/
1947	char where=(char )u->Data();
1948	char what=(char )v->Data();
1949	char *found = strstr(where,what);
1950	if (found != NULL)
1951	{
1952	res->data=(char *)((found-where)+1);
1953	}
1954	/else res->data=NULL;/
1955	return FALSE;
1956	}
1957	static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
1958	{
1959	res->data=(char *)fractalWalkProc(u,v);
1960	setFlag( res, FLAG_STD );
1961	return FALSE;
1962	}
1963	static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1964	{
1965	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1966	int p0=ABS(uu),p1=ABS(vv);
1967	int r;
1968
1969	while ( p1!=0 )
1970	{
1971	r=p0 % p1;
1972	p0 = p1; p1 = r;
1973	}
1974	res->rtyp=INT_CMD;
1975	res->data=(char *)(long)p0;
1976	return FALSE;
1977	}
1978	static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
1979	{
1980	number a=(number) u->Data();
1981	number b=(number) v->Data();
1982	if (nlIsZero(a))
1983	{
1984	if (nlIsZero(b)) res->data=(char *)nlInit(1);
1985	else res->data=(char *)nlCopy(b);
1986	}
1987	else
1988	{
1989	if (nlIsZero(b)) res->data=(char *)nlCopy(a);
1990	else res->data=(char *)nlGcd(a, b, NULL);
1991	}
1992	return FALSE;
1993	}
1994	static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
1995	{
1996	number a=(number) u->Data();
1997	number b=(number) v->Data();
1998	if (nIsZero(a))
1999	{
2000	if (nIsZero(b)) res->data=(char *)nInit(1);
2001	else res->data=(char *)nCopy(b);
2002	}
2003	else
2004	{
2005	if (nIsZero(b)) res->data=(char *)nCopy(a);
2006	else res->data=(char *)nGcd(a, b, currRing);
2007	}
2008	return FALSE;
2009	}
2010	#ifdef HAVE_FACTORY
2011	static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
2012	{
2013	res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
2014	(poly)(v->CopyD(POLY_CMD)));
2015	return FALSE;
2016	}
2017	#endif /* HAVE_FACTORY */
2018	static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
2019	{
2020	assumeStdFlag(u);
2021	intvec module_w=(intvec)atGet(u,"isHomog",INTVEC_CMD);
2022	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
2023	switch((int)(long)v->Data())
2024	{
2025	case 1:
2026	res->data=(void *)iv;
2027	return FALSE;
2028	case 2:
2029	res->data=(void *)hSecondSeries(iv);
2030	delete iv;
2031	return FALSE;
2032	}
2033	WerrorS(feNotImplemented);
2034	delete iv;
2035	return TRUE;
2036	}
2037	static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
2038	{
2039	int i=pVar((poly)v->Data());
2040	if (i==0)
2041	{
2042	WerrorS("ringvar expected");
2043	return TRUE;
2044	}
2045	res->data = (char *)pHomogen((poly)u->Data(),i);
2046	return FALSE;
2047	}
2048	static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
2049	{
2050	int i=pVar((poly)v->Data());
2051	if (i==0)
2052	{
2053	WerrorS("ringvar expected");
2054	return TRUE;
2055	}
2056	res->data = (char *)idHomogen((ideal)u->Data(),i);
2057	return FALSE;
2058	}
2059	static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
2060	{
2061	assumeStdFlag(u);
2062	res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2063	currQuotient);
2064	return FALSE;
2065	}
2066	static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
2067	{
2068	res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2069	setFlag(res,FLAG_STD);
2070	return FALSE;
2071	}
2072	static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2073	{
2074	return jjStdJanetBasis(res,u,(int)(long)v->Data());
2075	}
2076	static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2077	{
2078	res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2079	return FALSE;
2080	}
2081	static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2082	{
2083	res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
2084	return FALSE;
2085	}
2086	static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2087	{
2088	assumeStdFlag(u);
2089	res->data = (char *)scKBase((int)(long)v->Data(),
2090	(ideal)(u->Data()),currQuotient);
2091	return FALSE;
2092	}
2093	static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2094	{
2095	return mpKoszul(res, u,v);
2096	}
2097	static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2098	{
2099	sleftv h;
2100	memset(&h,0,sizeof(sleftv));
2101	h.rtyp=INT_CMD;
2102	h.data=(void *)(long)IDELEMS((ideal)v->Data());
2103	return mpKoszul(res, u, &h, v);
2104	}
2105	static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2106	{
2107	ideal m;
2108	BITSET save_test=test;
2109	int ul= IDELEMS((ideal)u->Data());
2110	int vl= IDELEMS((ideal)v->Data());
2111	m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
2112	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
2113	test=save_test;
2114	return FALSE;
2115	}
2116	static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2117	{
2118	if ((v->rtyp!=IDHDL)\|\|(v->e!=NULL)) return TRUE;
2119	idhdl h=(idhdl)v->data;
2120	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2121	res->data = (char *)idLiftStd((ideal)u->Data(),
2122	&(h->data.umatrix),testHomog);
2123	setFlag(res,FLAG_STD);
2124	return FALSE;
2125	}
2126	static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2127	{
2128	char * s=(char *)u->Data();
2129	if(strcmp(s, "with")==0)
2130	return jjLOAD(res, v, TRUE);
2131	WerrorS("invalid second argument");
2132	WerrorS("load(\"libname\" [,\"with\"]);");
2133	return TRUE;
2134	}
2135	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2136	{
2137	res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2138	return (res->data==NULL);
2139	}
2140	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2141	{
2142	intvec w_u=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2143	tHomog hom=testHomog;
2144	if (w_u!=NULL)
2145	{
2146	w_u=ivCopy(w_u);
2147	hom=isHomog;
2148	}
2149	intvec w_v=(intvec )atGet(v,"isHomog",INTVEC_CMD);
2150	if (w_v!=NULL)
2151	{
2152	w_v=ivCopy(w_v);
2153	hom=isHomog;
2154	}
2155	if ((w_u!=NULL) && (w_v==NULL))
2156	w_v=ivCopy(w_u);
2157	if ((w_v!=NULL) && (w_u==NULL))
2158	w_u=ivCopy(w_v);
2159	ideal u_id=(ideal)u->Data();
2160	ideal v_id=(ideal)v->Data();
2161	if (w_u!=NULL)
2162	{
2163	if ((*w_u).compare((w_v))!=0)
2164	{
2165	WarnS("incompatible weights");
2166	delete w_u; w_u=NULL;
2167	hom=testHomog;
2168	}
2169	else
2170	{
2171	if ((!idTestHomModule(u_id,currQuotient,w_v))
2172	\|\| (!idTestHomModule(v_id,currQuotient,w_v)))
2173	{
2174	WarnS("wrong weights");
2175	delete w_u; w_u=NULL;
2176	hom=testHomog;
2177	}
2178	}
2179	}
2180	res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2181	if (w_u!=NULL)
2182	{
2183	atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2184	}
2185	delete w_v;
2186	return FALSE;
2187	}
2188	static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2189	{
2190	number q=(number)v->Data();
2191	if (nlIsZero(q))
2192	{
2193	WerrorS(ii_div_by_0);
2194	return TRUE;
2195	}
2196	res->data =(char *) nlIntMod((number)u->Data(),q);
2197	return FALSE;
2198	}
2199	static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2200	{
2201	number q=(number)v->Data();
2202	if (nIsZero(q))
2203	{
2204	WerrorS(ii_div_by_0);
2205	return TRUE;
2206	}
2207	res->data =(char *) nIntMod((number)u->Data(),q);
2208	return FALSE;
2209	}
2210	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2211	{
2212	char opt=(char )v->Data();
2213	int mode=0;
2214	while(*opt!='\0')
2215	{
2216	if (*opt=='i') mode \|= PROT_I;
2217	else if (*opt=='o') mode \|= PROT_O;
2218	opt++;
2219	}
2220	monitor((char *)(u->Data()),mode);
2221	return FALSE;
2222	}
2223	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2224	{
2225	idhdl h=(idhdl)u->data;
2226	int i=(int)(long)v->Data();
2227	int p=0;
2228	if ((0<i)
2229	&& (IDRING(h)->parameter!=NULL)
2230	&& (i<=(p=rPar(IDRING(h)))))
2231	res->data=omStrDup(IDRING(h)->parameter[i-1]);
2232	else
2233	{
2234	Werror("par number %d out of range 1..%d",i,p);
2235	return TRUE;
2236	}
2237	return FALSE;
2238	}
2239
2240	#ifdef HAVE_PLURAL
2241	static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2242	{
2243	return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2244	}
2245
2246	static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2247	{
2248	return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2249	}
2250
2251	static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2252	{
2253	return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2254	}
2255
2256	static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2257	{
2258	return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2259	}
2260
2261	static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2262	{
2263	if (rIsPluralRing(currRing))
2264	{
2265	poly p = (poly)a->CopyD(POLY_CMD);
2266	poly q = (poly)b->Data();
2267	res->data = nc_p_Bracket_qq(p,q);
2268	}
2269	else res->data=NULL;
2270	return FALSE;
2271	}
2272
2273	static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2274	{
2275	/* number, poly, vector, ideal, module, matrix */
2276	ring r = (ring)a->Data();
2277	if (r == currRing)
2278	{
2279	res->data = b->Data();
2280	res->rtyp = b->rtyp;
2281	return FALSE;
2282	}
2283	if (!rIsLikeOpposite(currRing, r))
2284	{
2285	Werror("%s is not an opposite ring to current ring",a->Fullname());
2286	return TRUE;
2287	}
2288	idhdl w;
2289	if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2290	{
2291	int argtype = IDTYP(w);
2292	switch (argtype)
2293	{
2294	case NUMBER_CMD:
2295	{
2296	/* since basefields are equal, we can apply nCopy */
2297	res->data = nCopy((number)IDDATA(w));
2298	res->rtyp = argtype;
2299	break;
2300	}
2301	case POLY_CMD:
2302	case VECTOR_CMD:
2303	{
2304	poly q = (poly)IDDATA(w);
2305	res->data = pOppose(r,q);
2306	res->rtyp = argtype;
2307	break;
2308	}
2309	case IDEAL_CMD:
2310	case MODUL_CMD:
2311	{
2312	ideal Q = (ideal)IDDATA(w);
2313	res->data = idOppose(r,Q);
2314	res->rtyp = argtype;
2315	break;
2316	}
2317	case MATRIX_CMD:
2318	{
2319	ring save = currRing;
2320	rChangeCurrRing(r);
2321	matrix m = (matrix)IDDATA(w);
2322	ideal Q = idMatrix2Module(mpCopy(m));
2323	rChangeCurrRing(save);
2324	ideal S = idOppose(r,Q);
2325	id_Delete(&Q, r);
2326	res->data = idModule2Matrix(S);
2327	res->rtyp = argtype;
2328	break;
2329	}
2330	default:
2331	{
2332	WerrorS("unsupported type in oppose");
2333	return TRUE;
2334	}
2335	}
2336	}
2337	else
2338	{
2339	Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2340	return TRUE;
2341	}
2342	return FALSE;
2343	}
2344	#endif /* HAVE_PLURAL */
2345
2346	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2347	{
2348	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2349	hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2350	idDelMultiples((ideal)(res->data));
2351	return FALSE;
2352	}
2353	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2354	{
2355	int i=(int)(long)u->Data();
2356	int j=(int)(long)v->Data();
2357	#ifdef buildin_rand
2358	res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
2359	#else /* buildin_rand */
2360	res->data =(char *)(long)((i > j) ? i : (rand() % (j-i+1)) + i);
2361	#endif /* buildin_rand */
2362	return FALSE;
2363	}
2364	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2365	{
2366	si_link l=(si_link)u->Data();
2367	leftv r=slRead(l,v);
2368	if (r==NULL)
2369	{
2370	const char *s;
2371	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2372	else s=sNoName;
2373	Werror("cannot read from `%s`",s);
2374	return TRUE;
2375	}
2376	memcpy(res,r,sizeof(sleftv));
2377	omFreeBin((ADDRESS)r, sleftv_bin);
2378	return FALSE;
2379	}
2380	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2381	{
2382	assumeStdFlag(v);
2383	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2384	return FALSE;
2385	}
2386	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2387	{
2388	assumeStdFlag(v);
2389	ideal ui=(ideal)u->Data();
2390	idTest(ui);
2391	ideal vi=(ideal)v->Data();
2392	idTest(vi);
2393	res->data = (char *)kNF(vi,currQuotient,ui);
2394	return FALSE;
2395	}
2396	#if 0
2397	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2398	{
2399	int maxl=(int)(long)v->Data();
2400	if (maxl<0)
2401	{
2402	WerrorS("length for res must not be negative");
2403	return TRUE;
2404	}
2405	int l=0;
2406	//resolvente r;
2407	syStrategy r;
2408	intvec *weights=NULL;
2409	int wmaxl=maxl;
2410	ideal u_id=(ideal)u->Data();
2411
2412	maxl--;
2413	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2414	{
2415	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2416	if (currQuotient!=NULL)
2417	{
2418	Warn(
2419	"full resolution in a qring may be infinite, setting max length to %d",
2420	maxl+1);
2421	}
2422	}
2423	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2424	if (weights!=NULL)
2425	{
2426	if (!idTestHomModule(u_id,currQuotient,weights))
2427	{
2428	WarnS("wrong weights given:");weights->show();PrintLn();
2429	weights=NULL;
2430	}
2431	}
2432
2433	intvec *ww=NULL;
2434	int add_row_shift=0;
2435	if (weights!=NULL)
2436	{
2437	ww=ivCopy(weights);
2438	add_row_shift = ww->min_in();
2439	(*ww) -= add_row_shift;
2440	}
2441	else
2442	idHomModule(u_id,currQuotient,&ww);
2443	weights=ww;
2444
2445	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2446	{
2447	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2448	}
2449	else if (iiOp==SRES_CMD)
2450	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2451	r=sySchreyer(u_id,maxl+1);
2452	else if (iiOp == LRES_CMD)
2453	{
2454	int dummy;
2455	if((currQuotient!=NULL)\|\|
2456	(!idHomIdeal (u_id,NULL)))
2457	{
2458	WerrorS
2459	("`lres` not implemented for inhomogeneous input or qring");
2460	return TRUE;
2461	}
2462	r=syLaScala3(u_id,&dummy);
2463	}
2464	else if (iiOp == KRES_CMD)
2465	{
2466	int dummy;
2467	if((currQuotient!=NULL)\|\|
2468	(!idHomIdeal (u_id,NULL)))
2469	{
2470	WerrorS
2471	("`kres` not implemented for inhomogeneous input or qring");
2472	return TRUE;
2473	}
2474	r=syKosz(u_id,&dummy);
2475	}
2476	else
2477	{
2478	int dummy;
2479	if((currQuotient!=NULL)\|\|
2480	(!idHomIdeal (u_id,NULL)))
2481	{
2482	WerrorS
2483	("`hres` not implemented for inhomogeneous input or qring");
2484	return TRUE;
2485	}
2486	r=syHilb(u_id,&dummy);
2487	}
2488	if (r==NULL) return TRUE;
2489	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2490	r->list_length=wmaxl;
2491	res->data=(void *)r;
2492	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2493	{
2494	intvec *w=ivCopy(r->weights[0]);
2495	if (weights!=NULL) (*w) += add_row_shift;
2496	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2497	delete w;
2498	}
2499	else
2500	{
2501	//#if 0
2502	// need to set weights for ALL components (sres)
2503	if (weights!=NULL)
2504	{
2505	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2506	r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2507	(r->weights)[0] = ivCopy(weights);
2508	}
2509	//#endif
2510	}
2511	if (ww!=NULL) { delete ww; ww=NULL; }
2512	return FALSE;
2513	}
2514	#else
2515	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2516	{
2517	int maxl=(int)(long)v->Data();
2518	if (maxl<0)
2519	{
2520	WerrorS("length for res must not be negative");
2521	return TRUE;
2522	}
2523	int l=0;
2524	//resolvente r;
2525	syStrategy r;
2526	intvec *weights=NULL;
2527	int wmaxl=maxl;
2528	ideal u_id=(ideal)u->Data();
2529
2530	maxl--;
2531	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2532	{
2533	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2534	if (currQuotient!=NULL)
2535	{
2536	Warn(
2537	"full resolution in a qring may be infinite, setting max length to %d",
2538	maxl+1);
2539	}
2540	}
2541	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2542	if (weights!=NULL)
2543	{
2544	if (!idTestHomModule(u_id,currQuotient,weights))
2545	{
2546	WarnS("wrong weights given:");weights->show();PrintLn();
2547	weights=NULL;
2548	}
2549	}
2550	intvec *ww=NULL;
2551	int add_row_shift=0;
2552	if (weights!=NULL)
2553	{
2554	ww=ivCopy(weights);
2555	add_row_shift = ww->min_in();
2556	(*ww) -= add_row_shift;
2557	}
2558
2559	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2560	{
2561	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2562	}
2563	else if (iiOp==SRES_CMD)
2564	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2565	r=sySchreyer(u_id,maxl+1);
2566	else if (iiOp == LRES_CMD)
2567	{
2568	int dummy;
2569	if((currQuotient!=NULL)\|\|
2570	(!idHomIdeal (u_id,NULL)))
2571	{
2572	WerrorS
2573	("`lres` not implemented for inhomogeneous input or qring");
2574	return TRUE;
2575	}
2576	r=syLaScala3(u_id,&dummy);
2577	}
2578	else if (iiOp == KRES_CMD)
2579	{
2580	int dummy;
2581	if((currQuotient!=NULL)\|\|
2582	(!idHomIdeal (u_id,NULL)))
2583	{
2584	WerrorS
2585	("`kres` not implemented for inhomogeneous input or qring");
2586	return TRUE;
2587	}
2588	r=syKosz(u_id,&dummy);
2589	}
2590	else
2591	{
2592	int dummy;
2593	if((currQuotient!=NULL)\|\|
2594	(!idHomIdeal (u_id,NULL)))
2595	{
2596	WerrorS
2597	("`hres` not implemented for inhomogeneous input or qring");
2598	return TRUE;
2599	}
2600	r=syHilb(u_id,&dummy);
2601	}
2602	if (r==NULL) return TRUE;
2603	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2604	r->list_length=wmaxl;
2605	res->data=(void *)r;
2606	if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2607	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2608	{
2609	ww=ivCopy(r->weights[0]);
2610	if (weights!=NULL) (*ww) += add_row_shift;
2611	atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2612	}
2613	else
2614	{
2615	if (weights!=NULL)
2616	{
2617	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2618	}
2619	}
2620	return FALSE;
2621	}
2622	#endif
2623	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2624	{
2625	ring r;
2626	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2627	res->data = (char *)r;
2628	return (i==-1);
2629	}
2630	#define SIMPL_LMDIV 32
2631	#define SIMPL_LMEQ 16
2632	#define SIMPL_MULT 8
2633	#define SIMPL_EQU 4
2634	#define SIMPL_NULL 2
2635	#define SIMPL_NORM 1
2636	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2637	{
2638	int sw = (int)(long)v->Data();
2639	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2640	ideal id = (ideal)u->CopyD(IDEAL_CMD);
2641	if (sw & SIMPL_LMDIV)
2642	{
2643	idDelDiv(id);
2644	}
2645	if (sw & SIMPL_LMEQ)
2646	{
2647	idDelLmEquals(id);
2648	}
2649	if (sw & SIMPL_MULT)
2650	{
2651	idDelMultiples(id);
2652	}
2653	else if(sw & SIMPL_EQU)
2654	{
2655	idDelEquals(id);
2656	}
2657	if (sw & SIMPL_NULL)
2658	{
2659	idSkipZeroes(id);
2660	}
2661	if (sw & SIMPL_NORM)
2662	{
2663	idNorm(id);
2664	}
2665	res->data = (char * )id;
2666	return FALSE;
2667	}
2668	#ifdef HAVE_FACTORY
2669	extern int singclap_factorize_retry;
2670	static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2671	{
2672	intvec *v=NULL;
2673	int sw=(int)(long)dummy->Data();
2674	int fac_sw=sw;
2675	if ((sw<0)\|\|(sw>2)) fac_sw=1;
2676	singclap_factorize_retry=0;
2677	ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2678	if (f==NULL)
2679	return TRUE;
2680	switch(sw)
2681	{
2682	case 0:
2683	case 2:
2684	{
2685	lists l=(lists)omAllocBin(slists_bin);
2686	l->Init(2);
2687	l->m[0].rtyp=IDEAL_CMD;
2688	l->m[0].data=(void *)f;
2689	l->m[1].rtyp=INTVEC_CMD;
2690	l->m[1].data=(void *)v;
2691	res->data=(void *)l;
2692	res->rtyp=LIST_CMD;
2693	return FALSE;
2694	}
2695	case 1:
2696	res->data=(void *)f;
2697	return FALSE;
2698	case 3:
2699	{
2700	poly p=f->m[0];
2701	int i=IDELEMS(f);
2702	f->m[0]=NULL;
2703	while(i>1)
2704	{
2705	i--;
2706	p=pMult(p,f->m[i]);
2707	f->m[i]=NULL;
2708	}
2709	res->data=(void *)p;
2710	res->rtyp=POLY_CMD;
2711	}
2712	return FALSE;
2713	}
2714	WerrorS("invalid switch");
2715	return TRUE;
2716	}
2717	#endif
2718	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2719	{
2720	res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2721	return FALSE;
2722	}
2723	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2724	{
2725	int sw = (int)(long)v->Data();
2726	// CopyD for POLY_CMD and VECTOR_CMD are identical:
2727	poly p = (poly)u->CopyD(POLY_CMD);
2728	if (sw & SIMPL_NORM)
2729	{
2730	pNorm(p);
2731	}
2732	res->data = (char * )p;
2733	return FALSE;
2734	}
2735	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2736	{
2737	ideal result;
2738	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2739	tHomog hom=testHomog;
2740	ideal u_id=(ideal)(u->Data());
2741	if (w!=NULL)
2742	{
2743	if (!idTestHomModule(u_id,currQuotient,w))
2744	{
2745	WarnS("wrong weights");
2746	w=NULL;
2747	}
2748	else
2749	{
2750	w=ivCopy(w);
2751	hom=isHomog;
2752	}
2753	}
2754	result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
2755	idSkipZeroes(result);
2756	res->data = (char *)result;
2757	setFlag(res,FLAG_STD);
2758	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2759	return FALSE;
2760	}
2761	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2762	{
2763	ideal result;
2764	assumeStdFlag(u);
2765	ideal i1=(ideal)(u->Data());
2766	ideal i0;
2767	int r=v->Typ();
2768	if ((/v->Typ()/r==POLY_CMD) \|\|(r==VECTOR_CMD))
2769	{
2770	i0=idInit(1,i1->rank);
2771	i0->m[0]=(poly)v->Data();
2772	}
2773	else /IDEAL/
2774	{
2775	i0=(ideal)v->Data();
2776	}
2777	int ii0=idElem(i0);
2778	i1=idSimpleAdd(i1,i0);
2779	memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
2780	idDelete(&i0);
2781	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2782	tHomog hom=testHomog;
2783	if (w!=NULL)
2784	{
2785	if (!idTestHomModule(i1,currQuotient,w))
2786	{
2787	// no warnung: this is legal, if i in std(i,p)
2788	// is homogeneous, but p not
2789	w=NULL;
2790	}
2791	else
2792	{
2793	w=ivCopy(w);
2794	hom=isHomog;
2795	}
2796	}
2797	BITSET save_test=test;
2798	test\|=Sy_bit(OPT_SB_1);
2799	result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-ii0);
2800	test=save_test;
2801	idDelete(&i1);
2802	idSkipZeroes(result);
2803	res->data = (char *)result;
2804	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
2805	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2806	return FALSE;
2807	}
2808	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2809	{
2810	idhdl h=(idhdl)u->data;
2811	int i=(int)(long)v->Data();
2812	if ((0<i) && (i<=IDRING(h)->N))
2813	res->data=omStrDup(IDRING(h)->names[i-1]);
2814	else
2815	{
2816	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2817	return TRUE;
2818	}
2819	return FALSE;
2820	}
2821	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2822	{
2823	res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2824	return FALSE;
2825	}
2826	#define jjWRONG2 (proc2)jjWRONG
2827	#define jjWRONG3 (proc3)jjWRONG
2828	static BOOLEAN jjWRONG(leftv res, leftv u)
2829	{
2830	return TRUE;
2831	}
2832
2833	/=================== operations with 2 args.: table =================/
2834
2835	struct sValCmd2 dArith2[]=
2836	{
2837	// operations:
2838	// proc cmd res arg1 arg2 plural
2839	{jjCOLCOL, COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD ALLOW_PLURAL}
2840	,{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2841	,{jjPLUS_BI, '+', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2842	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2843	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2844	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2845	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2846	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2847	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
2848	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2849	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2850	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2851	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2852	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2853	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2854	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2855	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2856	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2857	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
2858	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
2859	,{jjRSUM, '+', QRING_CMD, QRING_CMD, RING_CMD ALLOW_PLURAL}
2860	,{jjRSUM, '+', QRING_CMD, RING_CMD, QRING_CMD ALLOW_PLURAL}
2861	,{jjRSUM, '+', QRING_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
2862	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2863	,{jjMINUS_BI, '-', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2864	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2865	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2866	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2867	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2868	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2869	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2870	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2871	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2872	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2873	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2874	,{jjTIMES_BI, '*', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2875	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2876	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2877	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD ALLOW_PLURAL}
2878	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2879	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
2880	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
2881	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2882	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD ALLOW_PLURAL}
2883	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD NO_PLURAL}
2884	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2885	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2886	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2887	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
2888	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2889	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2890	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2891	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
2892	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2893	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2894	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2895	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2896	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2897	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2898	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2899	,{jjTIMES_IV, '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2900	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2901	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2902	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2903	,{jjDIV_Ma, '/', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2904	,{jjDIVMOD_I, '/', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2905	,{jjDIV_BI, '/', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2906	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2907	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2908	,{jjDIVMOD_I, INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2909	,{jjDIV_BI, INTDIV_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2910	,{jjOP_IV_I, INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2911	,{jjOP_IV_I, INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2912	,{jjDIVMOD_I, '%', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2913	,{jjMOD_BI, '%', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2914	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2915	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2916	,{jjMOD_N, '%', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2917	,{jjDIVMOD_I, INTMOD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2918	,{jjMOD_BI, INTMOD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2919	,{jjOP_IV_I, INTMOD_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2920	,{jjOP_IV_I, INTMOD_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2921	,{jjMOD_N, INTMOD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2922	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2923	,{jjPOWER_BI, '^', BIGINT_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
2924	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2925	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2926	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2927	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2928	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2929	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2930	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2931	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2932	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2933	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2934	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2935	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2936	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2937	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2938	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2939	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2940	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2941	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2942	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2943	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2944	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2945	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2946	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2947	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2948	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2949	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2950	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2951	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2952	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2953	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2954	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2955	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2956	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2957	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2958	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2959	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2960	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2961	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2962	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2963	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2964	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2965	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2966	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2967	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2968	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2969	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2970	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2971	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2972	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2973	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2974	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2975	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2976	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2977	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2978	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2979	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2980	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2981	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2982	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2983	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2984	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2985	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2986	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD ALLOW_PLURAL}
2987	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
2988	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
2989	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
2990	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
2991	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2992	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2993	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2994	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2995	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
2996	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2997	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2998	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2999	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
3000	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
3001	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
3002	// and the procedures with 2 arguments:
3003	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD ALLOW_PLURAL}
3004	,{jjWRONG2, BAREISS_CMD, 0, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3005	,{jjBETTI2, BETTI_CMD, INTMAT_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3006	,{syBetti2, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
3007	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3008	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3009	#ifdef HAVE_PLURAL
3010	,{jjBRACKET, BRACKET_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3011	#endif
3012	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3013	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3014	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3015	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3016	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3017	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3018	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
3019	,{jjDEG_IV, DEG_CMD, INT_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3020	,{jjDEG_M_IV, DEG_CMD, INT_CMD, MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
3021	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3022	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3023	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3024	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3025	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3026	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3027	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3028	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3029	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD NO_PLURAL}
3030	,{jjDIVISION, DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3031	,{jjDIVISION, DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
3032	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3033	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3034	,{jjEXPORTTO, EXPORTTO_CMD, NONE, PACKAGE_CMD, IDHDL ALLOW_PLURAL}
3035	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3036	#ifdef HAVE_FACTORY
3037	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3038	,{jjSQR_FREE_DEC,FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3039	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3040	#else
3041	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3042	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3043	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3044	#endif
3045	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3046	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3047	#ifdef HAVE_FGLM
3048	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3049	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3050	,{fglmQuotProc,FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD NO_PLURAL}
3051	#else
3052	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3053	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3054	,{jjWRONG2, FGLMQUOT_CMD, IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
3055	#endif
3056	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3057	,{jjFWALK, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3058
3059	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3060	,{jjGCD_N, GCD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3061	,{jjGCD_BI, GCD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3062	#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
3063	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3064	#else
3065	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3066	#endif
3067	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3068	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3069	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3070	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3071	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3072	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3073	,{jjRES, HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3074	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3075	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3076	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3077	,{jjIMPORTFROM,IMPORTFROM_CMD, NONE, PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
3078	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3079	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
3080	#ifdef HAVE_INTERPOLATION
3081	,{jjINTERPOLATION,INTERPOLATE_CMD,IDEAL_CMD, LIST_CMD, INTVEC_CMD NO_PLURAL}
3082	#endif
3083	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3084	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3085	,{jjJanetBasis2, JANET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3086	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3087	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3088	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3089	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3090	,{jjJET_ID, JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3091	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3092	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3093	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD ALLOW_PLURAL}
3094	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD NO_PLURAL}
3095	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
3096	,{jjRES, KRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3097	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3098	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3099	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
3100	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
3101	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3102	,{jjLOAD_E, LOAD_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3103	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3104	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3105	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3106	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3107	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3108	,{jjMONITOR2, MONITOR_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3109	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3110	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3111	,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3112	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3113	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3114	//,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3115	#ifdef HAVE_PLURAL
3116	,{jjPlural_num_poly, NCALGEBRA_CMD, NONE, POLY_CMD, POLY_CMD NO_PLURAL}
3117	,{jjPlural_num_mat, NCALGEBRA_CMD, NONE, POLY_CMD, MATRIX_CMD NO_PLURAL}
3118	,{jjPlural_mat_poly, NCALGEBRA_CMD, NONE, MATRIX_CMD, POLY_CMD NO_PLURAL}
3119	,{jjPlural_mat_mat, NCALGEBRA_CMD, NONE, MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3120	#endif
3121	#ifdef HAVE_PLURAL
3122	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, RING_CMD, DEF_CMD ALLOW_PLURAL}
3123	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, QRING_CMD, DEF_CMD ALLOW_PLURAL}
3124	#endif
3125	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3126	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3127	,{jjPRINT_FORMAT, PRINT_CMD, ANY_TYPE, DEF_CMD, STRING_CMD ALLOW_PLURAL}
3128	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3129	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3130	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3131	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3132	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3133	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
3134	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3135	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3136	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3137	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3138	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3139	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3140	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3141	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3142	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3143	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3144	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3145	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3146	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3147	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3148	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3149	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3150	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3151	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3152	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3153	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3154	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD ALLOW_PLURAL}
3155	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3156	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3157	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD NO_PLURAL}
3158	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD NO_PLURAL}
3159	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3160	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3161	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3162	,{NULL, 0, 0, 0, 0 NO_PLURAL}
3163	};
3164	/=================== operations with 1 arg.: static proc =================/
3165	static BOOLEAN jjDUMMY(leftv res, leftv u)
3166	{
3167	res->data = (char *)u->CopyD();
3168	return FALSE;
3169	}
3170	static BOOLEAN jjNULL(leftv res, leftv u)
3171	{
3172	return FALSE;
3173	}
3174	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3175	//{
3176	// res->data = (char *)((int)(long)u->Data()+1);
3177	// return FALSE;
3178	//}
3179	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3180	//{
3181	// res->data = (char *)((int)(long)u->Data()-1);
3182	// return FALSE;
3183	//}
3184	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3185	{
3186	if (IDTYP((idhdl)u->data)==INT_CMD)
3187	{
3188	int i=IDINT((idhdl)u->data);
3189	if (iiOp==PLUSPLUS) i++;
3190	else i--;
3191	IDDATA((idhdl)u->data)=(char *)(long)i;
3192	return FALSE;
3193	}
3194	return TRUE;
3195	}
3196	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3197	{
3198	res->data = (char *)(-(long)u->Data());
3199	return FALSE;
3200	}
3201	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3202	{
3203	number n=(number)u->CopyD(NUMBER_CMD);
3204	n=nNeg(n);
3205	res->data = (char *)n;
3206	return FALSE;
3207	}
3208	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3209	{
3210	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3211	return FALSE;
3212	}
3213	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3214	{
3215	poly m1=pISet(-1);
3216	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3217	return FALSE;
3218	}
3219	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3220	{
3221	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
3222	(iv)=(-1);
3223	res->data = (char *)iv;
3224	return FALSE;
3225	}
3226	static BOOLEAN jjPROC1(leftv res, leftv u)
3227	{
3228	return jjPROC(res,u,NULL);
3229	}
3230	static BOOLEAN jjBAREISS(leftv res, leftv v)
3231	{
3232	//matrix m=(matrix)v->Data();
3233	//lists l=mpBareiss(m,FALSE);
3234	intvec *iv;
3235	ideal m;
3236	smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3237	lists l=(lists)omAllocBin(slists_bin);
3238	l->Init(2);
3239	l->m[0].rtyp=MODUL_CMD;
3240	l->m[1].rtyp=INTVEC_CMD;
3241	l->m[0].data=(void *)m;
3242	l->m[1].data=(void *)iv;
3243	res->data = (char *)l;
3244	return FALSE;
3245	}
3246	//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3247	//{
3248	// intvec m=(intvec )v->CopyD(INTMAT_CMD);
3249	// ivTriangMat(m);
3250	// res->data = (char *)m;
3251	// return FALSE;
3252	//}
3253	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3254	{
3255	return iiExprArithM(res,u,iiOp);
3256	}
3257	static BOOLEAN jjCHAR(leftv res, leftv v)
3258	{
3259	res->data = (char *)(long)rChar((ring)v->Data());
3260	return FALSE;
3261	}
3262	static BOOLEAN jjCOLS(leftv res, leftv v)
3263	{
3264	res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3265	return FALSE;
3266	}
3267	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3268	{
3269	res->data = (char )(long)((intvec)(v->Data()))->cols();
3270	return FALSE;
3271	}
3272	static BOOLEAN jjCONTENT(leftv res, leftv v)
3273	{
3274	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3275	poly p=(poly)v->CopyD(POLY_CMD);
3276	if (p!=NULL) pCleardenom(p);
3277	res->data = (char *)p;
3278	return FALSE;
3279	}
3280	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3281	{
3282	res->data = (char *)(long)nSize((number)v->Data());
3283	return FALSE;
3284	}
3285	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3286	{
3287	lists l=(lists)v->Data();
3288	res->data = (char *)(long)(l->nr+1);
3289	return FALSE;
3290	}
3291	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3292	{
3293	matrix m=(matrix)v->Data();
3294	res->data = (char )(long)(MATROWS(m)MATCOLS(m));
3295	return FALSE;
3296	}
3297	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3298	{
3299	res->data = (char )(long)((intvec)(v->Data()))->length();
3300	return FALSE;
3301	}
3302	static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3303	{
3304	ring r=(ring)v->Data();
3305	int elems=-1;
3306	if (rField_is_Zp(r)\|\|rField_is_GF(r)) elems=rInternalChar(r);
3307	else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3308	{
3309	#ifdef HAVE_FACTORY
3310	extern int ipower ( int b, int n ); /* factory/cf_util */
3311	elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3312	#else
3313	elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3314	#endif
3315	}
3316	res->data = (char *)(long)elems;
3317	return FALSE;
3318	}
3319	static BOOLEAN jjDEG(leftv res, leftv v)
3320	{
3321	int dummy;
3322	poly p=(poly)v->Data();
3323	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3324	else res->data=(char *)-1;
3325	return FALSE;
3326	}
3327	static BOOLEAN jjDEG_M(leftv res, leftv u)
3328	{
3329	ideal I=(ideal)u->Data();
3330	int d=-1;
3331	int dummy;
3332	int i;
3333	for(i=IDELEMS(I)-1;i>=0;i--)
3334	if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3335	res->data = (char *)(long)d;
3336	return FALSE;
3337	}
3338	static BOOLEAN jjDEGREE(leftv res, leftv v)
3339	{
3340	assumeStdFlag(v);
3341	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3342	scDegree((ideal)v->Data(),module_w,currQuotient);
3343	return FALSE;
3344	}
3345	static BOOLEAN jjDEFINED(leftv res, leftv v)
3346	{
3347	if ((v->rtyp==IDHDL)
3348	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
3349	{
3350	res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3351	}
3352	else if (v->rtyp!=0) res->data=(void *)(-1);
3353	return FALSE;
3354	}
3355	#ifdef HAVE_FACTORY
3356	static BOOLEAN jjDET(leftv res, leftv v)
3357	{
3358	matrix m=(matrix)v->Data();
3359	poly p;
3360	if (smCheckDet((ideal)m,m->cols(),TRUE))
3361	{
3362	ideal I=idMatrix2Module(mpCopy(m));
3363	p=smCallDet(I);
3364	idDelete(&I);
3365	}
3366	else
3367	p=singclap_det(m);
3368	res ->data = (char *)p;
3369	return FALSE;
3370	}
3371	static BOOLEAN jjDET_I(leftv res, leftv v)
3372	{
3373	intvec * m=(intvec*)v->Data();
3374	int i,j;
3375	i=m->rows();j=m->cols();
3376	if(i==j)
3377	res->data = (char *)(long)singclap_det_i(m);
3378	else
3379	{
3380	Werror("det of %d x %d intmat",i,j);
3381	return TRUE;
3382	}
3383	return FALSE;
3384	}
3385	static BOOLEAN jjDET_S(leftv res, leftv v)
3386	{
3387	ideal I=(ideal)v->Data();
3388	poly p;
3389	if (smCheckDet(I,IDELEMS(I),FALSE))
3390	{
3391	matrix m=idModule2Matrix(idCopy(I));
3392	p=singclap_det(m);
3393	idDelete((ideal *)&m);
3394	}
3395	else
3396	p=smCallDet(I);
3397	res->data = (char *)p;
3398	return FALSE;
3399	}
3400	#endif
3401	static BOOLEAN jjDIM(leftv res, leftv v)
3402	{
3403	assumeStdFlag(v);
3404	res->data = (char *)(long)scDimInt((ideal)(v->Data()),currQuotient);
3405	return FALSE;
3406	}
3407	static BOOLEAN jjDUMP(leftv res, leftv v)
3408	{
3409	si_link l = (si_link)v->Data();
3410	if (slDump(l))
3411	{
3412	const char *s;
3413	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3414	else s=sNoName;
3415	Werror("cannot dump to `%s`",s);
3416	return TRUE;
3417	}
3418	else
3419	return FALSE;
3420	}
3421	static BOOLEAN jjE(leftv res, leftv v)
3422	{
3423	res->data = (char *)pOne();
3424	pSetComp((poly)res->data,(int)(long)v->Data());
3425	pSetm((poly)res->data);
3426	return FALSE;
3427	}
3428	static BOOLEAN jjEXECUTE(leftv res, leftv v)
3429	{
3430	char * d = (char *)v->Data();
3431	char * s = (char *)omAlloc(strlen(d) + 13);
3432	strcpy( s, (char *)d);
3433	strcat( s, "\n;RETURN();\n");
3434	newBuffer(s,BT_execute);
3435	return yyparse();
3436	}
3437	#ifdef HAVE_FACTORY
3438	static BOOLEAN jjFACSTD(leftv res, leftv v)
3439	{
3440	ideal_list p,h;
3441	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3442	p=h;
3443	int l=0;
3444	while (p!=NULL) { p=p->next;l++; }
3445	lists L=(lists)omAllocBin(slists_bin);
3446	L->Init(l);
3447	l=0;
3448	while(h!=NULL)
3449	{
3450	L->m[l].data=(char *)h->d;
3451	L->m[l].rtyp=IDEAL_CMD;
3452	p=h->next;
3453	omFreeSize(h,sizeof(*h));
3454	h=p;
3455	l++;
3456	}
3457	res->data=(void *)L;
3458	return FALSE;
3459	}
3460	static BOOLEAN jjFAC_P(leftv res, leftv u)
3461	{
3462	intvec *v=NULL;
3463	singclap_factorize_retry=0;
3464	ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3465	if (f==NULL) return TRUE;
3466	ivTest(v);
3467	lists l=(lists)omAllocBin(slists_bin);
3468	l->Init(2);
3469	l->m[0].rtyp=IDEAL_CMD;
3470	l->m[0].data=(void *)f;
3471	l->m[1].rtyp=INTVEC_CMD;
3472	l->m[1].data=(void *)v;
3473	res->data=(void *)l;
3474	return FALSE;
3475	}
3476	#endif
3477	static BOOLEAN jjGETDUMP(leftv res, leftv v)
3478	{
3479	si_link l = (si_link)v->Data();
3480	if (slGetDump(l))
3481	{
3482	const char *s;
3483	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3484	else s=sNoName;
3485	Werror("cannot get dump from `%s`",s);
3486	return TRUE;
3487	}
3488	else
3489	return FALSE;
3490	}
3491	static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3492	{
3493	assumeStdFlag(v);
3494	ideal I=(ideal)v->Data();
3495	res->data=(void *)iiHighCorner(I,0);
3496	return FALSE;
3497	}
3498	static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3499	{
3500	assumeStdFlag(v);
3501	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3502	BOOLEAN delete_w=FALSE;
3503	ideal I=(ideal)v->Data();
3504	int i;
3505	poly p=NULL,po=NULL;
3506	int rk=idRankFreeModule(I);
3507	if (w==NULL)
3508	{
3509	w = new intvec(rk);
3510	delete_w=TRUE;
3511	}
3512	for(i=rk;i>0;i--)
3513	{
3514	p=iiHighCorner(I,i);
3515	if (p==NULL)
3516	{
3517	WerrorS("module must be zero-dimensional");
3518	if (delete_w) delete w;
3519	return TRUE;
3520	}
3521	if (po==NULL)
3522	{
3523	po=p;
3524	}
3525	else
3526	{
3527	// now po!=NULL, p!=NULL
3528	int d=(pFDeg(po,currRing)-(w)[pGetComp(po)-1] - pFDeg(p,currRing)+(w)[i-1]);
3529	if (d==0)
3530	d=pLmCmp(po,p);
3531	if (d > 0)
3532	{
3533	pDelete(&p);
3534	}
3535	else // (d < 0)
3536	{
3537	pDelete(&po); po=p;
3538	}
3539	}
3540	}
3541	if (delete_w) delete w;
3542	res->data=(void *)po;
3543	return FALSE;
3544	}
3545	static BOOLEAN jjHILBERT(leftv res, leftv v)
3546	{
3547	assumeStdFlag(v);
3548	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3549	//scHilbertPoly((ideal)v->Data(),currQuotient);
3550	hLookSeries((ideal)v->Data(),module_w,currQuotient);
3551	return FALSE;
3552	}
3553	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3554	{
3555	res->data=(void )hSecondSeries((intvec )v->Data());
3556	return FALSE;
3557	}
3558	static BOOLEAN jjHOMOG1(leftv res, leftv v)
3559	{
3560	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3561	ideal v_id=(ideal)v->Data();
3562	if (w==NULL)
3563	{
3564	res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
3565	if ((res->data!=NULL) && (v->rtyp==IDHDL))
3566	{
3567	char *isHomog=omStrDup("isHomog");
3568	if (v->e==NULL)
3569	atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3570	else
3571	atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3572	}
3573	else if (w!=NULL) delete w;
3574	}
3575	else
3576	res->data=(void *)(long)idTestHomModule(v_id,currQuotient,w);
3577	return FALSE;
3578	}
3579	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3580	{
3581	matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3582	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3583	if (IDELEMS((ideal)mat)==0)
3584	{
3585	idDelete((ideal *)&mat);
3586	mat=(matrix)idInit(1,1);
3587	}
3588	else
3589	{
3590	MATROWS(mat)=1;
3591	mat->rank=1;
3592	idTest((ideal)mat);
3593	}
3594	res->data=(char *)mat;
3595	return FALSE;
3596	}
3597	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3598	{
3599	map m=(map)v->CopyD(MAP_CMD);
3600	omFree((ADDRESS)m->preimage);
3601	m->preimage=NULL;
3602	ideal I=(ideal)m;
3603	I->rank=1;
3604	res->data=(char *)I;
3605	return FALSE;
3606	}
3607	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3608	{
3609	if (currRing!=NULL)
3610	{
3611	ring q=(ring)v->Data();
3612	if (rEqual(currRing, q, 0))
3613	{
3614	if (q->qideal==NULL)
3615	res->data=(char *)idInit(1,1);
3616	else
3617	res->data=(char *)idCopy(q->qideal);
3618	return FALSE;
3619	}
3620	}
3621	WerrorS("can only get ideal from identical qring");
3622	return TRUE;
3623	}
3624	static BOOLEAN jjIm2Iv(leftv res, leftv v)
3625	{
3626	intvec iv = (intvec )v->CopyD(INTMAT_CMD);
3627	iv->makeVector();
3628	res->data = iv;
3629	return FALSE;
3630	}
3631	static BOOLEAN jjIMPART(leftv res, leftv v)
3632	{
3633	res->data = (char *)nImPart((number)v->Data());
3634	return FALSE;
3635	}
3636	static BOOLEAN jjINDEPSET(leftv res, leftv v)
3637	{
3638	assumeStdFlag(v);
3639	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3640	return FALSE;
3641	}
3642	static BOOLEAN jjINTERRED(leftv res, leftv v)
3643	{
3644	ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3645	if (TEST_OPT_PROT) { PrintLn(); mflush(); }
3646	res->data = result;
3647	return FALSE;
3648	}
3649	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3650	{
3651	res->data = (char *)(long)pVar((poly)v->Data());
3652	return FALSE;
3653	}
3654	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3655	{
3656	res->data = (char )(long)(r_IsRingVar((char )v->Data(), currRing)+1);
3657	return FALSE;
3658	}
3659	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3660	{
3661	res->data = (char *)0;
3662	return FALSE;
3663	}
3664	static BOOLEAN jjJACOB_P(leftv res, leftv v)
3665	{
3666	ideal i=idInit(pVariables,1);
3667	int k;
3668	poly p=(poly)(v->Data());
3669	for (k=pVariables;k>0;k--)
3670	{
3671	i->m[k-1]=pDiff(p,k);
3672	}
3673	res->data = (char *)i;
3674	return FALSE;
3675	}
3676	static BOOLEAN jjKBASE(leftv res, leftv v)
3677	{
3678	assumeStdFlag(v);
3679	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3680	return FALSE;
3681	}
3682	#ifdef MDEBUG
3683	static BOOLEAN jjpHead(leftv res, leftv v)
3684	{
3685	res->data=(char *)pHead((poly)v->Data());
3686	return FALSE;
3687	}
3688	#endif
3689	static BOOLEAN jjL2R(leftv res, leftv v)
3690	{
3691	res->data=(char *)syConvList((lists)v->Data());
3692	if (res->data != NULL)
3693	return FALSE;
3694	else
3695	return TRUE;
3696	}
3697	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3698	{
3699	poly p=(poly)v->Data();
3700	if (p==NULL)
3701	{
3702	res->data=(char *)nInit(0);
3703	}
3704	else
3705	{
3706	res->data=(char *)nCopy(pGetCoeff(p));
3707	}
3708	return FALSE;
3709	}
3710	static BOOLEAN jjLEADEXP(leftv res, leftv v)
3711	{
3712	poly p=(poly)v->Data();
3713	int s=pVariables;
3714	if (v->Typ()==VECTOR_CMD) s++;
3715	intvec *iv=new intvec(s);
3716	if (p!=NULL)
3717	{
3718	for(int i = pVariables;i;i--)
3719	{
3720	(*iv)[i-1]=pGetExp(p,i);
3721	}
3722	if (s!=pVariables)
3723	(*iv)[pVariables]=pGetComp(p);
3724	}
3725	res->data=(char *)iv;
3726	return FALSE;
3727	}
3728	static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3729	{
3730	poly p=(poly)v->Data();
3731	if (p == NULL)
3732	{
3733	res->data = (char*) NULL;
3734	}
3735	else
3736	{
3737	poly lm = pLmInit(p);
3738	pSetCoeff(lm, nInit(1));
3739	res->data = (char*) lm;
3740	}
3741	return FALSE;
3742	}
3743	static BOOLEAN jjLISTRING(leftv res, leftv v)
3744	{
3745	ring r=rCompose((lists)v->Data());
3746	if (r==NULL) return TRUE;
3747	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3748	res->data=(char *)r;
3749	return FALSE;
3750	}
3751	#if SIZEOF_LONG == 8
3752	static number jjBI2N(long d);
3753	#else
3754	#define jjBI2N(D) nlInit((int)D)
3755	#endif
3756	static BOOLEAN jjMEMORY(leftv res, leftv v)
3757	{
3758	omUpdateInfo();
3759	long d;
3760	switch(((int)(long)v->Data()))
3761	{
3762	case 0:
3763	res->data=(char *)jjBI2N(om_Info.UsedBytes);
3764	break;
3765	case 1:
3766	res->data = (char *)jjBI2N(om_Info.CurrentBytesSystem);
3767	break;
3768	case 2:
3769	res->data = (char *)jjBI2N(om_Info.MaxBytesSystem);
3770	break;
3771
3772	default:
3773	omPrintStats(stdout);
3774	omPrintInfo(stdout);
3775	omPrintBinStats(stdout);
3776	res->data = (char *)0;
3777	res->rtyp = NONE;
3778	}
3779	return FALSE;
3780	res->data = (char *)0;
3781	return FALSE;
3782	}
3783	#if SIZEOF_LONG == 8
3784	static number jjBI2N(long d)
3785	{
3786	if (d<((long)INT_MAX)) return nlInit((int)d);
3787	else
3788	{
3789	number n=nlRInit(0);
3790	mpz_set_si(&n->z,d);
3791	return n;
3792	}
3793	}
3794	#endif
3795	static BOOLEAN jjMONITOR1(leftv res, leftv v)
3796	{
3797	monitor((char *)(v->Data()),PROT_I);
3798	return FALSE;
3799	}
3800	static BOOLEAN jjMSTD(leftv res, leftv v)
3801	{
3802	int t=v->Typ();
3803	ideal r,m;
3804	r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3805	lists l=(lists)omAllocBin(slists_bin);
3806	l->Init(2);
3807	l->m[0].rtyp=t;
3808	l->m[0].data=(char *)r;
3809	setFlag(&(l->m[0]),FLAG_STD);
3810	l->m[1].rtyp=t;
3811	l->m[1].data=(char *)m;
3812	res->data=(char *)l;
3813	return FALSE;
3814	}
3815	static BOOLEAN jjMULT(leftv res, leftv v)
3816	{
3817	assumeStdFlag(v);
3818	res->data = (char *)(long)scMultInt((ideal)(v->Data()),currQuotient);
3819	return FALSE;
3820	}
3821	static BOOLEAN jjMINRES_R(leftv res, leftv v)
3822	{
3823	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3824	res->data=(char *)syMinimize((syStrategy)v->Data());
3825	if (weights!=NULL)
3826	atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3827	return FALSE;
3828	}
3829	static BOOLEAN jjN2BI(leftv res, leftv v)
3830	{
3831	number n,i; i=(number)v->Data();
3832	if (rField_is_Zp()) n=nlInit((int)(long)i);
3833	else if (rField_is_Q())
3834	{
3835	if ((SR_HDL(i)&SR_INT)==SR_INT) n=nlInit((int)SR_TO_INT(i));
3836	else if (i->s==3) n=nlCopy(i);
3837	else goto err;
3838	}
3839	else goto err;
3840	res->data=(void *)n;
3841	return FALSE;
3842	err:
3843	WerrorS("cannot convert to bigint"); return TRUE;
3844	}
3845	static BOOLEAN jjNAMEOF(leftv res, leftv v)
3846	{
3847	res->data = (char *)v->name;
3848	if (res->data==NULL) res->data=omStrDup("");
3849	v->name=NULL;
3850	return FALSE;
3851	}
3852	static BOOLEAN jjNAMES(leftv res, leftv v)
3853	{
3854	res->data=ipNameList(((ring)v->Data())->idroot);
3855	return FALSE;
3856	}
3857	static BOOLEAN jjNVARS(leftv res, leftv v)
3858	{
3859	res->data = (char *)(long)(((ring)(v->Data()))->N);
3860	return FALSE;
3861	}
3862	static BOOLEAN jjOpenClose(leftv res, leftv v)
3863	{
3864	si_link l=(si_link)v->Data();
3865	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3866	else return slClose(l);
3867	}
3868	static BOOLEAN jjORD(leftv res, leftv v)
3869	{
3870	poly p=(poly)v->Data();
3871	res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3872	return FALSE;
3873	}
3874	static BOOLEAN jjPAR1(leftv res, leftv v)
3875	{
3876	int i=(int)(long)v->Data();
3877	int p=0;
3878	p=rPar(currRing);
3879	if ((0<i) && (i<=p))
3880	{
3881	res->data=(char *)nPar(i);
3882	}
3883	else
3884	{
3885	Werror("par number %d out of range 1..%d",i,p);
3886	return TRUE;
3887	}
3888	return FALSE;
3889	}
3890	static BOOLEAN jjPARDEG(leftv res, leftv v)
3891	{
3892	res->data = (char *)(long)nParDeg((number)v->Data());
3893	return FALSE;
3894	}
3895	static BOOLEAN jjPARSTR1(leftv res, leftv v)
3896	{
3897	if (currRing==NULL)
3898	{
3899	WerrorS("no ring active");
3900	return TRUE;
3901	}
3902	int i=(int)(long)v->Data();
3903	int p=0;
3904	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3905	res->data=omStrDup(currRing->parameter[i-1]);
3906	else
3907	{
3908	Werror("par number %d out of range 1..%d",i,p);
3909	return TRUE;
3910	}
3911	return FALSE;
3912	}
3913	static BOOLEAN jjP2I(leftv res, leftv v)
3914	{
3915	poly p=(poly)v->Data();
3916	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
3917	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
3918	{
3919	WerrorS("poly must be constant");
3920	return TRUE;
3921	}
3922	res->data = (char *)(long)nInt(pGetCoeff(p));
3923	return FALSE;
3924	}
3925	static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3926	{
3927	map mapping=(map)v->Data();
3928	syMake(res,omStrDup(mapping->preimage));
3929	return FALSE;
3930	}
3931	static BOOLEAN jjPRIME(leftv res, leftv v)
3932	{
3933	int i = IsPrime((int)(long)(v->Data()));
3934	res->data = (char *)(long)(i > 1 ? i : 2);
3935	return FALSE;
3936	}
3937	static BOOLEAN jjPRUNE(leftv res, leftv v)
3938	{
3939	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
3940	ideal v_id=(ideal)v->Data();
3941	if (w!=NULL)
3942	{
3943	if (!idTestHomModule(v_id,currQuotient,w))
3944	{
3945	WarnS("wrong weights");
3946	w=NULL;
3947	// and continue at the non-homog case below
3948	}
3949	else
3950	{
3951	w=ivCopy(w);
3952	intvec **ww=&w;
3953	res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3954	atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3955	return FALSE;
3956	}
3957	}
3958	res->data = (char *)idMinEmbedding(v_id);
3959	return FALSE;
3960	}
3961	static BOOLEAN jjP2N(leftv res, leftv v)
3962	{
3963	number n;
3964	poly p;
3965	if (((p=(poly)v->Data())!=NULL)
3966	&& (pIsConstant(p)))
3967	{
3968	n=nCopy(pGetCoeff(p));
3969	}
3970	else
3971	{
3972	n=nInit(0);
3973	}
3974	res->data = (char *)n;
3975	return FALSE;
3976	}
3977	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3978	{
3979	char s= (char )v->Data();
3980	int i = 1;
3981	int l = strlen(s);
3982	for(i=0; i<sArithBase.nCmdUsed; i++)
3983	{
3984	if (strcmp(s, sArithBase.sCmds[i].name) == 0)
3985	{
3986	res->data = (char *)1;
3987	return FALSE;
3988	}
3989	i++;
3990	}
3991	//res->data = (char *)0;
3992	return FALSE;
3993	}
3994	static BOOLEAN jjREAD(leftv res, leftv v)
3995	{
3996	return jjREAD2(res,v,NULL);
3997	}
3998	static BOOLEAN jjREGULARITY(leftv res, leftv v)
3999	{
4000	res->data = (char *)(long)iiRegularity((lists)v->Data());
4001	return FALSE;
4002	}
4003	static BOOLEAN jjREPART(leftv res, leftv v)
4004	{
4005	res->data = (char *)nRePart((number)v->Data());
4006	return FALSE;
4007	}
4008	static BOOLEAN jjRINGLIST(leftv res, leftv v)
4009	{
4010	ring r=(ring)v->Data();
4011	if (r!=NULL)
4012	res->data = (char *)rDecompose((ring)v->Data());
4013	return (r==NULL)\|\|(res->data==NULL);
4014	}
4015	static BOOLEAN jjROWS(leftv res, leftv v)
4016	{
4017	ideal i = (ideal)v->Data();
4018	res->data = (char *)i->rank;
4019	return FALSE;
4020	}
4021	static BOOLEAN jjROWS_IV(leftv res, leftv v)
4022	{
4023	res->data = (char )(long)((intvec)(v->Data()))->rows();
4024	return FALSE;
4025	}
4026	static BOOLEAN jjRPAR(leftv res, leftv v)
4027	{
4028	res->data = (char *)(long)rPar(((ring)v->Data()));
4029	return FALSE;
4030	}
4031	static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4032	{
4033	if (currQuotient!=NULL)
4034	{
4035	Werror("qring not supported by slimgb at the moment");
4036	return TRUE;
4037	}
4038	if (pOrdSgn!=1)
4039	{
4040	Werror("ordering must be global for slimgb");
4041	return TRUE;
4042	}
4043	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
4044	tHomog hom=testHomog;
4045	ideal u_id=(ideal)u->Data();
4046	if (w!=NULL)
4047	{
4048	if (!idTestHomModule(u_id,currQuotient,w))
4049	{
4050	WarnS("wrong weights");
4051	w=NULL;
4052	}
4053	else
4054	{
4055	w=ivCopy(w);
4056	hom=isHomog;
4057	}
4058	}
4059
4060	assume(u_id->rank>=idRankFreeModule(u_id));
4061	res->data=(char *)t_rep_gb(currRing,
4062	u_id,u_id->rank);
4063	//res->data=(char *)t_rep_gb(currRing, u_id);
4064
4065	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4066	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4067	return FALSE;
4068	}
4069	static BOOLEAN jjSTD(leftv res, leftv v)
4070	{
4071	ideal result;
4072	ideal v_id=(ideal)v->Data();
4073	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4074	tHomog hom=testHomog;
4075	if (w!=NULL)
4076	{
4077	if (!idTestHomModule(v_id,currQuotient,w))
4078	{
4079	WarnS("wrong weights");
4080	w=NULL;
4081	}
4082	else
4083	{
4084	hom=isHomog;
4085	w=ivCopy(w);
4086	}
4087	}
4088	result=kStd(v_id,currQuotient,hom,&w);
4089	idSkipZeroes(result);
4090	res->data = (char *)result;
4091	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4092	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4093	return FALSE;
4094	}
4095	static BOOLEAN jjSort_Id(leftv res, leftv v)
4096	{
4097	res->data = (char *)idSort((ideal)v->Data());
4098	return FALSE;
4099	}
4100	#if 1
4101	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4102	{
4103	intvec *w=NULL;
4104	res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4105	if (w!=NULL) delete w;
4106	return FALSE;
4107	}
4108	#else
4109	// activate, if idSyz hadle moduke weights correctly !
4110	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4111	{
4112	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4113	ideal v_id=(ideal)v->Data();
4114	tHomog hom=testHomog;
4115	int add_row_shift=0;
4116	if (w!=NULL)
4117	{
4118	w=ivCopy(w);
4119	add_row_shift=w->min_in();
4120	(*w)-=add_row_shift;
4121	if (idTestHomModule(v_id,currQuotient,w))
4122	hom=isHomog;
4123	else
4124	{
4125	//WarnS("wrong weights");
4126	delete w; w=NULL;
4127	hom=testHomog;
4128	}
4129	}
4130	res->data = (char *)idSyzygies(v_id,hom,&w);
4131	if (w!=NULL)
4132	{
4133	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4134	}
4135	return FALSE;
4136	}
4137	#endif
4138	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4139	{
4140	res->data = (char )(long)ivTrace((intvec)(v->Data()));
4141	return FALSE;
4142	}
4143	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4144	{
4145	res->data = (char )ivTranp((intvec)(v->Data()));
4146	return FALSE;
4147	}
4148
4149	#ifdef HAVE_PLURAL
4150
4151	static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4152	{
4153	ring r = (ring)a->Data();
4154	if (rIsPluralRing(r))
4155	{
4156	res->data = rOpposite(r);
4157	}
4158	else res->data = rCopy(r);
4159	return FALSE;
4160	}
4161
4162	static BOOLEAN jjENVELOPE(leftv res, leftv a)
4163	{
4164	ring r = (ring)a->Data();
4165	if (rIsPluralRing(r))
4166	{
4167	// ideal i;
4168	// if (a->rtyp == QRING_CMD)
4169	// {
4170	// i = r->qideal;
4171	// r->qideal = NULL;
4172	// }
4173	ring s = rEnvelope(r);
4174	// if (a->rtyp == QRING_CMD)
4175	// {
4176	// ideal is = idOppose(r,i); /* twostd? */
4177	// is = idAdd(is,i);
4178	// s->qideal = i;
4179	// }
4180	res->data = s;
4181	}
4182	else res->data = rCopy(r);
4183	return FALSE;
4184	}
4185
4186	static BOOLEAN jjTWOSTD(leftv res, leftv a)
4187	{
4188	if (rIsPluralRing(currRing)) res->data=(ideal)twostd((ideal)a->Data());
4189	else res->data=(ideal)a->Data();
4190	setFlag(res,FLAG_STD);
4191	setFlag(res,FLAG_TWOSTD);
4192	return FALSE;
4193	}
4194	#endif
4195
4196	static BOOLEAN jjTYPEOF(leftv res, leftv v)
4197	{
4198	switch ((int)(long)v->data)
4199	{
4200	case INT_CMD: res->data=omStrDup("int"); break;
4201	case POLY_CMD: res->data=omStrDup("poly"); break;
4202	case VECTOR_CMD: res->data=omStrDup("vector"); break;
4203	case STRING_CMD: res->data=omStrDup("string"); break;
4204	case INTVEC_CMD: res->data=omStrDup("intvec"); break;
4205	case IDEAL_CMD: res->data=omStrDup("ideal"); break;
4206	case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4207	case MODUL_CMD: res->data=omStrDup("module"); break;
4208	case MAP_CMD: res->data=omStrDup("map"); break;
4209	case PROC_CMD: res->data=omStrDup("proc"); break;
4210	case RING_CMD: res->data=omStrDup("ring"); break;
4211	case QRING_CMD: res->data=omStrDup("qring"); break;
4212	case INTMAT_CMD: res->data=omStrDup("intmat"); break;
4213	case NUMBER_CMD: res->data=omStrDup("number"); break;
4214	case BIGINT_CMD: res->data=omStrDup("bigint"); break;
4215	case LIST_CMD: res->data=omStrDup("list"); break;
4216	case PACKAGE_CMD: res->data=omStrDup("package"); break;
4217	case LINK_CMD: res->data=omStrDup("link"); break;
4218	case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4219	case DEF_CMD:
4220	case NONE: res->data=omStrDup("none"); break;
4221	default: res->data=omStrDup("?unknown type?");
4222	}
4223	return FALSE;
4224	}
4225	static BOOLEAN jjVAR1(leftv res, leftv v)
4226	{
4227	int i=(int)(long)v->Data();
4228	if ((0<i) && (i<=currRing->N))
4229	{
4230	poly p=pOne();
4231	pSetExp(p,i,1);
4232	pSetm(p);
4233	res->data=(char *)p;
4234	}
4235	else
4236	{
4237	Werror("var number %d out of range 1..%d",i,currRing->N);
4238	return TRUE;
4239	}
4240	return FALSE;
4241	}
4242	static BOOLEAN jjVARSTR1(leftv res, leftv v)
4243	{
4244	if (currRing==NULL)
4245	{
4246	WerrorS("no ring active");
4247	return TRUE;
4248	}
4249	int i=(int)(long)v->Data();
4250	if ((0<i) && (i<=currRing->N))
4251	res->data=omStrDup(currRing->names[i-1]);
4252	else
4253	{
4254	Werror("var number %d out of range 1..%d",i,currRing->N);
4255	return TRUE;
4256	}
4257	return FALSE;
4258	}
4259	static BOOLEAN jjVDIM(leftv res, leftv v)
4260	{
4261	assumeStdFlag(v);
4262	res->data = (char *)(long)scMult0Int((ideal)v->Data(),currQuotient);
4263	return FALSE;
4264	}
4265
4266	static BOOLEAN jjLOAD1(leftv res, leftv v)
4267	{
4268	return jjLOAD(res, v,iiOp==LIB_CMD);
4269	}
4270	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4271	{
4272	#ifdef HAVE_NS
4273	char * s=(char *)v->CopyD();
4274	char libnamebuf[256];
4275	lib_types LT = type_of_LIB(s, libnamebuf);
4276	#ifdef HAVE_DYNAMIC_LOADING
4277	extern BOOLEAN load_modules(char newlib, char fullpath, BOOLEAN autoexport);
4278	#endif /* HAVE_DYNAMIC_LOADING */
4279	switch(LT)
4280	{
4281	default:
4282	case LT_NONE:
4283	Werror("%s: unknown type", s);
4284	break;
4285	case LT_NOTFOUND:
4286	Werror("cannot open %s", s);
4287	break;
4288
4289	case LT_SINGULAR:
4290	{
4291	char *plib = iiConvName(s);
4292	idhdl pl = IDROOT->get(plib,0);
4293	if (pl==NULL)
4294	{
4295	pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4296	IDPACKAGE(pl)->language = LANG_SINGULAR;
4297	IDPACKAGE(pl)->libname=omStrDup(plib);
4298	}
4299	else if (IDTYP(pl)!=PACKAGE_CMD)
4300	{
4301	Werror("can not create package `%s`",plib);
4302	omFree(plib);
4303	return TRUE;
4304	}
4305	package savepack=currPack;
4306	currPack=IDPACKAGE(pl);
4307	IDPACKAGE(pl)->loaded=TRUE;
4308	char libnamebuf[256];
4309	FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4310	BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4311	currPack=savepack;
4312	IDPACKAGE(pl)->loaded=(!bo);
4313	return bo;
4314	}
4315	case LT_MACH_O:
4316	case LT_ELF:
4317	case LT_HPUX:
4318	#ifdef HAVE_DYNAMIC_LOADING
4319	return load_modules(s, libnamebuf, autoexport);
4320	#else /* HAVE_DYNAMIC_LOADING */
4321	WerrorS("Dynamic modules are not supported by this version of Singular");
4322	break;
4323	#endif /* HAVE_DYNAMIC_LOADING */
4324	}
4325	#endif
4326	return TRUE;
4327	}
4328
4329	/=================== operations with 1 arg.: table =================/
4330
4331	#ifdef INIT_BUG
4332	#define XS(A) -((short)A)
4333	#define jjstrlen (proc1)1
4334	#define jjpLength (proc1)2
4335	#define jjidElem (proc1)3
4336	#define jjmpDetBareiss (proc1)4
4337	#define jjidFreeModule (proc1)5
4338	#define jjidVec2Ideal (proc1)6
4339	#define jjrCharStr (proc1)7
4340	#ifndef MDEBUG
4341	#define jjpHead (proc1)8
4342	#endif
4343	#define jjidHead (proc1)9
4344	#define jjidMaxIdeal (proc1)10
4345	#define jjidMinBase (proc1)11
4346	#define jjsyMinBase (proc1)12
4347	#define jjpMaxComp (proc1)13
4348	#define jjmpTrace (proc1)14
4349	#define jjmpTransp (proc1)15
4350	#define jjrOrdStr (proc1)16
4351	#define jjrVarStr (proc1)18
4352	#define jjrParStr (proc1)19
4353	#define jjCOUNT_RES (proc1)22
4354	#define jjDIM_R (proc1)23
4355	#define jjidTransp (proc1)24
4356
4357	extern struct sValCmd1 dArith1[];
4358	void jjInitTab1()
4359	{
4360	int i=0;
4361	for (;dArith1[i].cmd!=0;i++)
4362	{
4363	if (dArith1[i].res<0)
4364	{
4365	switch ((int)dArith1[i].p)
4366	{
4367	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
4368	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
4369	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
4370	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
4371	#ifndef HAVE_FACTORY
4372	case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4373	#endif
4374	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4375	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
4376	#ifndef MDEBUG
4377	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
4378	#endif
4379	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
4380	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
4381	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
4382	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
4383	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxCompProc; break;
4384	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
4385	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
4386	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
4387	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
4388	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
4389	case (int)jjCOUNT_RES: dArith1[i].p=(proc1)syLength; break;
4390	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
4391	case (int)jjidTransp: dArith1[i].p=(proc1)idTransp; break;
4392	#ifdef GENTABLE
4393	default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4394	#endif
4395	}
4396	}
4397	}
4398	}
4399	#else
4400	#if defined(PROC_BUG)
4401	#define XS(A) A
4402	static BOOLEAN jjstrlen(leftv res, leftv v)
4403	{
4404	res->data = (char )strlen((char )v->Data());
4405	return FALSE;
4406	}
4407	static BOOLEAN jjpLength(leftv res, leftv v)
4408	{
4409	res->data = (char *)pLength((poly)v->Data());
4410	return FALSE;
4411	}
4412	static BOOLEAN jjidElem(leftv res, leftv v)
4413	{
4414	res->data = (char *)idElem((ideal)v->Data());
4415	return FALSE;
4416	}
4417	static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4418	{
4419	res->data = (char *)mpDetBareiss((matrix)v->Data());
4420	return FALSE;
4421	}
4422	static BOOLEAN jjidFreeModule(leftv res, leftv v)
4423	{
4424	res->data = (char *)idFreeModule((int)(long)v->Data());
4425	return FALSE;
4426	}
4427	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4428	{
4429	res->data = (char *)idVec2Ideal((poly)v->Data());
4430	return FALSE;
4431	}
4432	static BOOLEAN jjrCharStr(leftv res, leftv v)
4433	{
4434	res->data = rCharStr((ring)v->Data());
4435	return FALSE;
4436	}
4437	#ifndef MDEBUG
4438	static BOOLEAN jjpHead(leftv res, leftv v)
4439	{
4440	res->data = (char *)pHead((poly)v->Data());
4441	return FALSE;
4442	}
4443	#endif
4444	static BOOLEAN jjidHead(leftv res, leftv v)
4445	{
4446	res->data = (char *)idHead((ideal)v->Data());
4447	return FALSE;
4448	}
4449	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4450	{
4451	res->data = (char *)idMaxIdeal((int)(long)v->Data());
4452	return FALSE;
4453	}
4454	static BOOLEAN jjidMinBase(leftv res, leftv v)
4455	{
4456	res->data = (char *)idMinBase((ideal)v->Data());
4457	return FALSE;
4458	}
4459	static BOOLEAN jjsyMinBase(leftv res, leftv v)
4460	{
4461	res->data = (char *)syMinBase((ideal)v->Data());
4462	return FALSE;
4463	}
4464	static BOOLEAN jjpMaxComp(leftv res, leftv v)
4465	{
4466	res->data = (char *)pMaxComp((poly)v->Data());
4467	return FALSE;
4468	}
4469	static BOOLEAN jjmpTrace(leftv res, leftv v)
4470	{
4471	res->data = (char *)mpTrace((matrix)v->Data());
4472	return FALSE;
4473	}
4474	static BOOLEAN jjmpTransp(leftv res, leftv v)
4475	{
4476	res->data = (char *)mpTransp((matrix)v->Data());
4477	return FALSE;
4478	}
4479	static BOOLEAN jjrOrdStr(leftv res, leftv v)
4480	{
4481	res->data = rOrdStr((ring)v->Data());
4482	return FALSE;
4483	}
4484	static BOOLEAN jjrVarStr(leftv res, leftv v)
4485	{
4486	res->data = rVarStr((ring)v->Data());
4487	return FALSE;
4488	}
4489	static BOOLEAN jjrParStr(leftv res, leftv v)
4490	{
4491	res->data = rParStr((ring)v->Data());
4492	return FALSE;
4493	}
4494	static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4495	{
4496	res->data=(char *)syLength((syStrategy)v->Data());
4497	return FALSE;
4498	}
4499	static BOOLEAN jjDIM_R(leftv res, leftv v)
4500	{
4501	res->data = (char *)syDim((syStrategy)v->Data());
4502	return FALSE;
4503	}
4504	static BOOLEAN jjidTransp(leftv res, leftv v)
4505	{
4506	res->data = (char *)idTransp((ideal)v->Data());
4507	return FALSE;
4508	}
4509	#else
4510	#define XS(A) -((short)A)
4511	#define jjstrlen (proc1)strlen
4512	#define jjpLength (proc1)pLength
4513	#define jjidElem (proc1)idElem
4514	#define jjmpDetBareiss (proc1)mpDetBareiss
4515	#define jjidFreeModule (proc1)idFreeModule
4516	#define jjidVec2Ideal (proc1)idVec2Ideal
4517	#define jjrCharStr (proc1)rCharStr
4518	#ifndef MDEBUG
4519	#define jjpHead (proc1)pHeadProc
4520	#endif
4521	#define jjidHead (proc1)idHead
4522	#define jjidMaxIdeal (proc1)idMaxIdeal
4523	#define jjidMinBase (proc1)idMinBase
4524	#define jjsyMinBase (proc1)syMinBase
4525	#define jjpMaxComp (proc1)pMaxCompProc
4526	#define jjmpTrace (proc1)mpTrace
4527	#define jjmpTransp (proc1)mpTransp
4528	#define jjrOrdStr (proc1)rOrdStr
4529	#define jjrVarStr (proc1)rVarStr
4530	#define jjrParStr (proc1)rParStr
4531	#define jjCOUNT_RES (proc1)syLength
4532	#define jjDIM_R (proc1)syDim
4533	#define jjidTransp (proc1)idTransp
4534	#endif
4535	#endif
4536	static BOOLEAN jjnInt(leftv res, leftv u)
4537	{
4538	number n=(number)u->Data();
4539	res->data=(char *)(long)nInt(n);
4540	return FALSE;
4541	}
4542	static BOOLEAN jjnlInt(leftv res, leftv u)
4543	{
4544	number n=(number)u->Data();
4545	res->data=(char *)(long)nlInt(n);
4546	return FALSE;
4547	}
4548	#define s short
4549	struct sValCmd1 dArith1[]=
4550	{
4551	// operations:
4552	// proc cmd res arg plural
4553	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4554	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4555	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL ALLOW_PLURAL}
4556	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL ALLOW_PLURAL}
4557	,{jjUMINUS_I, '-', INT_CMD, INT_CMD ALLOW_PLURAL}
4558	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4559	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD ALLOW_PLURAL}
4560	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4561	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4562	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4563	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4564	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD ALLOW_PLURAL}
4565	,{jjLOAD1, '(', NONE, STRING_CMD ALLOW_PLURAL}
4566	// and the procedures with 1 argument:
4567	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4568	//,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD NO_PLURAL}
4569	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4570	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD ALLOW_PLURAL}
4571	,{syBetti1, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4572	,{jjBETTI, BETTI_CMD, INTMAT_CMD, IDEAL_CMD ALLOW_PLURAL}
4573	,{jjBETTI, BETTI_CMD, INTMAT_CMD, MODUL_CMD ALLOW_PLURAL}
4574	,{jjN2BI, BIGINT_CMD, BIGINT_CMD, NUMBER_CMD ALLOW_PLURAL}
4575	,{jjDUMMY, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
4576	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4577	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4578	#ifdef HAVE_FACTORY
4579	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4580	#else
4581	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4582	#endif
4583	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4584	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4585	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4586	//,{jjWRONG, COLS_CMD, 0, VECTOR_CMD ALLOW_PLURAL}
4587	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4588	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4589	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4590	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4591	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4592	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4593	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4594	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4595	,{jjCOUNT_RES, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4596	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD ALLOW_PLURAL}
4597	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD ALLOW_PLURAL}
4598	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4599	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD ALLOW_PLURAL}
4600	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD ALLOW_PLURAL}
4601	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4602	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4603	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4604	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD ALLOW_PLURAL}
4605	,{jjCOUNT_RG, COUNT_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4606	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
4607	,{jjWRONG, DEF_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4608	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4609	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4610	,{jjDEG_M, DEG_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4611	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD NO_PLURAL}
4612	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD NO_PLURAL}
4613	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD ALLOW_PLURAL}
4614	#ifdef HAVE_FACTORY
4615	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4616	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
4617	,{jjDET_S, DET_CMD, POLY_CMD, MODUL_CMD NO_PLURAL}
4618	#else
4619	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4620	,{jjmpDetBareiss,DET_CMD, XS(POLY_CMD), MATRIX_CMD NO_PLURAL}
4621	#endif
4622	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4623	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4624	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4625	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4626	,{jjE, E_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
4627	,{jjEXECUTE, EXECUTE_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4628	,{jjERROR, ERROR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4629	#ifdef HAVE_FACTORY
4630	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4631	#else
4632	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4633	#endif
4634	#ifdef HAVE_FGLM
4635	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4636	#else
4637	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4638	#endif
4639	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD ALLOW_PLURAL}
4640	#ifdef HAVE_FACTORY
4641	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4642	#else
4643	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4644	#endif
4645	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4646	,{jjHIGHCORNER, HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
4647	,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD NO_PLURAL}
4648	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD NO_PLURAL}
4649	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD NO_PLURAL}
4650	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
4651	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4652	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4653	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD ALLOW_PLURAL}
4654	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
4655	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD ALLOW_PLURAL}
4656	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD ALLOW_PLURAL}
4657	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD ALLOW_PLURAL}
4658	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4659	,{jjIMPART, IMPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4660	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD NO_PLURAL}
4661	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4662	,{jjnlInt, INT_CMD, INT_CMD, BIGINT_CMD ALLOW_PLURAL}
4663	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4664	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4665	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4666	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
4667	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4668	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
4669	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4670	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD ALLOW_PLURAL}
4671	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD ALLOW_PLURAL}
4672	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE ALLOW_PLURAL}
4673	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
4674	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD ALLOW_PLURAL}
4675	,{jjJanetBasis, JANET_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4676	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4677	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4678	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL ALLOW_PLURAL}
4679	#ifdef MDEBUG
4680	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4681	#else
4682	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD ALLOW_PLURAL}
4683	#endif
4684	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD ALLOW_PLURAL}
4685	#ifdef MDEBUG
4686	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4687	#else
4688	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD ALLOW_PLURAL}
4689	#endif
4690	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4691	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4692	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD ALLOW_PLURAL}
4693	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD ALLOW_PLURAL}
4694	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD ALLOW_PLURAL}
4695	,{jjLEADMONOM, LEADMONOM_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4696	,{jjLEADMONOM, LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4697	,{jjLOAD1, LIB_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4698	,{jjDUMMY, LINK_CMD, LINK_CMD, LINK_CMD ALLOW_PLURAL}
4699	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
4700	,{jjWRONG, MAP_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4701	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4702	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD ALLOW_PLURAL}
4703	,{jjMEMORY, MEMORY_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
4704	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD NO_PLURAL}
4705	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD NO_PLURAL}
4706	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
4707	,{jjMINRES_R, MINRES_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4708	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4709	,{jjMONITOR1, MONITOR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4710	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4711	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4712	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4713	,{jjMSTD, MSTD_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4714	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4715	,{jjNAMES, NAMES_CMD, LIST_CMD, PACKAGE_CMD ALLOW_PLURAL}
4716	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4717	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4718	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4719	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4720	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4721	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4722	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4723	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4724	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4725	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4726	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4727	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4728	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4729	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
4730	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4731	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4732	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4733	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4734	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4735	,{jjPREIMAGE_R, PREIMAGE_CMD, RING_CMD, MAP_CMD NO_PLURAL}
4736	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4737	,{jjPRINT, PRINT_CMD, NONE, LIST_CMD ALLOW_PLURAL}
4738	,{jjPRINT, PRINT_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4739	,{jjPRUNE, PRUNE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4740	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4741	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4742	,{jjWRONG, QRING_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4743	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD ALLOW_PLURAL}
4744	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD NO_PLURAL}
4745	,{jjREPART, REPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4746	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD ALLOW_PLURAL}
4747	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD ALLOW_PLURAL}
4748	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4749	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4750	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4751	,{jjDUMMY, RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4752	,{jjLISTRING, RING_CMD, RING_CMD, LIST_CMD ALLOW_PLURAL}
4753	//,{jjWRONG, ROWS_CMD, 0, POLY_CMD ALLOW_PLURAL}
4754	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4755	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4756	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4757	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4758	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4759	,{jjSLIM_GB, SLIM_GB_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4760	,{jjSLIM_GB, SLIM_GB_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4761	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4762	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4763	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4764	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4765	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
4766	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4767	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
4768	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4769	#ifdef HAVE_PLURAL
4770	,{jjENVELOPE, ENVELOPE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4771	,{jjENVELOPE, ENVELOPE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4772	,{jjOPPOSITE, OPPOSITE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4773	,{jjOPPOSITE, OPPOSITE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4774	,{jjTWOSTD, TWOSTD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4775	#endif
4776	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4777	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD ALLOW_PLURAL}
4778	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4779	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD ALLOW_PLURAL}
4780	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
4781	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4782	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD ALLOW_PLURAL}
4783	,{jjidTransp, TRANSPOSE_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4784	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4785	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4786	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4787	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4788	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
4789	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4790	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4791	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4792	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4793	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4794	,{jjLOAD1, LOAD_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4795	,{loNewtonP, NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4796	,{NULL, 0, 0, 0 NO_PLURAL}
4797	};
4798	#undef s
4799	/=================== operations with 3 args.: static proc =================/
4800	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4801	{
4802	char s= (char )u->Data();
4803	int r = (int)(long)v->Data();
4804	int c = (int)(long)w->Data();
4805	int l = strlen(s);
4806
4807	if ( (r<1) \|\| (r>l) \|\| (c<0) )
4808	{
4809	Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4810	return TRUE;
4811	}
4812	res->data = (char *)omAlloc((long)(c+1));
4813	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
4814	return FALSE;
4815	}
4816	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4817	{
4818	intvec iv = (intvec )u->Data();
4819	int r = (int)(long)v->Data();
4820	int c = (int)(long)w->Data();
4821	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
4822	{
4823	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4824	r,c,u->Fullname(),iv->rows(),iv->cols());
4825	return TRUE;
4826	}
4827	res->data=u->data; u->data=NULL;
4828	res->rtyp=u->rtyp; u->rtyp=0;
4829	res->name=u->name; u->name=NULL;
4830	res->attribute=u->attribute; u->attribute=NULL;
4831	Subexpr e=jjMakeSub(v);
4832	e->next=jjMakeSub(w);
4833	if (u->e==NULL) res->e=e;
4834	else
4835	{
4836	Subexpr h=u->e;
4837	while (h->next!=NULL) h=h->next;
4838	h->next=e;
4839	res->e=u->e;
4840	u->e=NULL;
4841	}
4842	return FALSE;
4843	}
4844	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4845	{
4846	matrix m= (matrix)u->Data();
4847	int r = (int)(long)v->Data();
4848	int c = (int)(long)w->Data();
4849	//Print("gen. elem %d, %d\n",r,c);
4850	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
4851	{
4852	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4853	MATROWS(m),MATCOLS(m));
4854	return TRUE;
4855	}
4856	res->data=u->data; u->data=NULL;
4857	res->rtyp=u->rtyp; u->rtyp=0;
4858	res->name=u->name; u->name=NULL;
4859	res->attribute=u->attribute; u->attribute=NULL;
4860	Subexpr e=jjMakeSub(v);
4861	e->next=jjMakeSub(w);
4862	if (u->e==NULL)
4863	res->e=e;
4864	else
4865	{
4866	Subexpr h=u->e;
4867	while (h->next!=NULL) h=h->next;
4868	h->next=e;
4869	res->e=u->e;
4870	u->e=NULL;
4871	}
4872	return FALSE;
4873	}
4874	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4875	{
4876	sleftv t;
4877	sleftv ut;
4878	leftv p=NULL;
4879	intvec iv=(intvec )w->Data();
4880	int l;
4881	BOOLEAN nok;
4882
4883	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4884	{
4885	WerrorS("cannot build expression lists from unnamed objects");
4886	return TRUE;
4887	}
4888	memcpy(&ut,u,sizeof(ut));
4889	memset(&t,0,sizeof(t));
4890	t.rtyp=INT_CMD;
4891	for (l=0;l< iv->length(); l++)
4892	{
4893	t.data=(char )(long)((iv)[l]);
4894	if (p==NULL)
4895	{
4896	p=res;
4897	}
4898	else
4899	{
4900	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4901	p=p->next;
4902	}
4903	memcpy(u,&ut,sizeof(ut));
4904	if (u->Typ() == MATRIX_CMD)
4905	nok=jjBRACK_Ma(p,u,v,&t);
4906	else /* INTMAT_CMD */
4907	nok=jjBRACK_Im(p,u,v,&t);
4908	if (nok)
4909	{
4910	while (res->next!=NULL)
4911	{
4912	p=res->next->next;
4913	omFreeBin((ADDRESS)res->next, sleftv_bin);
4914	// res->e aufraeumen !!!!
4915	res->next=p;
4916	}
4917	return TRUE;
4918	}
4919	}
4920	return FALSE;
4921	}
4922	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4923	{
4924	sleftv t;
4925	sleftv ut;
4926	leftv p=NULL;
4927	intvec iv=(intvec )v->Data();
4928	int l;
4929	BOOLEAN nok;
4930
4931	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4932	{
4933	WerrorS("cannot build expression lists from unnamed objects");
4934	return TRUE;
4935	}
4936	memcpy(&ut,u,sizeof(ut));
4937	memset(&t,0,sizeof(t));
4938	t.rtyp=INT_CMD;
4939	for (l=0;l< iv->length(); l++)
4940	{
4941	t.data=(char )(long)((iv)[l]);
4942	if (p==NULL)
4943	{
4944	p=res;
4945	}
4946	else
4947	{
4948	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4949	p=p->next;
4950	}
4951	memcpy(u,&ut,sizeof(ut));
4952	if (u->Typ() == MATRIX_CMD)
4953	nok=jjBRACK_Ma(p,u,&t,w);
4954	else /* INTMAT_CMD */
4955	nok=jjBRACK_Im(p,u,&t,w);
4956	if (nok)
4957	{
4958	while (res->next!=NULL)
4959	{
4960	p=res->next->next;
4961	omFreeBin((ADDRESS)res->next, sleftv_bin);
4962	// res->e aufraeumen !!
4963	res->next=p;
4964	}
4965	return TRUE;
4966	}
4967	}
4968	return FALSE;
4969	}
4970	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4971	{
4972	sleftv t1,t2,ut;
4973	leftv p=NULL;
4974	intvec vv=(intvec )v->Data();
4975	intvec wv=(intvec )w->Data();
4976	int vl;
4977	int wl;
4978	BOOLEAN nok;
4979
4980	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4981	{
4982	WerrorS("cannot build expression lists from unnamed objects");
4983	return TRUE;
4984	}
4985	memcpy(&ut,u,sizeof(ut));
4986	memset(&t1,0,sizeof(sleftv));
4987	memset(&t2,0,sizeof(sleftv));
4988	t1.rtyp=INT_CMD;
4989	t2.rtyp=INT_CMD;
4990	for (vl=0;vl< vv->length(); vl++)
4991	{
4992	t1.data=(char )(long)((vv)[vl]);
4993	for (wl=0;wl< wv->length(); wl++)
4994	{
4995	t2.data=(char )(long)((wv)[wl]);
4996	if (p==NULL)
4997	{
4998	p=res;
4999	}
5000	else
5001	{
5002	p->next=(leftv)omAlloc0Bin(sleftv_bin);
5003	p=p->next;
5004	}
5005	memcpy(u,&ut,sizeof(ut));
5006	if (u->Typ() == MATRIX_CMD)
5007	nok=jjBRACK_Ma(p,u,&t1,&t2);
5008	else /* INTMAT_CMD */
5009	nok=jjBRACK_Im(p,u,&t1,&t2);
5010	if (nok)
5011	{
5012	res->CleanUp();
5013	return TRUE;
5014	}
5015	}
5016	}
5017	return FALSE;
5018	}
5019	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
5020	{
5021	v->next=(leftv)omAllocBin(sleftv_bin);
5022	memcpy(v->next,w,sizeof(sleftv));
5023	memset(w,0,sizeof(sleftv));
5024	return jjPROC(res,u,v);
5025	}
5026	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
5027	{
5028	u->next=(leftv)omAllocBin(sleftv_bin);
5029	memcpy(u->next,v,sizeof(sleftv));
5030	u->next->next=(leftv)omAllocBin(sleftv_bin);
5031	memcpy(u->next->next,w,sizeof(sleftv));
5032	BOOLEAN r=iiExprArithM(res,u,iiOp);
5033	v->Init();
5034	w->Init();
5035	//w->rtyp=0; w->data=NULL;
5036	// iiExprArithM did the CleanUp
5037	return r;
5038	}
5039	static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5040	{
5041	intvec *iv;
5042	ideal m;
5043	lists l=(lists)omAllocBin(slists_bin);
5044	int k=(int)(long)w->Data();
5045	if (k>=0)
5046	{
5047	smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
5048	l->Init(2);
5049	l->m[0].rtyp=MODUL_CMD;
5050	l->m[1].rtyp=INTVEC_CMD;
5051	l->m[0].data=(void *)m;
5052	l->m[1].data=(void *)iv;
5053	}
5054	else
5055	{
5056	m=smCallSolv((ideal)u->Data());
5057	l->Init(1);
5058	l->m[0].rtyp=IDEAL_CMD;
5059	l->m[0].data=(void *)m;
5060	}
5061	res->data = (char *)l;
5062	return FALSE;
5063	}
5064	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5065	{
5066	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5067	{
5068	WerrorS("3rd argument must be a name of a matrix");
5069	return TRUE;
5070	}
5071	ideal i=(ideal)u->Data();
5072	int rank=(int)i->rank;
5073	BOOLEAN r=jjCOEFFS_Id(res,u,v);
5074	if (r) return TRUE;
5075	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5076	return FALSE;
5077	}
5078	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5079	{
5080	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5081	(ideal)(v->Data()),(poly)(w->Data()));
5082	return FALSE;
5083	}
5084	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5085	{
5086	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5087	{
5088	WerrorS("3rd argument must be a name of a matrix");
5089	return TRUE;
5090	}
5091	// CopyD for POLY_CMD and VECTOR_CMD are identical:
5092	poly p=(poly)u->CopyD(POLY_CMD);
5093	ideal i=idInit(1,1);
5094	i->m[0]=p;
5095	sleftv t;
5096	memset(&t,0,sizeof(t));
5097	t.data=(char *)i;
5098	t.rtyp=IDEAL_CMD;
5099	int rank=1;
5100	if (u->Typ()==VECTOR_CMD)
5101	{
5102	i->rank=rank=pMaxComp(p);
5103	t.rtyp=MODUL_CMD;
5104	}
5105	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5106	t.CleanUp();
5107	if (r) return TRUE;
5108	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5109	return FALSE;
5110	}
5111	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5112	{
5113	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5114	(intvec *)w->Data());
5115	setFlag(res,FLAG_STD);
5116	return FALSE;
5117	}
5118	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5119	{
5120	/*4
5121	* look for the substring what in the string where
5122	* starting at position n
5123	* return the position of the first char of what in where
5124	* or 0
5125	*/
5126	int n=(int)(long)w->Data();
5127	char where=(char )u->Data();
5128	char what=(char )v->Data();
5129	char *found;
5130	if ((1>n)\|\|(n>(int)strlen(where)))
5131	{
5132	Werror("start position %d out of range",n);
5133	return TRUE;
5134	}
5135	found = strchr(where+n-1,*what);
5136	if (*(what+1)!='\0')
5137	{
5138	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5139	{
5140	found=strchr(found+1,*what);
5141	}
5142	}
5143	if (found != NULL)
5144	{
5145	res->data=(char *)((found-where)+1);
5146	}
5147	return FALSE;
5148	}
5149	static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5150	{
5151	if ((int)(long)w->Data()==0)
5152	res->data=(char *)walkProc(u,v);
5153	else
5154	res->data=(char *)fractalWalkProc(u,v);
5155	setFlag( res, FLAG_STD );
5156	return FALSE;
5157	}
5158	static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5159	{
5160	assumeStdFlag(u);
5161	intvec module_w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
5162	intvec wdegree=(intvec)w->Data();
5163	if (wdegree->length()!=pVariables)
5164	{
5165	Werror("weight vector must have size %d, not %d",
5166	pVariables,wdegree->length());
5167	return TRUE;
5168	}
5169	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5170	switch((int)(long)v->Data())
5171	{
5172	case 1:
5173	res->data=(void *)iv;
5174	return FALSE;
5175	case 2:
5176	res->data=(void *)hSecondSeries(iv);
5177	delete iv;
5178	return FALSE;
5179	}
5180	WerrorS(feNotImplemented);
5181	delete iv;
5182	return TRUE;
5183	}
5184	static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5185	{
5186	intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5187	intvec* arg = (intvec*) u->Data();
5188	int i, n = si_min(im->cols()im->rows(), arg->cols()arg->rows());
5189
5190	for (i=0; i<n; i++)
5191	{
5192	(im)[i] = (arg)[i];
5193	}
5194
5195	res->data = (char *)im;
5196	return FALSE;
5197	}
5198	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5199	{
5200	short iw=iv2array((intvec )w->Data());
5201	res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5202	omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5203	return FALSE;
5204	}
5205	static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5206	{
5207	if (!pIsUnit((poly)v->Data()))
5208	{
5209	WerrorS("2nd argument must be a unit");
5210	return TRUE;
5211	}
5212	res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5213	return FALSE;
5214	}
5215	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5216	{
5217	res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5218	(intvec *)w->Data());
5219	return FALSE;
5220	}
5221	static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5222	{
5223	if (!mpIsDiagUnit((matrix)v->Data()))
5224	{
5225	WerrorS("2nd argument must be a diagonal matrix of units");
5226	return TRUE;
5227	}
5228	res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5229	(matrix)v->CopyD());
5230	return FALSE;
5231	}
5232	static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5233	{
5234	assumeStdFlag(w);
5235	res->data = (char *)idMinors(
5236	(matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5237	return FALSE;
5238	}
5239	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5240	{
5241	idhdl h;
5242	ring rr;
5243	map mapping;
5244
5245	if ((v->name==NULL) \|\| (w->name==NULL))
5246	{
5247	WerrorS("2nd/3rd arguments must have names");
5248	return TRUE;
5249	}
5250	rr=(ring)u->Data();
5251	const char *ring_name=u->Name();
5252	if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5253	{
5254	if (h->typ==MAP_CMD)
5255	{
5256	mapping=IDMAP(h);
5257	idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5258	if ((preim_ring==NULL)
5259	\|\| (IDRING(preim_ring)!=currRing))
5260	{
5261	Werror("preimage ring `%s` is not the basering",mapping->preimage);
5262	return TRUE;
5263	}
5264	}
5265	else if (h->typ==IDEAL_CMD)
5266	{
5267	mapping=IDMAP(h);
5268	}
5269	else
5270	{
5271	Werror("`%s` is no map nor ideal",IDID(h));
5272	return TRUE;
5273	}
5274	}
5275	else
5276	{
5277	Werror("`%s` is not defined in `%s`",v->name,ring_name);
5278	return TRUE;
5279	}
5280	if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5281	{
5282	if (h->typ==IDEAL_CMD)
5283	{
5284	if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5285	\|\| ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5286	{
5287	WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5288	}
5289	res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5290	if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5291	}
5292	else
5293	{
5294	Werror("`%s` is no ideal",IDID(h));
5295	return TRUE;
5296	}
5297	}
5298	else
5299	{
5300	Werror("`%s` is not defined in `%s`",w->name,ring_name);
5301	return TRUE;
5302	}
5303	return FALSE;
5304	}
5305	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5306	{
5307	int di, k;
5308	int i=(int)(long)u->Data();
5309	int r=(int)(long)v->Data();
5310	int c=(int)(long)w->Data();
5311	if ((r<=0) \|\| (c<=0)) return TRUE;
5312	intvec *iv = new intvec(r, c, 0);
5313	if (iv->rows()==0)
5314	{
5315	delete iv;
5316	return TRUE;
5317	}
5318	if (i!=0)
5319	{
5320	if (i<0) i = -i;
5321	di = 2 * i + 1;
5322	for (k=0; k<iv->length(); k++)
5323	{
5324	#ifdef buildin_rand
5325	(*iv)[k] = ((siRand() % di) - i);
5326	#else
5327	(*iv)[k] = ((rand() % di) - i);
5328	#endif
5329	}
5330	}
5331	res->data = (char *)iv;
5332	return FALSE;
5333	}
5334	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5335	int &ringvar, poly &monomexpr)
5336	{
5337	monomexpr=(poly)w->Data();
5338	poly p=(poly)v->Data();
5339	#if 0
5340	if (pLength(monomexpr)>1)
5341	{
5342	Werror("`%s` substitutes a ringvar only by a term",
5343	Tok2Cmdname(SUBST_CMD));
5344	return TRUE;
5345	}
5346	#endif
5347	if (!(ringvar=pVar(p)))
5348	{
5349	if (rField_is_Extension(currRing))
5350	{
5351	assume(currRing->algring!=NULL);
5352	lnumber n=(lnumber)pGetCoeff(p);
5353	ringvar=-p_Var(n->z,currRing->algring);
5354	}
5355	if(ringvar==0)
5356	{
5357	WerrorS("ringvar/par expected");
5358	return TRUE;
5359	}
5360	}
5361	return FALSE;
5362	}
5363	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5364	{
5365	int ringvar;
5366	poly monomexpr;
5367	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5368	if (nok) return TRUE;
5369	if (ringvar>0)
5370	{
5371	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5372	res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5373	else
5374	res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5375	}
5376	else
5377	{
5378	res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5379	}
5380	return FALSE;
5381	}
5382	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5383	{
5384	int ringvar;
5385	poly monomexpr;
5386	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5387	if (nok) return TRUE;
5388	if (ringvar>0)
5389	{
5390	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5391	res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5392	else
5393	res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5394	}
5395	else
5396	{
5397	res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5398	}
5399	return FALSE;
5400	}
5401	// we do not want to have jjSUBST_Id_X inlined:
5402	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5403	int input_type);
5404	static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5405	{
5406	return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5407	}
5408	static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5409	{
5410	return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5411	}
5412	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5413	{
5414	sleftv tmp;
5415	memset(&tmp,0,sizeof(tmp));
5416	// do not check the result, conversion from int/number to poly works always
5417	iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5418	BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5419	tmp.CleanUp();
5420	return b;
5421	}
5422	static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5423	{
5424	matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5425	ideal I=(ideal)u->CopyD(IDEAL_CMD);
5426	int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5427	//for(i=i-1;i>=0;i--)
5428	//{
5429	// m->m[i]=I->m[i];
5430	// I->m[i]=NULL;
5431	//}
5432	memcpy4(m->m,I->m,i*sizeof(poly));
5433	memset(I->m,0,i*sizeof(poly));
5434	idDelete(&I);
5435	res->data = (char *)m;
5436	return FALSE;
5437	}
5438	static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5439	{
5440	res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5441	(int)(long)v->Data(),(int)(long)w->Data());
5442	return FALSE;
5443	}
5444	static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5445	{
5446	matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5447	matrix I=(matrix)u->CopyD(MATRIX_CMD);
5448	int r=si_min(MATROWS(I),(int)(long)v->Data());
5449	int c=si_min(MATCOLS(I),(int)(long)w->Data());
5450	int i,j;
5451	for(i=r;i>0;i--)
5452	{
5453	for(j=c;j>0;j--)
5454	{
5455	MATELEM(m,i,j)=MATELEM(I,i,j);
5456	MATELEM(I,i,j)=NULL;
5457	}
5458	}
5459	idDelete((ideal *)&I);
5460	res->data = (char *)m;
5461	return FALSE;
5462	}
5463	static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5464	{
5465	if (w->rtyp!=IDHDL) return TRUE;
5466	BITSET save_test=test;
5467	int ul= IDELEMS((ideal)u->Data());
5468	int vl= IDELEMS((ideal)v->Data());
5469	ideal m
5470	= idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5471	FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
5472	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
5473	test=save_test;
5474	return FALSE;
5475	}
5476	static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
5477	{
5478	assumeStdFlag(v);
5479	if (!idIsZeroDim((ideal)v->Data()))
5480	{
5481	Werror("`%s` must be 0-dimensional",v->Name());
5482	return TRUE;
5483	}
5484	res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
5485	(poly)w->CopyD());
5486	return FALSE;
5487	}
5488	static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
5489	{
5490	assumeStdFlag(v);
5491	if (!idIsZeroDim((ideal)v->Data()))
5492	{
5493	Werror("`%s` must be 0-dimensional",v->Name());
5494	return TRUE;
5495	}
5496	res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
5497	(matrix)w->CopyD());
5498	return FALSE;
5499	}
5500	static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
5501	{
5502	assumeStdFlag(v);
5503	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
5504	0,(int)(long)w->Data());
5505	return FALSE;
5506	}
5507	static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
5508	{
5509	assumeStdFlag(v);
5510	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
5511	0,(int)(long)w->Data());
5512	return FALSE;
5513	}
5514	#ifdef OLD_RES
5515	static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
5516	{
5517	int maxl=(int)v->Data();
5518	ideal u_id=(ideal)u->Data();
5519	int l=0;
5520	resolvente r;
5521	intvec **weights=NULL;
5522	int wmaxl=maxl;
5523	maxl--;
5524	if ((maxl==-1) && (iiOp!=MRES_CMD))
5525	maxl = pVariables-1;
5526	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
5527	{
5528	intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
5529	if (iv!=NULL)
5530	{
5531	l=1;
5532	if (!idTestHomModule(u_id,currQuotient,iv))
5533	{
5534	WarnS("wrong weights");
5535	iv=NULL;
5536	}
5537	else
5538	{
5539	weights = (intvec**)omAlloc0Bin(void_ptr_bin);
5540	weights[0] = ivCopy(iv);
5541	}
5542	}
5543	r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
5544	}
5545	else
5546	r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
5547	if (r==NULL) return TRUE;
5548	int t3=u->Typ();
5549	iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
5550	return FALSE;
5551	}
5552	#endif
5553	static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
5554	{
5555	res->data=(void *)rInit(u,v,w);
5556	return (res->data==NULL);
5557	}
5558	static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
5559	{
5560	int yes;
5561	jjSTATUS2(res, u, v);
5562	yes = (strcmp((char ) res->data, (char ) w->Data()) == 0);
5563	omFree((ADDRESS) res->data);
5564	res->data = (void *)(long)yes;
5565	return FALSE;
5566	}
5567	static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
5568	{
5569	intvec vw=(intvec )w->Data(); // weights of vars
5570	if (vw->length()!=currRing->N)
5571	{
5572	Werror("%d weights for %d variables",vw->length(),currRing->N);
5573	return TRUE;
5574	}
5575	ideal result;
5576	intvec ww=(intvec )atGet(u,"isHomog",INTVEC_CMD);
5577	tHomog hom=testHomog;
5578	ideal u_id=(ideal)(u->Data());
5579	if (ww!=NULL)
5580	{
5581	if (!idTestHomModule(u_id,currQuotient,ww))
5582	{
5583	WarnS("wrong weights");
5584	ww=NULL;
5585	}
5586	else
5587	{
5588	ww=ivCopy(ww);
5589	hom=isHomog;
5590	}
5591	}
5592	result=kStd(u_id,
5593	currQuotient,
5594	hom,
5595	&ww, // module weights
5596	(intvec *)v->Data(), // hilbert series
5597	0,0, // syzComp, newIdeal
5598	vw); // weights of vars
5599	idSkipZeroes(result);
5600	res->data = (char *)result;
5601	setFlag(res,FLAG_STD);
5602	if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
5603	return FALSE;
5604	}
5605
5606	/=================== operations with 3 args.: table =================/
5607	struct sValCmd3 dArith3[]=
5608	{
5609	// operations:
5610	// proc cmd res arg1 arg2 arg3 plural
5611	{jjBRACK_S, '[', STRING_CMD, STRING_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5612	,{jjBRACK_Im, '[', INT_CMD, INTMAT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5613	,{jjBRACK_Ma_I_IV, '[', INT_CMD, INTMAT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5614	,{jjBRACK_Ma_IV_I, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5615	,{jjBRACK_Ma_IV_IV, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5616	,{jjBRACK_Ma, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5617	,{jjBRACK_Ma_I_IV, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5618	,{jjBRACK_Ma_IV_I, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
5619	,{jjBRACK_Ma_IV_IV, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5620	,{jjPROC3, '(', ANY_TYPE, PROC_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5621	,{atATTRIB3, ATTRIB_CMD, NONE, IDHDL, STRING_CMD, DEF_CMD ALLOW_PLURAL}
5622	,{jjBAREISS3, BAREISS_CMD,LIST_CMD, MODUL_CMD, INT_CMD, INT_CMD NO_PLURAL}
5623	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
5624	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
5625	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
5626	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
5627	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
5628	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
5629	,{jjELIMIN_HILB, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
5630	,{jjFIND3, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5631	,{jjFWALK3, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD, INT_CMD NO_PLURAL}
5632	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD NO_PLURAL}
5633	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD NO_PLURAL}
5634	,{jjCALL3MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5635	,{lInsert3, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
5636	//,{jjCALL3MANY, INTERSECT_CMD, NONE, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5637	,{jjINTMAT3, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5638	,{jjCALL3MANY, INTVEC_CMD, INTVEC_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5639	,{jjJET_P_IV, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5640	,{jjJET_ID_IV, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5641	,{jjJET_P_IV, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5642	,{jjJET_ID_IV, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5643	,{jjJET_P_P, JET_CMD, POLY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
5644	,{jjJET_P_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
5645	,{jjJET_ID_M, JET_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5646	,{jjJET_ID_M, JET_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
5647	,{jjWRONG3, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5648	,{mpKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
5649	,{jjCALL3MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5650	,{jjMATRIX_Id, MATRIX_CMD, MATRIX_CMD, IDEAL_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5651	,{jjMATRIX_Mo, MATRIX_CMD, MATRIX_CMD, MODUL_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5652	,{jjMATRIX_Ma, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5653	,{jjMINOR3, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
5654	,{jjCALL3MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5655	#ifdef OLD_RES
5656	,{jjRES3, MRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
5657	,{jjRES3, MRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
5658	#endif
5659	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
5660	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
5661	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ANY_TYPE ALLOW_PLURAL}
5662	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE, ANY_TYPE ALLOW_PLURAL}
5663	,{jjRANDOM_Im, RANDOM_CMD, INTMAT_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5664	,{jjREDUCE3_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
5665	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
5666	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
5667	,{jjREDUCE3_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
5668	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
5669	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
5670	,{jjREDUCE3_CP, REDUCE_CMD, POLY_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
5671	,{jjREDUCE3_CP, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, MODUL_CMD ALLOW_PLURAL}
5672	,{jjREDUCE3_CID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
5673	,{jjREDUCE3_CID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
5674	#ifdef OLD_RES
5675	,{jjRES3, RES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
5676	,{jjRES3, RES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
5677	#endif
5678	#ifdef HAVE_FACTORY
5679	,{jjRESULTANT, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
5680	#else
5681	,{jjWRONG3, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
5682	#endif
5683	,{jjRING3, RING_CMD, RING_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5684	#ifdef OLD_RES
5685	,{jjRES3, SRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE NO_PLURAL}
5686	,{jjRES3, SRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE NO_PLURAL}
5687	#endif
5688	,{jjSTATUS3, STATUS_CMD, INT_CMD, LINK_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
5689	,{jjSTD_HILB_W, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5690	,{jjSTD_HILB_W, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5691	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5692	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5693	,{jjSUBST_P, SUBST_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5694	,{jjSUBST_Id, SUBST_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5695	,{jjSUBST_Id, SUBST_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5696	,{jjSUBST_Id, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5697	,{jjSUBST_Id_I, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
5698	,{jjSUBST_Id_N, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, NUMBER_CMD ALLOW_PLURAL}
5699	,{jjCALL3MANY, SYSTEM_CMD, NONE, STRING_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
5700	,{nuLagSolve, LAGSOLVE_CMD,LIST_CMD, POLY_CMD, INT_CMD, INT_CMD NO_PLURAL}
5701	,{nuVanderSys, VANDER_CMD, POLY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
5702	,{NULL, 0, 0, 0, 0, 0 NO_PLURAL}
5703	};
5704	/=================== operations with many arg.: static proc =================/
5705	static BOOLEAN jjBREAK0(leftv res, leftv v)
5706	{
5707	#ifdef HAVE_SDB
5708	sdb_show_bp();
5709	#endif
5710	return FALSE;
5711	}
5712	static BOOLEAN jjBREAK1(leftv res, leftv v)
5713	{
5714	#ifdef HAVE_SDB
5715	if(v->Typ()==PROC_CMD)
5716	{
5717	int lineno=0;
5718	if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
5719	{
5720	lineno=(int)(long)v->next->Data();
5721	}
5722	return sdb_set_breakpoint(v->Name(),lineno);
5723	}
5724	return TRUE;
5725	#else
5726	return FALSE;
5727	#endif
5728	}
5729	static BOOLEAN jjCALL1ARG(leftv res, leftv v)
5730	{
5731	return iiExprArith1(res,v,iiOp);
5732	}
5733	static BOOLEAN jjCALL2ARG(leftv res, leftv u)
5734	{
5735	leftv v=u->next;
5736	u->next=NULL;
5737	BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
5738	u->next=v;
5739	return b;
5740	}
5741	static BOOLEAN jjCALL3ARG(leftv res, leftv u)
5742	{
5743	leftv v = u->next;
5744	leftv w = v->next;
5745	u->next = NULL;
5746	v->next = NULL;
5747	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
5748	u->next = v;
5749	v->next = w;
5750	return b;
5751	}
5752
5753	static BOOLEAN jjCOEF_M(leftv res, leftv v)
5754	{
5755	if((v->Typ() != VECTOR_CMD)
5756	\|\| (v->next->Typ() != POLY_CMD)
5757	\|\| (v->next->next->Typ() != MATRIX_CMD)
5758	\|\| (v->next->next->next->Typ() != MATRIX_CMD))
5759	return TRUE;
5760	if (v->next->next->rtyp!=IDHDL) return TRUE;
5761	idhdl c=(idhdl)v->next->next->data;
5762	if (v->next->next->next->rtyp!=IDHDL) return TRUE;
5763	idhdl m=(idhdl)v->next->next->next->data;
5764	idDelete((ideal *)&(c->data.uideal));
5765	idDelete((ideal *)&(m->data.uideal));
5766	mpCoef2((poly)v->Data(),(poly)v->next->Data(),
5767	(matrix )&(c->data.umatrix),(matrix )&(m->data.umatrix));
5768	return FALSE;
5769	}
5770
5771	static BOOLEAN jjDIVISION4(leftv res, leftv v)
5772	{ // may have 3 or 4 arguments
5773	leftv v1=v;
5774	leftv v2=v1->next;
5775	leftv v3=v2->next;
5776	leftv v4=v3->next;
5777	assumeStdFlag(v2);
5778
5779	int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
5780	int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
5781
5782	if(i1==0\|\|i2==0\|\|v3->Typ()!=INT_CMD\|\|(v4!=NULL&&v4->Typ()!=INTVEC_CMD))
5783	{
5784	WarnS("<module>,<module>,<int>[,<intvec>] expected!");
5785	return TRUE;
5786	}
5787
5788	sleftv w1,w2;
5789	iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
5790	iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
5791	ideal P=(ideal)w1.Data();
5792	ideal Q=(ideal)w2.Data();
5793
5794	int n=(int)(long)v3->Data();
5795	short *w=NULL;
5796	if(v4!=NULL)
5797	{
5798	w=iv2array((intvec *)v4->Data());
5799	short *w0=w+1;
5800	int i=pVariables;
5801	while(i>0&&*w0>0)
5802	{
5803	w0++;
5804	i--;
5805	}
5806	if(i>0)
5807	WarnS("not all weights are positive!");
5808	}
5809
5810	matrix T;
5811	ideal R;
5812	idLiftW(P,Q,n,T,R,w);
5813
5814	if(w!=NULL)
5815	omFree(w);
5816	lists L=(lists) omAllocBin(slists_bin);
5817	L->Init(2);
5818	L->m[1].rtyp=v1->Typ();
5819	if(v1->Typ()==POLY_CMD\|\|v1->Typ()==VECTOR_CMD)
5820	{
5821	if(v1->Typ()==POLY_CMD)
5822	pShift(&R->m[0],-1);
5823	L->m[1].data=(void *)R->m[0];
5824	R->m[0]=NULL;
5825	idDelete(&R);
5826	}
5827	else
5828	if(v1->Typ()==IDEAL_CMD\|\|v1->Typ()==MATRIX_CMD)
5829	L->m[1].data=(void *)idModule2Matrix(R);
5830	else
5831	L->m[1].rtyp=MODUL_CMD;
5832	L->m[0].rtyp=MATRIX_CMD;
5833	L->m[0].data=(char *)T;
5834
5835	res->data=L;
5836	res->rtyp=LIST_CMD;
5837
5838	return FALSE;
5839	}
5840
5841	//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
5842	//{
5843	// int l=u->listLength();
5844	// if (l<2) return TRUE;
5845	// BOOLEAN b;
5846	// leftv v=u->next;
5847	// leftv zz=v;
5848	// leftv z=zz;
5849	// u->next=NULL;
5850	// do
5851	// {
5852	// leftv z=z->next;
5853	// b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
5854	// if (b) break;
5855	// } while (z!=NULL);
5856	// u->next=zz;
5857	// return b;
5858	//}
5859	static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
5860	{
5861	int s=1;
5862	leftv h=v;
5863	if (h!=NULL) s=exprlist_length(h);
5864	ideal id=idInit(s,1);
5865	int rank=1;
5866	int i=0;
5867	poly p;
5868	while (h!=NULL)
5869	{
5870	switch(h->Typ())
5871	{
5872	case POLY_CMD:
5873	{
5874	p=(poly)h->CopyD(POLY_CMD);
5875	break;
5876	}
5877	case INT_CMD:
5878	{
5879	number n=nInit((int)(long)h->Data());
5880	if (!nIsZero(n))
5881	{
5882	p=pOne();
5883	pSetCoeff(p,n);
5884	}
5885	else
5886	{
5887	p=NULL;
5888	nDelete(&n);
5889	}
5890	break;
5891	}
5892	case NUMBER_CMD:
5893	{
5894	number n=(number)h->CopyD(NUMBER_CMD);
5895	if (!nIsZero(n))
5896	{
5897	p=pOne();
5898	pSetCoeff(p,n);
5899	}
5900	else
5901	{
5902	p=NULL;
5903	nDelete(&n);
5904	}
5905	break;
5906	}
5907	case VECTOR_CMD:
5908	{
5909	p=(poly)h->CopyD(VECTOR_CMD);
5910	if (iiOp!=MODUL_CMD)
5911	{
5912	idDelete(&id);
5913	pDelete(&p);
5914	return TRUE;
5915	}
5916	rank=si_max(rank,(int)pMaxComp(p));
5917	break;
5918	}
5919	default:
5920	{
5921	idDelete(&id);
5922	return TRUE;
5923	}
5924	}
5925	if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
5926	{
5927	pSetCompP(p,1);
5928	}
5929	id->m[i]=p;
5930	i++;
5931	h=h->next;
5932	}
5933	id->rank=rank;
5934	res->data=(char *)id;
5935	return FALSE;
5936	}
5937	static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
5938	{
5939	leftv h=v;
5940	int l=v->listLength();
5941	resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
5942	BOOLEAN copied=(BOOLEAN )omAlloc0(l*sizeof(BOOLEAN));
5943	int t=0;
5944	// try to convert to IDEAL_CMD
5945	while (h!=NULL)
5946	{
5947	if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
5948	{
5949	t=IDEAL_CMD;
5950	}
5951	else break;
5952	h=h->next;
5953	}
5954	// if failure, try MODUL_CMD
5955	if (t==0)
5956	{
5957	h=v;
5958	while (h!=NULL)
5959	{
5960	if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
5961	{
5962	t=MODUL_CMD;
5963	}
5964	else break;
5965	h=h->next;
5966	}
5967	}
5968	// check for success in converting
5969	if (t==0)
5970	{
5971	WerrorS("cannot convert to ideal or module");
5972	return TRUE;
5973	}
5974	// call idMultSect
5975	h=v;
5976	int i=0;
5977	sleftv tmp;
5978	while (h!=NULL)
5979	{
5980	if (h->Typ()==t)
5981	{
5982	r[i]=(ideal)h->Data(); /no copy/
5983	h=h->next;
5984	}
5985	else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
5986	{
5987	omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
5988	omFreeSize((ADDRESS)r,l*sizeof(ideal));
5989	Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
5990	return TRUE;
5991	}
5992	else
5993	{
5994	r[i]=(ideal)tmp.Data(); /now it's a copy/
5995	copied[i]=TRUE;
5996	h=tmp.next;
5997	}
5998	i++;
5999	}
6000	res->rtyp=t;
6001	res->data=(char *)idMultSect(r,i);
6002	while(i>0)
6003	{
6004	i--;
6005	if (copied[i]) idDelete(&(r[i]));
6006	}
6007	omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
6008	omFreeSize((ADDRESS)r,l*sizeof(ideal));
6009	return FALSE;
6010	}
6011	static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
6012	{
6013	int i=0;
6014	leftv h=v;
6015	if (h!=NULL) i=exprlist_length(h);
6016	intvec *iv=new intvec(i);
6017	i=0;
6018	while (h!=NULL)
6019	{
6020	if(h->Typ()==INT_CMD)
6021	{
6022	(*iv)[i]=(int)(long)h->Data();
6023	}
6024	else
6025	{
6026	delete iv;
6027	return TRUE;
6028	}
6029	i++;
6030	h=h->next;
6031	}
6032	res->data=(char *)iv;
6033	return FALSE;
6034	}
6035	static BOOLEAN jjJET4(leftv res, leftv u)
6036	{
6037	leftv u1=u;
6038	leftv u2=u1->next;
6039	leftv u3=u2->next;
6040	leftv u4=u3->next;
6041	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6042	(u4->Typ()==INTVEC_CMD)\|\|
6043	(u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6044	(u4->Typ()==INTVEC_CMD))
6045	{
6046	if(!pIsUnit((poly)u2->Data()))
6047	{
6048	WerrorS("2nd argument must be a unit");
6049	return TRUE;
6050	}
6051	res->rtyp=u1->Typ();
6052	res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
6053	pCopy((poly)u2->Data()),(intvec*)u4->Data());
6054	return FALSE;
6055	}
6056	else
6057	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6058	(u4->Typ()==INTVEC_CMD)\|\|
6059	(u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6060	(u4->Typ()==INTVEC_CMD))
6061	{
6062	if(!mpIsDiagUnit((matrix)u2->Data()))
6063	{
6064	WerrorS("2nd argument must be a diagonal matrix of units");
6065	return TRUE;
6066	}
6067	res->rtyp=u1->Typ();
6068	res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
6069	mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
6070	return FALSE;
6071	}
6072	else
6073	{
6074	Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
6075	Tok2Cmdname(iiOp));
6076	return TRUE;
6077	}
6078	}
6079	static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
6080	{
6081	if ((yyInRingConstruction)
6082	&& ((strcmp(u->Name(),"real")==0) \|\| (strcmp(u->Name(),"complex")==0)))
6083	{
6084	memcpy(res,u,sizeof(sleftv));
6085	memset(u,0,sizeof(sleftv));
6086	return FALSE;
6087	}
6088	leftv v=u->next;
6089	BOOLEAN b;
6090	if(v==NULL)
6091	b=iiExprArith1(res,u,iiOp);
6092	else
6093	{
6094	u->next=NULL;
6095	b=iiExprArith2(res,u,iiOp,v);
6096	u->next=v;
6097	}
6098	return b;
6099	}
6100	static BOOLEAN jjLIST_PL(leftv res, leftv v)
6101	{
6102	int sl=0;
6103	if (v!=NULL) sl = v->listLength();
6104	lists L;
6105	if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
6106	{
6107	int add_row_shift = 0;
6108	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
6109	if (weights!=NULL) add_row_shift=weights->min_in();
6110	L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
6111	}
6112	else
6113	{
6114	L=(lists)omAllocBin(slists_bin);
6115	leftv h=NULL;
6116	int i;
6117	int rt;
6118
6119	L->Init(sl);
6120	for (i=0;i<sl;i++)
6121	{
6122	if (h!=NULL) { /* e.g. not in the first step:
6123	* h is the pointer to the old sleftv,
6124	* v is the pointer to the next sleftv
6125	* (in this moment) */
6126	h->next=v;
6127	}
6128	h=v;
6129	v=v->next;
6130	h->next=NULL;
6131	rt=h->Typ();
6132	if (rt==0)
6133	{
6134	L->Clean();
6135	Werror("`%s` is undefined",h->Fullname());
6136	return TRUE;
6137	}
6138	if ((rt==RING_CMD)\|\|(rt==QRING_CMD))
6139	{
6140	L->m[i].rtyp=rt; L->m[i].data=h->Data();
6141	((ring)L->m[i].data)->ref++;
6142	}
6143	else
6144	L->m[i].Copy(h);
6145	}
6146	}
6147	res->data=(char *)L;
6148	return FALSE;
6149	}
6150	static BOOLEAN jjNAMES0(leftv res, leftv v)
6151	{
6152	res->data=(void *)ipNameList(IDROOT);
6153	return FALSE;
6154	}
6155	static BOOLEAN jjOPTION_PL(leftv res, leftv v)
6156	{
6157	if(v==NULL)
6158	{
6159	res->data=(char *)showOption();
6160	return FALSE;
6161	}
6162	res->rtyp=NONE;
6163	return setOption(res,v);
6164	}
6165	static BOOLEAN jjREDUCE4(leftv res, leftv u)
6166	{
6167	leftv u1=u;
6168	leftv u2=u1->next;
6169	leftv u3=u2->next;
6170	leftv u4=u3->next;
6171	if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
6172	{
6173	int save_d=Kstd1_deg;
6174	Kstd1_deg=(int)(long)u3->Data();
6175	kModW=(intvec *)u4->Data();
6176	BITSET save=verbose;
6177	verbose\|=Sy_bit(V_DEG_STOP);
6178	u2->next=NULL;
6179	BOOLEAN r=jjCALL2ARG(res,u);
6180	kModW=NULL;
6181	Kstd1_deg=save_d;
6182	verbose=save;
6183	u->next->next=u3;
6184	return r;
6185	}
6186	else
6187	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6188	(u4->Typ()==INT_CMD))
6189	{
6190	assumeStdFlag(u3);
6191	if(!mpIsDiagUnit((matrix)u2->Data()))
6192	{
6193	WerrorS("2nd argument must be a diagonal matrix of units");
6194	return TRUE;
6195	}
6196	res->rtyp=IDEAL_CMD;
6197	res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6198	mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
6199	return FALSE;
6200	}
6201	else
6202	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6203	(u4->Typ()==INT_CMD))
6204	{
6205	assumeStdFlag(u3);
6206	if(!pIsUnit((poly)u2->Data()))
6207	{
6208	WerrorS("2nd argument must be a unit");
6209	return TRUE;
6210	}
6211	res->rtyp=POLY_CMD;
6212	res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6213	pCopy((poly)u2->Data()),(int)(long)u4->Data());
6214	return FALSE;
6215	}
6216	else
6217	{
6218	Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
6219	return TRUE;
6220	}
6221	}
6222	static BOOLEAN jjREDUCE5(leftv res, leftv u)
6223	{
6224	leftv u1=u;
6225	leftv u2=u1->next;
6226	leftv u3=u2->next;
6227	leftv u4=u3->next;
6228	leftv u5=u4->next;
6229	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6230	(u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6231	{
6232	assumeStdFlag(u3);
6233	if(!mpIsDiagUnit((matrix)u2->Data()))
6234	{
6235	WerrorS("2nd argument must be a diagonal matrix of units");
6236	return TRUE;
6237	}
6238	res->rtyp=IDEAL_CMD;
6239	res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6240	mpCopy((matrix)u2->Data()),
6241	(int)(long)u4->Data(),(intvec*)u5->Data());
6242	return FALSE;
6243	}
6244	else
6245	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6246	(u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6247	{
6248	assumeStdFlag(u3);
6249	if(!pIsUnit((poly)u2->Data()))
6250	{
6251	WerrorS("2nd argument must be a unit");
6252	return TRUE;
6253	}
6254	res->rtyp=POLY_CMD;
6255	res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6256	pCopy((poly)u2->Data()),
6257	(int)(long)u4->Data(),(intvec*)u5->Data());
6258	return FALSE;
6259	}
6260	else
6261	{
6262	Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
6263	Tok2Cmdname(iiOp));
6264	return TRUE;
6265	}
6266	}
6267	static BOOLEAN jjRESERVED0(leftv res, leftv v)
6268	{
6269	int i=1;
6270	int nCount = (sArithBase.nCmdUsed-1)/3;
6271	if((3*nCount)<sArithBase.nCmdUsed) nCount++;
6272	//Print("CMDS: %d/%d\n", sArithBase.nCmdUsed,
6273	// sArithBase.nCmdAllocated);
6274	for(i=0; i<nCount; i++)
6275	{
6276	Print("%-20s",sArithBase.sCmds[i+1].name);
6277	if(i+1+nCount<sArithBase.nCmdUsed)
6278	Print("%-20s",sArithBase.sCmds[i+1+nCount].name);
6279	if(i+1+2*nCount<sArithBase.nCmdUsed)
6280	Print("%-20s",sArithBase.sCmds[i+1+2*nCount].name);
6281	//if ((i%3)==1) PrintLn();
6282	PrintLn();
6283	}
6284	PrintLn();
6285	return FALSE;
6286	}
6287	static BOOLEAN jjSTRING_PL(leftv res, leftv v)
6288	{
6289	if (v == NULL)
6290	{
6291	res->data = omStrDup("");
6292	return FALSE;
6293	}
6294	int n = v->listLength();
6295	if (n == 1)
6296	{
6297	res->data = v->String();
6298	return FALSE;
6299	}
6300
6301	char slist = (char) omAlloc(nsizeof(char));
6302	int i, j;
6303
6304	for (i=0, j=0; i<n; i++, v = v ->next)
6305	{
6306	slist[i] = v->String();
6307	assume(slist[i] != NULL);
6308	j+=strlen(slist[i]);
6309	}
6310	char* s = (char) omAlloc((j+1)sizeof(char));
6311	*s='\0';
6312	for (i=0;i<n;i++)
6313	{
6314	strcat(s, slist[i]);
6315	omFree(slist[i]);
6316	}
6317	omFreeSize(slist, nsizeof(char));
6318	res->data = s;
6319	return FALSE;
6320	}
6321	static BOOLEAN jjTEST(leftv res, leftv v)
6322	{
6323	do
6324	{
6325	if (v->Typ()!=INT_CMD)
6326	return TRUE;
6327	test_cmd((int)(long)v->Data());
6328	v=v->next;
6329	}
6330	while (v!=NULL);
6331	return FALSE;
6332	}
6333
6334	#if defined(__alpha) && !defined(linux)
6335	extern "C"
6336	{
6337	void usleep(unsigned long usec);
6338	};
6339	#endif
6340
6341	static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6342	{
6343	if ((v->Typ() != LINK_CMD) \|\|
6344	(v->next->Typ() != STRING_CMD) \|\|
6345	(v->next->next->Typ() != STRING_CMD) \|\|
6346	(v->next->next->next->Typ() != INT_CMD))
6347	return TRUE;
6348	jjSTATUS3(res, v, v->next, v->next->next);
6349	#if defined(HAVE_USLEEP)
6350	if (((long) res->data) == 0L)
6351	{
6352	int i_s = (int)(long) v->next->next->next->Data();
6353	if (i_s > 0)
6354	{
6355	usleep((int)(long) v->next->next->next->Data());
6356	jjSTATUS3(res, v, v->next, v->next->next);
6357	}
6358	}
6359	#elif defined(HAVE_SLEEP)
6360	if (((int) res->data) == 0)
6361	{
6362	int i_s = (int) v->next->next->next->Data();
6363	if (i_s > 0)
6364	{
6365	sleep((is - 1)/1000000 + 1);
6366	jjSTATUS3(res, v, v->next, v->next->next);
6367	}
6368	}
6369	#endif
6370	return FALSE;
6371	}
6372	static BOOLEAN jjSUBST_M(leftv res, leftv u)
6373	{
6374	leftv v = u->next; // number of args > 0
6375	if (v==NULL) return TRUE;
6376	leftv w = v->next;
6377	if (w==NULL) return TRUE;
6378	leftv rest = w->next;;
6379
6380	u->next = NULL;
6381	v->next = NULL;
6382	w->next = NULL;
6383	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6384	if ((rest!=NULL) && (!b))
6385	{
6386	sleftv tmp_res;
6387	leftv tmp_next=res->next;
6388	res->next=rest;
6389	memset(&tmp_res,0,sizeof(tmp_res));
6390	b = iiExprArithM(&tmp_res,res,iiOp);
6391	memcpy(res,&tmp_res,sizeof(tmp_res));
6392	res->next=tmp_next;
6393	}
6394	u->next = v;
6395	v->next = w;
6396	// rest was w->next, but is already cleaned
6397	return b;
6398	}
6399
6400	/=================== operations with many arg.: table =================/
6401	/* number_of_args: -1: any, -2: any >0, .. */
6402	struct sValCmdM dArithM[]=
6403	{
6404	// operations:
6405	// proc cmd res number_of_args plural
6406	{jjKLAMMER_PL, '(', ANY_TYPE, -2 ALLOW_PLURAL}
6407	,{jjBREAK0, BREAKPOINT_CMD, NONE, 0 ALLOW_PLURAL}
6408	,{jjBREAK1, BREAKPOINT_CMD, NONE, -2 ALLOW_PLURAL}
6409	,{jjCALL2ARG, COEF_CMD, MATRIX_CMD, 2 ALLOW_PLURAL}
6410	,{jjCOEF_M, COEF_CMD, NONE, 4 ALLOW_PLURAL}
6411	,{jjCALL2ARG, DIVISION_CMD, ANY_TYPE/or set by p/,2 ALLOW_PLURAL}
6412	,{jjDIVISION4, DIVISION_CMD, ANY_TYPE/or set by p/,3 NO_PLURAL}
6413	,{jjDIVISION4, DIVISION_CMD, ANY_TYPE/or set by p/,4 NO_PLURAL}
6414	,{jjDBPRINT, DBPRINT_CMD, NONE, -2 ALLOW_PLURAL}
6415	//,{jjEXPORTTO_M, EXPORTTO_CMD, NONE, -2 ALLOW_PLURAL}
6416	,{jjCALL1ARG, IDEAL_CMD, IDEAL_CMD, 1 ALLOW_PLURAL}
6417	,{jjIDEAL_PL, IDEAL_CMD, IDEAL_CMD, -1 ALLOW_PLURAL}
6418	,{jjCALL2ARG, INTERSECT_CMD, IDEAL_CMD, 2 ALLOW_PLURAL}
6419	,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD, -2 ALLOW_PLURAL}
6420	,{jjCALL1ARG, INTVEC_CMD, INTVEC_CMD, 1 ALLOW_PLURAL}
6421	,{jjINTVEC_PL, INTVEC_CMD, INTVEC_CMD, -2 ALLOW_PLURAL}
6422	,{jjCALL2ARG, JET_CMD, POLY_CMD,/or set by p/ 2 ALLOW_PLURAL}
6423	,{jjCALL3ARG, JET_CMD, POLY_CMD,/or set by p/ 3 ALLOW_PLURAL}
6424	,{jjJET4, JET_CMD, POLY_CMD,/or set by p/ 4 ALLOW_PLURAL}
6425	,{jjLIST_PL, LIST_CMD, LIST_CMD, -1 ALLOW_PLURAL}
6426	,{jjCALL1ARG, MODUL_CMD, MODUL_CMD, 1 ALLOW_PLURAL}
6427	,{jjIDEAL_PL, MODUL_CMD, MODUL_CMD, -1 ALLOW_PLURAL}
6428	,{jjCALL1ARG, NAMES_CMD, LIST_CMD, 1 ALLOW_PLURAL}
6429	,{jjNAMES0, NAMES_CMD, LIST_CMD, 0 ALLOW_PLURAL}
6430	,{jjOPTION_PL, OPTION_CMD, STRING_CMD/or set by p/,-1 ALLOW_PLURAL}
6431	,{jjCALL2ARG, REDUCE_CMD, IDEAL_CMD/or set by p/, 2 ALLOW_PLURAL}
6432	,{jjCALL3ARG, REDUCE_CMD, IDEAL_CMD/or set by p/, 3 ALLOW_PLURAL}
6433	,{jjREDUCE4, REDUCE_CMD, IDEAL_CMD/or set by p/, 4 ALLOW_PLURAL}
6434	,{jjREDUCE5, REDUCE_CMD, IDEAL_CMD/or set by p/, 5 ALLOW_PLURAL}
6435	,{jjCALL1ARG, RESERVEDNAME_CMD, INT_CMD, 1 ALLOW_PLURAL}
6436	,{jjRESERVED0, RESERVEDNAME_CMD, NONE, 0 ALLOW_PLURAL}
6437	,{jjSTRING_PL, STRING_CMD, STRING_CMD, -1 ALLOW_PLURAL}
6438	,{jjCALL3ARG, SUBST_CMD, NONE/set by p/, 3 ALLOW_PLURAL}
6439	,{jjSUBST_M, SUBST_CMD, NONE/set by p/, -2 ALLOW_PLURAL}
6440	,{jjSYSTEM, SYSTEM_CMD, NONE/or set by p/,-2 ALLOW_PLURAL}
6441	,{jjTEST, TEST_CMD, NONE, -2 ALLOW_PLURAL}
6442	,{iiWRITE, WRITE_CMD, NONE, -2 ALLOW_PLURAL}
6443	,{jjCALL2ARG, STATUS_CMD, STRING_CMD, 2 ALLOW_PLURAL}
6444	,{jjCALL3ARG, STATUS_CMD, INT_CMD, 3 ALLOW_PLURAL}
6445	,{jjSTATUS_M, STATUS_CMD, INT_CMD, 4 ALLOW_PLURAL}
6446	,{loSimplex, SIMPLEX_CMD, LIST_CMD, 6 NO_PLURAL}
6447	,{nuUResSolve, URSOLVE_CMD, LIST_CMD, 4 NO_PLURAL}
6448	,{NULL, 0, 0, 0 NO_PLURAL}
6449	};
6450	#ifdef MDEBUG
6451	static Subexpr jjDBMakeSub(leftv e,char *f, int l)
6452	#else
6453	static Subexpr jjMakeSub(leftv e)
6454	#endif
6455	{
6456	assume( e->Typ()==INT_CMD );
6457	Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
6458	r->start =(int)(long)e->Data();
6459	return r;
6460	}
6461
6462	/================ generating tables ============================/
6463	#ifdef GENTABLE
6464	extern struct sValAssign dAssign[];
6465	struct sValCmdTab dArithTab1[]={ {0,0}};
6466	#define JJTAB1LEN 0
6467	struct sValCmdTab dArithTab2[]={ {0,0}};
6468	#define JJTAB2LEN 0
6469	void ttGen1()
6470	{
6471	FILE *outfile = myfopen("iparith.inc","w");
6472	int i,j,l1=0,l2=0;
6473	currRing=(ring)omAllocBin(sip_sring_bin);
6474	fprintf(outfile,
6475	"/****************************************\n"
6476	"* Computer Algebra System SINGULAR *\n"
6477	"****************************************/\n\n");
6478	/-------------------------------------------------------------------/
6479	fprintf(outfile,"// syntax table for Singular\n//\n");
6480	fprintf(outfile,"// - search for an exact match of the argument types\n");
6481	fprintf(outfile,"// - otherwise search for the first possibility\n");
6482	fprintf(outfile,"// with converted types of the arguments\n");
6483	fprintf(outfile,"// - otherwise report an error\n//\n");
6484
6485	int op;
6486	i=0;
6487	while ((op=dArith1[i].cmd)!=0)
6488	{
6489	if (dArith1[i].p==jjWRONG)
6490	fprintf(outfile,"// DUMMY ");
6491	char *s = iiTwoOps(op);
6492	fprintf(outfile,"// operation: %s (%s) -> %s\n",
6493	s,
6494	Tok2Cmdname(dArith1[i].arg),
6495	Tok2Cmdname(ABS(dArith1[i].res)));
6496	i++;
6497	}
6498	fprintf(outfile,"/---------------------------------------------/\n");
6499	i=0;
6500	while ((op=dArith2[i].cmd)!=0)
6501	{
6502	if (dArith2[i].p==jjWRONG2)
6503	fprintf(outfile,"// DUMMY ");
6504	char *s = iiTwoOps(op);
6505	fprintf(outfile,"// operation: %s (%s, %s) -> %s\n",
6506	s,
6507	Tok2Cmdname(dArith2[i].arg1),
6508	Tok2Cmdname(dArith2[i].arg2),
6509	Tok2Cmdname(dArith2[i].res));
6510	i++;
6511	}
6512	fprintf(outfile,"/---------------------------------------------/\n");
6513	i=0;
6514	while ((op=dArith3[i].cmd)!=0)
6515	{
6516	char *s = iiTwoOps(op);
6517	if (dArith3[i].p==jjWRONG3)
6518	fprintf(outfile,"// DUMMY ");
6519	fprintf(outfile,"// operation: %s (%s, %s, %s) -> %s\n",
6520	s,
6521	Tok2Cmdname(dArith3[i].arg1),
6522	Tok2Cmdname(dArith3[i].arg2),
6523	Tok2Cmdname(dArith3[i].arg3),
6524	Tok2Cmdname(dArith3[i].res));
6525	i++;
6526	}
6527	fprintf(outfile,"/---------------------------------------------/\n");
6528	i=0;
6529	while ((op=dArithM[i].cmd)!=0)
6530	{
6531	char *s = iiTwoOps(op);
6532	fprintf(outfile,"// operation: %s (...) -> %s",
6533	s,
6534	Tok2Cmdname(dArithM[i].res));
6535	switch(dArithM[i].number_of_args)
6536	{
6537	case -2:
6538	fprintf(outfile," ( number of arguments >0 )\n");
6539	break;
6540	case -1:
6541	fprintf(outfile," ( any number of arguments )\n");
6542	break;
6543	default:
6544	fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
6545	break;
6546	}
6547	i++;
6548	}
6549	fprintf(outfile,"/---------------------------------------------/\n");
6550	i=0;
6551	while ((op=dAssign[i].res)!=0)
6552	{
6553	fprintf(outfile,"// assign: %s = %s\n",
6554	Tok2Cmdname(op/dAssign[i].res/),
6555	Tok2Cmdname(dAssign[i].arg));
6556	i++;
6557	}
6558	/-------------------------------------------------------------------/
6559	fprintf(outfile,"/---------------------------------------------/\n");
6560	for (j=257;j<=MAX_TOK+1;j++)
6561	{
6562	for(i=257;i<=MAX_TOK+1;i++)
6563	{
6564	if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
6565	&& iiTestConvert(i,j))
6566	{
6567	fprintf(outfile,"// convert %s -> %s\n",
6568	Tok2Cmdname(i), Tok2Cmdname(j));
6569	if (j==ANY_TYPE) break;
6570	}
6571	}
6572	}
6573	fprintf(outfile,"/---------------------------------------------/\n");
6574	char ops[]="=><+*/[.^,%(;";
6575	for(i=0;ops[i]!='\0';i++)
6576	fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
6577	for (i=257;i<=MAX_TOK;i++)
6578	{
6579	char *s=iiTwoOps(i);
6580	if (s[0]!='$')
6581	{
6582	fprintf(outfile,"// token %d : %s\n", i, s);
6583	}
6584	}
6585	/-------------------------------------------------------------------/
6586	fprintf(outfile,"/--max. token: %d, gr: %d --/\n",MAX_TOK,UMINUS);
6587	/-------------------------------------------------------------------/
6588	fprintf(outfile,"/---------------------------------------------/\n");
6589	fprintf(outfile,
6590	"struct sValCmdTab dArithTab1[]=\n"
6591	"{\n");
6592	for (j=1;j<=MAX_TOK+1;j++)
6593	{
6594	for(i=0;dArith1[i].cmd!=0;i++)
6595	{
6596	if (dArith1[i].cmd==j)
6597	{
6598	fprintf(outfile," { %d,%d },\n",j,i);
6599	l1++;
6600	break;
6601	}
6602	}
6603	}
6604	fprintf(outfile," { 10000,0 }\n};\n");
6605	fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
6606	/-------------------------------------------------------------------/
6607	fprintf(outfile,
6608	"struct sValCmdTab dArithTab2[]=\n"
6609	"{\n");
6610	for (j=1;j<=MAX_TOK+1;j++)
6611	{
6612	for(i=0;dArith2[i].cmd!=0;i++)
6613	{
6614	if (dArith2[i].cmd==j)
6615	{
6616	fprintf(outfile," { %d,%d },\n",j,i);
6617	l2++;
6618	break;
6619	}
6620	}
6621	}
6622	fprintf(outfile," { 10000,0 }\n};\n");
6623	fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
6624	fclose(outfile);
6625	}
6626	/-------------------------------------------------------------------/
6627	#if 0
6628	void ttGen2()
6629	{
6630	FILE *outfile = myfopen("iparith.inc","a");
6631	fprintf(outfile,
6632	"/****************************************\n"
6633	"* Computer Algebra System SINGULAR *\n"
6634	"****************************************/\n\n");
6635	/-------------------------------------------------------------------/
6636	fprintf(outfile,"// identifier table for Singular\n//\n");
6637
6638	fprintf(outfile,
6639	"cmdnames OLDcmds[] =\n"
6640	"{ // name-string alias tokval toktype\n"
6641	"{ \"$INVALID$\", 0, -1, 0},\n");
6642	int i=1;
6643	int m=-1;
6644	int id_nr=0;
6645	BOOLEAN f=FALSE;
6646	loop
6647	{
6648	while (cmds[i].tokval!=0)
6649	{
6650	if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
6651	{
6652	if(m==-1)
6653	{
6654	m=i;
6655	f=TRUE;
6656	}
6657	else if(strcmp(cmds[m].name,cmds[i].name)>0)
6658	{
6659	m=i;
6660	f=TRUE;
6661	}
6662	}
6663	i++;
6664	}
6665	if(f)
6666	{
6667	id_nr++;
6668	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
6669	fprintf(outfile," {\"%s\", %*d, %3d, ",cmds[m].name,
6670	20-strlen(cmds[m].name),
6671	cmds[m].alias,
6672	cmds[m].tokval);
6673	switch(cmds[m].toktype)
6674	{
6675	case CMD_1: fprintf(outfile,"CMD_1 },\n"); break;
6676	case CMD_2: fprintf(outfile,"CMD_2 },\n"); break;
6677	case CMD_3: fprintf(outfile,"CMD_3 },\n"); break;
6678	case CMD_12: fprintf(outfile,"CMD_12 },\n"); break;
6679	case CMD_123 : fprintf(outfile,"CMD_123 },\n"); break;
6680	case CMD_23: fprintf(outfile,"CMD_23 },\n"); break;
6681	case CMD_M: fprintf(outfile,"CMD_M },\n"); break;
6682	case SYSVAR: fprintf(outfile,"SYSVAR },\n"); break;
6683	case ROOT_DECL: fprintf(outfile,"ROOT_DECL },\n"); break;
6684	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
6685	case RING_DECL: fprintf(outfile,"RING_DECL },\n"); break;
6686	case NONE: fprintf(outfile,"NONE },\n"); break;
6687	default: if((cmds[m].toktype>' ')
6688	&&(cmds[m].toktype<127))
6689	{
6690	fprintf(outfile,"'%c' },\n",cmds[m].toktype);
6691	}
6692	else
6693	{
6694	fprintf(outfile,"%d },\n",cmds[m].toktype);
6695	}
6696	break;
6697	}
6698	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
6699	cmds[m].name=NULL;
6700	m=-1;
6701	i=1;
6702	f=FALSE;
6703	}
6704	else break;
6705	}
6706	fprintf(outfile,
6707	"/* list of scanner identifiers/only for feread/reservedName */\n");
6708	f=FALSE;
6709	i=1;m=-1;
6710	loop
6711	{
6712	while (cmds[i].tokval!=0)
6713	{
6714	if (cmds[i].name!=NULL)
6715	{
6716	if(m==-1)
6717	{
6718	m=i;
6719	f=TRUE;
6720	}
6721	else if(strcmp(cmds[m].name,cmds[i].name)>0)
6722	{
6723	m=i;
6724	f=TRUE;
6725	}
6726	}
6727	i++;
6728	}
6729	if(f)
6730	{
6731	fprintf(outfile," {\"%s\", %*d, -1, 0 },\n",cmds[m].name,
6732	20-strlen(cmds[m].name),
6733	0/cmds[m].alias/
6734	/-1 cmds[m].tokval/
6735	/0 cmds[m].toktype/);
6736	cmds[m].name=NULL;
6737	m=-1;
6738	i=1;
6739	f=FALSE;
6740	}
6741	else break;
6742	}
6743	fprintf(outfile,
6744	"/* end of list marker */\n"
6745	" { NULL, 0, 0, 0}\n"
6746	"};\n"
6747	"#ifdef HAVE_RTIMER\n"
6748	"#define LAST_IDENTIFIER %d\n"
6749	"#else\n"
6750	"#define LAST_IDENTIFIER %d\n"
6751	"#endif\n",id_nr,id_nr-1);
6752	fclose(outfile);
6753	}
6754	#endif
6755	/---------------------------------------------------------------------/
6756	/**
6757	* @brief generate cmds initialisation
6758	**/
6759	/---------------------------------------------------------------------/
6760
6761	void ttGen2b()
6762	{
6763	int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
6764
6765	FILE *outfile = myfopen("iparith.inc","a");
6766	fprintf(outfile,
6767	"/****************************************\n"
6768	"* Computer Algebra System SINGULAR *\n"
6769	"****************************************/\n\n");
6770	/-------------------------------------------------------------------/
6771	fprintf(outfile,"// identifier table for Singular\n//\n");
6772
6773	fprintf(
6774	outfile,
6775	"#ifdef MODULE_GENERATOR\n"
6776	"#define omAlloc0(A) malloc(A)\n"
6777	"#endif\n"
6778	"void iiInitCmdName() {\n"
6779	" sArithBase.nCmdUsed = 0;\n"
6780	" sArithBase.nCmdAllocated = %d;\n"
6781	" sArithBase.sCmds = (cmdnames)omAlloc0(sArithBase.nCmdAllocatedsizeof(cmdnames));\n"
6782	"\n"
6783	" // name-string alias tokval toktype\n",
6784	cmd_size);
6785	int m=0;
6786	int id_nr=0;
6787
6788	qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
6789
6790	for(m=0; m<cmd_size; m++) {
6791	if(cmds[m].tokval>0) id_nr++;
6792	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
6793	fprintf(outfile," iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
6794	20-strlen(cmds[m].name),
6795	cmds[m].alias,
6796	cmds[m].tokval);
6797	switch(cmds[m].toktype) {
6798	case CMD_1: fprintf(outfile,"CMD_1"); break;
6799	case CMD_2: fprintf(outfile,"CMD_2"); break;
6800	case CMD_3: fprintf(outfile,"CMD_3"); break;
6801	case CMD_12: fprintf(outfile,"CMD_12"); break;
6802	case CMD_123 : fprintf(outfile,"CMD_123"); break;
6803	case CMD_23: fprintf(outfile,"CMD_23"); break;
6804	case CMD_M: fprintf(outfile,"CMD_M"); break;
6805	case SYSVAR: fprintf(outfile,"SYSVAR"); break;
6806	case ROOT_DECL: fprintf(outfile,"ROOT_DECL"); break;
6807	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST"); break;
6808	case RING_DECL: fprintf(outfile,"RING_DECL"); break;
6809	case NONE: fprintf(outfile,"NONE"); break;
6810	default:
6811	if((cmds[m].toktype>' ') &&(cmds[m].toktype<127)) {
6812	fprintf(outfile,"'%c'",cmds[m].toktype);
6813	} else {
6814	fprintf(outfile,"%d",cmds[m].toktype);
6815	}
6816	break;
6817	#if 0
6818	fprintf(outfile," iiArithAddCmd(\"%s\", %*d, -1, 0 );\n",
6819	cmds[m].name, 20-strlen(cmds[m].name),
6820	0/cmds[m].alias/
6821	/-1 cmds[m].tokval/
6822	/0 cmds[m].toktype/);
6823	#endif
6824	}
6825	fprintf(outfile,", %d);\n", m);
6826	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
6827	}
6828	fprintf(outfile, "/* end of list marker */\n");
6829	fprintf(outfile,
6830	"#ifdef HAVE_RTIMER\n"
6831	" sArithBase.nLastIdentifier = %d;\n"
6832	"#else /* HAVE_RTIMER */\n"
6833	" sArithBase.nLastIdentifier = %d;\n"
6834	"#endif /* HAVE_RTIMER */\n",
6835	id_nr,id_nr-1);
6836
6837
6838	fprintf(outfile,
6839	"}\n"
6840	"#ifdef HAVE_RTIMER\n"
6841	"#define LAST_IDENTIFIER %d\n"
6842	"#else\n"
6843	"#define LAST_IDENTIFIER %d\n"
6844	"#endif\n",id_nr,id_nr-1);
6845	fclose(outfile);
6846	}
6847	/-------------------------------------------------------------------/
6848	#if 0
6849	void ttGen3()
6850	{
6851	FILE *outfile = myfopen("mpsr_tok.inc","w");
6852	fprintf(outfile,
6853	"/****************************************\n"
6854	"* Computer Algebra System SINGULAR *\n"
6855	"****************************************/\n\n");
6856	/-------------------------------------------------------------------/
6857	fprintf(outfile,"// token table for Singular\n//\n");
6858
6859	fprintf(outfile,
6860	"short vtok[] =\n"
6861	"{\n");
6862	// operations with 1 arg: ===========================================
6863	int i=0;
6864	while (dArith1[i].cmd!=0)
6865	{
6866	if ((dArith1[i].p!=jjWRONG)
6867	&&((i==0)\|\|(dArith1[i].cmd!=dArith1[i-1].cmd)))
6868	{
6869	fprintf(outfile," %d,\n",dArith1[i].cmd);
6870	}
6871	i++;
6872	}
6873	// operations with 2 args: ===========================================
6874	i=0;
6875	while (dArith2[i].cmd!=0)
6876	{
6877	if ((dArith2[i].p!=jjWRONG2)
6878	&&((i==0)\|\|(dArith2[i].cmd!=dArith2[i-1].cmd)))
6879	{
6880	fprintf(outfile," %d,\n",dArith2[i].cmd);
6881	}
6882	i++;
6883	}
6884	// operations with 3 args: ===========================================
6885	i=0;
6886	while (dArith3[i].cmd!=0)
6887	{
6888	if (
6889	((i==0)\|\|(dArith3[i].cmd!=dArith3[i-1].cmd)))
6890	{
6891	fprintf(outfile," %d,\n",dArith3[i].cmd);
6892	}
6893	i++;
6894	}
6895	// operations with many args: ===========================================
6896	i=0;
6897	while (dArithM[i].cmd!=0)
6898	{
6899	if (
6900	((i==0)\|\|(dArithM[i].cmd!=dArithM[i-1].cmd)))
6901	{
6902	fprintf(outfile," %d,\n",dArithM[i].cmd);
6903	}
6904	i++;
6905	}
6906	// ====================================================================
6907	fprintf(outfile,
6908	"/* end of list marker */\n"
6909	" %d };\n",MAX_TOK);
6910	fclose(outfile);
6911	}
6912	#endif
6913	void ttGen4()
6914	{
6915	FILE *outfile = myfopen("plural_cmd.inc","w");
6916	int i;
6917	char *old_s="";
6918	fprintf(outfile,
6919	"@c *****************************************\n"
6920	"@c * Computer Algebra System SINGULAR *\n"
6921	"@c *****************************************\n\n");
6922	/-------------------------------------------------------------------/
6923	fprintf(outfile,"@multicolumn .45 .45\n");
6924	int op;
6925	i=0;
6926	while ((op=dArith1[i].cmd)!=0)
6927	{
6928	if (dArith1[i].p!=jjWRONG)
6929	{
6930	char *s = iiTwoOps(op);
6931	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6932	{
6933	old_s=s;
6934	#ifdef HAVE_PLURAL
6935	switch (dArith1[i].valid_for_plural)
6936	{
6937	case NO_PLURAL_N:
6938	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6939	break;
6940	case ALLOW_PLURAL_N:
6941	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6942	break;
6943	case COMM_PLURAL_N:
6944	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6945	break;
6946	}
6947	#endif
6948	}
6949	}
6950	i++;
6951	}
6952	fprintf(outfile,"@c ---------------------------------------------\n");
6953	i=0;
6954	while ((op=dArith2[i].cmd)!=0)
6955	{
6956	if (dArith2[i].p!=jjWRONG2)
6957	{
6958	char *s = iiTwoOps(op);
6959	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6960	{
6961	old_s=s;
6962	#ifdef HAVE_PLURAL
6963	switch (dArith2[i].valid_for_plural)
6964	{
6965	case NO_PLURAL_N:
6966	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6967	break;
6968	case ALLOW_PLURAL_N:
6969	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6970	break;
6971	case COMM_PLURAL_N:
6972	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
6973	break;
6974	}
6975	#endif
6976	}
6977	}
6978	i++;
6979	}
6980	fprintf(outfile,"@c ---------------------------------------------\n");
6981	i=0;
6982	while ((op=dArith3[i].cmd)!=0)
6983	{
6984	char *s = iiTwoOps(op);
6985	if (dArith3[i].p!=jjWRONG3)
6986	{
6987	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
6988	{
6989	old_s=s;
6990	#ifdef HAVE_PLURAL
6991	switch (dArith3[i].valid_for_plural)
6992	{
6993	case NO_PLURAL_N:
6994	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
6995	break;
6996	case ALLOW_PLURAL_N:
6997	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
6998	break;
6999	case COMM_PLURAL_N:
7000	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7001	break;
7002	}
7003	#endif
7004	}
7005	}
7006	i++;
7007	}
7008	fprintf(outfile,"@c ---------------------------------------------\n");
7009	i=0;
7010	while ((op=dArithM[i].cmd)!=0)
7011	{
7012	char *s = iiTwoOps(op);
7013	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7014	{
7015	old_s=s;
7016	#ifdef HAVE_PLURAL
7017	switch (dArithM[i].valid_for_plural)
7018	{
7019	case NO_PLURAL_N:
7020	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7021	break;
7022	case ALLOW_PLURAL_N:
7023	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7024	break;
7025	case COMM_PLURAL_N:
7026	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7027	break;
7028	}
7029	#endif
7030	}
7031	i++;
7032	}
7033	fprintf(outfile,"@c ---------------------------------------------\n");
7034	fprintf(outfile,"@end table\n");
7035	fclose(outfile);
7036	}
7037	/-------------------------------------------------------------------/
7038	#else
7039	#include "iparith.inc"
7040	#endif
7041
7042	/=================== operations with 2 args. ============================/
7043
7044	BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
7045	{
7046	#ifndef GENTABLE
7047	memset(res,0,sizeof(sleftv));
7048
7049	if (!errorreported)
7050	{
7051	#ifdef SIQ
7052	if (siq>0)
7053	{
7054	//Print("siq:%d\n",siq);
7055	command d=(command)omAlloc0Bin(ip_command_bin);
7056	memcpy(&d->arg1,a,sizeof(sleftv));
7057	//a->Init();
7058	memcpy(&d->arg2,b,sizeof(sleftv));
7059	//b->Init();
7060	d->argc=2;
7061	d->op=op;
7062	res->data=(char *)d;
7063	res->rtyp=COMMAND;
7064	return FALSE;
7065	}
7066	#endif
7067	int at=a->Typ();
7068	int bt=b->Typ();
7069	int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
7070	int index=i;
7071
7072	iiOp=op;
7073	while (dArith2[i].cmd==op)
7074	{
7075	if ((at==dArith2[i].arg1)
7076	&& (bt==dArith2[i].arg2))
7077	{
7078	res->rtyp=dArith2[i].res;
7079	#ifdef HAVE_PLURAL
7080	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7081	{
7082	if (dArith2[i].valid_for_plural==0 /NO_PLURAL/)
7083	{
7084	WerrorS(ii_not_for_plural);
7085	break;
7086	}
7087	else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7088	{
7089	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7090	}
7091	/* else ALLOW_PLURAL */
7092	}
7093	#endif
7094	if (dArith2[i].p(res,a,b))
7095	{
7096	break;// leave loop, goto error handling
7097	}
7098	a->CleanUp();
7099	b->CleanUp();
7100	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7101	return FALSE;
7102	}
7103	i++;
7104	}
7105	// implicite type conversion ----------------------------------------------
7106	if (dArith2[i].cmd!=op)
7107	{
7108	int ai,bi;
7109	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7110	leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7111	BOOLEAN failed=FALSE;
7112	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
7113	//Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
7114	while (dArith2[i].cmd==op)
7115	{
7116	//Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7117	if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
7118	{
7119	if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
7120	{
7121	res->rtyp=dArith2[i].res;
7122	#ifdef HAVE_PLURAL
7123	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7124	{
7125	if (dArith2[i].valid_for_plural==0 /NO_PLURAL/)
7126	{
7127	WerrorS(ii_not_for_plural);
7128	break;
7129	}
7130	else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7131	{
7132	Warn("assume commutative subalgebra for cmd `%s`",
7133	Tok2Cmdname(i));
7134	}
7135	/* else ALLOW_PLURAL */
7136	}
7137	#endif
7138	failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
7139	\|\| (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
7140	\|\| (dArith2[i].p(res,an,bn)));
7141	// everything done, clean up temp. variables
7142	if (failed)
7143	{
7144	// leave loop, goto error handling
7145	break;
7146	}
7147	else
7148	{
7149	// everything ok, clean up and return
7150	an->CleanUp();
7151	bn->CleanUp();
7152	omFreeBin((ADDRESS)an, sleftv_bin);
7153	omFreeBin((ADDRESS)bn, sleftv_bin);
7154	a->CleanUp();
7155	b->CleanUp();
7156	return FALSE;
7157	}
7158	}
7159	}
7160	i++;
7161	}
7162	an->CleanUp();
7163	bn->CleanUp();
7164	omFreeBin((ADDRESS)an, sleftv_bin);
7165	omFreeBin((ADDRESS)bn, sleftv_bin);
7166	}
7167	// error handling ---------------------------------------------------
7168	const char *s=NULL;
7169	if (!errorreported)
7170	{
7171	if ((at==0) && (a->Fullname()!=sNoName))
7172	{
7173	s=a->Fullname();
7174	}
7175	else if ((bt==0) && (b->Fullname()!=sNoName))
7176	{
7177	s=b->Fullname();
7178	}
7179	if (s!=NULL)
7180	Werror("`%s` is not defined",s);
7181	else
7182	{
7183	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
7184	s = iiTwoOps(op);
7185	if (proccall)
7186	{
7187	Werror("%s(`%s`,`%s`) is not supported"
7188	,s,Tok2Cmdname(at),Tok2Cmdname(bt));
7189	}
7190	else
7191	{
7192	Werror("`%s` %s `%s` is not supported"
7193	,Tok2Cmdname(at),s,Tok2Cmdname(bt));
7194	}
7195	if (BVERBOSE(V_SHOW_USE))
7196	{
7197	while (dArith2[i].cmd==op)
7198	{
7199	if(((at==dArith2[i].arg1)\|\|(bt==dArith2[i].arg2))
7200	&& (dArith2[i].res!=0)
7201	&& (dArith2[i].p!=jjWRONG2))
7202	{
7203	if (proccall)
7204	Werror("expected %s(`%s`,`%s`)"
7205	,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7206	else
7207	Werror("expected `%s` %s `%s`"
7208	,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
7209	}
7210	i++;
7211	}
7212	}
7213	}
7214	}
7215	res->rtyp = UNKNOWN;
7216	}
7217	a->CleanUp();
7218	b->CleanUp();
7219	#endif
7220	return TRUE;
7221	}
7222
7223	/==================== operations with 1 arg. ===============================/
7224
7225	BOOLEAN iiExprArith1(leftv res, leftv a, int op)
7226	{
7227	#ifndef GENTABLE
7228	memset(res,0,sizeof(sleftv));
7229
7230	if (!errorreported)
7231	{
7232	#ifdef SIQ
7233	if (siq>0)
7234	{
7235	//Print("siq:%d\n",siq);
7236	command d=(command)omAlloc0Bin(ip_command_bin);
7237	memcpy(&d->arg1,a,sizeof(sleftv));
7238	//a->Init();
7239	d->op=op;
7240	d->argc=1;
7241	res->data=(char *)d;
7242	res->rtyp=COMMAND;
7243	return FALSE;
7244	}
7245	#endif
7246	int at=a->Typ();
7247	BOOLEAN failed=FALSE;
7248
7249	iiOp=op;
7250	int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
7251	int ti = i;
7252	while (dArith1[i].cmd==op)
7253	{
7254	if (at==dArith1[i].arg)
7255	{
7256	int r=res->rtyp=dArith1[i].res;
7257	#ifdef HAVE_PLURAL
7258	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7259	{
7260	if (dArith1[i].valid_for_plural==0 /NO_PLURAL/)
7261	{
7262	WerrorS(ii_not_for_plural);
7263	break;
7264	}
7265	else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7266	{
7267	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7268	}
7269	/* else ALLOW_PLURAL */
7270	}
7271	#endif
7272	if (r<0)
7273	{
7274	res->rtyp=-r;
7275	#ifdef PROC_BUG
7276	dArith1[i].p(res,a);
7277	#else
7278	res->data=(char )((Proc1)dArith1[i].p)((char )a->Data());
7279	#endif
7280	}
7281	else if (dArith1[i].p(res,a))
7282	{
7283	break;// leave loop, goto error handling
7284	}
7285	if (a->Next()!=NULL)
7286	{
7287	res->next=(leftv)omAllocBin(sleftv_bin);
7288	failed=iiExprArith1(res->next,a->next,op);
7289	}
7290	a->CleanUp();
7291	return failed;
7292	}
7293	i++;
7294	}
7295	// implicite type conversion --------------------------------------------
7296	if (dArith1[i].cmd!=op)
7297	{
7298	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7299	i=ti;
7300	//Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
7301	while (dArith1[i].cmd==op)
7302	{
7303	int ai;
7304	//Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
7305	if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
7306	{
7307	int r=res->rtyp=dArith1[i].res;
7308	#ifdef HAVE_PLURAL
7309	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7310	{
7311	if (dArith1[i].valid_for_plural==0 /NO_PLURAL/)
7312	{
7313	WerrorS(ii_not_for_plural);
7314	break;
7315	}
7316	else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7317	{
7318	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7319	}
7320	/* else ALLOW_PLURAL */
7321	}
7322	#endif
7323	if (r<0)
7324	{
7325	res->rtyp=-r;
7326	failed= iiConvert(at,dArith1[i].arg,ai,a,an);
7327	if (!failed)
7328	{
7329	#ifdef PROC_BUG
7330	dArith1[i].p(res,a);
7331	#else
7332	res->data=(char )((Proc1)dArith1[i].p)((char )an->Data());
7333	#endif
7334	}
7335	}
7336	else
7337	{
7338	failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
7339	\|\| (dArith1[i].p(res,an)));
7340	}
7341	// everything done, clean up temp. variables
7342	if (failed)
7343	{
7344	// leave loop, goto error handling
7345	break;
7346	}
7347	else
7348	{
7349	if (an->Next() != NULL)
7350	{
7351	res->next = (leftv)omAllocBin(sleftv_bin);
7352	failed=iiExprArith1(res->next,an->next,op);
7353	}
7354	// everything ok, clean up and return
7355	an->CleanUp();
7356	omFreeBin((ADDRESS)an, sleftv_bin);
7357	a->CleanUp();
7358	return failed;
7359	}
7360	}
7361	i++;
7362	}
7363	an->CleanUp();
7364	omFreeBin((ADDRESS)an, sleftv_bin);
7365	}
7366	// error handling
7367	if (!errorreported)
7368	{
7369	if ((at==0) && (a->Fullname()!=sNoName))
7370	{
7371	Werror("`%s` is not defined",a->Fullname());
7372	}
7373	else
7374	{
7375	i=ti;
7376	char *s = iiTwoOps(op);
7377	Werror("%s(`%s`) is not supported"
7378	,s,Tok2Cmdname(at));
7379	if (BVERBOSE(V_SHOW_USE))
7380	{
7381	while (dArith1[i].cmd==op)
7382	{
7383	if ((dArith1[i].res!=0)
7384	&& (dArith1[i].p!=jjWRONG))
7385	Werror("expected %s(`%s`)"
7386	,s,Tok2Cmdname(dArith1[i].arg));
7387	i++;
7388	}
7389	}
7390	}
7391	}
7392	res->rtyp = UNKNOWN;
7393	}
7394	a->CleanUp();
7395	#endif
7396	return TRUE;
7397	}
7398
7399	/=================== operations with 3 args. ============================/
7400
7401	BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
7402	{
7403	#ifndef GENTABLE
7404	memset(res,0,sizeof(sleftv));
7405
7406	if (!errorreported)
7407	{
7408	#ifdef SIQ
7409	if (siq>0)
7410	{
7411	//Print("siq:%d\n",siq);
7412	command d=(command)omAlloc0Bin(ip_command_bin);
7413	memcpy(&d->arg1,a,sizeof(sleftv));
7414	//a->Init();
7415	memcpy(&d->arg2,b,sizeof(sleftv));
7416	//b->Init();
7417	memcpy(&d->arg3,c,sizeof(sleftv));
7418	//c->Init();
7419	d->op=op;
7420	d->argc=3;
7421	res->data=(char *)d;
7422	res->rtyp=COMMAND;
7423	return FALSE;
7424	}
7425	#endif
7426	int at=a->Typ();
7427	int bt=b->Typ();
7428	int ct=c->Typ();
7429
7430	iiOp=op;
7431	int i=0;
7432	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7433	while (dArith3[i].cmd==op)
7434	{
7435	if ((at==dArith3[i].arg1)
7436	&& (bt==dArith3[i].arg2)
7437	&& (ct==dArith3[i].arg3))
7438	{
7439	res->rtyp=dArith3[i].res;
7440	#ifdef HAVE_PLURAL
7441	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7442	{
7443	if (dArith3[i].valid_for_plural==0 /NO_PLURAL/)
7444	{
7445	WerrorS(ii_not_for_plural);
7446	break;
7447	}
7448	else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7449	{
7450	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7451	}
7452	/* else ALLOW_PLURAL */
7453	}
7454	#endif
7455	if (dArith3[i].p(res,a,b,c))
7456	{
7457	break;// leave loop, goto error handling
7458	}
7459	a->CleanUp();
7460	b->CleanUp();
7461	c->CleanUp();
7462	return FALSE;
7463	}
7464	i++;
7465	}
7466	// implicite type conversion ----------------------------------------------
7467	if (dArith3[i].cmd!=op)
7468	{
7469	int ai,bi,ci;
7470	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7471	leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7472	leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
7473	BOOLEAN failed=FALSE;
7474	i=0;
7475	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7476	while (dArith3[i].cmd==op)
7477	{
7478	if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
7479	{
7480	if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
7481	{
7482	if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
7483	{
7484	res->rtyp=dArith3[i].res;
7485	#ifdef HAVE_PLURAL
7486	if ((currRing!=NULL)
7487	&& (rIsPluralRing(currRing)))
7488	{
7489	if (dArith3[i].valid_for_plural==0 /NO_PLURAL/)
7490	{
7491	WerrorS(ii_not_for_plural);
7492	break;
7493	}
7494	else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
7495	{
7496	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7497	}
7498	/* else ALLOW_PLURAL */
7499	}
7500	#endif
7501	failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
7502	\|\| (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
7503	\|\| (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
7504	\|\| (dArith3[i].p(res,an,bn,cn)));
7505	// everything done, clean up temp. variables
7506	if (failed)
7507	{
7508	// leave loop, goto error handling
7509	break;
7510	}
7511	else
7512	{
7513	// everything ok, clean up and return
7514	an->CleanUp();
7515	bn->CleanUp();
7516	cn->CleanUp();
7517	omFreeBin((ADDRESS)an, sleftv_bin);
7518	omFreeBin((ADDRESS)bn, sleftv_bin);
7519	omFreeBin((ADDRESS)cn, sleftv_bin);
7520	a->CleanUp();
7521	b->CleanUp();
7522	c->CleanUp();
7523	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7524	return FALSE;
7525	}
7526	}
7527	}
7528	}
7529	i++;
7530	}
7531	an->CleanUp();
7532	bn->CleanUp();
7533	cn->CleanUp();
7534	omFreeBin((ADDRESS)an, sleftv_bin);
7535	omFreeBin((ADDRESS)bn, sleftv_bin);
7536	omFreeBin((ADDRESS)cn, sleftv_bin);
7537	}
7538	// error handling ---------------------------------------------------
7539	if (!errorreported)
7540	{
7541	const char *s=NULL;
7542	if ((at==0) && (a->Fullname()!=sNoName))
7543	{
7544	s=a->Fullname();
7545	}
7546	else if ((bt==0) && (b->Fullname()!=sNoName))
7547	{
7548	s=b->Fullname();
7549	}
7550	else if ((ct==0) && (c->Fullname()!=sNoName))
7551	{
7552	s=c->Fullname();
7553	}
7554	if (s!=NULL)
7555	Werror("`%s` is not defined",s);
7556	else
7557	{
7558	i=0;
7559	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
7560	char *s = iiTwoOps(op);
7561	Werror("%s(`%s`,`%s`,`%s`) is not supported"
7562	,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
7563	if (BVERBOSE(V_SHOW_USE))
7564	{
7565	while (dArith3[i].cmd==op)
7566	{
7567	if(((at==dArith3[i].arg1)
7568	\|\|(bt==dArith3[i].arg2)
7569	\|\|(ct==dArith3[i].arg3))
7570	&& (dArith3[i].res!=0))
7571	{
7572	Werror("expected %s(`%s`,`%s`,`%s`)"
7573	,s,Tok2Cmdname(dArith3[i].arg1)
7574	,Tok2Cmdname(dArith3[i].arg2)
7575	,Tok2Cmdname(dArith3[i].arg3));
7576	}
7577	i++;
7578	}
7579	}
7580	}
7581	}
7582	res->rtyp = UNKNOWN;
7583	}
7584	a->CleanUp();
7585	b->CleanUp();
7586	c->CleanUp();
7587	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7588	#endif
7589	return TRUE;
7590	}
7591	/==================== operations with many arg. ===============================/
7592
7593	BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
7594	{
7595	// cnt = 0: all
7596	// cnt = 1: only first one
7597	leftv next;
7598	BOOLEAN failed = TRUE;
7599	if(v==NULL) return failed;
7600	res->rtyp = LIST_CMD;
7601	if(cnt) v->next = NULL;
7602	next = v->next; // saving next-pointer
7603	failed = jjLIST_PL(res, v);
7604	v->next = next; // writeback next-pointer
7605	return failed;
7606	}
7607
7608	BOOLEAN iiExprArithM(leftv res, leftv a, int op)
7609	{
7610	#ifndef GENTABLE
7611	memset(res,0,sizeof(sleftv));
7612
7613	if (!errorreported)
7614	{
7615	#ifdef SIQ
7616	if (siq>0)
7617	{
7618	//Print("siq:%d\n",siq);
7619	command d=(command)omAlloc0Bin(ip_command_bin);
7620	d->op=op;
7621	res->data=(char *)d;
7622	if (a!=NULL)
7623	{
7624	d->argc=a->listLength();
7625	// else : d->argc=0;
7626	memcpy(&d->arg1,a,sizeof(sleftv));
7627	switch(d->argc)
7628	{
7629	case 3:
7630	memcpy(&d->arg3,a->next->next,sizeof(sleftv));
7631	a->next->next->Init();
7632	/* no break */
7633	case 2:
7634	memcpy(&d->arg2,a->next,sizeof(sleftv));
7635	a->next->Init();
7636	a->next->next=d->arg2.next;
7637	d->arg2.next=NULL;
7638	/* no break */
7639	case 1:
7640	a->Init();
7641	a->next=d->arg1.next;
7642	d->arg1.next=NULL;
7643	}
7644	if (d->argc>3) a->next=NULL;
7645	a->name=NULL;
7646	a->rtyp=0;
7647	a->data=NULL;
7648	a->e=NULL;
7649	a->attribute=NULL;
7650	a->CleanUp();
7651	}
7652	res->rtyp=COMMAND;
7653	return FALSE;
7654	}
7655	#endif
7656	BOOLEAN failed=FALSE;
7657	int args=0;
7658	if (a!=NULL) args=a->listLength();
7659
7660	iiOp=op;
7661	int i=0;
7662	while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
7663	while (dArithM[i].cmd==op)
7664	{
7665	if ((args==dArithM[i].number_of_args)
7666	\|\| (dArithM[i].number_of_args==-1)
7667	\|\| ((dArithM[i].number_of_args==-2)&&(args>0)))
7668	{
7669	res->rtyp=dArithM[i].res;
7670	#ifdef HAVE_PLURAL
7671	if ((currRing!=NULL)
7672	&& (rIsPluralRing(currRing)))
7673	{
7674	if (dArithM[i].valid_for_plural==0 /NO_PLURAL/)
7675	{
7676	WerrorS(ii_not_for_plural);
7677	break;
7678	}
7679	else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
7680	{
7681	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7682	}
7683	/* else ALLOW_PLURAL */
7684	}
7685	#endif
7686	if (dArithM[i].p(res,a))
7687	{
7688	break;// leave loop, goto error handling
7689	}
7690	if (a!=NULL) a->CleanUp();
7691	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7692	return failed;
7693	}
7694	i++;
7695	}
7696	// error handling
7697	if (!errorreported)
7698	{
7699	if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
7700	{
7701	Werror("`%s` is not defined",a->Fullname());
7702	}
7703	else
7704	{
7705	char *s = iiTwoOps(op);
7706	Werror("%s(...) is not supported",s);
7707	}
7708	}
7709	res->rtyp = UNKNOWN;
7710	}
7711	if (a!=NULL) a->CleanUp();
7712	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7713	#endif
7714	return TRUE;
7715	}
7716
7717	/=================== general utilities ============================/
7718	int IsCmd(const char *n, int & tok)
7719	{
7720	#ifndef GENTABLE
7721	int i;
7722	int an=1;
7723	int en=sArithBase.nLastIdentifier;
7724
7725	loop
7726	//for(an=0; an<sArithBase.nCmdUsed; )
7727	{
7728	if(an>=en-1)
7729	{
7730	if (strcmp(n, sArithBase.sCmds[an].name) == 0)
7731	{
7732	i=an;
7733	break;
7734	}
7735	else if ((an!=en) && (strcmp(n, sArithBase.sCmds[en].name) == 0))
7736	{
7737	i=en;
7738	break;
7739	}
7740	else
7741	{
7742	return 0;
7743	}
7744	}
7745	i=(an+en)/2;
7746	if (n < (sArithBase.sCmds[i].name))
7747	{
7748	en=i-1;
7749	}
7750	else if (n > (sArithBase.sCmds[i].name))
7751	{
7752	an=i+1;
7753	}
7754	else
7755	{
7756	int v=strcmp(n,sArithBase.sCmds[i].name);
7757	if(v<0)
7758	{
7759	en=i-1;
7760	}
7761	else if(v>0)
7762	{
7763	an=i+1;
7764	}
7765	else /v==0/
7766	{
7767	break;
7768	}
7769	}
7770	}
7771	lastreserved=sArithBase.sCmds[i].name;
7772	tok=sArithBase.sCmds[i].tokval;
7773	if(sArithBase.sCmds[i].alias==2)
7774	{
7775	Warn("outdated identifier `%s` used - please change your code",
7776	sArithBase.sCmds[i].name);
7777	sArithBase.sCmds[i].alias=1;
7778	}
7779	if (currRingHdl==NULL)
7780	{
7781	#ifdef SIQ
7782	if (siq<=0)
7783	{
7784	#endif
7785	if ((tok>=BEGIN_RING) && (tok<=END_RING))
7786	{
7787	WerrorS("no ring active");
7788	return 0;
7789	}
7790	#ifdef SIQ
7791	}
7792	#endif
7793	}
7794	if (!expected_parms)
7795	{
7796	switch (tok)
7797	{
7798	case IDEAL_CMD:
7799	case INT_CMD:
7800	case INTVEC_CMD:
7801	case MAP_CMD:
7802	case MATRIX_CMD:
7803	case MODUL_CMD:
7804	case POLY_CMD:
7805	case PROC_CMD:
7806	case RING_CMD:
7807	case STRING_CMD:
7808	cmdtok = tok;
7809	break;
7810	}
7811	}
7812	return sArithBase.sCmds[i].toktype;
7813	#else
7814	return 0;
7815	#endif
7816	}
7817	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
7818	{
7819	#ifndef GENTABLE
7820	int a=0;
7821	int e=len;
7822	int p=len/2;
7823	do
7824	{
7825	if (op==dArithTab[p].cmd) return dArithTab[p].start;
7826	if (op<dArithTab[p].cmd) e=p-1;
7827	else a = p+1;
7828	p=a+(e-a)/2;
7829	}
7830	while ( a <= e);
7831
7832	#endif
7833	assume(0);
7834	return 0;
7835	}
7836
7837	#ifdef GENTABLE
7838	char * Tok2Cmdname(int tok)
7839	{
7840	int i = 0;
7841	if (tok < 0)
7842	{
7843	return cmds[0].name;
7844	}
7845	if (tok==ANY_TYPE) return "any_type";
7846	if (tok==NONE) return "nothing";
7847	//if (tok==IFBREAK) return "if_break";
7848	//if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
7849	//if (tok==ORDER_VECTOR) return "ordering";
7850	//if (tok==REF_VAR) return "ref";
7851	//if (tok==OBJECT) return "object";
7852	//if (tok==PRINT_EXPR) return "print_expr";
7853	if (tok==IDHDL) return "identifier";
7854	while (cmds[i].tokval!=0)
7855	{
7856	if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
7857	{
7858	return cmds[i].name;
7859	}
7860	i++;
7861	}
7862	return cmds[0].name;
7863	}
7864	#else /* GENTABLE */
7865	char * Tok2Cmdname(int tok)
7866	{
7867	int i = 0;
7868	if (tok <= 0)
7869	{
7870	return sArithBase.sCmds[0].name;
7871	}
7872	if (tok==ANY_TYPE) return "any_type";
7873	if (tok==NONE) return "nothing";
7874	//if (tok==IFBREAK) return "if_break";
7875	//if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
7876	//if (tok==ORDER_VECTOR) return "ordering";
7877	//if (tok==REF_VAR) return "ref";
7878	//if (tok==OBJECT) return "object";
7879	//if (tok==PRINT_EXPR) return "print_expr";
7880	if (tok==IDHDL) return "identifier";
7881	for(i=0; i<sArithBase.nCmdUsed; i++)
7882	//while (sArithBase.sCmds[i].tokval!=0)
7883	{
7884	if ((sArithBase.sCmds[i].tokval == tok)&&
7885	(sArithBase.sCmds[i].alias==0))
7886	{
7887	return sArithBase.sCmds[i].name;
7888	}
7889	}
7890	return sArithBase.sCmds[0].name;
7891	}
7892	#endif /* GENTABLE */
7893
7894
7895	/---------------------------------------------------------------------/
7896	/**
7897	* @brief compares to entry of cmdsname-list
7898
7899	@param[in] a
7900	@param[in] b
7901
7902	@return <ReturnValue>
7903	**/
7904	/---------------------------------------------------------------------/
7905	static int _gentable_sort_cmds( const void a, const void b )
7906	{
7907	cmdnames pCmdL = (cmdnames)a;
7908	cmdnames pCmdR = (cmdnames)b;
7909
7910	if(a==NULL \|\| b==NULL) return 0;
7911
7912	/* empty entries goes to the end of the list for later reuse */
7913	if(pCmdL->name==NULL) return 1;
7914	if(pCmdR->name==NULL) return -1;
7915
7916	/* $INVALID$ must come first */
7917	if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
7918	if(strcmp(pCmdR->name, "$INVALID$")==0) return 1;
7919
7920	/* tokval=-1 are reserved names at the end */
7921	if (pCmdL->tokval==-1)
7922	{
7923	if (pCmdR->tokval==-1)
7924	return strcmp(pCmdL->name, pCmdR->name);
7925	/* pCmdL->tokval==-1, pCmdL goes at the end */
7926	return 1;
7927	}
7928	/* pCmdR->tokval==-1, pCmdR goes at the end */
7929	if(pCmdR->tokval==-1) return -1;
7930
7931	return strcmp(pCmdL->name, pCmdR->name);
7932	}
7933
7934	/---------------------------------------------------------------------/
7935	/**
7936	* @brief initialisation of arithmetic structured data
7937
7938	@retval 0 on success
7939
7940	**/
7941	/---------------------------------------------------------------------/
7942	int iiInitArithmetic()
7943	{
7944	int i;
7945	//printf("iiInitArithmetic()\n");
7946	#ifndef GENTABLE
7947	memset(&sArithBase, 0, sizeof(sArithBase));
7948	iiInitCmdName();
7949	/* fix last-identifier */
7950	#if 0
7951	/* we expect that gentable allready did every thing */
7952	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
7953	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--) {
7954	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
7955	}
7956	#endif
7957	//Print("L=%d\n", sArithBase.nLastIdentifier);
7958
7959	//iiArithAddCmd(szName, nAlias, nTokval, nToktype);
7960	//iiArithAddCmd("mygcd", 1, GCD_CMD, CMD_2);
7961
7962	//iiArithAddCmd("Top", 0,-1,0);
7963
7964
7965	//for(i=0; i<sArithBase.nCmdUsed; i++) {
7966	// printf("CMD[%03d] %s, %d, %d, %d\n", i,
7967	// sArithBase.sCmds[i].name,
7968	// sArithBase.sCmds[i].alias,
7969	// sArithBase.sCmds[i].tokval,
7970	// sArithBase.sCmds[i].toktype);
7971	//}
7972	//iiArithRemoveCmd("Top");
7973	//iiArithAddCmd("mygcd", 2, GCD_CMD, CMD_2);
7974	//iiArithRemoveCmd("mygcd");
7975	//iiArithAddCmd("kkk", 1, 1234, CMD_1);
7976	#endif /* !GENTABLE */
7977	return 0;
7978	}
7979
7980	/---------------------------------------------------------------------/
7981	/**
7982	* @brief append newitem of size sizeofitem to the list named list.
7983
7984	@param[in,out] list
7985	@param[in,out] item_count
7986	@param[in] sizeofitem
7987	@param[in] newitem
7988
7989	@retval 0 success
7990	@retval -1 failure
7991	**/
7992	/---------------------------------------------------------------------/
7993	int iiArithAddItem2list(
7994	void **list,
7995	long *item_count,
7996	long sizeofitem,
7997	void *newitem
7998	)
7999	{
8000	int count = *item_count;
8001
8002	//TRACE(0, "add_item_to_list(%p, %p, %ld, %p)\n", list, item_count,
8003	// sizeofitem, newitem);
8004
8005	if(count==0)
8006	{
8007	list = (void )omAlloc(sizeofitem);
8008	}
8009	else
8010	{
8011	list = (void )omRealloc(list, (count+1) sizeofitem);
8012	}
8013	if((*list)==NULL) return -1;
8014
8015	//memset((list)+countsizeofitem, 0, sizeofitem);
8016	//memcpy((list)+countsizeofitem, newitem, sizeofitem);
8017
8018	/* erhoehe counter um 1 */
8019	(count)++;
8020	*item_count = count;
8021	return 0;
8022	}
8023
8024	int iiArithFindCmd(const char *szName)
8025	{
8026	#ifndef GENTABLE
8027	int an=0;
8028	int i = 0,v = 0;
8029	int en=sArithBase.nLastIdentifier;
8030
8031	loop
8032	//for(an=0; an<sArithBase.nCmdUsed; )
8033	{
8034	if(an>=en-1)
8035	{
8036	if (strcmp(szName, sArithBase.sCmds[an].name) == 0)
8037	{
8038	//Print("RET-an=%d %s\n", an, sArithBase.sCmds[an].name);
8039	return an;
8040	}
8041	else if (strcmp(szName, sArithBase.sCmds[en].name) == 0)
8042	{
8043	//Print("RET-en=%d %s\n", en, sArithBase.sCmds[en].name);
8044	return en;
8045	}
8046	else
8047	{
8048	//Print("RET- 1\n");
8049	return -1;
8050	}
8051	}
8052	i=(an+en)/2;
8053	if (szName < (sArithBase.sCmds[i].name))
8054	{
8055	en=i-1;
8056	}
8057	else if (szName > (sArithBase.sCmds[i].name))
8058	{
8059	an=i+1;
8060	}
8061	else
8062	{
8063	v=strcmp(szName,sArithBase.sCmds[i].name);
8064	if(v<0)
8065	{
8066	en=i-1;
8067	}
8068	else if(v>0)
8069	{
8070	an=i+1;
8071	}
8072	else /v==0/
8073	{
8074	//Print("RET-i=%d %s\n", i, sArithBase.sCmds[i].name);
8075	return i;
8076	}
8077	}
8078	}
8079	//if(i>=0 && i<sArithBase.nCmdUsed)
8080	// return i;
8081	//Print("RET-2\n");
8082	return -2;
8083	#else
8084	return 0;
8085	#endif
8086	}
8087
8088	char *iiArithGetCmd( int nPos )
8089	{
8090	if(nPos<0) return NULL;
8091	if(nPos<sArithBase.nCmdUsed)
8092	return sArithBase.sCmds[nPos].name;
8093	return NULL;
8094	}
8095
8096	int iiArithRemoveCmd( char *szName)
8097	{
8098	int nIndex;
8099	if(szName==NULL) return -1;
8100
8101	nIndex = iiArithFindCmd(szName);
8102	if(nIndex<0 \|\| nIndex>=sArithBase.nCmdUsed)
8103	{
8104	Print("'%s' not found (%d)\n", szName, nIndex);
8105	return -1;
8106	}
8107	omFree(sArithBase.sCmds[nIndex].name);
8108	sArithBase.sCmds[nIndex].name=0;
8109	qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8110	(&_gentable_sort_cmds));
8111	sArithBase.nCmdUsed--;
8112
8113	/* fix last-identifier */
8114	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8115	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8116	{
8117	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8118	}
8119	//Print("L=%d\n", sArithBase.nLastIdentifier);
8120	return 0;
8121	}
8122
8123	int iiArithAddCmd(
8124	char *szName,
8125	short nAlias,
8126	short nTokval,
8127	short nToktype,
8128	short nPos
8129	)
8130	{
8131	//printf("AddCmd(%s, %d, %d, %d, %d)\n", szName, nAlias,
8132	// nTokval, nToktype, nPos);
8133	if(nPos>=0)
8134	{
8135	// no checks: we rely on a correct generated code in iparith.inc
8136	assume(nPos < sArithBase.nCmdAllocated);
8137	assume(szName!=NULL);
8138	sArithBase.sCmds[nPos].name = omStrDup(szName);
8139	sArithBase.sCmds[nPos].alias = nAlias;
8140	sArithBase.sCmds[nPos].tokval = nTokval;
8141	sArithBase.sCmds[nPos].toktype = nToktype;
8142	sArithBase.nCmdUsed++;
8143	//if(nTokval>0) sArithBase.nLastIdentifier++;
8144	}
8145	else
8146	{
8147	if(szName==NULL) return -1;
8148	int nIndex = iiArithFindCmd(szName);
8149	if(nIndex>=0)
8150	{
8151	Print("'%s' already exists at %d\n", szName, nIndex);
8152	return -1;
8153	}
8154
8155	if(sArithBase.nCmdUsed>=sArithBase.nCmdAllocated)
8156	{
8157	/* needs to create new slots */
8158	unsigned long nSize = (sArithBase.nCmdAllocated+1)*sizeof(cmdnames);
8159	sArithBase.sCmds = (cmdnames *)omRealloc(sArithBase.sCmds, nSize);
8160	if(sArithBase.sCmds==NULL) return -1;
8161	sArithBase.nCmdAllocated++;
8162	}
8163	/* still free slots available */
8164	sArithBase.sCmds[sArithBase.nCmdUsed].name = omStrDup(szName);
8165	sArithBase.sCmds[sArithBase.nCmdUsed].alias = nAlias;
8166	sArithBase.sCmds[sArithBase.nCmdUsed].tokval = nTokval;
8167	sArithBase.sCmds[sArithBase.nCmdUsed].toktype = nToktype;
8168	sArithBase.nCmdUsed++;
8169
8170	qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8171	(&_gentable_sort_cmds));
8172	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8173	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8174	{
8175	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8176	}
8177	//Print("L=%d\n", sArithBase.nLastIdentifier);
8178	}
8179	return 0;
8180	}
8181
8182	#ifdef GENTABLE
8183	// some special cmds which do not fit in with the others, and
8184	// nevertheless need to be transmitted
8185	short ExtraCmds[] =
8186	{
8187	OPTION_CMD,
8188	NAMES_CMD,
8189	// RESERVEDNAME_CMD,
8190	PROC_CMD,
8191	MAP_CMD,
8192	PACKAGE_CMD,
8193	'=',
8194	0
8195	};
8196
8197	// This returns 1 if tok is a token which can appear in a Singular
8198	// (quoted) command, and 0 otherwise
8199	short IsCmdToken(short tok)
8200	{
8201	int i = 0;
8202	// cmds with one arg
8203	while (dArith1[i].cmd != 0)
8204	if (dArith1[i].cmd == tok) return 1;
8205	else i++;
8206
8207	// cmds with two args
8208	i=0;
8209	while (dArith2[i].cmd != 0)
8210	if (dArith2[i].cmd == tok) return 1;
8211	else i++;
8212
8213	// cmds with three args
8214	i=0;
8215	while (dArith3[i].cmd != 0)
8216	if (dArith3[i].cmd == tok) return 1;
8217	else i++;
8218
8219	// cmds with many args
8220	i=0;
8221	while (dArithM[i].cmd != 0)
8222	if (dArithM[i].cmd == tok) return 1;
8223	else i++;
8224
8225	// cmds which are somewhat special (like those having 0 args)
8226	i=0;
8227	while (ExtraCmds[i] != 0)
8228	if (ExtraCmds[i] == tok) return 1;
8229	else i++;
8230
8231	return 0;
8232	}
8233	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: