Context Navigation

source: git/Singular/iparith.cc @ 35ee46c

spielwiese

Last change on this file since 35ee46c was 35ee46c, checked in by Hans Schönemann <hannes@…>, 17 years ago
*hannes: 64bit: jjLONG2N git-svn-id: file:///usr/local/Singular/svn/trunk@9736 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 239.8 KB

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

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

Download in other formats: