Context Navigation

iparith.cc @ a02569

spielwiese

Last change on this file since a02569 was a02569, checked in by Hans Schönemann <hannes@…>, 17 years ago
*hannes: better error handling (large exp. in monom) git-svn-id: file:///usr/local/Singular/svn/trunk@9448 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 237.2 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/* $Id: iparith.cc,v 1.414 2006-10-06 14:47:45 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 jjLOAD2(leftv res, leftv v, leftv w)
2126	{
2127	return jjLOAD(res, v,(int)(long)w->Data());
2128	}
2129	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2130	{
2131	res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2132	return (res->data==NULL);
2133	}
2134	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2135	{
2136	intvec w_u=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2137	tHomog hom=testHomog;
2138	if (w_u!=NULL)
2139	{
2140	w_u=ivCopy(w_u);
2141	hom=isHomog;
2142	}
2143	intvec w_v=(intvec )atGet(v,"isHomog",INTVEC_CMD);
2144	if (w_v!=NULL)
2145	{
2146	w_v=ivCopy(w_v);
2147	hom=isHomog;
2148	}
2149	if ((w_u!=NULL) && (w_v==NULL))
2150	w_v=ivCopy(w_u);
2151	if ((w_v!=NULL) && (w_u==NULL))
2152	w_u=ivCopy(w_v);
2153	ideal u_id=(ideal)u->Data();
2154	ideal v_id=(ideal)v->Data();
2155	if (w_u!=NULL)
2156	{
2157	if ((*w_u).compare((w_v))!=0)
2158	{
2159	WarnS("incompatible weights");
2160	delete w_u; w_u=NULL;
2161	hom=testHomog;
2162	}
2163	else
2164	{
2165	if ((!idTestHomModule(u_id,currQuotient,w_v))
2166	\|\| (!idTestHomModule(v_id,currQuotient,w_v)))
2167	{
2168	WarnS("wrong weights");
2169	delete w_u; w_u=NULL;
2170	hom=testHomog;
2171	}
2172	}
2173	}
2174	res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2175	if (w_u!=NULL)
2176	{
2177	atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2178	}
2179	delete w_v;
2180	return FALSE;
2181	}
2182	static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2183	{
2184	number q=(number)v->Data();
2185	if (nlIsZero(q))
2186	{
2187	WerrorS(ii_div_by_0);
2188	return TRUE;
2189	}
2190	res->data =(char *) nlIntMod((number)u->Data(),q);
2191	return FALSE;
2192	}
2193	static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2194	{
2195	number q=(number)v->Data();
2196	if (nIsZero(q))
2197	{
2198	WerrorS(ii_div_by_0);
2199	return TRUE;
2200	}
2201	res->data =(char *) nIntMod((number)u->Data(),q);
2202	return FALSE;
2203	}
2204	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2205	{
2206	char opt=(char )v->Data();
2207	int mode=0;
2208	while(*opt!='\0')
2209	{
2210	if (*opt=='i') mode \|= PROT_I;
2211	else if (*opt=='o') mode \|= PROT_O;
2212	opt++;
2213	}
2214	monitor((char *)(u->Data()),mode);
2215	return FALSE;
2216	}
2217	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2218	{
2219	idhdl h=(idhdl)u->data;
2220	int i=(int)(long)v->Data();
2221	int p=0;
2222	if ((0<i)
2223	&& (IDRING(h)->parameter!=NULL)
2224	&& (i<=(p=rPar(IDRING(h)))))
2225	res->data=omStrDup(IDRING(h)->parameter[i-1]);
2226	else
2227	{
2228	Werror("par number %d out of range 1..%d",i,p);
2229	return TRUE;
2230	}
2231	return FALSE;
2232	}
2233
2234	#ifdef HAVE_PLURAL
2235	static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2236	{
2237	return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2238	}
2239
2240	static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2241	{
2242	return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2243	}
2244
2245	static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2246	{
2247	return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2248	}
2249
2250	static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2251	{
2252	return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2253	}
2254
2255	static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2256	{
2257	if (rIsPluralRing(currRing))
2258	{
2259	poly p = (poly)a->CopyD(POLY_CMD);
2260	poly q = (poly)b->Data();
2261	res->data = nc_p_Bracket_qq(p,q);
2262	}
2263	else res->data=NULL;
2264	return FALSE;
2265	}
2266
2267	static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2268	{
2269	/* number, poly, vector, ideal, module, matrix */
2270	ring r = (ring)a->Data();
2271	if (r == currRing)
2272	{
2273	res->data = b->Data();
2274	res->rtyp = b->rtyp;
2275	return FALSE;
2276	}
2277	if (!rIsLikeOpposite(currRing, r))
2278	{
2279	Werror("%s is not an opposite ring to current ring",a->Fullname());
2280	return TRUE;
2281	}
2282	idhdl w;
2283	if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2284	{
2285	int argtype = IDTYP(w);
2286	switch (argtype)
2287	{
2288	case NUMBER_CMD:
2289	{
2290	/* since basefields are equal, we can apply nCopy */
2291	res->data = nCopy((number)IDDATA(w));
2292	res->rtyp = argtype;
2293	break;
2294	}
2295	case POLY_CMD:
2296	case VECTOR_CMD:
2297	{
2298	poly q = (poly)IDDATA(w);
2299	res->data = pOppose(r,q);
2300	res->rtyp = argtype;
2301	break;
2302	}
2303	case IDEAL_CMD:
2304	case MODUL_CMD:
2305	{
2306	ideal Q = (ideal)IDDATA(w);
2307	res->data = idOppose(r,Q);
2308	res->rtyp = argtype;
2309	break;
2310	}
2311	case MATRIX_CMD:
2312	{
2313	ring save = currRing;
2314	rChangeCurrRing(r);
2315	matrix m = (matrix)IDDATA(w);
2316	ideal Q = idMatrix2Module(mpCopy(m));
2317	rChangeCurrRing(save);
2318	ideal S = idOppose(r,Q);
2319	id_Delete(&Q, r);
2320	res->data = idModule2Matrix(S);
2321	res->rtyp = argtype;
2322	break;
2323	}
2324	default:
2325	{
2326	WerrorS("unsupported type in oppose");
2327	return TRUE;
2328	}
2329	}
2330	}
2331	else
2332	{
2333	Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2334	return TRUE;
2335	}
2336	return FALSE;
2337	}
2338	#endif /* HAVE_PLURAL */
2339
2340	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2341	{
2342	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2343	hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2344	idDelMultiples((ideal)(res->data));
2345	return FALSE;
2346	}
2347	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2348	{
2349	int i=(int)(long)u->Data();
2350	int j=(int)(long)v->Data();
2351	#ifdef buildin_rand
2352	res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
2353	#else /* buildin_rand */
2354	res->data =(char *)(long)((i > j) ? i : (rand() % (j-i+1)) + i);
2355	#endif /* buildin_rand */
2356	return FALSE;
2357	}
2358	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2359	{
2360	si_link l=(si_link)u->Data();
2361	leftv r=slRead(l,v);
2362	if (r==NULL)
2363	{
2364	const char *s;
2365	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2366	else s=sNoName;
2367	Werror("cannot read from `%s`",s);
2368	return TRUE;
2369	}
2370	memcpy(res,r,sizeof(sleftv));
2371	omFreeBin((ADDRESS)r, sleftv_bin);
2372	return FALSE;
2373	}
2374	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2375	{
2376	assumeStdFlag(v);
2377	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2378	return FALSE;
2379	}
2380	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2381	{
2382	assumeStdFlag(v);
2383	ideal ui=(ideal)u->Data();
2384	idTest(ui);
2385	ideal vi=(ideal)v->Data();
2386	idTest(vi);
2387	res->data = (char *)kNF(vi,currQuotient,ui);
2388	return FALSE;
2389	}
2390	#if 0
2391	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2392	{
2393	int maxl=(int)(long)v->Data();
2394	if (maxl<0)
2395	{
2396	WerrorS("length for res must not be negative");
2397	return TRUE;
2398	}
2399	int l=0;
2400	//resolvente r;
2401	syStrategy r;
2402	intvec *weights=NULL;
2403	int wmaxl=maxl;
2404	ideal u_id=(ideal)u->Data();
2405
2406	maxl--;
2407	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2408	{
2409	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2410	if (currQuotient!=NULL)
2411	{
2412	Warn(
2413	"full resolution in a qring may be infinite, setting max length to %d",
2414	maxl+1);
2415	}
2416	}
2417	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2418	if (weights!=NULL)
2419	{
2420	if (!idTestHomModule(u_id,currQuotient,weights))
2421	{
2422	WarnS("wrong weights given:");weights->show();PrintLn();
2423	weights=NULL;
2424	}
2425	}
2426
2427	intvec *ww=NULL;
2428	int add_row_shift=0;
2429	if (weights!=NULL)
2430	{
2431	ww=ivCopy(weights);
2432	add_row_shift = ww->min_in();
2433	(*ww) -= add_row_shift;
2434	}
2435	else
2436	idHomModule(u_id,currQuotient,&ww);
2437	weights=ww;
2438
2439	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2440	{
2441	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2442	}
2443	else if (iiOp==SRES_CMD)
2444	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2445	r=sySchreyer(u_id,maxl+1);
2446	else if (iiOp == LRES_CMD)
2447	{
2448	int dummy;
2449	if((currQuotient!=NULL)\|\|
2450	(!idHomIdeal (u_id,NULL)))
2451	{
2452	WerrorS
2453	("`lres` not implemented for inhomogeneous input or qring");
2454	return TRUE;
2455	}
2456	r=syLaScala3(u_id,&dummy);
2457	}
2458	else if (iiOp == KRES_CMD)
2459	{
2460	int dummy;
2461	if((currQuotient!=NULL)\|\|
2462	(!idHomIdeal (u_id,NULL)))
2463	{
2464	WerrorS
2465	("`kres` not implemented for inhomogeneous input or qring");
2466	return TRUE;
2467	}
2468	r=syKosz(u_id,&dummy);
2469	}
2470	else
2471	{
2472	int dummy;
2473	if((currQuotient!=NULL)\|\|
2474	(!idHomIdeal (u_id,NULL)))
2475	{
2476	WerrorS
2477	("`hres` not implemented for inhomogeneous input or qring");
2478	return TRUE;
2479	}
2480	r=syHilb(u_id,&dummy);
2481	}
2482	if (r==NULL) return TRUE;
2483	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2484	r->list_length=wmaxl;
2485	res->data=(void *)r;
2486	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2487	{
2488	intvec *w=ivCopy(r->weights[0]);
2489	if (weights!=NULL) (*w) += add_row_shift;
2490	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2491	delete w;
2492	}
2493	else
2494	{
2495	//#if 0
2496	// need to set weights for ALL components (sres)
2497	if (weights!=NULL)
2498	{
2499	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2500	r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2501	(r->weights)[0] = ivCopy(weights);
2502	}
2503	//#endif
2504	}
2505	if (ww!=NULL) { delete ww; ww=NULL; }
2506	return FALSE;
2507	}
2508	#else
2509	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2510	{
2511	int maxl=(int)(long)v->Data();
2512	if (maxl<0)
2513	{
2514	WerrorS("length for res must not be negative");
2515	return TRUE;
2516	}
2517	int l=0;
2518	//resolvente r;
2519	syStrategy r;
2520	intvec *weights=NULL;
2521	int wmaxl=maxl;
2522	ideal u_id=(ideal)u->Data();
2523
2524	maxl--;
2525	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2526	{
2527	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2528	if (currQuotient!=NULL)
2529	{
2530	Warn(
2531	"full resolution in a qring may be infinite, setting max length to %d",
2532	maxl+1);
2533	}
2534	}
2535	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2536	if (weights!=NULL)
2537	{
2538	if (!idTestHomModule(u_id,currQuotient,weights))
2539	{
2540	WarnS("wrong weights given:");weights->show();PrintLn();
2541	weights=NULL;
2542	}
2543	}
2544	intvec *ww=NULL;
2545	int add_row_shift=0;
2546	if (weights!=NULL)
2547	{
2548	ww=ivCopy(weights);
2549	add_row_shift = ww->min_in();
2550	(*ww) -= add_row_shift;
2551	}
2552
2553	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2554	{
2555	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2556	}
2557	else if (iiOp==SRES_CMD)
2558	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2559	r=sySchreyer(u_id,maxl+1);
2560	else if (iiOp == LRES_CMD)
2561	{
2562	int dummy;
2563	if((currQuotient!=NULL)\|\|
2564	(!idHomIdeal (u_id,NULL)))
2565	{
2566	WerrorS
2567	("`lres` not implemented for inhomogeneous input or qring");
2568	return TRUE;
2569	}
2570	r=syLaScala3(u_id,&dummy);
2571	}
2572	else if (iiOp == KRES_CMD)
2573	{
2574	int dummy;
2575	if((currQuotient!=NULL)\|\|
2576	(!idHomIdeal (u_id,NULL)))
2577	{
2578	WerrorS
2579	("`kres` not implemented for inhomogeneous input or qring");
2580	return TRUE;
2581	}
2582	r=syKosz(u_id,&dummy);
2583	}
2584	else
2585	{
2586	int dummy;
2587	if((currQuotient!=NULL)\|\|
2588	(!idHomIdeal (u_id,NULL)))
2589	{
2590	WerrorS
2591	("`hres` not implemented for inhomogeneous input or qring");
2592	return TRUE;
2593	}
2594	r=syHilb(u_id,&dummy);
2595	}
2596	if (r==NULL) return TRUE;
2597	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2598	r->list_length=wmaxl;
2599	res->data=(void *)r;
2600	if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2601	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2602	{
2603	ww=ivCopy(r->weights[0]);
2604	if (weights!=NULL) (*ww) += add_row_shift;
2605	atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2606	}
2607	else
2608	{
2609	if (weights!=NULL)
2610	{
2611	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2612	}
2613	}
2614	return FALSE;
2615	}
2616	#endif
2617	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2618	{
2619	ring r;
2620	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2621	res->data = (char *)r;
2622	return (i==-1);
2623	}
2624	#define SIMPL_LMDIV 32
2625	#define SIMPL_LMEQ 16
2626	#define SIMPL_MULT 8
2627	#define SIMPL_EQU 4
2628	#define SIMPL_NULL 2
2629	#define SIMPL_NORM 1
2630	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2631	{
2632	int sw = (int)(long)v->Data();
2633	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2634	ideal id = (ideal)u->CopyD(IDEAL_CMD);
2635	if (sw & SIMPL_LMDIV)
2636	{
2637	idDelDiv(id);
2638	}
2639	if (sw & SIMPL_LMEQ)
2640	{
2641	idDelLmEquals(id);
2642	}
2643	if (sw & SIMPL_NULL)
2644	{
2645	idSkipZeroes(id);
2646	}
2647	if (sw & SIMPL_NORM)
2648	{
2649	idNorm(id);
2650	}
2651	if (sw & SIMPL_MULT)
2652	{
2653	idDelMultiples(id);
2654	}
2655	else if(sw & SIMPL_EQU)
2656	{
2657	idDelEquals(id);
2658	}
2659	res->data = (char * )id;
2660	return FALSE;
2661	}
2662	#ifdef HAVE_FACTORY
2663	extern int singclap_factorize_retry;
2664	static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2665	{
2666	intvec *v=NULL;
2667	int sw=(int)(long)dummy->Data();
2668	int fac_sw=sw;
2669	if ((sw<0)\|\|(sw>2)) fac_sw=1;
2670	singclap_factorize_retry=0;
2671	ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2672	if (f==NULL)
2673	return TRUE;
2674	switch(sw)
2675	{
2676	case 0:
2677	case 2:
2678	{
2679	lists l=(lists)omAllocBin(slists_bin);
2680	l->Init(2);
2681	l->m[0].rtyp=IDEAL_CMD;
2682	l->m[0].data=(void *)f;
2683	l->m[1].rtyp=INTVEC_CMD;
2684	l->m[1].data=(void *)v;
2685	res->data=(void *)l;
2686	res->rtyp=LIST_CMD;
2687	return FALSE;
2688	}
2689	case 1:
2690	res->data=(void *)f;
2691	return FALSE;
2692	case 3:
2693	{
2694	poly p=f->m[0];
2695	int i=IDELEMS(f);
2696	f->m[0]=NULL;
2697	while(i>1)
2698	{
2699	i--;
2700	p=pMult(p,f->m[i]);
2701	f->m[i]=NULL;
2702	}
2703	res->data=(void *)p;
2704	res->rtyp=POLY_CMD;
2705	}
2706	return FALSE;
2707	}
2708	WerrorS("invalid switch");
2709	return TRUE;
2710	}
2711	#endif
2712	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2713	{
2714	res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2715	return FALSE;
2716	}
2717	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2718	{
2719	int sw = (int)(long)v->Data();
2720	// CopyD for POLY_CMD and VECTOR_CMD are identical:
2721	poly p = (poly)u->CopyD(POLY_CMD);
2722	if (sw & SIMPL_NORM)
2723	{
2724	pNorm(p);
2725	}
2726	res->data = (char * )p;
2727	return FALSE;
2728	}
2729	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2730	{
2731	ideal result;
2732	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2733	tHomog hom=testHomog;
2734	ideal u_id=(ideal)(u->Data());
2735	if (w!=NULL)
2736	{
2737	if (!idTestHomModule(u_id,currQuotient,w))
2738	{
2739	WarnS("wrong weights");
2740	w=NULL;
2741	}
2742	else
2743	{
2744	w=ivCopy(w);
2745	hom=isHomog;
2746	}
2747	}
2748	result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
2749	idSkipZeroes(result);
2750	res->data = (char *)result;
2751	setFlag(res,FLAG_STD);
2752	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2753	return FALSE;
2754	}
2755	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2756	{
2757	ideal result;
2758	assumeStdFlag(u);
2759	ideal i1=(ideal)(u->Data());
2760	ideal i0;
2761	int r=v->Typ();
2762	if ((/v->Typ()/r==POLY_CMD) \|\|(r==VECTOR_CMD))
2763	{
2764	i0=idInit(1,i1->rank);
2765	i0->m[0]=(poly)v->Data();
2766	}
2767	else /IDEAL/
2768	{
2769	i0=(ideal)v->Data();
2770	}
2771	i1=idSimpleAdd(i1,i0);
2772	memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
2773	idDelete(&i0);
2774	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2775	tHomog hom=testHomog;
2776	if (w!=NULL)
2777	{
2778	if (!idTestHomModule(i1,currQuotient,w))
2779	{
2780	// no warnung: this is legal, if i in std(i,p)
2781	// is homogeneous, but p not
2782	w=NULL;
2783	}
2784	else
2785	{
2786	w=ivCopy(w);
2787	hom=isHomog;
2788	}
2789	}
2790	BITSET save_test=test;
2791	test\|=Sy_bit(OPT_SB_1);
2792	result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2793	test=save_test;
2794	idDelete(&i1);
2795	idSkipZeroes(result);
2796	res->data = (char *)result;
2797	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
2798	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2799	return FALSE;
2800	}
2801	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2802	{
2803	idhdl h=(idhdl)u->data;
2804	int i=(int)(long)v->Data();
2805	if ((0<i) && (i<=IDRING(h)->N))
2806	res->data=omStrDup(IDRING(h)->names[i-1]);
2807	else
2808	{
2809	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2810	return TRUE;
2811	}
2812	return FALSE;
2813	}
2814	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2815	{
2816	res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2817	return FALSE;
2818	}
2819	#define jjWRONG2 (proc2)jjWRONG
2820	#define jjWRONG3 (proc3)jjWRONG
2821	static BOOLEAN jjWRONG(leftv res, leftv u)
2822	{
2823	return TRUE;
2824	}
2825
2826	static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2827	{
2828	char * s=(char *)u->Data();
2829	if(strcmp(s, "with")==0)
2830	return jjLOAD(res, v, TRUE);
2831	WerrorS("invalid second argument");
2832	WerrorS("load(\"libname\" [,\"with\"]);");
2833	return TRUE;
2834	}
2835
2836	/=================== operations with 2 args.: table =================/
2837
2838	struct sValCmd2 dArith2[]=
2839	{
2840	// operations:
2841	// proc cmd res arg1 arg2 plural
2842	{jjCOLCOL, COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD ALLOW_PLURAL}
2843	,{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2844	,{jjPLUS_BI, '+', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2845	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2846	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2847	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2848	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2849	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2850	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
2851	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2852	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2853	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2854	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2855	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2856	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2857	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2858	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2859	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2860	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
2861	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
2862	,{jjRSUM, '+', QRING_CMD, QRING_CMD, RING_CMD ALLOW_PLURAL}
2863	,{jjRSUM, '+', QRING_CMD, RING_CMD, QRING_CMD ALLOW_PLURAL}
2864	,{jjRSUM, '+', QRING_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
2865	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2866	,{jjMINUS_BI, '-', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2867	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2868	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2869	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2870	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2871	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2872	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2873	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2874	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2875	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2876	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2877	,{jjTIMES_BI, '*', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2878	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2879	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2880	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD ALLOW_PLURAL}
2881	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2882	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
2883	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
2884	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2885	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD ALLOW_PLURAL}
2886	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2887	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2888	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2889	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2890	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
2891	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2892	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2893	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2894	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
2895	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2896	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2897	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2898	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2899	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2900	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2901	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2902	,{jjTIMES_IV, '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2903	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2904	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2905	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2906	,{jjDIV_Ma, '/', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2907	,{jjDIVMOD_I, '/', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2908	,{jjDIV_BI, '/', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2909	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2910	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2911	,{jjDIVMOD_I, INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2912	,{jjDIV_BI, INTDIV_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2913	,{jjOP_IV_I, INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2914	,{jjOP_IV_I, INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2915	,{jjDIVMOD_I, '%', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2916	,{jjMOD_BI, '%', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2917	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2918	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2919	,{jjMOD_N, '%', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2920	,{jjDIVMOD_I, INTMOD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2921	,{jjMOD_BI, INTMOD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2922	,{jjOP_IV_I, INTMOD_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2923	,{jjOP_IV_I, INTMOD_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2924	,{jjMOD_N, INTMOD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2925	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2926	,{jjPOWER_BI, '^', BIGINT_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
2927	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2928	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2929	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2930	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2931	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2932	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2933	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2934	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2935	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2936	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2937	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2938	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2939	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2940	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2941	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2942	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2943	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2944	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2945	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2946	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2947	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2948	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2949	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2950	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2951	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2952	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2953	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2954	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2955	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2956	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2957	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2958	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2959	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2960	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2961	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2962	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2963	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2964	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2965	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2966	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2967	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2968	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2969	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2970	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2971	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2972	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2973	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2974	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2975	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2976	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2977	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2978	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2979	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2980	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2981	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2982	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2983	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2984	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2985	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2986	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2987	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2988	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2989	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD ALLOW_PLURAL}
2990	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
2991	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
2992	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
2993	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
2994	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2995	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2996	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2997	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2998	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
2999	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3000	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3001	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
3002	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
3003	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
3004	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
3005	// and the procedures with 2 arguments:
3006	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD ALLOW_PLURAL}
3007	,{jjWRONG2, BAREISS_CMD, 0, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3008	,{jjBETTI2, BETTI_CMD, INTMAT_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3009	,{syBetti2, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
3010	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3011	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3012	#ifdef HAVE_PLURAL
3013	,{jjBRACKET, BRACKET_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3014	#endif
3015	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3016	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3017	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3018	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3019	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3020	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3021	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
3022	,{jjDEG_IV, DEG_CMD, INT_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3023	,{jjDEG_M_IV, DEG_CMD, INT_CMD, MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
3024	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3025	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3026	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3027	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3028	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3029	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3030	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3031	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3032	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD NO_PLURAL}
3033	,{jjDIVISION, DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3034	,{jjDIVISION, DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
3035	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3036	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3037	,{jjEXPORTTO, EXPORTTO_CMD, NONE, PACKAGE_CMD, IDHDL ALLOW_PLURAL}
3038	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3039	#ifdef HAVE_FACTORY
3040	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3041	,{jjSQR_FREE_DEC,FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3042	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3043	#else
3044	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3045	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3046	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3047	#endif
3048	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3049	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3050	#ifdef HAVE_FGLM
3051	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3052	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3053	,{fglmQuotProc,FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD NO_PLURAL}
3054	#else
3055	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3056	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3057	,{jjWRONG2, FGLMQUOT_CMD, IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
3058	#endif
3059	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3060	,{jjFWALK, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3061
3062	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3063	,{jjGCD_N, GCD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3064	,{jjGCD_BI, GCD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3065	#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
3066	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3067	#else
3068	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3069	#endif
3070	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3071	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3072	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3073	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3074	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3075	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3076	,{jjRES, HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3077	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3078	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3079	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3080	,{jjIMPORTFROM,IMPORTFROM_CMD, NONE, PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
3081	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3082	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
3083	#ifdef HAVE_INTERPOLATION
3084	,{jjINTERPOLATION,INTERPOLATE_CMD,IDEAL_CMD, LIST_CMD, INTVEC_CMD NO_PLURAL}
3085	#endif
3086	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3087	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3088	,{jjJanetBasis2, JANET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3089	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3090	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3091	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3092	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3093	,{jjJET_ID, JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3094	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3095	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3096	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD ALLOW_PLURAL}
3097	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD NO_PLURAL}
3098	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
3099	,{jjRES, KRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3100	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3101	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3102	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
3103	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
3104	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3105	,{jjLOAD2, LOAD_CMD, NONE, STRING_CMD, INT_CMD ALLOW_PLURAL}
3106	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3107	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3108	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3109	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3110	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3111	,{jjMONITOR2, MONITOR_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3112	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3113	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3114	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3115	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3116	#ifdef HAVE_PLURAL
3117	,{jjPlural_num_poly, NCALGEBRA_CMD, NONE, POLY_CMD, POLY_CMD NO_PLURAL}
3118	,{jjPlural_num_mat, NCALGEBRA_CMD, NONE, POLY_CMD, MATRIX_CMD NO_PLURAL}
3119	,{jjPlural_mat_poly, NCALGEBRA_CMD, NONE, MATRIX_CMD, POLY_CMD NO_PLURAL}
3120	,{jjPlural_mat_mat, NCALGEBRA_CMD, NONE, MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3121	#endif
3122	#ifdef HAVE_PLURAL
3123	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, RING_CMD, DEF_CMD ALLOW_PLURAL}
3124	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, QRING_CMD, DEF_CMD ALLOW_PLURAL}
3125	#endif
3126	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3127	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3128	,{jjPRINT_FORMAT, PRINT_CMD, ANY_TYPE, DEF_CMD, STRING_CMD ALLOW_PLURAL}
3129	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3130	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3131	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3132	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3133	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3134	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
3135	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3136	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3137	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3138	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3139	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3140	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3141	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3142	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3143	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3144	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3145	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3146	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3147	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3148	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3149	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3150	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3151	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3152	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3153	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3154	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3155	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD ALLOW_PLURAL}
3156	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3157	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3158	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD NO_PLURAL}
3159	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD NO_PLURAL}
3160	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3161	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3162	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3163	,{jjLOAD_E, LOAD_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3164	,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3165	,{NULL, 0, 0, 0, 0 NO_PLURAL}
3166	};
3167	/=================== operations with 1 arg.: static proc =================/
3168	static BOOLEAN jjDUMMY(leftv res, leftv u)
3169	{
3170	res->data = (char *)u->CopyD();
3171	return FALSE;
3172	}
3173	static BOOLEAN jjNULL(leftv res, leftv u)
3174	{
3175	return FALSE;
3176	}
3177	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3178	//{
3179	// res->data = (char *)((int)(long)u->Data()+1);
3180	// return FALSE;
3181	//}
3182	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3183	//{
3184	// res->data = (char *)((int)(long)u->Data()-1);
3185	// return FALSE;
3186	//}
3187	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3188	{
3189	if (IDTYP((idhdl)u->data)==INT_CMD)
3190	{
3191	int i=IDINT((idhdl)u->data);
3192	if (iiOp==PLUSPLUS) i++;
3193	else i--;
3194	IDDATA((idhdl)u->data)=(char *)(long)i;
3195	return FALSE;
3196	}
3197	return TRUE;
3198	}
3199	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3200	{
3201	res->data = (char *)(-(long)u->Data());
3202	return FALSE;
3203	}
3204	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3205	{
3206	number n=(number)u->CopyD(NUMBER_CMD);
3207	n=nNeg(n);
3208	res->data = (char *)n;
3209	return FALSE;
3210	}
3211	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3212	{
3213	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3214	return FALSE;
3215	}
3216	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3217	{
3218	poly m1=pISet(-1);
3219	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3220	return FALSE;
3221	}
3222	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3223	{
3224	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
3225	(iv)=(-1);
3226	res->data = (char *)iv;
3227	return FALSE;
3228	}
3229	static BOOLEAN jjPROC1(leftv res, leftv u)
3230	{
3231	return jjPROC(res,u,NULL);
3232	}
3233	static BOOLEAN jjBAREISS(leftv res, leftv v)
3234	{
3235	//matrix m=(matrix)v->Data();
3236	//lists l=mpBareiss(m,FALSE);
3237	intvec *iv;
3238	ideal m;
3239	smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3240	lists l=(lists)omAllocBin(slists_bin);
3241	l->Init(2);
3242	l->m[0].rtyp=MODUL_CMD;
3243	l->m[1].rtyp=INTVEC_CMD;
3244	l->m[0].data=(void *)m;
3245	l->m[1].data=(void *)iv;
3246	res->data = (char *)l;
3247	return FALSE;
3248	}
3249	//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3250	//{
3251	// intvec m=(intvec )v->CopyD(INTMAT_CMD);
3252	// ivTriangMat(m);
3253	// res->data = (char *)m;
3254	// return FALSE;
3255	//}
3256	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3257	{
3258	return iiExprArithM(res,u,iiOp);
3259	}
3260	static BOOLEAN jjCHAR(leftv res, leftv v)
3261	{
3262	res->data = (char *)(long)rChar((ring)v->Data());
3263	return FALSE;
3264	}
3265	static BOOLEAN jjCOLS(leftv res, leftv v)
3266	{
3267	res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3268	return FALSE;
3269	}
3270	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3271	{
3272	res->data = (char )(long)((intvec)(v->Data()))->cols();
3273	return FALSE;
3274	}
3275	static BOOLEAN jjCONTENT(leftv res, leftv v)
3276	{
3277	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3278	poly p=(poly)v->CopyD(POLY_CMD);
3279	if (p!=NULL) pCleardenom(p);
3280	res->data = (char *)p;
3281	return FALSE;
3282	}
3283	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3284	{
3285	res->data = (char *)(long)nSize((number)v->Data());
3286	return FALSE;
3287	}
3288	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3289	{
3290	lists l=(lists)v->Data();
3291	res->data = (char *)(long)(l->nr+1);
3292	return FALSE;
3293	}
3294	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3295	{
3296	matrix m=(matrix)v->Data();
3297	res->data = (char )(long)(MATROWS(m)MATCOLS(m));
3298	return FALSE;
3299	}
3300	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3301	{
3302	res->data = (char )(long)((intvec)(v->Data()))->length();
3303	return FALSE;
3304	}
3305	static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3306	{
3307	ring r=(ring)v->Data();
3308	int elems=-1;
3309	if (rField_is_Zp(r)\|\|rField_is_GF(r)) elems=rInternalChar(r);
3310	else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3311	{
3312	#ifdef HAVE_FACTORY
3313	extern int ipower ( int b, int n ); /* factory/cf_util */
3314	elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3315	#else
3316	elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3317	#endif
3318	}
3319	res->data = (char *)(long)elems;
3320	return FALSE;
3321	}
3322	static BOOLEAN jjDEG(leftv res, leftv v)
3323	{
3324	int dummy;
3325	poly p=(poly)v->Data();
3326	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3327	else res->data=(char *)-1;
3328	return FALSE;
3329	}
3330	static BOOLEAN jjDEG_M(leftv res, leftv u)
3331	{
3332	ideal I=(ideal)u->Data();
3333	int d=-1;
3334	int dummy;
3335	int i;
3336	for(i=IDELEMS(I)-1;i>=0;i--)
3337	if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3338	res->data = (char *)(long)d;
3339	return FALSE;
3340	}
3341	static BOOLEAN jjDEGREE(leftv res, leftv v)
3342	{
3343	assumeStdFlag(v);
3344	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3345	scDegree((ideal)v->Data(),module_w,currQuotient);
3346	return FALSE;
3347	}
3348	static BOOLEAN jjDEFINED(leftv res, leftv v)
3349	{
3350	if ((v->rtyp==IDHDL)
3351	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
3352	{
3353	res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3354	}
3355	else if (v->rtyp!=0) res->data=(void *)(-1);
3356	return FALSE;
3357	}
3358	#ifdef HAVE_FACTORY
3359	static BOOLEAN jjDET(leftv res, leftv v)
3360	{
3361	matrix m=(matrix)v->Data();
3362	poly p;
3363	if (smCheckDet((ideal)m,m->cols(),TRUE))
3364	{
3365	ideal I=idMatrix2Module(mpCopy(m));
3366	p=smCallDet(I);
3367	idDelete(&I);
3368	}
3369	else
3370	p=singclap_det(m);
3371	res ->data = (char *)p;
3372	return FALSE;
3373	}
3374	static BOOLEAN jjDET_I(leftv res, leftv v)
3375	{
3376	intvec * m=(intvec*)v->Data();
3377	int i,j;
3378	i=m->rows();j=m->cols();
3379	if(i==j)
3380	res->data = (char *)(long)singclap_det_i(m);
3381	else
3382	{
3383	Werror("det of %d x %d intmat",i,j);
3384	return TRUE;
3385	}
3386	return FALSE;
3387	}
3388	static BOOLEAN jjDET_S(leftv res, leftv v)
3389	{
3390	ideal I=(ideal)v->Data();
3391	poly p;
3392	if (smCheckDet(I,IDELEMS(I),FALSE))
3393	{
3394	matrix m=idModule2Matrix(idCopy(I));
3395	p=singclap_det(m);
3396	idDelete((ideal *)&m);
3397	}
3398	else
3399	p=smCallDet(I);
3400	res->data = (char *)p;
3401	return FALSE;
3402	}
3403	#endif
3404	static BOOLEAN jjDIM(leftv res, leftv v)
3405	{
3406	assumeStdFlag(v);
3407	res->data = (char *)(long)scDimInt((ideal)(v->Data()),currQuotient);
3408	return FALSE;
3409	}
3410	static BOOLEAN jjDUMP(leftv res, leftv v)
3411	{
3412	si_link l = (si_link)v->Data();
3413	if (slDump(l))
3414	{
3415	const char *s;
3416	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3417	else s=sNoName;
3418	Werror("cannot dump to `%s`",s);
3419	return TRUE;
3420	}
3421	else
3422	return FALSE;
3423	}
3424	static BOOLEAN jjE(leftv res, leftv v)
3425	{
3426	res->data = (char *)pOne();
3427	pSetComp((poly)res->data,(int)(long)v->Data());
3428	pSetm((poly)res->data);
3429	return FALSE;
3430	}
3431	static BOOLEAN jjEXECUTE(leftv res, leftv v)
3432	{
3433	char * d = (char *)v->Data();
3434	char * s = (char *)omAlloc(strlen(d) + 13);
3435	strcpy( s, (char *)d);
3436	strcat( s, "\n;RETURN();\n");
3437	newBuffer(s,BT_execute);
3438	return yyparse();
3439	}
3440	#ifdef HAVE_FACTORY
3441	static BOOLEAN jjFACSTD(leftv res, leftv v)
3442	{
3443	ideal_list p,h;
3444	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3445	p=h;
3446	int l=0;
3447	while (p!=NULL) { p=p->next;l++; }
3448	lists L=(lists)omAllocBin(slists_bin);
3449	L->Init(l);
3450	l=0;
3451	while(h!=NULL)
3452	{
3453	L->m[l].data=(char *)h->d;
3454	L->m[l].rtyp=IDEAL_CMD;
3455	p=h->next;
3456	omFreeSize(h,sizeof(*h));
3457	h=p;
3458	l++;
3459	}
3460	res->data=(void *)L;
3461	return FALSE;
3462	}
3463	static BOOLEAN jjFAC_P(leftv res, leftv u)
3464	{
3465	intvec *v=NULL;
3466	singclap_factorize_retry=0;
3467	ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3468	if (f==NULL) return TRUE;
3469	ivTest(v);
3470	lists l=(lists)omAllocBin(slists_bin);
3471	l->Init(2);
3472	l->m[0].rtyp=IDEAL_CMD;
3473	l->m[0].data=(void *)f;
3474	l->m[1].rtyp=INTVEC_CMD;
3475	l->m[1].data=(void *)v;
3476	res->data=(void *)l;
3477	return FALSE;
3478	}
3479	#endif
3480	static BOOLEAN jjGETDUMP(leftv res, leftv v)
3481	{
3482	si_link l = (si_link)v->Data();
3483	if (slGetDump(l))
3484	{
3485	const char *s;
3486	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3487	else s=sNoName;
3488	Werror("cannot get dump from `%s`",s);
3489	return TRUE;
3490	}
3491	else
3492	return FALSE;
3493	}
3494	static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3495	{
3496	assumeStdFlag(v);
3497	ideal I=(ideal)v->Data();
3498	res->data=(void *)iiHighCorner(I,0);
3499	return FALSE;
3500	}
3501	static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3502	{
3503	assumeStdFlag(v);
3504	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3505	BOOLEAN delete_w=FALSE;
3506	ideal I=(ideal)v->Data();
3507	int i;
3508	poly p=NULL,po=NULL;
3509	int rk=idRankFreeModule(I);
3510	if (w==NULL)
3511	{
3512	w = new intvec(rk);
3513	delete_w=TRUE;
3514	}
3515	for(i=rk;i>0;i--)
3516	{
3517	p=iiHighCorner(I,i);
3518	if (p==NULL)
3519	{
3520	WerrorS("module must be zero-dimensional");
3521	if (delete_w) delete w;
3522	return TRUE;
3523	}
3524	if (po==NULL)
3525	{
3526	po=p;
3527	}
3528	else
3529	{
3530	// now po!=NULL, p!=NULL
3531	int d=(pFDeg(po,currRing)-(w)[pGetComp(po)-1] - pFDeg(p,currRing)+(w)[i-1]);
3532	if (d==0)
3533	d=pLmCmp(po,p);
3534	if (d > 0)
3535	{
3536	pDelete(&p);
3537	}
3538	else // (d < 0)
3539	{
3540	pDelete(&po); po=p;
3541	}
3542	}
3543	}
3544	if (delete_w) delete w;
3545	res->data=(void *)po;
3546	return FALSE;
3547	}
3548	static BOOLEAN jjHILBERT(leftv res, leftv v)
3549	{
3550	assumeStdFlag(v);
3551	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3552	//scHilbertPoly((ideal)v->Data(),currQuotient);
3553	hLookSeries((ideal)v->Data(),module_w,currQuotient);
3554	return FALSE;
3555	}
3556	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3557	{
3558	res->data=(void )hSecondSeries((intvec )v->Data());
3559	return FALSE;
3560	}
3561	static BOOLEAN jjHOMOG1(leftv res, leftv v)
3562	{
3563	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3564	ideal v_id=(ideal)v->Data();
3565	if (w==NULL)
3566	{
3567	res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
3568	if ((res->data!=NULL) && (v->rtyp==IDHDL))
3569	{
3570	char *isHomog=omStrDup("isHomog");
3571	if (v->e==NULL)
3572	atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3573	else
3574	atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3575	}
3576	else if (w!=NULL) delete w;
3577	}
3578	else
3579	res->data=(void *)(long)idTestHomModule(v_id,currQuotient,w);
3580	return FALSE;
3581	}
3582	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3583	{
3584	matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3585	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3586	if (IDELEMS((ideal)mat)==0)
3587	{
3588	idDelete((ideal *)&mat);
3589	mat=(matrix)idInit(1,1);
3590	}
3591	else
3592	{
3593	MATROWS(mat)=1;
3594	mat->rank=1;
3595	idTest((ideal)mat);
3596	}
3597	res->data=(char *)mat;
3598	return FALSE;
3599	}
3600	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3601	{
3602	map m=(map)v->CopyD(MAP_CMD);
3603	omFree((ADDRESS)m->preimage);
3604	m->preimage=NULL;
3605	ideal I=(ideal)m;
3606	I->rank=1;
3607	res->data=(char *)I;
3608	return FALSE;
3609	}
3610	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3611	{
3612	if (currRing!=NULL)
3613	{
3614	ring q=(ring)v->Data();
3615	if (rEqual(currRing, q, 0))
3616	{
3617	if (q->qideal==NULL)
3618	res->data=(char *)idInit(1,1);
3619	else
3620	res->data=(char *)idCopy(q->qideal);
3621	return FALSE;
3622	}
3623	}
3624	WerrorS("can only get ideal from identical qring");
3625	return TRUE;
3626	}
3627	static BOOLEAN jjIm2Iv(leftv res, leftv v)
3628	{
3629	intvec iv = (intvec )v->CopyD(INTMAT_CMD);
3630	iv->makeVector();
3631	res->data = iv;
3632	return FALSE;
3633	}
3634	static BOOLEAN jjIMPART(leftv res, leftv v)
3635	{
3636	res->data = (char *)nImPart((number)v->Data());
3637	return FALSE;
3638	}
3639	static BOOLEAN jjINDEPSET(leftv res, leftv v)
3640	{
3641	assumeStdFlag(v);
3642	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3643	return FALSE;
3644	}
3645	static BOOLEAN jjINTERRED(leftv res, leftv v)
3646	{
3647	ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3648	//if (result==NULL) return TRUE;
3649	res->data = result;
3650	return FALSE;
3651	}
3652	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3653	{
3654	res->data = (char *)(long)pVar((poly)v->Data());
3655	return FALSE;
3656	}
3657	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3658	{
3659	res->data = (char )(long)(r_IsRingVar((char )v->Data(), currRing)+1);
3660	return FALSE;
3661	}
3662	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3663	{
3664	res->data = (char *)0;
3665	return FALSE;
3666	}
3667	static BOOLEAN jjJACOB_P(leftv res, leftv v)
3668	{
3669	ideal i=idInit(pVariables,1);
3670	int k;
3671	poly p=(poly)(v->Data());
3672	for (k=pVariables;k>0;k--)
3673	{
3674	i->m[k-1]=pDiff(p,k);
3675	}
3676	res->data = (char *)i;
3677	return FALSE;
3678	}
3679	static BOOLEAN jjKBASE(leftv res, leftv v)
3680	{
3681	assumeStdFlag(v);
3682	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3683	return FALSE;
3684	}
3685	#ifdef MDEBUG
3686	static BOOLEAN jjpHead(leftv res, leftv v)
3687	{
3688	res->data=(char *)pHead((poly)v->Data());
3689	return FALSE;
3690	}
3691	#endif
3692	static BOOLEAN jjL2R(leftv res, leftv v)
3693	{
3694	res->data=(char *)syConvList((lists)v->Data());
3695	if (res->data != NULL)
3696	return FALSE;
3697	else
3698	return TRUE;
3699	}
3700	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3701	{
3702	poly p=(poly)v->Data();
3703	if (p==NULL)
3704	{
3705	res->data=(char *)nInit(0);
3706	}
3707	else
3708	{
3709	res->data=(char *)nCopy(pGetCoeff(p));
3710	}
3711	return FALSE;
3712	}
3713	static BOOLEAN jjLEADEXP(leftv res, leftv v)
3714	{
3715	poly p=(poly)v->Data();
3716	int s=pVariables;
3717	if (v->Typ()==VECTOR_CMD) s++;
3718	intvec *iv=new intvec(s);
3719	if (p!=NULL)
3720	{
3721	for(int i = pVariables;i;i--)
3722	{
3723	(*iv)[i-1]=pGetExp(p,i);
3724	}
3725	if (s!=pVariables)
3726	(*iv)[pVariables]=pGetComp(p);
3727	}
3728	res->data=(char *)iv;
3729	return FALSE;
3730	}
3731	static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3732	{
3733	poly p=(poly)v->Data();
3734	if (p == NULL)
3735	{
3736	res->data = (char*) NULL;
3737	}
3738	else
3739	{
3740	poly lm = pLmInit(p);
3741	pSetCoeff(lm, nInit(1));
3742	res->data = (char*) lm;
3743	}
3744	return FALSE;
3745	}
3746	static BOOLEAN jjLISTRING(leftv res, leftv v)
3747	{
3748	ring r=rCompose((lists)v->Data());
3749	if (r==NULL) return TRUE;
3750	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3751	res->data=(char *)r;
3752	return FALSE;
3753	}
3754	#if SIZEOF_LONG == 8
3755	static number jjBI2N(long d);
3756	#else
3757	#define jjBI2N(D) nlInit((int)D)
3758	#endif
3759	static BOOLEAN jjMEMORY(leftv res, leftv v)
3760	{
3761	omUpdateInfo();
3762	long d;
3763	switch(((int)(long)v->Data()))
3764	{
3765	case 0:
3766	res->data=(char *)jjBI2N(om_Info.UsedBytes);
3767	break;
3768	case 1:
3769	res->data = (char *)jjBI2N(om_Info.CurrentBytesSystem);
3770	break;
3771	case 2:
3772	res->data = (char *)jjBI2N(om_Info.MaxBytesSystem);
3773	break;
3774
3775	default:
3776	omPrintStats(stdout);
3777	omPrintInfo(stdout);
3778	omPrintBinStats(stdout);
3779	res->data = (char *)0;
3780	res->rtyp = NONE;
3781	}
3782	return FALSE;
3783	res->data = (char *)0;
3784	return FALSE;
3785	}
3786	#if SIZEOF_LONG == 8
3787	static number jjBI2N(long d)
3788	{
3789	if (d<((long)INT_MAX)) return nlInit((int)d);
3790	else
3791	{
3792	number n=nlRInit(0);
3793	mpz_set_si(&n->z,d);
3794	return n;
3795	}
3796	}
3797	#endif
3798	static BOOLEAN jjMONITOR1(leftv res, leftv v)
3799	{
3800	monitor((char *)(v->Data()),PROT_I);
3801	return FALSE;
3802	}
3803	static BOOLEAN jjMSTD(leftv res, leftv v)
3804	{
3805	int t=v->Typ();
3806	ideal r,m;
3807	r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3808	lists l=(lists)omAllocBin(slists_bin);
3809	l->Init(2);
3810	l->m[0].rtyp=t;
3811	l->m[0].data=(char *)r;
3812	setFlag(&(l->m[0]),FLAG_STD);
3813	l->m[1].rtyp=t;
3814	l->m[1].data=(char *)m;
3815	res->data=(char *)l;
3816	return FALSE;
3817	}
3818	static BOOLEAN jjMULT(leftv res, leftv v)
3819	{
3820	assumeStdFlag(v);
3821	res->data = (char *)(long)scMultInt((ideal)(v->Data()),currQuotient);
3822	return FALSE;
3823	}
3824	static BOOLEAN jjMINRES_R(leftv res, leftv v)
3825	{
3826	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3827	res->data=(char *)syMinimize((syStrategy)v->Data());
3828	if (weights!=NULL)
3829	atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3830	return FALSE;
3831	}
3832	static BOOLEAN jjN2BI(leftv res, leftv v)
3833	{
3834	number n,i; i=(number)v->Data();
3835	if (rField_is_Zp()) n=nlInit((int)(long)i);
3836	else if (rField_is_Q())
3837	{
3838	if ((SR_HDL(i)&SR_INT)==SR_INT) n=nlInit((int)SR_TO_INT(i));
3839	else if (i->s==3) n=nlCopy(i);
3840	else goto err;
3841	}
3842	else goto err;
3843	res->data=(void *)n;
3844	return FALSE;
3845	err:
3846	WerrorS("cannot convert to bigint"); return TRUE;
3847	}
3848	static BOOLEAN jjNAMEOF(leftv res, leftv v)
3849	{
3850	res->data = (char *)v->name;
3851	if (res->data==NULL) res->data=omStrDup("");
3852	v->name=NULL;
3853	return FALSE;
3854	}
3855	static BOOLEAN jjNAMES(leftv res, leftv v)
3856	{
3857	res->data=ipNameList(((ring)v->Data())->idroot);
3858	return FALSE;
3859	}
3860	static BOOLEAN jjNVARS(leftv res, leftv v)
3861	{
3862	res->data = (char *)(long)(((ring)(v->Data()))->N);
3863	return FALSE;
3864	}
3865	static BOOLEAN jjOpenClose(leftv res, leftv v)
3866	{
3867	si_link l=(si_link)v->Data();
3868	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3869	else return slClose(l);
3870	}
3871	static BOOLEAN jjORD(leftv res, leftv v)
3872	{
3873	poly p=(poly)v->Data();
3874	res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3875	return FALSE;
3876	}
3877	static BOOLEAN jjPAR1(leftv res, leftv v)
3878	{
3879	int i=(int)(long)v->Data();
3880	int p=0;
3881	p=rPar(currRing);
3882	if ((0<i) && (i<=p))
3883	{
3884	res->data=(char *)nPar(i);
3885	}
3886	else
3887	{
3888	Werror("par number %d out of range 1..%d",i,p);
3889	return TRUE;
3890	}
3891	return FALSE;
3892	}
3893	static BOOLEAN jjPARDEG(leftv res, leftv v)
3894	{
3895	res->data = (char *)(long)nParDeg((number)v->Data());
3896	return FALSE;
3897	}
3898	static BOOLEAN jjPARSTR1(leftv res, leftv v)
3899	{
3900	if (currRing==NULL)
3901	{
3902	WerrorS("no ring active");
3903	return TRUE;
3904	}
3905	int i=(int)(long)v->Data();
3906	int p=0;
3907	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3908	res->data=omStrDup(currRing->parameter[i-1]);
3909	else
3910	{
3911	Werror("par number %d out of range 1..%d",i,p);
3912	return TRUE;
3913	}
3914	return FALSE;
3915	}
3916	static BOOLEAN jjP2I(leftv res, leftv v)
3917	{
3918	poly p=(poly)v->Data();
3919	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
3920	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
3921	{
3922	WerrorS("poly must be constant");
3923	return TRUE;
3924	}
3925	res->data = (char *)(long)nInt(pGetCoeff(p));
3926	return FALSE;
3927	}
3928	static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3929	{
3930	map mapping=(map)v->Data();
3931	syMake(res,omStrDup(mapping->preimage));
3932	return FALSE;
3933	}
3934	static BOOLEAN jjPRIME(leftv res, leftv v)
3935	{
3936	int i = IsPrime((int)(long)(v->Data()));
3937	res->data = (char *)(long)(i > 1 ? i : 2);
3938	return FALSE;
3939	}
3940	static BOOLEAN jjPRUNE(leftv res, leftv v)
3941	{
3942	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
3943	ideal v_id=(ideal)v->Data();
3944	if (w!=NULL)
3945	{
3946	if (!idTestHomModule(v_id,currQuotient,w))
3947	{
3948	WarnS("wrong weights");
3949	w=NULL;
3950	// and continue at the non-homog case below
3951	}
3952	else
3953	{
3954	w=ivCopy(w);
3955	intvec **ww=&w;
3956	res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3957	atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3958	return FALSE;
3959	}
3960	}
3961	res->data = (char *)idMinEmbedding(v_id);
3962	return FALSE;
3963	}
3964	static BOOLEAN jjP2N(leftv res, leftv v)
3965	{
3966	number n;
3967	poly p;
3968	if (((p=(poly)v->Data())!=NULL)
3969	&& (pIsConstant(p)))
3970	{
3971	n=nCopy(pGetCoeff(p));
3972	}
3973	else
3974	{
3975	n=nInit(0);
3976	}
3977	res->data = (char *)n;
3978	return FALSE;
3979	}
3980	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3981	{
3982	char s= (char )v->Data();
3983	int i = 1;
3984	int l = strlen(s);
3985	for(i=0; i<sArithBase.nCmdUsed; i++)
3986	{
3987	if (strcmp(s, sArithBase.sCmds[i].name) == 0)
3988	{
3989	res->data = (char *)1;
3990	return FALSE;
3991	}
3992	i++;
3993	}
3994	//res->data = (char *)0;
3995	return FALSE;
3996	}
3997	static BOOLEAN jjREAD(leftv res, leftv v)
3998	{
3999	return jjREAD2(res,v,NULL);
4000	}
4001	static BOOLEAN jjREGULARITY(leftv res, leftv v)
4002	{
4003	res->data = (char *)(long)iiRegularity((lists)v->Data());
4004	return FALSE;
4005	}
4006	static BOOLEAN jjREPART(leftv res, leftv v)
4007	{
4008	res->data = (char *)nRePart((number)v->Data());
4009	return FALSE;
4010	}
4011	static BOOLEAN jjRINGLIST(leftv res, leftv v)
4012	{
4013	ring r=(ring)v->Data();
4014	if (r!=NULL)
4015	res->data = (char *)rDecompose((ring)v->Data());
4016	return (r==NULL)\|\|(res->data==NULL);
4017	}
4018	static BOOLEAN jjROWS(leftv res, leftv v)
4019	{
4020	ideal i = (ideal)v->Data();
4021	res->data = (char *)i->rank;
4022	return FALSE;
4023	}
4024	static BOOLEAN jjROWS_IV(leftv res, leftv v)
4025	{
4026	res->data = (char )(long)((intvec)(v->Data()))->rows();
4027	return FALSE;
4028	}
4029	static BOOLEAN jjRPAR(leftv res, leftv v)
4030	{
4031	res->data = (char *)(long)rPar(((ring)v->Data()));
4032	return FALSE;
4033	}
4034	static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4035	{
4036	if (currQuotient!=NULL)
4037	{
4038	Werror("qring not supported by slimgb at the moment");
4039	return TRUE;
4040	}
4041	if (pOrdSgn!=1)
4042	{
4043	Werror("ordering must be global for slimgb");
4044	return TRUE;
4045	}
4046	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
4047	tHomog hom=testHomog;
4048	ideal u_id=(ideal)u->Data();
4049	if (w!=NULL)
4050	{
4051	if (!idTestHomModule(u_id,currQuotient,w))
4052	{
4053	WarnS("wrong weights");
4054	w=NULL;
4055	}
4056	else
4057	{
4058	w=ivCopy(w);
4059	hom=isHomog;
4060	}
4061	}
4062
4063	assume(u_id->rank>=idRankFreeModule(u_id));
4064	res->data=(char *)t_rep_gb(currRing,
4065	u_id,u_id->rank);
4066	//res->data=(char *)t_rep_gb(currRing, u_id);
4067
4068	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4069	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4070	return FALSE;
4071	}
4072	static BOOLEAN jjSTD(leftv res, leftv v)
4073	{
4074	ideal result;
4075	ideal v_id=(ideal)v->Data();
4076	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4077	tHomog hom=testHomog;
4078	if (w!=NULL)
4079	{
4080	if (!idTestHomModule(v_id,currQuotient,w))
4081	{
4082	WarnS("wrong weights");
4083	w=NULL;
4084	}
4085	else
4086	{
4087	hom=isHomog;
4088	w=ivCopy(w);
4089	}
4090	}
4091	result=kStd(v_id,currQuotient,hom,&w);
4092	idSkipZeroes(result);
4093	res->data = (char *)result;
4094	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4095	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4096	return FALSE;
4097	}
4098	static BOOLEAN jjSort_Id(leftv res, leftv v)
4099	{
4100	res->data = (char *)idSort((ideal)v->Data());
4101	return FALSE;
4102	}
4103	#if 1
4104	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4105	{
4106	intvec *w=NULL;
4107	res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4108	if (w!=NULL) delete w;
4109	return FALSE;
4110	}
4111	#else
4112	// activate, if idSyz hadle moduke weights correctly !
4113	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4114	{
4115	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4116	ideal v_id=(ideal)v->Data();
4117	tHomog hom=testHomog;
4118	int add_row_shift=0;
4119	if (w!=NULL)
4120	{
4121	w=ivCopy(w);
4122	add_row_shift=w->min_in();
4123	(*w)-=add_row_shift;
4124	if (idTestHomModule(v_id,currQuotient,w))
4125	hom=isHomog;
4126	else
4127	{
4128	//WarnS("wrong weights");
4129	delete w; w=NULL;
4130	hom=testHomog;
4131	}
4132	}
4133	res->data = (char *)idSyzygies(v_id,hom,&w);
4134	if (w!=NULL)
4135	{
4136	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4137	}
4138	return FALSE;
4139	}
4140	#endif
4141	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4142	{
4143	res->data = (char )(long)ivTrace((intvec)(v->Data()));
4144	return FALSE;
4145	}
4146	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4147	{
4148	res->data = (char )ivTranp((intvec)(v->Data()));
4149	return FALSE;
4150	}
4151
4152	#ifdef HAVE_PLURAL
4153
4154	static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4155	{
4156	ring r = (ring)a->Data();
4157	if (rIsPluralRing(r))
4158	{
4159	res->data = rOpposite(r);
4160	}
4161	else res->data = rCopy(r);
4162	return FALSE;
4163	}
4164
4165	static BOOLEAN jjENVELOPE(leftv res, leftv a)
4166	{
4167	ring r = (ring)a->Data();
4168	if (rIsPluralRing(r))
4169	{
4170	// ideal i;
4171	// if (a->rtyp == QRING_CMD)
4172	// {
4173	// i = r->qideal;
4174	// r->qideal = NULL;
4175	// }
4176	ring s = rEnvelope(r);
4177	// if (a->rtyp == QRING_CMD)
4178	// {
4179	// ideal is = idOppose(r,i); /* twostd? */
4180	// is = idAdd(is,i);
4181	// s->qideal = i;
4182	// }
4183	res->data = s;
4184	}
4185	else res->data = rCopy(r);
4186	return FALSE;
4187	}
4188
4189	static BOOLEAN jjTWOSTD(leftv res, leftv a)
4190	{
4191	if (rIsPluralRing(currRing)) res->data=(ideal)twostd((ideal)a->Data());
4192	else res->data=(ideal)a->Data();
4193	setFlag(res,FLAG_STD);
4194	setFlag(res,FLAG_TWOSTD);
4195	return FALSE;
4196	}
4197	#endif
4198
4199	static BOOLEAN jjTYPEOF(leftv res, leftv v)
4200	{
4201	switch ((int)(long)v->data)
4202	{
4203	case INT_CMD: res->data=omStrDup("int"); break;
4204	case POLY_CMD: res->data=omStrDup("poly"); break;
4205	case VECTOR_CMD: res->data=omStrDup("vector"); break;
4206	case STRING_CMD: res->data=omStrDup("string"); break;
4207	case INTVEC_CMD: res->data=omStrDup("intvec"); break;
4208	case IDEAL_CMD: res->data=omStrDup("ideal"); break;
4209	case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4210	case MODUL_CMD: res->data=omStrDup("module"); break;
4211	case MAP_CMD: res->data=omStrDup("map"); break;
4212	case PROC_CMD: res->data=omStrDup("proc"); break;
4213	case RING_CMD: res->data=omStrDup("ring"); break;
4214	case QRING_CMD: res->data=omStrDup("qring"); break;
4215	case INTMAT_CMD: res->data=omStrDup("intmat"); break;
4216	case NUMBER_CMD: res->data=omStrDup("number"); break;
4217	case BIGINT_CMD: res->data=omStrDup("bigint"); break;
4218	case LIST_CMD: res->data=omStrDup("list"); break;
4219	case PACKAGE_CMD: res->data=omStrDup("package"); break;
4220	case LINK_CMD: res->data=omStrDup("link"); break;
4221	case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4222	case DEF_CMD:
4223	case NONE: res->data=omStrDup("none"); break;
4224	default: res->data=omStrDup("?unknown type?");
4225	}
4226	return FALSE;
4227	}
4228	static BOOLEAN jjVAR1(leftv res, leftv v)
4229	{
4230	int i=(int)(long)v->Data();
4231	if ((0<i) && (i<=currRing->N))
4232	{
4233	poly p=pOne();
4234	pSetExp(p,i,1);
4235	pSetm(p);
4236	res->data=(char *)p;
4237	}
4238	else
4239	{
4240	Werror("var number %d out of range 1..%d",i,currRing->N);
4241	return TRUE;
4242	}
4243	return FALSE;
4244	}
4245	static BOOLEAN jjVARSTR1(leftv res, leftv v)
4246	{
4247	if (currRing==NULL)
4248	{
4249	WerrorS("no ring active");
4250	return TRUE;
4251	}
4252	int i=(int)(long)v->Data();
4253	if ((0<i) && (i<=currRing->N))
4254	res->data=omStrDup(currRing->names[i-1]);
4255	else
4256	{
4257	Werror("var number %d out of range 1..%d",i,currRing->N);
4258	return TRUE;
4259	}
4260	return FALSE;
4261	}
4262	static BOOLEAN jjVDIM(leftv res, leftv v)
4263	{
4264	assumeStdFlag(v);
4265	res->data = (char *)(long)scMult0Int((ideal)v->Data(),currQuotient);
4266	return FALSE;
4267	}
4268
4269	static BOOLEAN jjLOAD1(leftv res, leftv v)
4270	{
4271	return jjLOAD(res, v,iiOp==LIB_CMD);
4272	}
4273	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4274	{
4275	#ifdef HAVE_NS
4276	char * s=(char *)v->CopyD();
4277	char libnamebuf[256];
4278	lib_types LT = type_of_LIB(s, libnamebuf);
4279	#ifdef HAVE_DYNAMIC_LOADING
4280	extern BOOLEAN load_modules(char newlib, char fullpath, BOOLEAN autoexport);
4281	#endif /* HAVE_DYNAMIC_LOADING */
4282	switch(LT)
4283	{
4284	default:
4285	case LT_NONE:
4286	Werror("%s: unknown type", s);
4287	break;
4288	case LT_NOTFOUND:
4289	Werror("cannot open %s", s);
4290	break;
4291
4292	case LT_SINGULAR:
4293	{
4294	char *plib = iiConvName(s);
4295	idhdl pl = IDROOT->get(plib,0);
4296	if (pl==NULL)
4297	{
4298	pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4299	IDPACKAGE(pl)->language = LANG_SINGULAR;
4300	IDPACKAGE(pl)->libname=omStrDup(plib);
4301	}
4302	else if (IDTYP(pl)!=PACKAGE_CMD)
4303	{
4304	Werror("can not create package `%s`",plib);
4305	omFree(plib);
4306	return TRUE;
4307	}
4308	package savepack=currPack;
4309	currPack=IDPACKAGE(pl);
4310	IDPACKAGE(pl)->loaded=TRUE;
4311	char libnamebuf[256];
4312	FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4313	BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4314	currPack=savepack;
4315	IDPACKAGE(pl)->loaded=(!bo);
4316	return bo;
4317	}
4318	case LT_MACH_O:
4319	case LT_ELF:
4320	case LT_HPUX:
4321	#ifdef HAVE_DYNAMIC_LOADING
4322	return load_modules(s, libnamebuf, autoexport);
4323	#else /* HAVE_DYNAMIC_LOADING */
4324	WerrorS("Dynamic modules are not supported by this version of Singular");
4325	break;
4326	#endif /* HAVE_DYNAMIC_LOADING */
4327	}
4328	#endif
4329	return TRUE;
4330	}
4331
4332	/=================== operations with 1 arg.: table =================/
4333
4334	#ifdef INIT_BUG
4335	#define XS(A) -((short)A)
4336	#define jjstrlen (proc1)1
4337	#define jjpLength (proc1)2
4338	#define jjidElem (proc1)3
4339	#define jjmpDetBareiss (proc1)4
4340	#define jjidFreeModule (proc1)5
4341	#define jjidVec2Ideal (proc1)6
4342	#define jjrCharStr (proc1)7
4343	#ifndef MDEBUG
4344	#define jjpHead (proc1)8
4345	#endif
4346	#define jjidHead (proc1)9
4347	#define jjidMaxIdeal (proc1)10
4348	#define jjidMinBase (proc1)11
4349	#define jjsyMinBase (proc1)12
4350	#define jjpMaxComp (proc1)13
4351	#define jjmpTrace (proc1)14
4352	#define jjmpTransp (proc1)15
4353	#define jjrOrdStr (proc1)16
4354	#define jjrVarStr (proc1)18
4355	#define jjrParStr (proc1)19
4356	#define jjCOUNT_RES (proc1)22
4357	#define jjDIM_R (proc1)23
4358	#define jjidTransp (proc1)24
4359
4360	extern struct sValCmd1 dArith1[];
4361	void jjInitTab1()
4362	{
4363	int i=0;
4364	for (;dArith1[i].cmd!=0;i++)
4365	{
4366	if (dArith1[i].res<0)
4367	{
4368	switch ((int)dArith1[i].p)
4369	{
4370	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
4371	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
4372	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
4373	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
4374	#ifndef HAVE_FACTORY
4375	case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4376	#endif
4377	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4378	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
4379	#ifndef MDEBUG
4380	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
4381	#endif
4382	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
4383	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
4384	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
4385	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
4386	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxCompProc; break;
4387	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
4388	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
4389	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
4390	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
4391	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
4392	case (int)jjCOUNT_RES: dArith1[i].p=(proc1)syLength; break;
4393	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
4394	case (int)jjidTransp: dArith1[i].p=(proc1)idTransp; break;
4395	#ifdef GENTABLE
4396	default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4397	#endif
4398	}
4399	}
4400	}
4401	}
4402	#else
4403	#if defined(PROC_BUG)
4404	#define XS(A) A
4405	static BOOLEAN jjstrlen(leftv res, leftv v)
4406	{
4407	res->data = (char )strlen((char )v->Data());
4408	return FALSE;
4409	}
4410	static BOOLEAN jjpLength(leftv res, leftv v)
4411	{
4412	res->data = (char *)pLength((poly)v->Data());
4413	return FALSE;
4414	}
4415	static BOOLEAN jjidElem(leftv res, leftv v)
4416	{
4417	res->data = (char *)idElem((ideal)v->Data());
4418	return FALSE;
4419	}
4420	static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4421	{
4422	res->data = (char *)mpDetBareiss((matrix)v->Data());
4423	return FALSE;
4424	}
4425	static BOOLEAN jjidFreeModule(leftv res, leftv v)
4426	{
4427	res->data = (char *)idFreeModule((int)(long)v->Data());
4428	return FALSE;
4429	}
4430	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4431	{
4432	res->data = (char *)idVec2Ideal((poly)v->Data());
4433	return FALSE;
4434	}
4435	static BOOLEAN jjrCharStr(leftv res, leftv v)
4436	{
4437	res->data = rCharStr((ring)v->Data());
4438	return FALSE;
4439	}
4440	#ifndef MDEBUG
4441	static BOOLEAN jjpHead(leftv res, leftv v)
4442	{
4443	res->data = (char *)pHead((poly)v->Data());
4444	return FALSE;
4445	}
4446	#endif
4447	static BOOLEAN jjidHead(leftv res, leftv v)
4448	{
4449	res->data = (char *)idHead((ideal)v->Data());
4450	return FALSE;
4451	}
4452	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4453	{
4454	res->data = (char *)idMaxIdeal((int)(long)v->Data());
4455	return FALSE;
4456	}
4457	static BOOLEAN jjidMinBase(leftv res, leftv v)
4458	{
4459	res->data = (char *)idMinBase((ideal)v->Data());
4460	return FALSE;
4461	}
4462	static BOOLEAN jjsyMinBase(leftv res, leftv v)
4463	{
4464	res->data = (char *)syMinBase((ideal)v->Data());
4465	return FALSE;
4466	}
4467	static BOOLEAN jjpMaxComp(leftv res, leftv v)
4468	{
4469	res->data = (char *)pMaxComp((poly)v->Data());
4470	return FALSE;
4471	}
4472	static BOOLEAN jjmpTrace(leftv res, leftv v)
4473	{
4474	res->data = (char *)mpTrace((matrix)v->Data());
4475	return FALSE;
4476	}
4477	static BOOLEAN jjmpTransp(leftv res, leftv v)
4478	{
4479	res->data = (char *)mpTransp((matrix)v->Data());
4480	return FALSE;
4481	}
4482	static BOOLEAN jjrOrdStr(leftv res, leftv v)
4483	{
4484	res->data = rOrdStr((ring)v->Data());
4485	return FALSE;
4486	}
4487	static BOOLEAN jjrVarStr(leftv res, leftv v)
4488	{
4489	res->data = rVarStr((ring)v->Data());
4490	return FALSE;
4491	}
4492	static BOOLEAN jjrParStr(leftv res, leftv v)
4493	{
4494	res->data = rParStr((ring)v->Data());
4495	return FALSE;
4496	}
4497	static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4498	{
4499	res->data=(char *)syLength((syStrategy)v->Data());
4500	return FALSE;
4501	}
4502	static BOOLEAN jjDIM_R(leftv res, leftv v)
4503	{
4504	res->data = (char *)syDim((syStrategy)v->Data());
4505	return FALSE;
4506	}
4507	static BOOLEAN jjidTransp(leftv res, leftv v)
4508	{
4509	res->data = (char *)idTransp((ideal)v->Data());
4510	return FALSE;
4511	}
4512	#else
4513	#define XS(A) -((short)A)
4514	#define jjstrlen (proc1)strlen
4515	#define jjpLength (proc1)pLength
4516	#define jjidElem (proc1)idElem
4517	#define jjmpDetBareiss (proc1)mpDetBareiss
4518	#define jjidFreeModule (proc1)idFreeModule
4519	#define jjidVec2Ideal (proc1)idVec2Ideal
4520	#define jjrCharStr (proc1)rCharStr
4521	#ifndef MDEBUG
4522	#define jjpHead (proc1)pHeadProc
4523	#endif
4524	#define jjidHead (proc1)idHead
4525	#define jjidMaxIdeal (proc1)idMaxIdeal
4526	#define jjidMinBase (proc1)idMinBase
4527	#define jjsyMinBase (proc1)syMinBase
4528	#define jjpMaxComp (proc1)pMaxCompProc
4529	#define jjmpTrace (proc1)mpTrace
4530	#define jjmpTransp (proc1)mpTransp
4531	#define jjrOrdStr (proc1)rOrdStr
4532	#define jjrVarStr (proc1)rVarStr
4533	#define jjrParStr (proc1)rParStr
4534	#define jjCOUNT_RES (proc1)syLength
4535	#define jjDIM_R (proc1)syDim
4536	#define jjidTransp (proc1)idTransp
4537	#endif
4538	#endif
4539	static BOOLEAN jjnInt(leftv res, leftv u)
4540	{
4541	number n=(number)u->Data();
4542	res->data=(char *)(long)nInt(n);
4543	return FALSE;
4544	}
4545	static BOOLEAN jjnlInt(leftv res, leftv u)
4546	{
4547	number n=(number)u->Data();
4548	res->data=(char *)(long)nlInt(n);
4549	return FALSE;
4550	}
4551	#define s short
4552	struct sValCmd1 dArith1[]=
4553	{
4554	// operations:
4555	// proc cmd res arg plural
4556	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4557	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4558	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL ALLOW_PLURAL}
4559	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL ALLOW_PLURAL}
4560	,{jjUMINUS_I, '-', INT_CMD, INT_CMD ALLOW_PLURAL}
4561	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4562	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD ALLOW_PLURAL}
4563	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4564	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4565	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4566	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4567	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD ALLOW_PLURAL}
4568	,{jjLOAD1, '(', NONE, STRING_CMD ALLOW_PLURAL}
4569	// and the procedures with 1 argument:
4570	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4571	//,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD NO_PLURAL}
4572	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4573	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD ALLOW_PLURAL}
4574	,{syBetti1, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4575	,{jjBETTI, BETTI_CMD, INTMAT_CMD, IDEAL_CMD ALLOW_PLURAL}
4576	,{jjBETTI, BETTI_CMD, INTMAT_CMD, MODUL_CMD ALLOW_PLURAL}
4577	,{jjN2BI, BIGINT_CMD, BIGINT_CMD, NUMBER_CMD ALLOW_PLURAL}
4578	,{jjDUMMY, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
4579	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4580	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4581	#ifdef HAVE_FACTORY
4582	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4583	#else
4584	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4585	#endif
4586	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4587	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4588	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4589	//,{jjWRONG, COLS_CMD, 0, VECTOR_CMD ALLOW_PLURAL}
4590	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4591	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4592	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4593	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4594	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4595	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4596	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4597	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4598	,{jjCOUNT_RES, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4599	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD ALLOW_PLURAL}
4600	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD ALLOW_PLURAL}
4601	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4602	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD ALLOW_PLURAL}
4603	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD ALLOW_PLURAL}
4604	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4605	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4606	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4607	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD ALLOW_PLURAL}
4608	,{jjCOUNT_RG, COUNT_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4609	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
4610	,{jjWRONG, DEF_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4611	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4612	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4613	,{jjDEG_M, DEG_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4614	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD NO_PLURAL}
4615	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD NO_PLURAL}
4616	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD ALLOW_PLURAL}
4617	#ifdef HAVE_FACTORY
4618	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4619	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
4620	,{jjDET_S, DET_CMD, POLY_CMD, MODUL_CMD NO_PLURAL}
4621	#else
4622	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4623	,{jjmpDetBareiss,DET_CMD, XS(POLY_CMD), MATRIX_CMD NO_PLURAL}
4624	#endif
4625	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4626	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4627	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4628	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4629	,{jjE, E_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
4630	,{jjEXECUTE, EXECUTE_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4631	,{jjERROR, ERROR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4632	#ifdef HAVE_FACTORY
4633	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4634	#else
4635	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4636	#endif
4637	#ifdef HAVE_FGLM
4638	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4639	#else
4640	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4641	#endif
4642	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD ALLOW_PLURAL}
4643	#ifdef HAVE_FACTORY
4644	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4645	#else
4646	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4647	#endif
4648	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4649	,{jjHIGHCORNER, HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
4650	,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD NO_PLURAL}
4651	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD NO_PLURAL}
4652	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD NO_PLURAL}
4653	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
4654	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4655	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4656	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD ALLOW_PLURAL}
4657	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
4658	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD ALLOW_PLURAL}
4659	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD ALLOW_PLURAL}
4660	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD ALLOW_PLURAL}
4661	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4662	,{jjIMPART, IMPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4663	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD NO_PLURAL}
4664	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4665	,{jjnlInt, INT_CMD, INT_CMD, BIGINT_CMD ALLOW_PLURAL}
4666	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4667	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4668	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4669	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
4670	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4671	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
4672	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4673	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD ALLOW_PLURAL}
4674	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD ALLOW_PLURAL}
4675	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE ALLOW_PLURAL}
4676	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
4677	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD ALLOW_PLURAL}
4678	,{jjJanetBasis, JANET_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4679	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4680	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4681	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL ALLOW_PLURAL}
4682	#ifdef MDEBUG
4683	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4684	#else
4685	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD ALLOW_PLURAL}
4686	#endif
4687	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD ALLOW_PLURAL}
4688	#ifdef MDEBUG
4689	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4690	#else
4691	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD ALLOW_PLURAL}
4692	#endif
4693	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4694	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4695	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD ALLOW_PLURAL}
4696	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD ALLOW_PLURAL}
4697	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD ALLOW_PLURAL}
4698	,{jjLEADMONOM, LEADMONOM_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4699	,{jjLEADMONOM, LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4700	,{jjLOAD1, LIB_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4701	,{jjDUMMY, LINK_CMD, LINK_CMD, LINK_CMD ALLOW_PLURAL}
4702	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
4703	,{jjWRONG, MAP_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4704	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4705	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD ALLOW_PLURAL}
4706	,{jjMEMORY, MEMORY_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
4707	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD NO_PLURAL}
4708	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD NO_PLURAL}
4709	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
4710	,{jjMINRES_R, MINRES_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4711	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4712	,{jjMONITOR1, MONITOR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4713	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4714	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4715	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4716	,{jjMSTD, MSTD_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4717	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4718	,{jjNAMES, NAMES_CMD, LIST_CMD, PACKAGE_CMD ALLOW_PLURAL}
4719	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4720	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4721	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4722	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4723	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4724	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4725	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4726	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4727	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4728	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4729	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4730	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4731	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4732	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
4733	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4734	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4735	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4736	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4737	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4738	,{jjPREIMAGE_R, PREIMAGE_CMD, RING_CMD, MAP_CMD NO_PLURAL}
4739	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4740	,{jjPRINT, PRINT_CMD, NONE, LIST_CMD ALLOW_PLURAL}
4741	,{jjPRINT, PRINT_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4742	,{jjPRUNE, PRUNE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4743	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4744	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4745	,{jjWRONG, QRING_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4746	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD ALLOW_PLURAL}
4747	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD NO_PLURAL}
4748	,{jjREPART, REPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4749	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD ALLOW_PLURAL}
4750	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD ALLOW_PLURAL}
4751	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4752	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4753	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4754	,{jjDUMMY, RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4755	,{jjLISTRING, RING_CMD, RING_CMD, LIST_CMD ALLOW_PLURAL}
4756	//,{jjWRONG, ROWS_CMD, 0, POLY_CMD ALLOW_PLURAL}
4757	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4758	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4759	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4760	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4761	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4762	,{jjSLIM_GB, SLIM_GB_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4763	,{jjSLIM_GB, SLIM_GB_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4764	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4765	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4766	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4767	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4768	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
4769	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4770	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
4771	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4772	#ifdef HAVE_PLURAL
4773	,{jjENVELOPE, ENVELOPE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4774	,{jjENVELOPE, ENVELOPE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4775	,{jjOPPOSITE, OPPOSITE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4776	,{jjOPPOSITE, OPPOSITE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4777	,{jjTWOSTD, TWOSTD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4778	#endif
4779	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4780	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD ALLOW_PLURAL}
4781	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4782	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD ALLOW_PLURAL}
4783	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
4784	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4785	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD ALLOW_PLURAL}
4786	,{jjidTransp, TRANSPOSE_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4787	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4788	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4789	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4790	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4791	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
4792	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4793	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4794	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4795	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4796	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4797	,{jjLOAD1, LOAD_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4798	,{loNewtonP, NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4799	,{NULL, 0, 0, 0 NO_PLURAL}
4800	};
4801	#undef s
4802	/=================== operations with 3 args.: static proc =================/
4803	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4804	{
4805	char s= (char )u->Data();
4806	int r = (int)(long)v->Data();
4807	int c = (int)(long)w->Data();
4808	int l = strlen(s);
4809
4810	if ( (r<1) \|\| (r>l) \|\| (c<0) )
4811	{
4812	Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4813	return TRUE;
4814	}
4815	res->data = (char *)omAlloc((long)(c+1));
4816	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
4817	return FALSE;
4818	}
4819	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4820	{
4821	intvec iv = (intvec )u->Data();
4822	int r = (int)(long)v->Data();
4823	int c = (int)(long)w->Data();
4824	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
4825	{
4826	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4827	r,c,u->Fullname(),iv->rows(),iv->cols());
4828	return TRUE;
4829	}
4830	res->data=u->data; u->data=NULL;
4831	res->rtyp=u->rtyp; u->rtyp=0;
4832	res->name=u->name; u->name=NULL;
4833	res->attribute=u->attribute; u->attribute=NULL;
4834	Subexpr e=jjMakeSub(v);
4835	e->next=jjMakeSub(w);
4836	if (u->e==NULL) res->e=e;
4837	else
4838	{
4839	Subexpr h=u->e;
4840	while (h->next!=NULL) h=h->next;
4841	h->next=e;
4842	res->e=u->e;
4843	u->e=NULL;
4844	}
4845	return FALSE;
4846	}
4847	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4848	{
4849	matrix m= (matrix)u->Data();
4850	int r = (int)(long)v->Data();
4851	int c = (int)(long)w->Data();
4852	//Print("gen. elem %d, %d\n",r,c);
4853	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
4854	{
4855	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4856	MATROWS(m),MATCOLS(m));
4857	return TRUE;
4858	}
4859	res->data=u->data; u->data=NULL;
4860	res->rtyp=u->rtyp; u->rtyp=0;
4861	res->name=u->name; u->name=NULL;
4862	res->attribute=u->attribute; u->attribute=NULL;
4863	Subexpr e=jjMakeSub(v);
4864	e->next=jjMakeSub(w);
4865	if (u->e==NULL)
4866	res->e=e;
4867	else
4868	{
4869	Subexpr h=u->e;
4870	while (h->next!=NULL) h=h->next;
4871	h->next=e;
4872	res->e=u->e;
4873	u->e=NULL;
4874	}
4875	return FALSE;
4876	}
4877	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4878	{
4879	sleftv t;
4880	sleftv ut;
4881	leftv p=NULL;
4882	intvec iv=(intvec )w->Data();
4883	int l;
4884	BOOLEAN nok;
4885
4886	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4887	{
4888	WerrorS("cannot build expression lists from unnamed objects");
4889	return TRUE;
4890	}
4891	memcpy(&ut,u,sizeof(ut));
4892	memset(&t,0,sizeof(t));
4893	t.rtyp=INT_CMD;
4894	for (l=0;l< iv->length(); l++)
4895	{
4896	t.data=(char )(long)((iv)[l]);
4897	if (p==NULL)
4898	{
4899	p=res;
4900	}
4901	else
4902	{
4903	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4904	p=p->next;
4905	}
4906	memcpy(u,&ut,sizeof(ut));
4907	if (u->Typ() == MATRIX_CMD)
4908	nok=jjBRACK_Ma(p,u,v,&t);
4909	else /* INTMAT_CMD */
4910	nok=jjBRACK_Im(p,u,v,&t);
4911	if (nok)
4912	{
4913	while (res->next!=NULL)
4914	{
4915	p=res->next->next;
4916	omFreeBin((ADDRESS)res->next, sleftv_bin);
4917	// res->e aufraeumen !!!!
4918	res->next=p;
4919	}
4920	return TRUE;
4921	}
4922	}
4923	return FALSE;
4924	}
4925	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4926	{
4927	sleftv t;
4928	sleftv ut;
4929	leftv p=NULL;
4930	intvec iv=(intvec )v->Data();
4931	int l;
4932	BOOLEAN nok;
4933
4934	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4935	{
4936	WerrorS("cannot build expression lists from unnamed objects");
4937	return TRUE;
4938	}
4939	memcpy(&ut,u,sizeof(ut));
4940	memset(&t,0,sizeof(t));
4941	t.rtyp=INT_CMD;
4942	for (l=0;l< iv->length(); l++)
4943	{
4944	t.data=(char )(long)((iv)[l]);
4945	if (p==NULL)
4946	{
4947	p=res;
4948	}
4949	else
4950	{
4951	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4952	p=p->next;
4953	}
4954	memcpy(u,&ut,sizeof(ut));
4955	if (u->Typ() == MATRIX_CMD)
4956	nok=jjBRACK_Ma(p,u,&t,w);
4957	else /* INTMAT_CMD */
4958	nok=jjBRACK_Im(p,u,&t,w);
4959	if (nok)
4960	{
4961	while (res->next!=NULL)
4962	{
4963	p=res->next->next;
4964	omFreeBin((ADDRESS)res->next, sleftv_bin);
4965	// res->e aufraeumen !!
4966	res->next=p;
4967	}
4968	return TRUE;
4969	}
4970	}
4971	return FALSE;
4972	}
4973	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4974	{
4975	sleftv t1,t2,ut;
4976	leftv p=NULL;
4977	intvec vv=(intvec )v->Data();
4978	intvec wv=(intvec )w->Data();
4979	int vl;
4980	int wl;
4981	BOOLEAN nok;
4982
4983	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4984	{
4985	WerrorS("cannot build expression lists from unnamed objects");
4986	return TRUE;
4987	}
4988	memcpy(&ut,u,sizeof(ut));
4989	memset(&t1,0,sizeof(sleftv));
4990	memset(&t2,0,sizeof(sleftv));
4991	t1.rtyp=INT_CMD;
4992	t2.rtyp=INT_CMD;
4993	for (vl=0;vl< vv->length(); vl++)
4994	{
4995	t1.data=(char )(long)((vv)[vl]);
4996	for (wl=0;wl< wv->length(); wl++)
4997	{
4998	t2.data=(char )(long)((wv)[wl]);
4999	if (p==NULL)
5000	{
5001	p=res;
5002	}
5003	else
5004	{
5005	p->next=(leftv)omAlloc0Bin(sleftv_bin);
5006	p=p->next;
5007	}
5008	memcpy(u,&ut,sizeof(ut));
5009	if (u->Typ() == MATRIX_CMD)
5010	nok=jjBRACK_Ma(p,u,&t1,&t2);
5011	else /* INTMAT_CMD */
5012	nok=jjBRACK_Im(p,u,&t1,&t2);
5013	if (nok)
5014	{
5015	res->CleanUp();
5016	return TRUE;
5017	}
5018	}
5019	}
5020	return FALSE;
5021	}
5022	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
5023	{
5024	v->next=(leftv)omAllocBin(sleftv_bin);
5025	memcpy(v->next,w,sizeof(sleftv));
5026	memset(w,0,sizeof(sleftv));
5027	return jjPROC(res,u,v);
5028	}
5029	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
5030	{
5031	u->next=(leftv)omAllocBin(sleftv_bin);
5032	memcpy(u->next,v,sizeof(sleftv));
5033	u->next->next=(leftv)omAllocBin(sleftv_bin);
5034	memcpy(u->next->next,w,sizeof(sleftv));
5035	BOOLEAN r=iiExprArithM(res,u,iiOp);
5036	// iiExprArithM did the CleanUp
5037	w->rtyp=0; w->data=NULL;
5038	return r;
5039	}
5040	static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5041	{
5042	intvec *iv;
5043	ideal m;
5044	lists l=(lists)omAllocBin(slists_bin);
5045	int k=(int)(long)w->Data();
5046	if (k>=0)
5047	{
5048	smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
5049	l->Init(2);
5050	l->m[0].rtyp=MODUL_CMD;
5051	l->m[1].rtyp=INTVEC_CMD;
5052	l->m[0].data=(void *)m;
5053	l->m[1].data=(void *)iv;
5054	}
5055	else
5056	{
5057	m=smCallSolv((ideal)u->Data());
5058	l->Init(1);
5059	l->m[0].rtyp=IDEAL_CMD;
5060	l->m[0].data=(void *)m;
5061	}
5062	res->data = (char *)l;
5063	return FALSE;
5064	}
5065	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5066	{
5067	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5068	{
5069	WerrorS("3rd argument must be a name of a matrix");
5070	return TRUE;
5071	}
5072	ideal i=(ideal)u->Data();
5073	int rank=(int)i->rank;
5074	BOOLEAN r=jjCOEFFS_Id(res,u,v);
5075	if (r) return TRUE;
5076	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5077	return FALSE;
5078	}
5079	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5080	{
5081	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5082	(ideal)(v->Data()),(poly)(w->Data()));
5083	return FALSE;
5084	}
5085	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5086	{
5087	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5088	{
5089	WerrorS("3rd argument must be a name of a matrix");
5090	return TRUE;
5091	}
5092	// CopyD for POLY_CMD and VECTOR_CMD are identical:
5093	poly p=(poly)u->CopyD(POLY_CMD);
5094	ideal i=idInit(1,1);
5095	i->m[0]=p;
5096	sleftv t;
5097	memset(&t,0,sizeof(t));
5098	t.data=(char *)i;
5099	t.rtyp=IDEAL_CMD;
5100	int rank=1;
5101	if (u->Typ()==VECTOR_CMD)
5102	{
5103	i->rank=rank=pMaxComp(p);
5104	t.rtyp=MODUL_CMD;
5105	}
5106	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5107	t.CleanUp();
5108	if (r) return TRUE;
5109	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5110	return FALSE;
5111	}
5112	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5113	{
5114	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5115	(intvec *)w->Data());
5116	setFlag(res,FLAG_STD);
5117	return FALSE;
5118	}
5119	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5120	{
5121	/*4
5122	* look for the substring what in the string where
5123	* starting at position n
5124	* return the position of the first char of what in where
5125	* or 0
5126	*/
5127	int n=(int)(long)w->Data();
5128	char where=(char )u->Data();
5129	char what=(char )v->Data();
5130	char *found;
5131	if ((1>n)\|\|(n>(int)strlen(where)))
5132	{
5133	Werror("start position %d out of range",n);
5134	return TRUE;
5135	}
5136	found = strchr(where+n-1,*what);
5137	if (*(what+1)!='\0')
5138	{
5139	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5140	{
5141	found=strchr(found+1,*what);
5142	}
5143	}
5144	if (found != NULL)
5145	{
5146	res->data=(char *)((found-where)+1);
5147	}
5148	return FALSE;
5149	}
5150	static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5151	{
5152	if ((int)(long)w->Data()==0)
5153	res->data=(char *)walkProc(u,v);
5154	else
5155	res->data=(char *)fractalWalkProc(u,v);
5156	setFlag( res, FLAG_STD );
5157	return FALSE;
5158	}
5159	static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5160	{
5161	assumeStdFlag(u);
5162	intvec module_w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
5163	intvec wdegree=(intvec)w->Data();
5164	if (wdegree->length()!=pVariables)
5165	{
5166	Werror("weight vector must have size %d, not %d",
5167	pVariables,wdegree->length());
5168	return TRUE;
5169	}
5170	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5171	switch((int)(long)v->Data())
5172	{
5173	case 1:
5174	res->data=(void *)iv;
5175	return FALSE;
5176	case 2:
5177	res->data=(void *)hSecondSeries(iv);
5178	delete iv;
5179	return FALSE;
5180	}
5181	WerrorS(feNotImplemented);
5182	delete iv;
5183	return TRUE;
5184	}
5185	static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5186	{
5187	intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5188	intvec* arg = (intvec*) u->Data();
5189	int i, n = si_min(im->cols()im->rows(), arg->cols()arg->rows());
5190
5191	for (i=0; i<n; i++)
5192	{
5193	(im)[i] = (arg)[i];
5194	}
5195
5196	res->data = (char *)im;
5197	return FALSE;
5198	}
5199	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5200	{
5201	short iw=iv2array((intvec )w->Data());
5202	res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5203	omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5204	return FALSE;
5205	}
5206	static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5207	{
5208	if (!pIsUnit((poly)v->Data()))
5209	{
5210	WerrorS("2nd argument must be a unit");
5211	return TRUE;
5212	}
5213	res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5214	return FALSE;
5215	}
5216	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5217	{
5218	res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5219	(intvec *)w->Data());
5220	return FALSE;
5221	}
5222	static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5223	{
5224	if (!mpIsDiagUnit((matrix)v->Data()))
5225	{
5226	WerrorS("2nd argument must be a diagonal matrix of units");
5227	return TRUE;
5228	}
5229	res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5230	(matrix)v->CopyD());
5231	return FALSE;
5232	}
5233	static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5234	{
5235	assumeStdFlag(w);
5236	res->data = (char *)idMinors(
5237	(matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5238	return FALSE;
5239	}
5240	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5241	{
5242	idhdl h;
5243	ring rr;
5244	map mapping;
5245
5246	if ((v->name==NULL) \|\| (w->name==NULL))
5247	{
5248	WerrorS("2nd/3rd arguments must have names");
5249	return TRUE;
5250	}
5251	rr=(ring)u->Data();
5252	const char *ring_name=u->Name();
5253	if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5254	{
5255	if (h->typ==MAP_CMD)
5256	{
5257	mapping=IDMAP(h);
5258	idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5259	if ((preim_ring==NULL)
5260	\|\| (IDRING(preim_ring)!=currRing))
5261	{
5262	Werror("preimage ring `%s` is not the basering",mapping->preimage);
5263	return TRUE;
5264	}
5265	}
5266	else if (h->typ==IDEAL_CMD)
5267	{
5268	mapping=IDMAP(h);
5269	}
5270	else
5271	{
5272	Werror("`%s` is no map nor ideal",IDID(h));
5273	return TRUE;
5274	}
5275	}
5276	else
5277	{
5278	Werror("`%s` is not defined in `%s`",v->name,ring_name);
5279	return TRUE;
5280	}
5281	if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5282	{
5283	if (h->typ==IDEAL_CMD)
5284	{
5285	if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5286	\|\| ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5287	{
5288	WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5289	}
5290	res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5291	if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5292	}
5293	else
5294	{
5295	Werror("`%s` is no ideal",IDID(h));
5296	return TRUE;
5297	}
5298	}
5299	else
5300	{
5301	Werror("`%s` is not defined in `%s`",w->name,ring_name);
5302	return TRUE;
5303	}
5304	return FALSE;
5305	}
5306	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5307	{
5308	int di, k;
5309	int i=(int)(long)u->Data();
5310	int r=(int)(long)v->Data();
5311	int c=(int)(long)w->Data();
5312	if ((r<=0) \|\| (c<=0)) return TRUE;
5313	intvec *iv = new intvec(r, c, 0);
5314	if (iv->rows()==0)
5315	{
5316	delete iv;
5317	return TRUE;
5318	}
5319	if (i!=0)
5320	{
5321	if (i<0) i = -i;
5322	di = 2 * i + 1;
5323	for (k=0; k<iv->length(); k++)
5324	{
5325	#ifdef buildin_rand
5326	(*iv)[k] = ((siRand() % di) - i);
5327	#else
5328	(*iv)[k] = ((rand() % di) - i);
5329	#endif
5330	}
5331	}
5332	res->data = (char *)iv;
5333	return FALSE;
5334	}
5335	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5336	int &ringvar, poly &monomexpr)
5337	{
5338	monomexpr=(poly)w->Data();
5339	poly p=(poly)v->Data();
5340	#if 0
5341	if (pLength(monomexpr)>1)
5342	{
5343	Werror("`%s` substitutes a ringvar only by a term",
5344	Tok2Cmdname(SUBST_CMD));
5345	return TRUE;
5346	}
5347	#endif
5348	if (!(ringvar=pVar(p)))
5349	{
5350	if (rField_is_Extension(currRing))
5351	{
5352	assume(currRing->algring!=NULL);
5353	lnumber n=(lnumber)pGetCoeff(p);
5354	ringvar=-p_Var(n->z,currRing->algring);
5355	}
5356	if(ringvar==0)
5357	{
5358	WerrorS("ringvar/par expected");
5359	return TRUE;
5360	}
5361	}
5362	return FALSE;
5363	}
5364	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5365	{
5366	int ringvar;
5367	poly monomexpr;
5368	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5369	if (nok) return TRUE;
5370	if (ringvar>0)
5371	{
5372	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5373	res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5374	else
5375	res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5376	}
5377	else
5378	{
5379	res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5380	}
5381	return FALSE;
5382	}
5383	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5384	{
5385	int ringvar;
5386	poly monomexpr;
5387	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5388	if (nok) return TRUE;
5389	if (ringvar>0)
5390	{
5391	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5392	res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5393	else
5394	res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5395