Context Navigation

source: git/Singular/iparith.cc @ b863e9

spielwiese

Last change on this file since b863e9 was b863e9, checked in by Hans Schönemann <hannes@…>, 17 years ago
*hannes: better error message: intmat compare git-svn-id: file:///usr/local/Singular/svn/trunk@9893 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 240.0 KB

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

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

Download in other formats: