Context Navigation

source: git/Singular/iparith.cc @ 3ab391

spielwiese

Last change on this file since 3ab391 was 3ab391, checked in by Motsak Oleksandr <motsak@…>, 15 years ago
*motsak: jacob for modules git-svn-id: file:///usr/local/Singular/svn/trunk@11323 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 250.7 KB

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

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

Download in other formats: