Context Navigation

source: git/Singular/iparith.cc @ f62996

spielwiese

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

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

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

Download in other formats: