Context Navigation

source: git/Singular/iparith.cc @ 8f63da5

spielwiese

Last change on this file since 8f63da5 was 8f63da5, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes; mpresmat re-activated git-svn-id: file:///usr/local/Singular/svn/trunk@9457 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 237.1 KB

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

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

Download in other formats: