Context Navigation

source: git/Singular/iparith.cc @ 0e80d3

spielwiese

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

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

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

Download in other formats: