Context Navigation

source: git/Singular/iparith.cc @ 45f7bf

spielwiese

Last change on this file since 45f7bf was 45f7bf, checked in by Olaf Bachmann <obachman@…>, 25 years ago
* status with sleep in microseconds * groebner with 2 args git-svn-id: file:///usr/local/Singular/svn/trunk@1962 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 153.8 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/*
5	* ABSTRACT: table driven kernel interface, used by interpreter
6	*/
7
8	#include <stdlib.h>
9	#include <string.h>
10	#include <ctype.h>
11
12	#include <stdio.h>
13	#include <time.h>
14
15	#include <unistd.h>
16
17	#include "mod2.h"
18	#include "tok.h"
19	#include "ipid.h"
20	#include "intvec.h"
21	#include "mmemory.h"
22	#include "febase.h"
23	#include "longalg.h"
24	#include "polys.h"
25	#include "ideals.h"
26	#include "matpol.h"
27	#include "kstd1.h"
28	#include "timer.h"
29	#include "ring.h"
30	#include "subexpr.h"
31	#include "lists.h"
32	#include "numbers.h"
33	#include "stairc.h"
34	#include "maps.h"
35	#include "syz.h"
36	#include "weight.h"
37	#include "ipconv.h"
38	#include "ipprint.h"
39	#include "sing_dld.h"
40	#include "attrib.h"
41	#include "silink.h"
42	#ifdef HAVE_FACTORY
43	#include "clapsing.h"
44	#include "kstdfac.h"
45	#endif
46	#ifdef HAVE_FGLM
47	#include "fglm.h"
48	#endif
49	#include "ipshell.h"
50
51	/=============== types =====================/
52	struct sValCmdTab
53	{
54	short cmd;
55	short start;
56	};
57
58	typedef sValCmdTab jjValCmdTab[];
59
60	/* ifdef GENTABLE: definitions are in ipshell.h */
61	#ifndef GENTABLE
62	typedef char * (Proc1)(char );
63	struct sValCmd1
64	{
65	proc1 p;
66	short cmd;
67	short res;
68	short arg;
69	};
70
71	typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
72	struct sValCmd2
73	{
74	proc2 p;
75	short cmd;
76	short res;
77	short arg1;
78	short arg2;
79	};
80
81	typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
82	struct sValCmd3
83	{
84	proc3 p;
85	short cmd;
86	short res;
87	short arg1;
88	short arg2;
89	short arg3;
90	};
91	struct sValCmdM
92	{
93	proc1 p;
94	short cmd;
95	short res;
96	short number_of_args; /* -1: any, -2: any >0, .. */
97	};
98	#endif
99
100
101	/============= proc =======================/
102	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
103	#ifdef MDEBUG
104	#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
105	static Subexpr jjDBMakeSub(leftv e,char *f, int l);
106	#else
107	static Subexpr jjMakeSub(leftv e);
108	#endif
109
110
111	/============= vars ======================/
112	extern int cmdtok;
113	extern BOOLEAN expected_parms;
114
115	int iiOp; /* the current operation*/
116
117	#ifdef GENTABLE
118	cmdnames cmds[] =
119	{ // name-string alias tokval toktype
120	{ "$INVALID$", 0, -1, 0},
121	{ "and", 0, '&' , '&'},
122	{ "attrib", 0, ATTRIB_CMD , CMD_123},
123	{ "bareiss", 0, BAREISS_CMD , CMD_1},
124	{ "betti", 0, BETTI_CMD , CMD_1},
125	{ "break", 0, BREAK_CMD , BREAK_CMD},
126	{ "char", 0, CHARACTERISTIC_CMD ,CMD_1},
127	{ "char_series", 0, CHAR_SERIES_CMD , CMD_1},
128	{ "charstr", 0, CHARSTR_CMD , CMD_1},
129	{ "cleardenom", 0, CONTENT_CMD , CMD_1},
130	{ "close", 0, CLOSE_CMD , CMD_1},
131	{ "coef", 0, COEF_CMD , CMD_M},
132	{ "coeffs", 0, COEFFS_CMD , CMD_23},
133	{ "continue", 0, CONTINUE_CMD , CONTINUE_CMD},
134	{ "contract", 0, CONTRACT_CMD , CMD_2},
135	{ "dbprint", 0, DBPRINT_CMD , CMD_M},
136	{ "def", 0, DEF_CMD , ROOT_DECL},
137	{ "defined", 0, DEFINED_CMD , CMD_1},
138	{ "deg", 0, DEG_CMD , CMD_12},
139	{ "degree", 0, DEGREE_CMD , CMD_1},
140	{ "delete", 0, DELETE_CMD , CMD_2},
141	{ "det", 0, DET_CMD , CMD_1},
142	{ "diff", 0, DIFF_CMD , CMD_2},
143	{ "dim", 0, DIM_CMD , CMD_1},
144	{ "div", 0, INTDIV , INTDIV},
145	//#ifdef DRING
146	{ "dring", 0, DRING_CMD , DRING_CMD},
147	//#endif
148	{ "dump", 0, DUMP_CMD, CMD_1},
149	{ "extgcd", 0, EXTGCD_CMD , CMD_2},
150	{ "EXTGCD", 2, EXTGCD_CMD , CMD_2},
151	{ "eliminate", 0, ELIMINATION_CMD, CMD_23},
152	{ "else", 0, ELSE_CMD , ELSE_CMD},
153	{ "eval", 0, EVAL , EVAL},
154	{ "example", 0, EXAMPLE_CMD , EXAMPLE_CMD},
155	{ "execute", 0, EXECUTE_CMD , EXECUTE_CMD},
156	{ "export", 0, EXPORT_CMD , EXPORT_CMD},
157	{ "factorize", 0, FAC_CMD , CMD_12},
158	{ "fetch", 0, FETCH_CMD , CMD_2},
159	{ "fglm", 0, FGLM_CMD , CMD_2},
160	{ "find", 0, FIND_CMD , CMD_23},
161	{ "finduni", 0, FINDUNI_CMD, CMD_1},
162	{ "forif", 0, IF_CMD , IF_CMD},
163	{ "freemodule", 0, FREEMODULE_CMD , CMD_1},
164	{ "facstd", 0, FACSTD_CMD , CMD_12},
165	{ "gen", 0, E_CMD , CMD_1},
166	{ "getdump", 0, GETDUMP_CMD, CMD_1},
167	{ "gcd", 0, GCD_CMD , CMD_2},
168	{ "GCD", 2, GCD_CMD , CMD_2},
169	{ "hilb", 0, HILBERT_CMD , CMD_12},
170	{ "homog", 0, HOMOG_CMD , CMD_12},
171	{ "ideal", 0, IDEAL_CMD , IDEAL_CMD},
172	{ "if", 0, IF_CMD , IF_CMD},
173	{ "imap", 0, IMAP_CMD , CMD_2},
174	{ "indepSet", 0, INDEPSET_CMD , CMD_12},
175	{ "insert", 0, INSERT_CMD , CMD_23},
176	{ "int", 0, INT_CMD , ROOT_DECL},
177	{ "interred", 0, INTERRED_CMD , CMD_1},
178	{ "intersect", 0, INTERSECT_CMD , CMD_M},
179	{ "intmat", 0, INTMAT_CMD , INTMAT_CMD},
180	{ "intvec", 0, INTVEC_CMD , ROOT_DECL_LIST},
181	{ "jacob", 0, JACOB_CMD , CMD_1},
182	{ "jet", 0, JET_CMD , CMD_23},
183	{ "kbase", 0, KBASE_CMD , CMD_12},
184	{ "keepring", 0, KEEPRING_CMD , KEEPRING_CMD},
185	{ "kill", 0, KILL_CMD , KILL_CMD},
186	{ "killattrib", 0, KILLATTR_CMD , CMD_12},
187	{ "koszul", 0, KOSZUL_CMD , CMD_23},
188	{ "lead", 0, LEAD_CMD , CMD_1},
189	{ "leadcoef", 0, LEADCOEF_CMD , CMD_1},
190	{ "leadexp", 0, LEADEXP_CMD , CMD_1},
191	{ "LIB", 0, LIB_CMD , SYSVAR},
192	{ "lift", 0, LIFT_CMD , CMD_2},
193	{ "liftstd", 0, LIFTSTD_CMD , CMD_2},
194	{ "link", 0, LINK_CMD , ROOT_DECL},
195	{ "listvar", 0, LISTVAR_CMD , LISTVAR_CMD},
196	{ "list", 0, LIST_CMD , ROOT_DECL_LIST},
197	{ "lres", 0, LRES_CMD , CMD_2},
198	{ "map", 0, MAP_CMD , RING_DECL},
199	{ "matrix", 0, MATRIX_CMD , MATRIX_CMD},
200	{ "maxideal", 0, MAXID_CMD , CMD_1},
201	{ "memory", 0, MEMORY_CMD , CMD_1},
202	{ "minbase", 0, MINBASE_CMD , CMD_1},
203	{ "minor", 0, MINOR_CMD , CMD_2},
204	{ "minres", 0, MINRES_CMD , CMD_1},
205	{ "mod", 0, '%', '%'},
206	{ "module", 0, MODUL_CMD , MODUL_CMD},
207	{ "modulo", 0, MODULO_CMD , CMD_2},
208	{ "monitor", 0, MONITOR_CMD , CMD_12},
209	{ "mult", 0, MULTIPLICITY_CMD , CMD_1},
210	#ifdef OLD_RES
211	{ "mres", 0, MRES_CMD , CMD_23},
212	#else
213	{ "mres", 0, MRES_CMD , CMD_2},
214	#endif
215	{ "mstd", 0, MSTD_CMD , CMD_1},
216	{ "nameof", 0, NAMEOF_CMD , CMD_1},
217	{ "names", 0, NAMES_CMD , CMD_M},
218	{ "ncols", 0, COLS_CMD , CMD_1},
219	{ "not", 0, NOT , NOT},
220	{ "npars", 0, NPARS_CMD , CMD_1},
221	{ "nrows", 0, ROWS_CMD , CMD_1},
222	{ "number", 0, NUMBER_CMD , RING_DECL},
223	{ "nvars", 0, NVARS_CMD , CMD_1},
224	{ "open", 0, OPEN_CMD , CMD_1},
225	{ "option", 0, OPTION_CMD , CMD_M},
226	{ "or", 0, '\|' , '\|'},
227	{ "ord", 0, ORD_CMD , CMD_1},
228	{ "ordstr", 0, ORDSTR_CMD , CMD_1},
229	{ "package", 0, PACKAGE_CMD , ROOT_DECL},
230	{ "par", 0, PAR_CMD , CMD_1},
231	{ "parameter", 0, PARAMETER , PARAMETER},
232	{ "pardeg", 0, PARDEG_CMD , CMD_1},
233	{ "parstr", 0, PARSTR_CMD , CMD_12},
234	{ "poly", 0, POLY_CMD , RING_DECL},
235	{ "preimage", 0, PREIMAGE_CMD , CMD_3},
236	{ "prime", 0, PRIME_CMD , CMD_1},
237	{ "print", 0, PRINT_CMD , CMD_12},
238	{ "prune", 0, PRUNE_CMD , CMD_1},
239	{ "proc", 0, PROC_CMD , PROC_CMD},
240	{ "qring", 0, QRING_CMD , ROOT_DECL},
241	{ "quotient", 0, QUOTIENT_CMD , CMD_2},
242	{ "quote", 0, QUOTE , QUOTE},
243	{ "qhweight", 0, QHWEIGHT_CMD , CMD_1},
244	{ "random", 0, RANDOM_CMD , CMD_23},
245	{ "read", 0, READ_CMD , CMD_12},
246	{ "reduce", 0, REDUCE_CMD , CMD_23},
247	{ "regularity", 0, REGULARITY_CMD , CMD_1},
248	#ifdef OLD_RES
249	{ "res", 0, RES_CMD , CMD_23},
250	#else
251	{ "res", 0, RES_CMD , CMD_2},
252	#endif
253	{ "reservedName",0, RESERVEDNAME_CMD , CMD_M},
254	{ "resolution", 0, RESOLUTION_CMD , RING_DECL},
255	{ "resultant", 0, RESULTANT_CMD, CMD_3},
256	{ "return", 0, RETURN , RETURN},
257	{ "RETURN", 0, END_GRAMMAR , RETURN},
258	{ "ring", 0, RING_CMD , RING_CMD},
259	{ "rvar", 0, IS_RINGVAR , CMD_1},
260	{ "setring", 0, SETRING_CMD , SETRING_CMD},
261	{ "simplify", 0, SIMPLIFY_CMD , CMD_2},
262	{ "size", 0, COUNT_CMD , CMD_1},
263	{ "sortvec", 0, SORTVEC_CMD , CMD_1},
264	#ifdef OLD_RES
265	{ "sres", 0, SRES_CMD , CMD_23},
266	#else
267	{ "sres", 0, SRES_CMD , CMD_2},
268	#endif
269	{ "status", 0, STATUS_CMD, CMD_M},
270	{ "std", 0, STD_CMD , CMD_12},
271	{ "string", 0, STRING_CMD , ROOT_DECL_LIST},
272	{ "subst", 0, SUBST_CMD , CMD_3},
273	{ "system", 0, SYSTEM_CMD, CMD_M},
274	{ "syz", 0, SYZYGY_CMD , CMD_1},
275	{ "test", 0, TEST_CMD , CMD_M},
276	{ "trace", 0, TRACE_CMD , CMD_1},
277	{ "transpose", 0, TRANSPOSE_CMD , CMD_1},
278	{ "type", 0, TYPE_CMD , TYPE_CMD},
279	{ "typeof", 0, TYPEOF_CMD , CMD_1},
280	{ "var", 0, VAR_CMD , CMD_1},
281	{ "varstr", 0, VARSTR_CMD , CMD_12},
282	{ "vdim", 0, VDIM_CMD , CMD_1},
283	{ "vector", 0, VECTOR_CMD , RING_DECL},
284	{ "wedge", 0, WEDGE_CMD , CMD_2},
285	{ "weight", 0, WEIGHT_CMD , CMD_1},
286	{ "whileif", 0, IF_CMD , IF_CMD},
287	{ "write", 0, WRITE_CMD , CMD_M},
288	/* delete for next version:*/
289	{ "IN", 1, LEAD_CMD , CMD_1},
290	{ "NF", 1, REDUCE_CMD , CMD_23},
291	{ "multiplicity",1, MULTIPLICITY_CMD , CMD_1},
292	{ "verbose", 2, OPTION_CMD , CMD_M},
293	// { "rank", 1, ROWS_CMD , CMD_1},
294
295	/* set sys vars*/
296	//#ifdef SRING
297	{ "alternating", 0, VALTVARS , SYSVAR},
298	//#endif
299	{ "degBound", 0, VMAXDEG , SYSVAR},
300	{ "echo", 0, VECHO , SYSVAR},
301	{ "minpoly", 0, VMINPOLY , SYSVAR},
302	{ "multBound", 0, VMAXMULT , SYSVAR},
303	{ "noether", 0, VNOETHER , SYSVAR},
304	{ "pagelength", 0, VPAGELENGTH , SYSVAR},
305	{ "pagewidth", 0, VCOLMAX , SYSVAR},
306	{ "printlevel", 0, VPRINTLEVEL , SYSVAR},
307	{ "short", 0, VSHORTOUT , SYSVAR},
308	{ "timer", 0, VTIMER , SYSVAR},
309	{ "rtimer", 0, VRTIMER, SYSVAR},
310	{ "TRACE", 0, TRACE , SYSVAR},
311	{ "voice", 0, VOICE , SYSVAR},
312
313
314	/* other reserved words:scanner.l */
315	{ "pause", 2, -1 , 0},
316	{ "while", 0, -1 , 0},
317	{ "for", 0, -1 , 0},
318	{ "help", 0, -1 , 0},
319	{ "newline", 0, -1 , 0},
320	{ "exit", 0, -1 , 0},
321	{ "quit", 0, -1 , 0},
322	/* end of list marker */
323	{ NULL, 0, 0, 0}
324	};
325	#endif
326
327	/=================== operations with 2 args.: static proc =================/
328	static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
329	{
330	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
331	int bb = (int)(v->Data());
332	if (errorreported) return TRUE;
333	switch (iiOp)
334	{
335	case '+': (*aa) += bb; break;
336	case '-': (*aa) -= bb; break;
337	case '': (aa) *= bb; break;
338	case '/':
339	case INTDIV: (*aa) /= bb; break;
340	case '%': (*aa) %= bb; break;
341	}
342	res->data=(char *)aa;
343	return FALSE;
344	}
345	static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
346	{
347	return jjOP_IV_I(res,v,u);
348	}
349	static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
350	{
351	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
352	int bb = (int)(v->Data());
353	int i=min(aa->rows(),aa->cols());
354	switch (iiOp)
355	{
356	case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
357	break;
358	case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
359	break;
360	}
361	res->data=(char *)aa;
362	return FALSE;
363	}
364	static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
365	{
366	return jjOP_IM_I(res,v,u);
367	}
368	static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
369	{
370	res->data=(char *)new intvec((int)u->Data(),(int)v->Data());
371	return FALSE;
372	}
373	static void jjEQUAL_REST(leftv res,leftv u,leftv v)
374	{
375	if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
376	{
377	int save_iiOp=iiOp;
378	if (iiOp==NOTEQUAL)
379	iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
380	else
381	iiExprArith2(res,u->next,iiOp,v->next);
382	iiOp=save_iiOp;
383	}
384	if (iiOp==NOTEQUAL) res->data=(char *)(!(int)res->data);
385	}
386	static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
387	{
388	intvec* a = (intvec * )(u->Data());
389	intvec* b = (intvec * )(v->Data());
390	int r=a->compare(b);
391	switch (iiOp)
392	{
393	case '<':
394	res->data = (char *) (r<0);
395	break;
396	case '>':
397	res->data = (char *) (r>0);
398	break;
399	case LE:
400	res->data = (char *) (r<=0);
401	break;
402	case GE:
403	res->data = (char *) (r>=0);
404	break;
405	case EQUAL_EQUAL:
406	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
407	res->data = (char *) (r==0);
408	break;
409	}
410	jjEQUAL_REST(res,u,v);
411	return r==-2;
412	}
413	static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
414	{
415	intvec* a = (intvec * )(u->Data());
416	int b = (int ) (v->Data());
417	int r=a->compare(b);
418	switch (iiOp)
419	{
420	case '<':
421	res->data = (char *) (r<0);
422	break;
423	case '>':
424	res->data = (char *) (r>0);
425	break;
426	case LE:
427	res->data = (char *) (r<=0);
428	break;
429	case GE:
430	res->data = (char *) (r>=0);
431	break;
432	case EQUAL_EQUAL:
433	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
434	res->data = (char *) (r==0);
435	break;
436	}
437	jjEQUAL_REST(res,u,v);
438	return FALSE;
439	}
440	static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
441	{
442	poly p=(poly)u->Data();
443	poly q=(poly)v->Data();
444	int r=pComp(p,q);
445	if (r==0)
446	{
447	/* compare lead coeffs */
448	number h=nSub(pGetCoeff(p),pGetCoeff(q));
449	r = -1+nIsZero(h)+2nGreaterZero(h); / -1: <, 0:==, 1: > */
450	nDelete(&h);
451	}
452	else if (p==NULL)
453	{
454	if (q==NULL)
455	{
456	/* compare 0, 0 */
457	r=0;
458	}
459	else if(pIsConstant(q))
460	{
461	/* compare 0, const */
462	r = 1-2nGreaterZero(pGetCoeff(q)); / -1: <, 1: > */
463	}
464	}
465	else if (q==NULL)
466	{
467	if (pIsConstant(p))
468	{
469	/* compare const, 0 */
470	r = -1+2nGreaterZero(pGetCoeff(p)); / -1: <, 1: > */
471	}
472	}
473	switch (iiOp)
474	{
475	case '<':
476	res->data = (char *) (r < 0);
477	break;
478	case '>':
479	res->data = (char *) (r > 0);
480	break;
481	case LE:
482	res->data = (char *) (r <= 0);
483	break;
484	case GE:
485	res->data = (char *) (r >= 0);
486	break;
487	//case EQUAL_EQUAL:
488	//case NOTEQUAL: /* negation handled by jjEQUAL_REST */
489	// res->data = (char *) (r == 0);
490	// break;
491	}
492	jjEQUAL_REST(res,u,v);
493	return FALSE;
494	}
495	static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
496	{
497	char* a = (char * )(u->Data());
498	char* b = (char * )(v->Data());
499	int result = strcmp(a,b);
500	switch (iiOp)
501	{
502	case '<':
503	res->data = (char *) (result < 0);
504	break;
505	case '>':
506	res->data = (char *) (result > 0);
507	break;
508	case LE:
509	res->data = (char *) (result <= 0);
510	break;
511	case GE:
512	res->data = (char *) (result >= 0);
513	break;
514	case EQUAL_EQUAL:
515	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
516	res->data = (char *) (result == 0);
517	break;
518	}
519	jjEQUAL_REST(res,u,v);
520	return FALSE;
521	}
522	static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
523	{
524	int b=(int)u->Data();
525	int e=(int)v->Data();
526	int rc = 1;
527	BOOLEAN overflow=FALSE;
528	if ((e >= 0)&&(b!=0))
529	{
530	int oldrc;
531	while ((e--)!=0)
532	{
533	oldrc=rc;
534	rc *= b;
535	if (!overflow)
536	{
537	if(rc/b!=oldrc) overflow=TRUE;
538	}
539	}
540	}
541	if (overflow)
542	Warn("int overflow(^), result may be wrong");
543	res->data = (char *)rc;
544	return FALSE;
545	}
546	static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
547	{
548	int e=(int)v->Data();
549	number n=(number)u->CopyD();
550	if (e<0)
551	{
552	number m=nInvers(n);
553	nDelete(&n);
554	n=m;
555	e=-e;
556	}
557	nPower(n,e,(number*)&res->data);
558	nDelete(&n);
559	return FALSE;
560	}
561	static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
562	{
563	res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)v->Data());
564	return FALSE;
565	}
566	static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
567	{
568	res->data = (char *)idPower((ideal)(u->Data()),(int)(v->Data()));
569	return FALSE;
570	}
571	static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
572	{
573	u=u->next;
574	v=v->next;
575	if (u==NULL)
576	{
577	if (v==NULL) return FALSE; /* u==NULL, v==NULL */
578	if (iiOp=='-') /* u==NULL, v<>NULL, iiOp=='-'*/
579	return iiExprArith1(res->next,v,'-');
580	loop /* u==NULL, v<>NULL, iiOp=='+' */
581	{
582	res->next = (leftv)Alloc0(sizeof(sleftv));
583	res=res->next;
584	res->data = v->CopyD();
585	res->rtyp = v->Typ();
586	v=v->next;
587	if (v==NULL) return FALSE;
588	}
589	}
590	if (v!=NULL) /* u<>NULL, v<>NULL */
591	{
592	res->next = (leftv)Alloc(sizeof(sleftv));
593	return iiExprArith2(res->next,u,iiOp,v);
594	}
595	loop /* u<>NULL, v==NULL */
596	{
597	res->next = (leftv)Alloc0(sizeof(sleftv));
598	res=res->next;
599	res->data = u->CopyD();
600	res->rtyp = u->Typ();
601	u=u->next;
602	if (u==NULL) return FALSE;
603	}
604	}
605	static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
606	{
607	unsigned int a=(unsigned int)u->Data();
608	unsigned int b=(unsigned int)v->Data();
609	unsigned int c=a+b;
610	res->data = (char *)c;
611	if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
612	{
613	Warn("int overflow(+), result may be wrong");
614	}
615	return jjPLUSMINUS_Gen(res,u,v);
616	}
617	static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
618	{
619	res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
620	return jjPLUSMINUS_Gen(res,u,v);
621	}
622	static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
623	{
624	res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
625	return jjPLUSMINUS_Gen(res,u,v);
626	}
627	static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
628	{
629	res->data = (char )ivAdd((intvec)(u->Data()), (intvec*)(v->Data()));
630	if (res->data==NULL)
631	{
632	WerrorS("intmat size not compatible");
633	return TRUE;
634	}
635	return jjPLUSMINUS_Gen(res,u,v);
636	}
637	static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
638	{
639	res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
640	if (res->data==NULL)
641	{
642	WerrorS("matrix size not compatible");
643	return TRUE;
644	}
645	return jjPLUSMINUS_Gen(res,u,v);
646	}
647	static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
648	{
649	matrix m=(matrix)u->Data();
650	matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD()));
651	if (iiOp=='+')
652	res->data = (char *)mpAdd(m , p);
653	else
654	res->data = (char *)mpSub(m , p);
655	idDelete((ideal *)&p);
656	return jjPLUSMINUS_Gen(res,u,v);
657	}
658	static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
659	{
660	return jjPLUS_MA_P(res,v,u);
661	}
662	static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
663	{
664	char* a = (char * )(u->Data());
665	char* b = (char * )(v->Data());
666	char* r = (char * )AllocL(strlen(a) + strlen(b) + 1);
667	strcpy(r,a);
668	strcat(r,b);
669	res->data=r;
670	return jjPLUSMINUS_Gen(res,u,v);
671	}
672	static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
673	{
674	res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
675	return jjPLUSMINUS_Gen(res,u,v);
676	}
677	static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
678	{
679	unsigned int a=(unsigned int)u->Data();
680	unsigned int b=(unsigned int)v->Data();
681	unsigned int c=a-b;
682	if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
683	{
684	Warn("int overflow(-), result may be wrong");
685	}
686	res->data = (char *)c;
687	return jjPLUSMINUS_Gen(res,u,v);
688	}
689	static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
690	{
691	res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
692	return jjPLUSMINUS_Gen(res,u,v);
693	}
694	static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
695	{
696	res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
697	return jjPLUSMINUS_Gen(res,u,v);
698	}
699	static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
700	{
701	res->data = (char )ivSub((intvec)(u->Data()), (intvec*)(v->Data()));
702	if (res->data==NULL)
703	{
704	WerrorS("intmat size not compatible");
705	return TRUE;
706	}
707	return jjPLUSMINUS_Gen(res,u,v);
708	}
709	static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
710	{
711	res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
712	if (res->data==NULL)
713	{
714	WerrorS("matrix size not compatible");
715	return TRUE;
716	}
717	return jjPLUSMINUS_Gen(res,u,v);
718	}
719	static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
720	{
721	int a=(int)u->Data();
722	int b=(int)v->Data();
723	int c=a * b;
724	if ((b!=0) && (c/b !=a))
725	Warn("int overflow(*), result may be wrong");
726	res->data = (char *)c;
727	if (u->Next()!=NULL)
728	{
729	u=u->next;
730	res->next = (leftv)Alloc(sizeof(sleftv));
731	return iiExprArith2(res->next,u,iiOp,v);
732	}
733	else if (v->Next()!=NULL)
734	{
735	v=v->next;
736	res->next = (leftv)Alloc(sizeof(sleftv));
737	return iiExprArith2(res->next,u,iiOp,v);
738	}
739	return FALSE;
740	}
741	static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
742	{
743	number a;
744	number b;
745
746	if (v->next==NULL)
747	{
748	a=(number)u->Data();
749	if (u->next==NULL)
750	{
751	res->data = (char *)(nMult( a, (number)v->Data()));
752	return FALSE;
753	}
754	// u->next exists: copy v
755	b=(number)v->Data();
756	res->data = (char *)(nMult( a, b));
757	res->next = (leftv)Alloc(sizeof(sleftv));
758	res=res->next;
759	return iiExprArith2(res,u->next,iiOp,v);
760	}
761	// v->next exists: copy u
762	a=nCopy((number)u->Data());
763	b=(number)v->CopyD();
764	res->data = (char *)(nMult( a, b));
765	res->next = (leftv)Alloc(sizeof(sleftv));
766	return iiExprArith2(res->next,u,iiOp,v->next);
767	}
768	static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
769	{
770	poly a;
771	poly b;
772
773	if (v->next==NULL)
774	{
775	a=(poly)u->CopyD();
776	if (u->next==NULL)
777	{
778	b=(poly)v->CopyD();
779	res->data = (char *)(pMult( a, b));
780	return FALSE;
781	}
782	// u->next exists: copy v
783	b=pCopy((poly)v->Data());
784	res->data = (char *)(pMult( a, b));
785	res->next = (leftv)Alloc(sizeof(sleftv));
786	res=res->next;
787	return iiExprArith2(res,u->next,iiOp,v);
788	}
789	// v->next exists: copy u
790	a=pCopy((poly)u->Data());
791	b=(poly)v->CopyD();
792	res->data = (char *)(pMult( a, b));
793	res->next = (leftv)Alloc(sizeof(sleftv));
794	return iiExprArith2(res->next,u,iiOp,v->next);
795	}
796	static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
797	{
798	res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
799	return FALSE;
800	}
801	static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
802	{
803	res->data = (char )ivMult((intvec)(u->Data()), (intvec*)(v->Data()));
804	if (res->data==NULL)
805	{
806	WerrorS("intmat size not compatible");
807	return TRUE;
808	}
809	return FALSE;
810	}
811	static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
812	{
813	poly p=(poly)v->CopyD(POLY_CMD);
814	int r=pMaxComp(p);/* recompute the rank for the case idealvector/
815	ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
816	if (r>0) I->rank=r;
817	res->data = (char *)I;
818	return FALSE;
819	}
820	static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
821	{
822	return jjTIMES_MA_P1(res,v,u);
823	}
824	static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
825	{
826	number n=(number)v->CopyD(NUMBER_CMD);
827	poly p=pOne();
828	pSetCoeff(p,n);
829	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
830	return FALSE;
831	}
832	static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
833	{
834	return jjTIMES_MA_N1(res,v,u);
835	}
836	static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
837	{
838	res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)v->Data());
839	return FALSE;
840	}
841	static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
842	{
843	return jjTIMES_MA_I1(res,v,u);
844	}
845	static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
846	{
847	res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
848	if (res->data==NULL)
849	{
850	WerrorS("matrix size not compatible");
851	return TRUE;
852	}
853	return FALSE;
854	}
855	static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
856	{
857	res->data = (char *)((int)u->Data() >= (int)v->Data());
858	return FALSE;
859	}
860	static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
861	{
862	number h=nSub((number)u->Data(),(number)v->Data());
863	res->data = (char *) (nGreaterZero(h)\|\|(nIsZero(h)));
864	nDelete(&h);
865	return FALSE;
866	}
867	static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
868	{
869	res->data = (char *)((int)u->Data()>(int)v->Data());
870	return FALSE;
871	}
872	static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
873	{
874	number h=nSub((number)u->Data(),(number)v->Data());
875	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
876	nDelete(&h);
877	return FALSE;
878	}
879	static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
880	{
881	res->data = (char *)((int)u->Data() <= (int)v->Data());
882	return FALSE;
883	}
884	static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
885	{
886	number h=nSub((number)v->Data(),(number)u->Data());
887	res->data = (char *) (nGreaterZero(h)\|\|nIsZero(h));
888	nDelete(&h);
889	return FALSE;
890	}
891	static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
892	{
893	res->data = (char *)((int)u->Data() < (int)v->Data());
894	return FALSE;
895	}
896	static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
897	{
898	number h=nSub((number)v->Data(),(number)u->Data());
899	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
900	nDelete(&h);
901	return FALSE;
902	}
903	static BOOLEAN jjDIV_I(leftv res, leftv u, leftv v)
904	{
905	int a= (int) u->Data();
906	int b= (int) v->Data();
907	if (b==0)
908	{
909	WerrorS("div. by 0");
910	return TRUE;
911	}
912	//int c=a%ABS(b);
913	//if(c<0) c+=ABS(b);
914	//res->data = (char *)((a-c) / b);
915	res->data = (char *)(a / b);
916	return FALSE;
917	}
918	static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
919	{
920	number q=(number)v->Data();
921	if (nIsZero(q))
922	{
923	WerrorS("div. by 0");
924	return TRUE;
925	}
926	q = nDiv((number)u->Data(),q);
927	nNormalize(q);
928	res->data = (char *)q;
929	return FALSE;
930	}
931	static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
932	{
933	poly q=(poly)v->Data();
934	if (q==NULL)
935	{
936	WerrorS("div. by 0");
937	return TRUE;
938	}
939	if (pNext(q)!=NULL)
940	{
941	#ifdef HAVE_FACTORY
942	res->data=(void*)(singclap_pdivide((poly)(u->Data()),
943	(poly)(v->Data())));
944	#else
945	WerrorS("division only by a monomial");
946	return TRUE;
947	#endif
948	}
949	else
950	{
951	res->data = (char *)pDivideM((poly)u->CopyD(POLY_CMD),pHead(q));
952	}
953	return FALSE;
954	}
955	static BOOLEAN jjMOD_I(leftv res, leftv u, leftv v)
956	{
957	int a=(int)u->Data();
958	int b=ABS((int)v->Data());
959	if (errorreported) return TRUE;
960	if (b==0)
961	{
962	WerrorS("div. by 0");
963	return TRUE;
964	}
965	int c=a%b;
966	if(c<0) c+=b;
967	res->data = (char *)c;
968	return FALSE;
969	}
970	static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
971	{
972	res->data = (char *)((int)u->Data() == (int)v->Data());
973	jjEQUAL_REST(res,u,v);
974	return FALSE;
975	}
976	static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
977	{
978	res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
979	jjEQUAL_REST(res,u,v);
980	return FALSE;
981	}
982	static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
983	{
984	res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
985	jjEQUAL_REST(res,u,v);
986	return FALSE;
987	}
988	static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
989	{
990	poly p=(poly)u->Data();
991	poly q=(poly)v->Data();
992	if (p==NULL)
993	{
994	res->data=(char *)(q==NULL);
995	}
996	else
997	{
998	if (q==NULL) res->data=(char *)FALSE;
999	else
1000	{
1001	int r=pComp(p,q);
1002	if (r==0)
1003	{
1004	p=pSub(pCopy(p),pCopy(q));
1005	res->data = (char *) (p==NULL);
1006	pDelete(&p);
1007	}
1008	else
1009	res->data = (char *) FALSE;
1010	}
1011	}
1012	jjEQUAL_REST(res,u,v);
1013	return FALSE;
1014	}
1015	static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1016	{
1017	res->data = (char *)((int)u->Data() && (int)v->Data());
1018	return FALSE;
1019	}
1020	static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1021	{
1022	res->data = (char *)((int)u->Data() \|\| (int)v->Data());
1023	return FALSE;
1024	}
1025	static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1026	{
1027	res->rtyp=u->rtyp; u->rtyp=0;
1028	res->data=u->data; u->data=NULL;
1029	res->name=u->name; u->name=NULL;
1030	res->e=u->e; u->e=NULL;
1031	if (res->e==NULL) res->e=jjMakeSub(v);
1032	else
1033	{
1034	Subexpr sh=res->e;
1035	while (sh->next != NULL) sh=sh->next;
1036	sh->next=jjMakeSub(v);
1037	}
1038	return FALSE;
1039	}
1040	static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1041	{
1042	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
1043	{
1044	WerrorS("indexed object must have a name");
1045	return TRUE;
1046	}
1047	intvec * iv=(intvec *)v->Data();
1048	leftv p=NULL;
1049	int i;
1050	sleftv t;
1051
1052	memset(&t,0,sizeof(t));
1053	t.rtyp=INT_CMD;
1054	for (i=0;i<iv->length(); i++)
1055	{
1056	t.data=(char )(iv)[i];
1057	if (p==NULL)
1058	{
1059	p=res;
1060	}
1061	else
1062	{
1063	p->next=(leftv)Alloc0(sizeof(sleftv));
1064	p=p->next;
1065	}
1066	p->rtyp=IDHDL;
1067	p->data=u->data;
1068	p->name=u->name;
1069	p->flag\|=u->flag;
1070	p->e=jjMakeSub(&t);
1071	}
1072	u->rtyp=0;
1073	u->data=NULL;
1074	u->name=NULL;
1075	return FALSE;
1076	}
1077	static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1078	{
1079	poly p=(poly)u->Data();
1080	int i=(int)v->Data();
1081	int j=0;
1082	while (p!=NULL)
1083	{
1084	j++;
1085	if (j==i)
1086	{
1087	res->data=(char *)pHead(p);
1088	return FALSE;
1089	}
1090	pIter(p);
1091	}
1092	return FALSE;
1093	}
1094	static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1095	{
1096	poly p=(poly)u->Data();
1097	poly r=NULL;
1098	intvec iv=(intvec )v->CopyD();
1099	int i;
1100	int sum=0;
1101	for(i=iv->length()-1;i>=0;i--)
1102	sum+=(*iv)[i];
1103	int j=0;
1104	while ((p!=NULL) && (sum>0))
1105	{
1106	j++;
1107	for(i=iv->length()-1;i>=0;i--)
1108	{
1109	if (j==(*iv)[i])
1110	{
1111	r=pAdd(r,pHead(p));
1112	sum-=j;
1113	(*iv)[i]=0;
1114	break;
1115	}
1116	}
1117	pIter(p);
1118	}
1119	delete iv;
1120	res->data=(char *)r;
1121	return FALSE;
1122	}
1123	static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1124	{
1125	poly p=(poly)u->CopyD();
1126	poly r=p; // pointer to the beginning of component i
1127	poly o=NULL;
1128	int i=(int)v->Data();
1129	while (p!=NULL)
1130	{
1131	if (pGetComp(p)!=i)
1132	{
1133	if (r==p) r=pNext(p);
1134	if (o!=NULL)
1135	{
1136	pDelete1(&pNext(o));
1137	p=pNext(o);
1138	}
1139	else
1140	pDelete1(&p);
1141	}
1142	else
1143	{
1144	pSetComp(p, 0);
1145	o=p;
1146	p=pNext(o);
1147	}
1148	}
1149	res->data=(char *)r;
1150	return FALSE;
1151	}
1152	static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1153	{
1154	poly p=(poly)u->CopyD();
1155	if (p!=NULL)
1156	{
1157	poly r=pOne();
1158	poly hp=r;
1159	intvec iv=(intvec )v->Data();
1160	int i;
1161	loop
1162	{
1163	for(i=0;i<iv->length();i++)
1164	{
1165	if (pGetComp(p)==(*iv)[i])
1166	{
1167	poly h;
1168	pSplit(p,&h);
1169	pNext(hp)=p;
1170	p=h;
1171	pIter(hp);
1172	break;
1173	}
1174	}
1175	if (p==NULL) break;
1176	if (i==iv->length())
1177	{
1178	pDelete1(&p);
1179	if (p==NULL) break;
1180	}
1181	}
1182	pDelete1(&r);
1183	res->data=(char *)r;
1184	}
1185	return FALSE;
1186	}
1187	static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1188	{
1189	if(u->name==NULL) return TRUE;
1190	char * n = (char *)AllocL(strlen(u->name) + 6);
1191	sprintf(n,"%s(%d)",u->name,(int)v->Data());
1192	FreeL((ADDRESS)u->name);
1193	u->name=NULL;
1194	syMake(res,n);
1195	return FALSE;
1196	}
1197	static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1198	{
1199	intvec * iv=(intvec *)v->Data();
1200	leftv p=NULL;
1201	int i;
1202	char *n;
1203
1204	for (i=0;i<iv->length(); i++)
1205	{
1206	if (p==NULL)
1207	{
1208	p=res;
1209	}
1210	else
1211	{
1212	p->next=(leftv)Alloc0(sizeof(sleftv));
1213	p=p->next;
1214	}
1215	n = (char *)AllocL(strlen(u->name) + 6);
1216	sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1217	syMake(p,n);
1218	}
1219	FreeL((ADDRESS)u->name);
1220	u->name=NULL;
1221	return FALSE;
1222	}
1223	static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1224	{
1225	leftv sl = iiMake_proc((idhdl)u->data,v);
1226	if (sl==NULL)
1227	{
1228	return TRUE;
1229	}
1230	else
1231	{
1232	memcpy(res,sl,sizeof(sleftv));
1233	}
1234	return FALSE;
1235	}
1236	static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1237	{
1238	//Print("try to map %s with %s\n",$3.Name(),$1.Name());
1239	leftv sl=NULL;
1240	if (v->e==NULL)
1241	{
1242	idhdl h=(idhdl)u->data;
1243	sl=iiMap(IDMAP(h),v->name);
1244	}
1245	//else
1246	//{
1247	// WerrorS("map_id(<name>) expected");
1248	//}
1249	if (sl==NULL) return TRUE;
1250	memcpy(res,sl,sizeof(sleftv));
1251	Free((ADDRESS)sl,sizeof(*sl));
1252	return FALSE;
1253	}
1254	static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1255	{
1256	u->next=(leftv)Alloc(sizeof(sleftv));
1257	memcpy(u->next,v,sizeof(sleftv));
1258	BOOLEAN r=iiExprArithM(res,u,iiOp);
1259	v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
1260	return r;
1261	}
1262	static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1263	{
1264	res->data=(char *)mpCoeffProc((poly)u->Data(),(poly)v->Data());
1265	return FALSE;
1266	}
1267	static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1268	{
1269	int i=pVar((poly)v->Data());
1270	if (i==0)
1271	{
1272	WerrorS("ringvar expected");
1273	return TRUE;
1274	}
1275	res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1276	return FALSE;
1277	}
1278	static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1279	{
1280	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1281	return FALSE;
1282	}
1283	static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1284	{
1285	short iv=iv2array((intvec )v->Data());
1286	res->data = (char *)pDegW((poly)u->Data(),iv);
1287	Free((ADDRESS)iv,(pVariables+1)*sizeof(short));
1288	return FALSE;
1289	}
1290	static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1291	{
1292	int i=pVar((poly)v->Data());
1293	if (i==0)
1294	{
1295	WerrorS("ringvar expected");
1296	return TRUE;
1297	}
1298	res->data=(char *)pDiff((poly)(u->Data()),i);
1299	return FALSE;
1300	}
1301	static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1302	{
1303	int i=pVar((poly)v->Data());
1304	if (i==0)
1305	{
1306	WerrorS("ringvar expected");
1307	return TRUE;
1308	}
1309	res->data=(char *)idDiff((matrix)(u->Data()),i);
1310	return FALSE;
1311	}
1312	static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1313	{
1314	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1315	return FALSE;
1316	}
1317
1318	static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1319	{
1320	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1321	setFlag(res,FLAG_STD);
1322	return FALSE;
1323	}
1324	static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1325	{
1326	assumeStdFlag(v);
1327	if(currQuotient==NULL)
1328	res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1329	else
1330	{
1331	ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1332	res->data = (char *)scDimInt((ideal)(v->Data()),q);
1333	idDelete(&q);
1334	}
1335	return FALSE;
1336	}
1337	static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1338	{
1339	int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1340	int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1341
1342	while ( p1!=0 )
1343	{
1344	q=p0 / p1;
1345	r=p0 % p1;
1346	p0 = p1; p1 = r;
1347	r = g0 - g1 * q;
1348	g0 = g1; g1 = r;
1349	r = f0 - f1 * q;
1350	f0 = f1; f1 = r;
1351	}
1352	int a = f0;
1353	int b = g0;
1354	if ( (int)u->Data() < 0 ) a=-a;
1355	if ( (int)v->Data() < 0 ) b=-b;
1356	lists L=(lists)Alloc(sizeof(slists));
1357	L->Init(3);
1358	L->m[0].rtyp=INT_CMD;
1359	L->m[0].data=(void *)p0;
1360	L->m[1].rtyp=INT_CMD;
1361	L->m[1].data=(void *)a;
1362	L->m[2].rtyp=INT_CMD;
1363	L->m[2].data=(void *)b;
1364	res->rtyp=LIST_CMD;
1365	res->data=(char *)L;
1366	return FALSE;
1367	}
1368	#ifdef HAVE_FACTORY
1369	static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1370	{
1371	res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL,
1372	(ideal)w->Data());
1373	setFlag(res,FLAG_STD);
1374	return FALSE;
1375	}
1376	#endif
1377	static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1378	{
1379	ring r=(ring)u->Data();
1380	idhdl w;
1381
1382	if ((iiOp!=IMAP_CMD)
1383	&& ((currRing->ch != r->ch)
1384	\|\| ((currRing->N != r->N)&& (iiOp==FETCH_CMD)))
1385	)
1386	goto err_fetch;
1387	if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1388	{
1389	int *perm=NULL;
1390	int *par_perm=NULL;
1391	int par_perm_size=0;
1392	BOOLEAN bo;
1393	if (iiOp==IMAP_CMD)
1394	{
1395	if (!nSetMap(r->ch,r->parameter,r->P,r->minpoly))
1396	{
1397	if (iiOp!=IMAP_CMD)
1398	goto err_fetch;
1399	par_perm_size=rPar(r);
1400	if (r->ch==1)
1401	{
1402	if ((currRing->ch!=0)
1403	&& (currRing->ch!=1))
1404	goto err_fetch;
1405	}
1406	else if(r->ch<(-1))
1407	{
1408	if ((currRing->ch==(-currRing->ch))
1409	&& (currRing->ch!=currRing->ch))
1410	goto err_fetch;
1411	}
1412	BITSET save_test=test;
1413	naSetChar(r->ch,TRUE,r->parameter,r->P);
1414	nSetChar(currRing->ch,TRUE,currRing->parameter,currRing->P);
1415	test=save_test;
1416	}
1417	perm=(int )Alloc0((r->N+1)sizeof(int));
1418	if (par_perm_size!=0)
1419	par_perm=(int )Alloc0(par_perm_sizesizeof(int));
1420	maFindPerm(r->names, r->N, r->parameter, r->P,
1421	currRing->names,currRing->N,currRing->parameter, currRing->P,
1422	perm,par_perm);
1423	}
1424	sleftv tmpW;
1425	memset(&tmpW,0,sizeof(sleftv));
1426	tmpW.rtyp=IDTYP(w);
1427	tmpW.data=IDDATA(w);
1428	if ((bo=maApplyFetch(iiOp,NULL,res,&tmpW, r, perm,par_perm,par_perm_size)))
1429	{
1430	Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1431	}
1432	if (perm!=NULL)
1433	Free((ADDRESS)perm,(r->N+1)*sizeof(int));
1434	if (par_perm!=NULL)
1435	Free((ADDRESS)par_perm,par_perm_size*sizeof(int));
1436	return bo;
1437	}
1438	else
1439	{
1440	Werror("%s undefined in %s",v->Name(),u->Name());
1441	}
1442	return TRUE;
1443	err_fetch:
1444	Werror("no identity map from %s",u->Name());
1445	return TRUE;
1446	}
1447	static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1448	{
1449	/*4
1450	* look for the substring what in the string where
1451	* return the position of the first char of what in where
1452	* or 0
1453	*/
1454	char where=(char )u->Data();
1455	char what=(char )v->Data();
1456	char *found = strstr(where,what);
1457	if (found != NULL)
1458	{
1459	res->data=(char *)((found-where)+1);
1460	}
1461	/else res->data=NULL;/
1462	return FALSE;
1463	}
1464	static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1465	{
1466	int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1467	int q, r;
1468
1469	while ( p1!=0 )
1470	{
1471	q=p0 / p1;
1472	r=p0 % p1;
1473	p0 = p1; p1 = r;
1474	}
1475	res->rtyp=INT_CMD;
1476	res->data=(char *)p0;
1477	return FALSE;
1478	}
1479	static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1480	{
1481	assumeStdFlag(u);
1482	intvec module_w=(intvec)atGet(u,"isHomog");
1483	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1484	switch((int)v->Data())
1485	{
1486	case 1:
1487	res->data=(void *)iv;
1488	return FALSE;
1489	case 2:
1490	res->data=(void *)hSecondSeries(iv);
1491	delete iv;
1492	return FALSE;
1493	}
1494	WerrorS(feNotImplemented);
1495	delete iv;
1496	return TRUE;
1497	}
1498	static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1499	{
1500	int i=pVar((poly)v->Data());
1501	if (i==0)
1502	{
1503	WerrorS("ringvar expected");
1504	return TRUE;
1505	}
1506	res->data = (char *)pHomogen((poly)u->Data(),i);
1507	return FALSE;
1508	}
1509	static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1510	{
1511	int i=pVar((poly)v->Data());
1512	if (i==0)
1513	{
1514	WerrorS("ringvar expected");
1515	return TRUE;
1516	}
1517	res->data = (char *)idHomogen((ideal)u->Data(),i);
1518	return FALSE;
1519	}
1520	static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1521	{
1522	assumeStdFlag(u);
1523	res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(v->Data()),
1524	currQuotient);
1525	return FALSE;
1526	}
1527	static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1528	{
1529	res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1530	setFlag(res,FLAG_STD);
1531	return FALSE;
1532	}
1533	static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1534	{
1535	res->data = (char *)pJet((poly)u->Data(),(int)v->Data());
1536	return FALSE;
1537	}
1538	static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1539	{
1540	res->data = (char *)idJet((ideal)u->Data(),(int)v->Data());
1541	return FALSE;
1542	}
1543	static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1544	{
1545	assumeStdFlag(u);
1546	res->data = (char *)scKBase((int)v->Data(),
1547	(ideal)(u->Data()),currQuotient);
1548	return FALSE;
1549	}
1550	static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1551	{
1552	return mpKoszul(res, u,v);
1553	}
1554	static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1555	{
1556	sleftv h;
1557	memset(&h,0,sizeof(sleftv));
1558	h.rtyp=INT_CMD;
1559	h.data=(void *)IDELEMS((ideal)v->Data());
1560	return mpKoszul(res, &h, u, v);
1561	}
1562	static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1563	{
1564	ideal m;
1565	int ul= IDELEMS((ideal)u->Data());
1566	int vl= IDELEMS((ideal)v->Data());
1567	if (hasFlag(u,FLAG_STD))
1568	{
1569	m = idLift((ideal)u->Data(),(ideal)v->Data());
1570	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1571	}
1572	else
1573	{
1574	// matrix ma=mpNew(1,1);
1575	// ideal mo=idLiftStd((ideal)u->CopyD(),currQuotient,&ma,testHomog);
1576	// m = idLift(mo,(ideal)v->Data());
1577	// matrix r=idModule2formatedMatrix(m, IDELEMS(mo),vl);
1578	// idDelete(&mo);
1579	// // idDelete(&m); already done by idModule2formatedMatrix
1580	// res->data=(char *)mpMult(ma,r);
1581	// idDelete((ideal *)&ma);
1582	// idDelete((ideal *)&r);
1583	m = idLiftNonStB((ideal)u->Data(),(ideal)v->Data());
1584	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1585	}
1586	return FALSE;
1587	}
1588	static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
1589	{
1590	if ((v->rtyp!=IDHDL)\|\|(v->e!=NULL)) return TRUE;
1591	idhdl h=(idhdl)v->data;
1592	res->data = (char *)idLiftStd((ideal)u->CopyD(), currQuotient,
1593	&(h->data.umatrix),testHomog);
1594	setFlag(res,FLAG_STD);
1595	return FALSE;
1596	}
1597	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
1598	{
1599	res->data = (char *)idMinors((matrix)u->Data(),(int)v->Data());
1600	return FALSE;
1601	}
1602	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
1603	{
1604	res->data = (char *)idModulo((ideal)u->Data(),(ideal)v->Data());
1605	return FALSE;
1606	}
1607	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
1608	{
1609	char opt=(char )v->Data();
1610	int mode=0;
1611	while(*opt!='\0')
1612	{
1613	if (*opt=='i') mode \|= PROT_I;
1614	else if (*opt=='o') mode \|= PROT_O;
1615	opt++;
1616	}
1617	monitor((char *)(u->Data()),mode);
1618	return FALSE;
1619	}
1620	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
1621	{
1622	idhdl h=(idhdl)u->data;
1623	int i=(int)v->Data();
1624	int p=0;
1625	if ((0<i)
1626	&& (IDRING(h)->parameter!=NULL)
1627	&& (i<=(p=rPar(IDRING(h)))))
1628	res->data=mstrdup(IDRING(h)->parameter[i-1]);
1629	else
1630	{
1631	Werror("par number %d out of range 1..%d",i,p);
1632	return TRUE;
1633	}
1634	return FALSE;
1635	}
1636	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
1637	{
1638	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
1639	hasFlag(u,FLAG_STD));
1640	idDelMultiples((ideal)(res->data));
1641	return FALSE;
1642	}
1643	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
1644	{
1645	int i=(int)u->Data();
1646	int j=(int)v->Data();
1647	#ifdef buildin_rand
1648	res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
1649	#else
1650	res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
1651	#endif
1652	return FALSE;
1653	}
1654	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
1655	{
1656	si_link l=(si_link)u->Data();
1657	leftv r=slRead(l,v);
1658	if (r==NULL)
1659	{
1660	const char *s;
1661	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
1662	else s=sNoName;
1663	Werror("cannot read from `%s`",s);
1664	return TRUE;
1665	}
1666	memcpy(res,r,sizeof(sleftv));
1667	Free((ADDRESS)r,sizeof(sleftv));
1668	return FALSE;
1669	}
1670	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
1671	{
1672	assumeStdFlag(v);
1673	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
1674	return FALSE;
1675	}
1676	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
1677	{
1678	assumeStdFlag(v);
1679	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data());
1680	return FALSE;
1681	}
1682	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
1683	{
1684	int maxl=(int)v->Data();
1685	if (maxl<0)
1686	{
1687	WerrorS("length for res must not be negative");
1688	return TRUE;
1689	}
1690	int l=0;
1691	//resolvente r;
1692	syStrategy r;
1693	intvec **weights=NULL;
1694	int wmaxl=maxl;
1695	ideal u_id=(ideal)u->Data();
1696	maxl--;
1697	if ((maxl==-1) && (iiOp!=MRES_CMD))
1698	maxl = pVariables-1;
1699	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
1700	{
1701	//if (BTEST1(28))
1702	//{
1703	// r=syMinRes(u_id,maxl,&l, iiOp==MRES_CMD);
1704	//}
1705	//else
1706	{
1707	intvec * iv=(intvec*)atGet(u,"isHomog");
1708	//if (iv!=NULL)
1709	//{
1710	// weights = (intvec*)Alloc0(sizeof(intvec));
1711	// weights[0] = ivCopy(iv);
1712	// l=1;
1713	//}
1714	//r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
1715	r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
1716	}
1717	}
1718	else if (iiOp==SRES_CMD)
1719	// r=sySchreyerResolvente(u_id,maxl+1,&l);
1720	r=sySchreyer(u_id,maxl+1);
1721	else /* LRES */
1722	{
1723	int dummy;
1724	if((currQuotient!=NULL)\|\|
1725	(!idHomIdeal (u_id,NULL)))
1726	{
1727	WerrorS
1728	("`lres` can not be called in q ring or with inhomogeneous input");
1729	return TRUE;
1730	}
1731	r=syLaScala3(u_id,&dummy);
1732	}
1733	if (r==NULL) return TRUE;
1734	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
1735	r->list_length=wmaxl;
1736	res->data=(void *)r;
1737	return FALSE;
1738	}
1739	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
1740	{
1741	ring r;
1742	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
1743	res->data = (char *)r;
1744	return (i==-1);
1745	}
1746	#define SIMPL_LMDIV 32
1747	#define SIMPL_LMEQ 16
1748	#define SIMPL_MULT 8
1749	#define SIMPL_EQU 4
1750	#define SIMPL_NULL 2
1751	#define SIMPL_NORM 1
1752	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
1753	{
1754	int sw = (int)v->Data();
1755	ideal id = (ideal)u->CopyD();
1756	if (sw & SIMPL_LMDIV)
1757	{
1758	idDelDiv(id);
1759	}
1760	if (sw & SIMPL_LMEQ)
1761	{
1762	idDelLmEquals(id);
1763	}
1764	if (sw & SIMPL_NULL)
1765	{
1766	idSkipZeroes(id);
1767	}
1768	if (sw & SIMPL_NORM)
1769	{
1770	idNorm(id);
1771	}
1772	if (sw & SIMPL_MULT)
1773	{
1774	idDelMultiples(id);
1775	}
1776	else if(sw & SIMPL_EQU)
1777	{
1778	idDelEquals(id);
1779	}
1780	res->data = (char * )id;
1781	return FALSE;
1782	}
1783	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
1784	{
1785	res->data = mstrdup(slStatus((si_link) u->Data(), (char *) v->Data()));
1786	return FALSE;
1787	}
1788	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
1789	{
1790	int sw = (int)v->Data();
1791	poly p = (poly)u->CopyD();
1792	if (sw & SIMPL_NORM)
1793	{
1794	pNorm(p);
1795	}
1796	res->data = (char * )p;
1797	return FALSE;
1798	}
1799	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
1800	{
1801	ideal result;
1802	intvec w=(intvec )atGet(u,"isHomog");
1803	tHomog hom=testHomog;
1804	if (w!=NULL)
1805	{
1806	w=ivCopy(w);
1807	hom=isHomog;
1808	}
1809	result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
1810	idSkipZeroes(result);
1811	res->data = (char *)result;
1812	setFlag(res,FLAG_STD);
1813	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
1814	return FALSE;
1815	}
1816	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
1817	{
1818	ideal result;
1819	intvec w=(intvec )atGet(u,"isHomog");
1820	tHomog hom=testHomog;
1821	if (w!=NULL)
1822	{
1823	w=ivCopy(w);
1824	hom=isHomog;
1825	}
1826	ideal i1=(ideal)u->Data();
1827	ideal i0=idInit(1,i1->rank);
1828	i0->m[0]=(poly)v->Data();
1829	i1=idSimpleAdd(i1,i0);
1830	i0->m[0]=NULL;
1831	idDelete(&i0);
1832	BITSET save_test=test;
1833	test\|=Sy_bit(OPT_SB_1);
1834	result=kStd(i1,currQuotient,hom,&w);
1835	test=save_test;
1836	idDelete(&i1);
1837	idSkipZeroes(result);
1838	res->data = (char *)result;
1839	setFlag(res,FLAG_STD);
1840	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
1841	return FALSE;
1842	}
1843	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
1844	{
1845	idhdl h=(idhdl)u->data;
1846	int i=(int)v->Data();
1847	if ((0<i) && (i<=IDRING(h)->N))
1848	res->data=mstrdup(IDRING(h)->names[i-1]);
1849	else
1850	{
1851	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
1852	return TRUE;
1853	}
1854	return FALSE;
1855	}
1856	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
1857	{
1858	res->data = (char *)mpWedge((matrix)u->Data(),(int)v->Data());
1859	return FALSE;
1860	}
1861	#define jjWRONG2 (proc2)jjWRONG
1862	#define jjWRONG3 (proc3)jjWRONG
1863	static BOOLEAN jjWRONG(leftv res, leftv u)
1864	{
1865	return TRUE;
1866	}
1867	/=================== operations with 2 args.: table =================/
1868	struct sValCmd2 dArith2[]=
1869	{
1870	// operations:
1871	// proc cmd res arg1 arg2
1872	{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD PROFILER}
1873	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1874	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
1875	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1876	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
1877	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
1878	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD PROFILER}
1879	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
1880	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
1881	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD PROFILER}
1882	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1883	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD PROFILER}
1884	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1885	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD PROFILER}
1886	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1887	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
1888	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD PROFILER}
1889	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD PROFILER}
1890	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD PROFILER}
1891	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1892	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
1893	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1894	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
1895	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
1896	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1897	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1898	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1899	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
1900	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD PROFILER}
1901	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1902	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
1903	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD PROFILER}
1904	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
1905	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
1906	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD PROFILER}
1907	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
1908	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD PROFILER}
1909	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD PROFILER}
1910	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD PROFILER}
1911	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
1912	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
1913	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD PROFILER}
1914	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD PROFILER}
1915	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD PROFILER}
1916	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD PROFILER}
1917	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD PROFILER}
1918	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
1919	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1920	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD PROFILER}
1921	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1922	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD PROFILER}
1923	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD PROFILER}
1924	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
1925	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1926	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
1927	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
1928	,{jjDIV_I, '/', INT_CMD, INT_CMD, INT_CMD PROFILER}
1929	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1930	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1931	,{jjDIV_I, INTDIV, INT_CMD, INT_CMD, INT_CMD PROFILER}
1932	,{jjOP_IV_I, INTDIV, INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1933	,{jjOP_IV_I, INTDIV, INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1934	,{jjMOD_I, '%', INT_CMD, INT_CMD, INT_CMD PROFILER}
1935	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
1936	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
1937	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD PROFILER}
1938	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD PROFILER}
1939	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD PROFILER}
1940	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
1941	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD PROFILER}
1942	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1943	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1944	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1945	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1946	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1947	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1948	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD PROFILER}
1949	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1950	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1951	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1952	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1953	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1954	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1955	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD PROFILER}
1956	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1957	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1958	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1959	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1960	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1961	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1962	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD PROFILER}
1963	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1964	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1965	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1966	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1967	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1968	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1969	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD PROFILER}
1970	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD PROFILER}
1971	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD PROFILER}
1972	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1973	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1974	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1975	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1976	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1977	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1978	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
1979	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
1980	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD PROFILER}
1981	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD PROFILER}
1982	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD PROFILER}
1983	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
1984	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
1985	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
1986	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
1987	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1988	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
1989	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
1990	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD PROFILER}
1991	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD PROFILER}
1992	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD PROFILER}
1993	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
1994	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
1995	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD PROFILER}
1996	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD PROFILER}
1997	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD PROFILER}
1998	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD PROFILER}
1999	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD PROFILER}
2000	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD PROFILER}
2001	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD PROFILER}
2002	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD PROFILER}
2003	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD PROFILER}
2004	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2005	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD PROFILER}
2006	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD PROFILER}
2007	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD PROFILER}
2008	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD PROFILER}
2009	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD PROFILER}
2010	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD PROFILER}
2011	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD PROFILER}
2012	// and the procedures with 2 arguments:
2013	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD PROFILER}
2014	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD PROFILER}
2015	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2016	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD PROFILER}
2017	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2018	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD PROFILER}
2019	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD PROFILER}
2020	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2021	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2022	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2023	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2024	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2025	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
2026	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2027	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2028	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2029	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2030	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD PROFILER}
2031	#ifdef HAVE_FACTORY
2032	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD PROFILER}
2033	,{jjSQR_FREE_DEC,FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD PROFILER}
2034	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2035	#else
2036	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD PROFILER}
2037	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD PROFILER}
2038	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2039	#endif
2040	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE PROFILER}
2041	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE PROFILER}
2042	#ifdef HAVE_FGLM
2043	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD PROFILER}
2044	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD PROFILER}
2045	#else
2046	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD PROFILER}
2047	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD PROFILER}
2048	#endif
2049	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2050	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2051	#ifdef HAVE_FACTORY
2052	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2053	#else
2054	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2055	#endif
2056	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD PROFILER}
2057	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD PROFILER}
2058	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2059	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2060	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2061	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2062	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD PROFILER}
2063	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE PROFILER}
2064	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE PROFILER}
2065	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2066	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD PROFILER}
2067	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2068	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2069	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2070	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2071	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD PROFILER}
2072	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2073	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2074	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2075	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD PROFILER}
2076	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD PROFILER}
2077	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD PROFILER}
2078	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2079	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2080	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD PROFILER}
2081	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD PROFILER}
2082	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD PROFILER}
2083	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2084	,{jjRES, LRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2085	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD PROFILER}
2086	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD PROFILER}
2087	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2088	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2089	,{jjMONITOR2, MONITOR_CMD, NONE, STRING_CMD, STRING_CMD PROFILER}
2090	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2091	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2092	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2093	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2094	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD PROFILER}
2095	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD PROFILER}
2096	,{jjPRINT_FORMAT, PRINT_CMD, NONE, DEF_CMD, STRING_CMD PROFILER}
2097	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2098	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2099	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2100	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2101	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD PROFILER}
2102	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD PROFILER}
2103	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD PROFILER}
2104	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD PROFILER}
2105	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2106	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2107	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2108	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2109	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2110	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2111	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2112	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD PROFILER}
2113	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2114	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD PROFILER}
2115	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2116	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2117	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2118	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2119	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2120	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2121	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD PROFILER}
2122	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2123	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD PROFILER}
2124	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD PROFILER}
2125	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD PROFILER}
2126	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD PROFILER}
2127	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD PROFILER}
2128	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD PROFILER}
2129	,{NULL, 0, 0, 0, 0 PROFILER}
2130	};
2131	/=================== operations with 1 arg.: static proc =================/
2132	static BOOLEAN jjDUMMY(leftv res, leftv u)
2133	{
2134	res->data = (char *)u->CopyD();
2135	return FALSE;
2136	}
2137	static BOOLEAN jjNULL(leftv res, leftv u)
2138	{
2139	return FALSE;
2140	}
2141	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2142	//{
2143	// res->data = (char *)((int)u->Data()+1);
2144	// return FALSE;
2145	//}
2146	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
2147	//{
2148	// res->data = (char *)((int)u->Data()-1);
2149	// return FALSE;
2150	//}
2151	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2152	{
2153	if (IDTYP((idhdl)u->data)==INT_CMD)
2154	{
2155	if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
2156	else IDINT((idhdl)u->data)--;
2157	return FALSE;
2158	}
2159	return TRUE;
2160	}
2161	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
2162	{
2163	res->data = (char *)(-(int)u->Data());
2164	return FALSE;
2165	}
2166	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
2167	{
2168	number n=nNeg((number)u->CopyD());
2169	res->data = (char *)n;
2170	return FALSE;
2171	}
2172	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
2173	{
2174	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
2175	return FALSE;
2176	}
2177	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
2178	{
2179	poly m1=pISet(-1);
2180	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
2181	return FALSE;
2182	}
2183	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
2184	{
2185	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
2186	(iv)=(-1);
2187	res->data = (char *)iv;
2188	return FALSE;
2189	}
2190	static BOOLEAN jjPROC1(leftv res, leftv u)
2191	{
2192	if ((u->rtyp!=IDHDL) \|\| (u->e!=NULL))
2193	return TRUE;
2194	leftv sl = iiMake_proc((idhdl) u->data,NULL);
2195	if (sl==NULL)
2196	{
2197	return TRUE;
2198	}
2199	else
2200	{
2201	memcpy(res,sl,sizeof(sleftv));
2202	}
2203	return FALSE;
2204	}
2205	static BOOLEAN jjBAREISS(leftv res, leftv v)
2206	{
2207	matrix m=(matrix)v->Data();
2208	lists l=mpBareiss(m,FALSE);
2209	res->data = (char *)l;
2210	return FALSE;
2211	}
2212	static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
2213	{
2214	intvec m=(intvec )v->CopyD();
2215	ivTriangMat(m,1,1);
2216	res->data = (char *)m;
2217	return FALSE;
2218	}
2219	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
2220	{
2221	return iiExprArithM(res,u,iiOp);
2222	}
2223	static BOOLEAN jjCHAR(leftv res, leftv v)
2224	{
2225	res->data = (char *)rChar((ring)v->Data());
2226	return FALSE;
2227	}
2228	static BOOLEAN jjCOLS(leftv res, leftv v)
2229	{
2230	res->data = (char *)MATCOLS((matrix)(v->Data()));
2231	return FALSE;
2232	}
2233	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
2234	{
2235	res->data = (char )((intvec)(v->Data()))->cols();
2236	return FALSE;
2237	}
2238	static BOOLEAN jjCONTENT(leftv res, leftv v)
2239	{
2240	poly p=(poly)v->CopyD();
2241	if (p!=NULL) pCleardenom(p);
2242	res->data = (char *)p;
2243	return FALSE;
2244	}
2245	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
2246	{
2247	res->data = (char *)nSize((number)v->Data());
2248	return FALSE;
2249	}
2250	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
2251	{
2252	lists l=(lists)v->Data();
2253	res->data = (char *)(l->nr+1);
2254	return FALSE;
2255	}
2256	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
2257	{
2258	matrix m=(matrix)v->Data();
2259	res->data = (char )(MATROWS(m)MATCOLS(m));
2260	return FALSE;
2261	}
2262	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
2263	{
2264	res->data = (char )((intvec)(v->Data()))->length();
2265	return FALSE;
2266	}
2267	static BOOLEAN jjDEG(leftv res, leftv v)
2268	{
2269	int dummy;
2270	poly p=(poly)v->Data();
2271	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy);
2272	else res->data=(char *)-1;
2273	return FALSE;
2274	}
2275	static BOOLEAN jjDEGREE(leftv res, leftv v)
2276	{
2277	assumeStdFlag(v);
2278	scDegree((ideal)v->Data(),currQuotient);
2279	return FALSE;
2280	}
2281	static BOOLEAN jjDEFINED(leftv res, leftv v)
2282	{
2283	if ((v->rtyp==IDHDL)
2284	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
2285	{
2286	res->data=(void *)(IDLEV((idhdl)v->data)+1);
2287	}
2288	else if (v->rtyp!=0) res->data=(void *)(-1);
2289	return FALSE;
2290	}
2291	#ifdef HAVE_FACTORY
2292	static BOOLEAN jjDET(leftv res, leftv v)
2293	{
2294	int i,j;
2295	matrix m=(matrix)v->Data();
2296	if (currRing->parameter==NULL)
2297	{
2298	for(i=m->rows();i>0;i--)
2299	{
2300	for(j=m->cols();j>0;j--)
2301	{
2302	if((MATELEM(m,i,j)!=NULL)
2303	&& (!pIsConstant(MATELEM(m,i,j))))
2304	{
2305	goto nonconst;
2306	}
2307	}
2308	}
2309	res->data = (char *)singclap_det(m);
2310	return FALSE;
2311	}
2312	nonconst:
2313	res->data = (char *)mpDet(m);
2314	return FALSE;
2315	}
2316	static BOOLEAN jjDET_I(leftv res, leftv v)
2317	{
2318	intvec * m=(intvec*)v->Data();
2319	int i,j;
2320	i=m->rows();j=m->cols();
2321	if(i==j)
2322	res->data = (char *)singclap_det_i(m);
2323	else
2324	{
2325	Werror("det of %d x %d intmat",i,j);
2326	return TRUE;
2327	}
2328	return FALSE;
2329	}
2330	#endif
2331	static BOOLEAN jjDIM(leftv res, leftv v)
2332	{
2333	assumeStdFlag(v);
2334	res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
2335	return FALSE;
2336	}
2337	static BOOLEAN jjDUMP(leftv res, leftv v)
2338	{
2339	si_link l = (si_link)v->Data();
2340	if (slDump(l))
2341	{
2342	const char *s;
2343	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2344	else s=sNoName;
2345	Werror("cannot dump to `%s`",s);
2346	return TRUE;
2347	}
2348	else
2349	return FALSE;
2350	}
2351	static BOOLEAN jjE(leftv res, leftv v)
2352	{
2353	res->data = (char *)pOne();
2354	pSetComp((poly)res->data,(int)v->Data());
2355	return FALSE;
2356	}
2357	static BOOLEAN jjGETDUMP(leftv res, leftv v)
2358	{
2359	si_link l = (si_link)v->Data();
2360	if (slGetDump(l))
2361	{
2362	const char *s;
2363	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2364	else s=sNoName;
2365	Werror("cannot get dump from `%s`",s);
2366	return TRUE;
2367	}
2368	else
2369	return FALSE;
2370	}
2371	#ifdef HAVE_FACTORY
2372	static BOOLEAN jjFACSTD(leftv res, leftv v)
2373	{
2374	res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
2375	setFlag(res,FLAG_STD);
2376	return FALSE;
2377	}
2378	#endif
2379	static BOOLEAN jjHILBERT(leftv res, leftv v)
2380	{
2381	assumeStdFlag(v);
2382	intvec module_w=(intvec)atGet(v,"isHomog");
2383	//scHilbertPoly((ideal)v->Data(),currQuotient);
2384	hLookSeries((ideal)v->Data(),module_w,currQuotient);
2385	return FALSE;
2386	}
2387	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
2388	{
2389	res->data=(void )hSecondSeries((intvec )v->Data());
2390	return FALSE;
2391	}
2392	static BOOLEAN jjHOMOG1(leftv res, leftv v)
2393	{
2394	intvec *w;
2395	res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
2396	if ((v->rtyp==IDHDL)&&(w!=NULL))
2397	atSet((idhdl)v->data,mstrdup("isHomog"),w,INTVEC_CMD);
2398	return FALSE;
2399	}
2400	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
2401	{
2402	matrix mat=(matrix)v->CopyD();
2403	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
2404	MATROWS(mat)=1;
2405	mat->rank=1;
2406	res->data=(char *)mat;
2407	return FALSE;
2408	}
2409	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
2410	{
2411	map m=(map)v->CopyD();
2412	FreeL((ADDRESS)m->preimage);
2413	m->preimage=NULL;
2414	ideal I=(ideal)m;
2415	I->rank=1;
2416	res->data=(char *)I;
2417	return FALSE;
2418	}
2419	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
2420	{
2421	if (currRing!=NULL)
2422	{
2423	ring q=(ring)v->Data();
2424	if ((q->ch==currRing->ch)
2425	&& (q->N==currRing->N)) /* && varnames equ. */
2426	{
2427	if (q->qideal==NULL)
2428	res->data=(char *)idInit(1,1);
2429	else
2430	res->data=(char *)idCopy(q->qideal);
2431	return FALSE;
2432	}
2433	}
2434	return TRUE;
2435	}
2436	static BOOLEAN jjIm2Iv(leftv res, leftv v)
2437	{
2438	intvec iv = (intvec )v->CopyD();
2439	iv->makeVector();
2440	res->data = iv;
2441	return FALSE;
2442	}
2443	static BOOLEAN jjINDEPSET(leftv res, leftv v)
2444	{
2445	assumeStdFlag(v);
2446	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
2447	return FALSE;
2448	}
2449	static BOOLEAN jjINTERRED(leftv res, leftv v)
2450	{
2451	ideal result=kInterRed((ideal)(v->Data()),currQuotient);
2452	//if (result==NULL) return TRUE;
2453	idSkipZeroes(result);
2454	res->data = result;
2455	return FALSE;
2456	}
2457	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
2458	{
2459	res->data = (char *)pVar((poly)v->Data());
2460	return FALSE;
2461	}
2462	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
2463	{
2464	res->data = (char )(rIsRingVar((char )v->Data())+1);
2465	return FALSE;
2466	}
2467	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
2468	{
2469	res->data = (char *)0;
2470	return FALSE;
2471	}
2472	static BOOLEAN jjJACOB_P(leftv res, leftv v)
2473	{
2474	ideal i=idInit(pVariables,1);
2475	int k;
2476	for (k=pVariables;k>0;k--)
2477	{
2478	i->m[k-1]=pDiff(pCopy((poly)(v->Data())),k);
2479	}
2480	res->data = (char *)i;
2481	return FALSE;
2482	}
2483	static BOOLEAN jjKBASE(leftv res, leftv v)
2484	{
2485	assumeStdFlag(v);
2486	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
2487	return FALSE;
2488	}
2489	static BOOLEAN jjKLAMMER_LIB(leftv res, leftv u)
2490	{
2491	char * s=(char *)u->Data();
2492	return iiLibCmd(s);
2493	}
2494	#ifdef MDEBUG
2495	static BOOLEAN jjpHead(leftv res, leftv v)
2496	{
2497	res->data=(char *)pHead((poly)v->Data());
2498	return FALSE;
2499	}
2500	#endif
2501	static BOOLEAN jjL2R(leftv res, leftv v)
2502	{
2503	res->data=(char *)syConvList((lists)v->Data());
2504	return FALSE;
2505	}
2506	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
2507	{
2508	poly p=(poly)v->Data();
2509	if (p==NULL)
2510	{
2511	res->data=(char *)nInit(0);
2512	}
2513	else
2514	{
2515	res->data=(char *)nCopy(pGetCoeff(p));
2516	}
2517	return FALSE;
2518	}
2519	static BOOLEAN jjLEADEXP(leftv res, leftv v)
2520	{
2521	poly p=(poly)v->Data();
2522	intvec *iv=new intvec(pVariables);
2523	if (p!=NULL)
2524	{
2525	for(int i = pVariables;i;i--)
2526	{
2527	(*iv)[i-1]=pGetExp(p,i);
2528	}
2529	}
2530	res->data=(char *)iv;
2531	return FALSE;
2532	}
2533	static BOOLEAN jjMEMORY(leftv res, leftv v)
2534	{
2535	#ifdef MM_COUNT
2536	switch(((int)v->Data()))
2537	{
2538	case 0:
2539	res->data = (char *)mmMemUsed();
2540	break;
2541	case 1:
2542	res->data = (char *)mmMemReal();
2543	break;
2544	#ifdef HAVE_SBRK
2545	case 2:
2546	res->data = (char *)mmMemPhysical();
2547	break;
2548	#endif
2549	default:
2550	#ifdef MM_STAT
2551	mmStat((int)v->Data());
2552	#endif
2553	res->data = (char *)0;
2554	}
2555	return FALSE;
2556	#else
2557	res->data = (char *)0;
2558	return FALSE;
2559	#endif
2560	}
2561	static BOOLEAN jjMONITOR1(leftv res, leftv v)
2562	{
2563	monitor((char *)(v->Data()),PROT_I);
2564	return FALSE;
2565	}
2566	static BOOLEAN jjMSTD(leftv res, leftv v)
2567	{
2568	res->data=(void *)min_std((ideal)v->Data(),currQuotient,testHomog,NULL);
2569	return FALSE;
2570	}
2571	static BOOLEAN jjMULT(leftv res, leftv v)
2572	{
2573	assumeStdFlag(v);
2574	res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
2575	return FALSE;
2576	}
2577	static BOOLEAN jjNAMEOF(leftv res, leftv v)
2578	{
2579	res->data = (char *)v->name;
2580	if (res->data==NULL) res->data=mstrdup("");
2581	v->name=NULL;
2582	return FALSE;
2583	}
2584	static BOOLEAN jjNAMES(leftv res, leftv v)
2585	{
2586	res->data=ipNameList(((ring)v->Data())->idroot);
2587	return FALSE;
2588	}
2589	static BOOLEAN jjNVARS(leftv res, leftv v)
2590	{
2591	res->data = (char *)(((ring)(v->Data()))->N);
2592	return FALSE;
2593	}
2594	static BOOLEAN jjOpenClose(leftv res, leftv v)
2595	{
2596	si_link l=(si_link)v->Data();
2597	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
2598	else return slClose(l);
2599	}
2600	static BOOLEAN jjORD(leftv res, leftv v)
2601	{
2602	poly p=(poly)v->Data();
2603	res->data=(char *)( p==NULL ? -1 : pFDeg(p) );
2604	return FALSE;
2605	}
2606	static BOOLEAN jjPAR1(leftv res, leftv v)
2607	{
2608	int i=(int)v->Data();
2609	int p=0;
2610	p=rPar(currRing);
2611	if ((0<i) && (i<=p))
2612	{
2613	res->data=(char *)nPar(i);
2614	}
2615	else
2616	{
2617	Werror("par number %d out of range 1..%d",i,p);
2618	return TRUE;
2619	}
2620	return FALSE;
2621	}
2622	static BOOLEAN jjPARDEG(leftv res, leftv v)
2623	{
2624	res->data = (char *)nParDeg((number)v->Data());
2625	return FALSE;
2626	}
2627	static BOOLEAN jjPARSTR1(leftv res, leftv v)
2628	{
2629	if (currRing==NULL)
2630	{
2631	WerrorS("no ring active");
2632	return TRUE;
2633	}
2634	int i=(int)v->Data();
2635	int p=0;
2636	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
2637	res->data=mstrdup(currRing->parameter[i-1]);
2638	else
2639	{
2640	Werror("par number %d out of range 1..%d",i,p);
2641	return TRUE;
2642	}
2643	return FALSE;
2644	}
2645	static BOOLEAN jjP2I(leftv res, leftv v)
2646	{
2647	poly p=(poly)v->Data();
2648	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
2649	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
2650	{
2651	WerrorS("poly must be constant");
2652	return TRUE;
2653	}
2654	res->data = (char *)nInt(pGetCoeff(p));
2655	return FALSE;
2656	}
2657	static BOOLEAN jjPRIME(leftv res, leftv v)
2658	{
2659	int i = IsPrime((int)(v->Data()));
2660	res->data = (char *)(i > 1 ? i : 2);
2661	return FALSE;
2662	}
2663	static BOOLEAN jjP2N(leftv res, leftv v)
2664	{
2665	number n;
2666	poly p;
2667	if (((p=(poly)v->Data())!=NULL)
2668	&& (pIsConstant(p)))
2669	{
2670	n=nCopy(pGetCoeff(p));
2671	}
2672	else
2673	{
2674	n=nInit(0);
2675	}
2676	res->data = (char *)n;
2677	return FALSE;
2678	}
2679	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
2680	{
2681	char s= (char )v->Data();
2682	int i = 1;
2683	int l = strlen(s);
2684	while (cmds[i].tokval!=0)
2685	{
2686	if (strcmp(s, cmds[i].name) == 0)
2687	{
2688	res->data = (char *)1;
2689	return FALSE;
2690	}
2691	i++;
2692	}
2693	//res->data = (char *)0;
2694	return FALSE;
2695	}
2696	static BOOLEAN jjREAD(leftv res, leftv v)
2697	{
2698	return jjREAD2(res,v,NULL);
2699	}
2700	static BOOLEAN jjREGULARITY(leftv res, leftv v)
2701	{
2702	res->data = (char *)iiRegularity((lists)v->Data());
2703	return FALSE;
2704	}
2705	static BOOLEAN jjROWS(leftv res, leftv v)
2706	{
2707	ideal i = (ideal)v->Data();
2708	res->data = (char *)i->rank;
2709	return FALSE;
2710	}
2711	static BOOLEAN jjROWS_IV(leftv res, leftv v)
2712	{
2713	res->data = (char )((intvec)(v->Data()))->rows();
2714	return FALSE;
2715	}
2716	static BOOLEAN jjRPAR(leftv res, leftv v)
2717	{
2718	res->data = (char *)((ring)v->Data())->P;
2719	return FALSE;
2720	}
2721	static BOOLEAN jjSTD(leftv res, leftv v)
2722	{
2723	ideal result;
2724	intvec w=(intvec )atGet(v,"isHomog");
2725	tHomog hom=testHomog;
2726	if (w!=NULL)
2727	{
2728	w=ivCopy(w);
2729	hom=isHomog;
2730	}
2731	//if (hasFlag(v,FLAG_STD))
2732	// result=stdred((ideal)v->Data(),currQuotient,hom,&w);
2733	//else
2734	result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
2735	idSkipZeroes(result);
2736	res->data = (char *)result;
2737	setFlag(res,FLAG_STD);
2738	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
2739	return FALSE;
2740	}
2741	static BOOLEAN jjSTRING(leftv res, leftv v)
2742	{
2743	res->data = (char *)v->String();
2744	if (res->data==NULL)
2745	{
2746	Werror("cannot convert %s to string",Tok2Cmdname(v->Typ()));
2747	return TRUE;
2748	}
2749	return FALSE;
2750	}
2751	static BOOLEAN jjSort_Id(leftv res, leftv v)
2752	{
2753	res->data = (char *)idSort((ideal)v->Data());
2754	return FALSE;
2755	}
2756	static BOOLEAN jjSTRING_PROC(leftv res, leftv v)
2757	{
2758	procinfov pi = IDPROC((idhdl)v->data);
2759	if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
2760	//if(pi->language == LANG_SINGULAR)
2761	{
2762	//if(pi->data.s.body==NULL)
2763	// iiGetLibProcBuffer(IDPROC((idhdl)v->data));
2764	res->data=mstrdup(pi->data.s.body);
2765	}
2766	else
2767	res->data=mstrdup("");
2768	return FALSE;
2769	}
2770	static BOOLEAN jjSYZYGY(leftv res, leftv v)
2771	{
2772	intvec *w=NULL;
2773	res->data = (char *)idSyzygies((ideal)v->Data(),currQuotient,testHomog,&w);
2774	if (w!=NULL) delete w;
2775	return FALSE;
2776	}
2777	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
2778	{
2779	res->data = (char )ivTrace((intvec)(v->Data()));
2780	return FALSE;
2781	}
2782	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
2783	{
2784	res->data = (char )ivTranp((intvec)(v->Data()));
2785	return FALSE;
2786	}
2787	static BOOLEAN jjTYPEOF(leftv res, leftv v)
2788	{
2789	switch ((int)v->data)
2790	{
2791	case INT_CMD: res->data=mstrdup("int"); break;
2792	case POLY_CMD: res->data=mstrdup("poly"); break;
2793	case VECTOR_CMD: res->data=mstrdup("vector"); break;
2794	case STRING_CMD: res->data=mstrdup("string"); break;
2795	case INTVEC_CMD: res->data=mstrdup("intvec"); break;
2796	case IDEAL_CMD: res->data=mstrdup("ideal"); break;
2797	case MATRIX_CMD: res->data=mstrdup("matrix"); break;
2798	case MODUL_CMD: res->data=mstrdup("module"); break;
2799	case MAP_CMD: res->data=mstrdup("map"); break;
2800	case PROC_CMD: res->data=mstrdup("proc"); break;
2801	case RING_CMD: res->data=mstrdup("ring"); break;
2802	case QRING_CMD: res->data=mstrdup("qring"); break;
2803	case INTMAT_CMD: res->data=mstrdup("intmat"); break;
2804	case NUMBER_CMD: res->data=mstrdup("number"); break;
2805	case LIST_CMD: res->data=mstrdup("list"); break;
2806	case PACKAGE_CMD: res->data=mstrdup("package"); break;
2807	case LINK_CMD: res->data=mstrdup("link"); break;
2808	case RESOLUTION_CMD:res->data=mstrdup("resolution");break;
2809	case DEF_CMD:
2810	case NONE: res->data=mstrdup("none"); break;
2811	default: res->data=mstrdup("?unknown type?");
2812	}
2813	return FALSE;
2814	}
2815	static BOOLEAN jjVAR1(leftv res, leftv v)
2816	{
2817	int i=(int)v->Data();
2818	if ((0<i) && (i<=currRing->N))
2819	{
2820	poly p=pOne();
2821	pSetExp(p,i,1);
2822	pSetm(p);
2823	res->data=(char *)p;
2824	}
2825	else
2826	{
2827	Werror("var number %d out of range 1..%d",i,currRing->N);
2828	return TRUE;
2829	}
2830	return FALSE;
2831	}
2832	static BOOLEAN jjVARSTR1(leftv res, leftv v)
2833	{
2834	if (currRing==NULL)
2835	{
2836	WerrorS("no ring active");
2837	return TRUE;
2838	}
2839	int i=(int)v->Data();
2840	if ((0<i) && (i<=currRing->N))
2841	res->data=mstrdup(currRing->names[i-1]);
2842	else
2843	{
2844	Werror("var number %d out of range 1..%d",i,currRing->N);
2845	return TRUE;
2846	}
2847	return FALSE;
2848	}
2849	static BOOLEAN jjVDIM(leftv res, leftv v)
2850	{
2851	assumeStdFlag(v);
2852	res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
2853	return FALSE;
2854	}
2855	/=================== operations with 1 arg.: table =================/
2856
2857	#ifdef INIT_BUG
2858	#define XS(A) -((short)A)
2859	#define jjstrlen (proc1)1
2860	#define jjpLength (proc1)2
2861	#define jjidElem (proc1)3
2862	#define jjmpDet (proc1)4
2863	#define jjidFreeModule (proc1)5
2864	#define jjidVec2Ideal (proc1)6
2865	#define jjrCharStr (proc1)7
2866	#ifndef MDEBUG
2867	#define jjpHead (proc1)8
2868	#endif
2869	#define jjidHead (proc1)9
2870	#define jjidMaxIdeal (proc1)10
2871	#define jjidMinBase (proc1)11
2872	#define jjsyMinBase (proc1)12
2873	#define jjpMaxComp (proc1)13
2874	#define jjmpTrace (proc1)14
2875	#define jjmpTransp (proc1)15
2876	#define jjrOrdStr (proc1)16
2877	#define jjrVarStr (proc1)18
2878	#define jjrParStr (proc1)19
2879	#define jjidMinEmbedding (proc1)20
2880	#define jjBETTI_R (proc1)21
2881	#define jjCOUNT_R (proc1)22
2882	#define jjDIM_R (proc1)23
2883	#define jjMINRES_R (proc1)24
2884
2885	extern struct sValCmd1 dArith1[];
2886	void jjInitTab1()
2887	{
2888	int i=0;
2889	for (;dArith1[i].cmd!=0;i++)
2890	{
2891	if (dArith1[i].res<0)
2892	{
2893	switch ((int)dArith1[i].p)
2894	{
2895	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
2896	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
2897	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
2898	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
2899	#ifndef HAVE_FACTORY
2900	case (int)jjmpDet: dArith1[i].p=(proc1)mpDet; break;
2901	#endif
2902	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
2903	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
2904	#ifndef MDEBUG
2905	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
2906	#endif
2907	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
2908	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
2909	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
2910	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
2911	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxComp; break;
2912	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
2913	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
2914	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
2915	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
2916	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
2917	case (int)jjidMinEmbedding: dArith1[i].p=(proc1)idMinEmbedding; break;
2918	case (int)jjBETTI_R: dArith1[i].p=(proc1)syBettiOfComputation; break;
2919	case (int)jjCOUNT_R: dArith1[i].p=(proc1)syLength; break;
2920	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
2921	case (int)jjMINRES_R: dArith1[i].p=(proc1)syMinimize; break;
2922	#ifdef GENTABLE
2923	default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
2924	#endif
2925	}
2926	}
2927	}
2928	}
2929	#else
2930	#if defined(PROC_BUG)
2931	#define XS(A) A
2932	static BOOLEAN jjstrlen(leftv res, leftv v)
2933	{
2934	res->data = (char )strlen((char )v->Data());
2935	return FALSE;
2936	}
2937	static BOOLEAN jjpLength(leftv res, leftv v)
2938	{
2939	res->data = (char *)pLength((poly)v->Data());
2940	return FALSE;
2941	}
2942	static BOOLEAN jjidElem(leftv res, leftv v)
2943	{
2944	res->data = (char *)idElem((ideal)v->Data());
2945	return FALSE;
2946	}
2947	static BOOLEAN jjmpDet(leftv res, leftv v)
2948	{
2949	res->data = (char *)mpDet((matrix)v->Data());
2950	return FALSE;
2951	}
2952	static BOOLEAN jjidFreeModule(leftv res, leftv v)
2953	{
2954	res->data = (char *)idFreeModule((int)v->Data());
2955	return FALSE;
2956	}
2957	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
2958	{
2959	res->data = (char *)idVec2Ideal((poly)v->Data());
2960	return FALSE;
2961	}
2962	static BOOLEAN jjrCharStr(leftv res, leftv v)
2963	{
2964	res->data = rCharStr((ring)v->Data());
2965	return FALSE;
2966	}
2967	#ifndef MDEBUG
2968	static BOOLEAN jjpHead(leftv res, leftv v)
2969	{
2970	res->data = (char *)pHead((poly)v->Data());
2971	return FALSE;
2972	}
2973	#endif
2974	static BOOLEAN jjidHead(leftv res, leftv v)
2975	{
2976	res->data = (char *)idHead((ideal)v->Data());
2977	return FALSE;
2978	}
2979	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
2980	{
2981	res->data = (char *)idMaxIdeal((int)v->Data());
2982	return FALSE;
2983	}
2984	static BOOLEAN jjidMinBase(leftv res, leftv v)
2985	{
2986	res->data = (char *)idMinBase((ideal)v->Data());
2987	return FALSE;
2988	}
2989	static BOOLEAN jjsyMinBase(leftv res, leftv v)
2990	{
2991	res->data = (char *)syMinBase((ideal)v->Data());
2992	return FALSE;
2993	}
2994	static BOOLEAN jjpMaxComp(leftv res, leftv v)
2995	{
2996	res->data = (char *)pMaxComp((poly)v->Data());
2997	return FALSE;
2998	}
2999	static BOOLEAN jjmpTrace(leftv res, leftv v)
3000	{
3001	res->data = (char *)mpTrace((matrix)v->Data());
3002	return FALSE;
3003	}
3004	static BOOLEAN jjmpTransp(leftv res, leftv v)
3005	{
3006	res->data = (char *)mpTransp((matrix)v->Data());
3007	return FALSE;
3008	}
3009	static BOOLEAN jjrOrdStr(leftv res, leftv v)
3010	{
3011	res->data = rOrdStr((ring)v->Data());
3012	return FALSE;
3013	}
3014	static BOOLEAN jjrVarStr(leftv res, leftv v)
3015	{
3016	res->data = rVarStr((ring)v->Data());
3017	return FALSE;
3018	}
3019	static BOOLEAN jjrParStr(leftv res, leftv v)
3020	{
3021	res->data = rParStr((ring)v->Data());
3022	return FALSE;
3023	}
3024	static BOOLEAN jjidMinEmbedding(leftv res, leftv v)
3025	{
3026	res->data = (char *)idMinEmbedding((ideal)v->Data());
3027	return FALSE;
3028	}
3029	static BOOLEAN jjBETTI_R(leftv res, leftv v)
3030	{
3031	res->data=(char *)syBettiOfComputation((syStrategy)v->Data());
3032	return FALSE;
3033	}
3034	static BOOLEAN jjCOUNT_R(leftv res, leftv v)
3035	{
3036	res->data=(char *)syLength((syStrategy)v->Data());
3037	return FALSE;
3038	}
3039	static BOOLEAN jjDIM_R(leftv res, leftv v)
3040	{
3041	res->data = (char *)syDim((syStrategy)v->Data());
3042	return FALSE;
3043	}
3044	static BOOLEAN jjMINRES_R(leftv res, leftv v)
3045	{
3046	res->data=(char *)syMinimize((syStrategy)v->Data());
3047	return FALSE;
3048	}
3049	#else
3050	#define XS(A) -((short)A)
3051	#define jjstrlen (proc1)strlen
3052	#define jjpLength (proc1)pLength
3053	#define jjidElem (proc1)idElem
3054	#define jjmpDet (proc1)mpDet
3055	#define jjidFreeModule (proc1)idFreeModule
3056	#define jjidVec2Ideal (proc1)idVec2Ideal
3057	#define jjrCharStr (proc1)rCharStr
3058	#ifndef MDEBUG
3059	#define jjpHead (proc1)pHead
3060	#endif
3061	#define jjidHead (proc1)idHead
3062	#define jjidMaxIdeal (proc1)idMaxIdeal
3063	#define jjidMinBase (proc1)idMinBase
3064	#define jjsyMinBase (proc1)syMinBase
3065	#define jjpMaxComp (proc1)pMaxComp
3066	#define jjmpTrace (proc1)mpTrace
3067	#define jjmpTransp (proc1)mpTransp
3068	#define jjrOrdStr (proc1)rOrdStr
3069	#define jjrVarStr (proc1)rVarStr
3070	#define jjrParStr (proc1)rParStr
3071	#define jjidMinEmbedding (proc1)idMinEmbedding
3072	#define jjBETTI_R (proc1)syBettiOfComputation
3073	#define jjCOUNT_R (proc1)syLength
3074	#define jjDIM_R (proc1)syDim
3075	#define jjMINRES_R (proc1)syMinimize
3076	#endif
3077	#endif
3078	BOOLEAN jjnInt(leftv res, leftv u)
3079	{
3080	number n=(number)u->CopyD();
3081	res->data=(char *)nInt(n);
3082	nDelete(&n);
3083	return FALSE;
3084	}
3085	#define s short
3086	struct sValCmd1 dArith1[]=
3087	{
3088	// operations:
3089	// proc cmd res arg
3090	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD }
3091	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD }
3092	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL }
3093	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL }
3094	,{jjUMINUS_I, '-', INT_CMD, INT_CMD }
3095	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD }
3096	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD }
3097	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD }
3098	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD }
3099	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD }
3100	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD }
3101	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD }
3102	,{jjKLAMMER_LIB,'(', NONE, STRING_CMD }
3103	// and the procedures with 1 argument:
3104	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD }
3105	,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD }
3106	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MATRIX_CMD }
3107	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD }
3108	,{jjBETTI_R, BETTI_CMD, XS(INTMAT_CMD), RESOLUTION_CMD }
3109	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD }
3110	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD }
3111	#ifdef HAVE_FACTORY
3112	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD }
3113	#else
3114	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD }
3115	#endif
3116	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD }
3117	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3118	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD }
3119	,{jjWRONG, COLS_CMD, 0, VECTOR_CMD }
3120	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD }
3121	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD }
3122	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD }
3123	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD }
3124	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD }
3125	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD }
3126	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD }
3127	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD }
3128	,{jjCOUNT_R, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD }
3129	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD }
3130	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD }
3131	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD }
3132	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD }
3133	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD }
3134	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD }
3135	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD }
3136	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD }
3137	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD }
3138	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD }
3139	,{jjWRONG, DEF_CMD, 0, ANY_TYPE }
3140	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD }
3141	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD }
3142	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD }
3143	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD }
3144	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD }
3145	#ifdef HAVE_FACTORY
3146	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD }
3147	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD }
3148	#else
3149	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD }
3150	,{jjmpDet, DET_CMD, XS(POLY_CMD), MATRIX_CMD }
3151	#endif
3152	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD }
3153	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD }
3154	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD }
3155	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD }
3156	,{jjE, E_CMD, VECTOR_CMD, INT_CMD }
3157	#ifdef HAVE_FACTORY
3158	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD }
3159	#else
3160	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD }
3161	#endif
3162	#ifdef HAVE_FGLM
3163	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD}
3164	#else
3165	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD}
3166	#endif
3167	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD }
3168	#ifdef HAVE_FACTORY
3169	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD }
3170	#else
3171	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD }
3172	#endif
3173	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD }
3174	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD }
3175	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD }
3176	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD }
3177	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD }
3178	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD }
3179	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD }
3180	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD }
3181	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD }
3182	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD }
3183	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD }
3184	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD }
3185	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD }
3186	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD }
3187	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD }
3188	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD }
3189	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD }
3190	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD }
3191	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD }
3192	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD }
3193	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD }
3194	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD }
3195	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD }
3196	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE }
3197	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD }
3198	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD }
3199	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD }
3200	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD }
3201	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL }
3202	#ifdef MDEBUG
3203	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD }
3204	#else
3205	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD }
3206	#endif
3207	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD }
3208	#ifdef MDEBUG
3209	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD }
3210	#else
3211	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD }
3212	#endif
3213	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD }
3214	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD }
3215	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD }
3216	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD }
3217	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD }
3218	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD }
3219	,{jjWRONG, MAP_CMD, 0, ANY_TYPE}
3220	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD }
3221	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD }
3222	,{jjMEMORY, MEMORY_CMD, INT_CMD, INT_CMD }
3223	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD }
3224	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD }
3225	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD }
3226	,{jjMINRES_R, MINRES_CMD, XS(RESOLUTION_CMD), RESOLUTION_CMD }
3227	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD }
3228	,{jjMONITOR1, MONITOR_CMD, NONE, STRING_CMD }
3229	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD }
3230	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD }
3231	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD }
3232	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE }
3233	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD }
3234	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD }
3235	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD }
3236	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD }
3237	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD }
3238	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD }
3239	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD }
3240	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD }
3241	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD }
3242	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD }
3243	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD }
3244	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD }
3245	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD }
3246	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD }
3247	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD }
3248	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD }
3249	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD }
3250	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3251	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD }
3252	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD }
3253	,{jjPRINT_GEN, PRINT_CMD, NONE, INT_CMD }
3254	,{jjPRINT_INTVEC,PRINT_CMD, NONE, INTVEC_CMD }
3255	,{jjPRINT_INTMAT,PRINT_CMD, NONE, INTMAT_CMD }
3256	,{jjPRINT_GEN, PRINT_CMD, NONE, STRING_CMD }
3257	,{jjPRINT_GEN, PRINT_CMD, NONE, POLY_CMD }
3258	,{jjPRINT_V, PRINT_CMD, NONE, VECTOR_CMD }
3259	,{jjPRINT_GEN, PRINT_CMD, NONE, IDEAL_CMD }
3260	,{jjPRINT_MA, PRINT_CMD, NONE, MATRIX_CMD }
3261	,{jjPRINT_LIST, PRINT_CMD, NONE, LIST_CMD }
3262	,{jjPRINT_GEN, PRINT_CMD, NONE, RESOLUTION_CMD }
3263	,{jjidMinEmbedding, PRUNE_CMD, XS(MODUL_CMD), MODUL_CMD }
3264	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD }
3265	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD }
3266	,{jjWRONG, QRING_CMD, 0, ANY_TYPE}
3267	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD }
3268	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD }
3269	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD }
3270	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD }
3271	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD }
3272	,{jjWRONG, ROWS_CMD, 0, POLY_CMD }
3273	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD }
3274	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD }
3275	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD }
3276	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD }
3277	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD }
3278	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD }
3279	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD }
3280	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD }
3281	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD }
3282	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD }
3283	,{jjSTRING, STRING_CMD, STRING_CMD, INT_CMD }
3284	,{jjSTRING, STRING_CMD, STRING_CMD, POLY_CMD }
3285	,{jjSTRING, STRING_CMD, STRING_CMD, VECTOR_CMD }
3286	,{jjSTRING, STRING_CMD, STRING_CMD, NUMBER_CMD }
3287	,{jjSTRING, STRING_CMD, STRING_CMD, MATRIX_CMD }
3288	,{jjSTRING, STRING_CMD, STRING_CMD, MODUL_CMD }
3289	,{jjSTRING, STRING_CMD, STRING_CMD, IDEAL_CMD }
3290	,{jjSTRING, STRING_CMD, STRING_CMD, MAP_CMD }
3291	,{jjSTRING, STRING_CMD, STRING_CMD, INTVEC_CMD }
3292	,{jjSTRING, STRING_CMD, STRING_CMD, INTMAT_CMD }
3293	,{jjSTRING_PROC,STRING_CMD, STRING_CMD, PROC_CMD }
3294	,{jjSTRING, STRING_CMD, STRING_CMD, RING_CMD }
3295	,{jjSTRING, STRING_CMD, STRING_CMD, QRING_CMD }
3296	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD }
3297	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD }
3298	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD }
3299	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD }
3300	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD }
3301	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD }
3302	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD }
3303	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD }
3304	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD }
3305	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD }
3306	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE }
3307	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD }
3308	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD }
3309	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD }
3310	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD }
3311	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD }
3312	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD }
3313	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3314	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD }
3315	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD }
3316	,{NULL, 0, 0, 0}
3317	};
3318	#undef s
3319	/=================== operations with 3 args.: static proc =================/
3320	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
3321	{
3322	char s= (char )u->Data();
3323	int r = (int)v->Data();
3324	int c = (int)w->Data();
3325	int l = strlen(s);
3326
3327	if ( (r<1) \|\| (r>l) \|\| (c<0) )
3328	{
3329	Werror("wrong range[%d,%d] in string %s",r,c,u->Name());
3330	return TRUE;
3331	}
3332	res->data = (char *)AllocL(c+1);
3333	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
3334	return FALSE;
3335	}
3336	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
3337	{
3338	intvec iv = (intvec )u->Data();
3339	int r = (int)v->Data();
3340	int c = (int)w->Data();
3341	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
3342	{
3343	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
3344	r,c,u->Name(),iv->rows(),iv->cols());
3345	return TRUE;
3346	}
3347	res->data=u->data;
3348	u->data=NULL;
3349	res->rtyp=u->rtyp;
3350	u->rtyp=0;
3351	res->name=u->name;
3352	u->name=NULL;
3353	Subexpr e=jjMakeSub(v);
3354	e->next=jjMakeSub(w);
3355	if (u->e==NULL) res->e=e;
3356	else
3357	{
3358	Subexpr h=u->e;
3359	while (h->next!=NULL) h=h->next;
3360	h->next=e;
3361	res->e=u->e;
3362	u->e=NULL;
3363	}
3364	return FALSE;
3365	}
3366	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
3367	{
3368	matrix m= (matrix)u->Data();
3369	int r = (int)v->Data();
3370	int c = (int)w->Data();
3371	//Print("gen. elem %d, %d\n",r,c);
3372	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
3373	{
3374	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Name(),
3375	MATROWS(m),MATCOLS(m));
3376	return TRUE;
3377	}
3378	res->data=u->data;
3379	u->data=NULL;
3380	res->rtyp=u->rtyp;
3381	u->rtyp=0;
3382	res->name=u->name;
3383	u->name=NULL;
3384	Subexpr e=jjMakeSub(v);
3385	e->next=jjMakeSub(w);
3386	if (u->e==NULL)
3387	res->e=e;
3388	else
3389	{
3390	Subexpr h=u->e;
3391	while (h->next!=NULL) h=h->next;
3392	h->next=e;
3393	res->e=u->e;
3394	u->e=NULL;
3395	}
3396	return FALSE;
3397	}
3398	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
3399	{
3400	sleftv t;
3401	sleftv ut;
3402	leftv p=NULL;
3403	intvec iv=(intvec )w->Data();
3404	int l;
3405	BOOLEAN nok;
3406
3407	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3408	{
3409	WerrorS("cannot build expression lists from unnamed objects");
3410	return TRUE;
3411	}
3412	memcpy(&ut,u,sizeof(ut));
3413	memset(&t,0,sizeof(t));
3414	t.rtyp=INT_CMD;
3415	for (l=0;l< iv->length(); l++)
3416	{
3417	t.data=(char )(iv)[l];
3418	if (p==NULL)
3419	{
3420	p=res;
3421	}
3422	else
3423	{
3424	p->next=(leftv)Alloc0(sizeof(sleftv));
3425	p=p->next;
3426	}
3427	memcpy(u,&ut,sizeof(ut));
3428	if (u->Typ() == MATRIX_CMD)
3429	nok=jjBRACK_Ma(p,u,v,&t);
3430	else /* INTMAT_CMD */
3431	nok=jjBRACK_Im(p,u,v,&t);
3432	if (nok)
3433	{
3434	while (res->next!=NULL)
3435	{
3436	p=res->next->next;
3437	Free((ADDRESS)res->next,sizeof(sleftv));
3438	// res->e aufraeumen !!!!
3439	res->next=p;
3440	}
3441	return TRUE;
3442	}
3443	}
3444	return FALSE;
3445	}
3446	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
3447	{
3448	sleftv t;
3449	sleftv ut;
3450	leftv p=NULL;
3451	intvec iv=(intvec )v->Data();
3452	int l;
3453	BOOLEAN nok;
3454
3455	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3456	{
3457	WerrorS("cannot build expression lists from unnamed objects");
3458	return TRUE;
3459	}
3460	memcpy(&ut,u,sizeof(ut));
3461	memset(&t,0,sizeof(t));
3462	t.rtyp=INT_CMD;
3463	for (l=0;l< iv->length(); l++)
3464	{
3465	t.data=(char )((iv)[l]);
3466	if (p==NULL)
3467	{
3468	p=res;
3469	}
3470	else
3471	{
3472	p->next=(leftv)Alloc0(sizeof(sleftv));
3473	p=p->next;
3474	}
3475	memcpy(u,&ut,sizeof(ut));
3476	if (u->Typ() == MATRIX_CMD)
3477	nok=jjBRACK_Ma(p,u,&t,w);
3478	else /* INTMAT_CMD */
3479	nok=jjBRACK_Im(p,u,&t,w);
3480	if (nok)
3481	{
3482	while (res->next!=NULL)
3483	{
3484	p=res->next->next;
3485	Free((ADDRESS)res->next,sizeof(sleftv));
3486	// res->e aufraeumen !!
3487	res->next=p;
3488	}
3489	return TRUE;
3490	}
3491	}
3492	return FALSE;
3493	}
3494	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
3495	{
3496	sleftv t1,t2,ut;
3497	leftv p=NULL;
3498	intvec vv=(intvec )v->Data();
3499	intvec wv=(intvec )w->Data();
3500	int vl;
3501	int wl;
3502	BOOLEAN nok;
3503
3504	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3505	{
3506	WerrorS("cannot build expression lists from unnamed objects");
3507	return TRUE;
3508	}
3509	memcpy(&ut,u,sizeof(ut));
3510	memset(&t1,0,sizeof(sleftv));
3511	memset(&t2,0,sizeof(sleftv));
3512	t1.rtyp=INT_CMD;
3513	t2.rtyp=INT_CMD;
3514	for (vl=0;vl< vv->length(); vl++)
3515	{
3516	t1.data=(char )((vv)[vl]);
3517	for (wl=0;wl< wv->length(); wl++)
3518	{
3519	t2.data=(char )((wv)[wl]);
3520	if (p==NULL)
3521	{
3522	p=res;
3523	}
3524	else
3525	{
3526	p->next=(leftv)Alloc0(sizeof(sleftv));
3527	p=p->next;
3528	}
3529	memcpy(u,&ut,sizeof(ut));
3530	if (u->Typ() == MATRIX_CMD)
3531	nok=jjBRACK_Ma(p,u,&t1,&t2);
3532	else /* INTMAT_CMD */
3533	nok=jjBRACK_Im(p,u,&t1,&t2);
3534	if (nok)
3535	{
3536	res->CleanUp();
3537	return TRUE;
3538	}
3539	}
3540	}
3541	return FALSE;
3542	}
3543	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
3544	{
3545	v->next=(leftv)Alloc(sizeof(sleftv));
3546	memcpy(v->next,w,sizeof(sleftv));
3547	BOOLEAN r=iiExprArith2(res,u,'(',v);
3548	v->rtyp=0; v->data=NULL;
3549	w->rtyp=0; w->data=NULL;
3550	return r;
3551	}
3552	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
3553	{
3554	u->next=(leftv)Alloc(sizeof(sleftv));
3555	memcpy(u->next,v,sizeof(sleftv));
3556	u->next->next=(leftv)Alloc(sizeof(sleftv));
3557	memcpy(u->next->next,w,sizeof(sleftv));
3558	BOOLEAN r=iiExprArithM(res,u,iiOp);
3559	v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
3560	w->rtyp=0; w->data=NULL;
3561	return r;
3562	}
3563	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
3564	{
3565	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
3566	{
3567	WerrorS("3rd argument must be a name of a matrix");
3568	return TRUE;
3569	}
3570	ideal i=(ideal)u->Data();
3571	int rank=(int)i->rank;
3572	BOOLEAN r=jjCOEFFS_Id(res,u,v);
3573	if (r) return TRUE;
3574	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3575	return FALSE;
3576	}
3577	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
3578	{
3579	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
3580	(ideal)(v->Data()),(poly)(w->Data()));
3581	return FALSE;
3582	}
3583	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
3584	{
3585	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
3586	{
3587	WerrorS("3rd argument must be a name of a matrix");
3588	return TRUE;
3589	}
3590	poly p=(poly)u->CopyD();
3591	ideal i=idInit(1,1);
3592	i->m[0]=p;
3593	sleftv t;
3594	memset(&t,0,sizeof(t));
3595	t.data=(char *)i;
3596	t.rtyp=IDEAL_CMD;
3597	int rank=1;
3598	if (u->Typ()==VECTOR_CMD)
3599	{
3600	i->rank=rank=pMaxComp(p);
3601	t.rtyp=MODUL_CMD;
3602	}
3603	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
3604	t.CleanUp();
3605	if (r) return TRUE;
3606	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3607	return FALSE;
3608	}
3609	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
3610	{
3611	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
3612	(intvec *)w->Data());
3613	setFlag(res,FLAG_STD);
3614	return FALSE;
3615	}
3616	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
3617	{
3618	/*4
3619	* look for the substring what in the string where
3620	* starting at position n
3621	* return the position of the first char of what in where
3622	* or 0
3623	*/
3624	int n=(int)w->Data();
3625	char where=(char )u->Data();
3626	char what=(char )v->Data();
3627	char *found;
3628	if ((1>n)\|\|(n>(int)strlen(where)))
3629	{
3630	Werror("start position %d out of range",n);
3631	return TRUE;
3632	}
3633	found = strchr(where+n-1,*what);
3634	if (*(what+1)!='\0')
3635	{
3636	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
3637	{
3638	found=strchr(found+1,*what);
3639	}
3640	}
3641	if (found != NULL)
3642	{
3643	res->data=(char *)((found-where)+1);
3644	}
3645	return FALSE;
3646	}
3647	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
3648	{
3649	short iw=iv2array((intvec )w->Data());
3650	res->data = (char *)pJetW((poly)u->Data(),(int)v->Data(),iw);
3651	Free((ADDRESS)iw,(pVariables+1)*sizeof(short));
3652	return FALSE;
3653	}
3654	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
3655	{
3656	res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
3657	(intvec *)w->Data());
3658	return FALSE;
3659	}
3660	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
3661	{
3662	idhdl h,rr;
3663	map mapping;
3664
3665	rr=(idhdl)u->data;
3666	if ((h=IDRING(rr)->idroot->get(v->name,myynest))!=NULL)
3667	{
3668	if (h->typ==MAP_CMD)
3669	{
3670	mapping=IDMAP(h);
3671	}
3672	else if (h->typ==IDEAL_CMD)
3673	{
3674	mapping=IDMAP(h);
3675	}
3676	else
3677	{
3678	Werror("`%s` is no map nor ideal",IDID(h));
3679	return TRUE;
3680	}
3681	}
3682	else
3683	{
3684	Werror("`%s` is not defined in `%s`",v->name,u->name);
3685	return TRUE;
3686	}
3687	if ((h=IDRING(rr)->idroot->get(w->name,myynest))!=NULL)
3688	{
3689	if (h->typ==IDEAL_CMD)
3690	{
3691	res->data=(char *)maGetPreimage(IDRING(rr),mapping,IDIDEAL(h));
3692	}
3693	else
3694	{
3695	Werror("`%s` is no ideal",IDID(h));
3696	return TRUE;
3697	}
3698	}
3699	else
3700	{
3701	Werror("`%s` is not defined in `%s`",w->name,u->name);
3702	return TRUE;
3703	}
3704	return FALSE;
3705	}
3706	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
3707	{
3708	int di, k;
3709	int i=(int)u->Data();
3710	int r=(int)v->Data();
3711	int c=(int)w->Data();
3712	intvec *iv = new intvec(r, c, 0);
3713	if (iv->rows()==0)
3714	{
3715	delete iv;
3716	return TRUE;
3717	}
3718	if (i!=0)
3719	{
3720	if (i<0) i = -i;
3721	di = 2 * i + 1;
3722	for (k=0; k<iv->length(); k++)
3723	{
3724	#ifdef buildin_rand
3725	(*iv)[k] = ((siRand() % di) - i);
3726	#else
3727	(*iv)[k] = ((rand() % di) - i);
3728	#endif
3729	}
3730	}
3731	res->data = (char *)iv;
3732	return FALSE;
3733	}
3734	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
3735	int &ringvar, poly &monomexpr)
3736	{
3737	monomexpr=(poly)w->Data();
3738	if (pLength(monomexpr)>1)
3739	{
3740	Werror("`%s` substitutes a ringvar only by a term",
3741	Tok2Cmdname(SUBST_CMD));
3742	return TRUE;
3743	}
3744	if (!(ringvar=pVar((poly)v->Data())))
3745	{
3746	WerrorS("ringvar expected");
3747	return TRUE;
3748	}
3749	return FALSE;
3750	}
3751	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
3752	{
3753	int ringvar;
3754	poly monomexpr;
3755	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
3756	if (nok) return TRUE;
3757	res->data = pSubst((poly)u->CopyD(POLY_CMD),ringvar,monomexpr);
3758	return FALSE;
3759	}
3760	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
3761	{
3762	int ringvar;
3763	poly monomexpr;
3764	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
3765	if (nok) return TRUE;
3766	res->data = idSubst((ideal)u->CopyD(IDEAL_CMD),ringvar,monomexpr);
3767	return FALSE;
3768	}
3769	static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
3770	{
3771	matrix m=mpNew((int)v->Data(),(int)w->Data());
3772	ideal I=(ideal)u->CopyD(IDEAL_CMD);
3773	int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
3774	//for(i=i-1;i>=0;i--)
3775	//{
3776	// m->m[i]=I->m[i];
3777	// I->m[i]=NULL;
3778	//}
3779	memcpy4(m->m,I->m,i*sizeof(poly));
3780	memset(I->m,0,i*sizeof(poly));
3781	idDelete(&I);
3782	res->data = (char *)m;
3783	return FALSE;
3784	}
3785	static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
3786	{
3787	res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
3788	(int)v->Data(),(int)w->Data());
3789	return FALSE;
3790	}
3791	static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
3792	{
3793	matrix m=mpNew((int)v->Data(),(int)w->Data());
3794	matrix I=(matrix)u->CopyD(MATRIX_CMD);
3795	int r=min(MATROWS(I),(int)v->Data());
3796	int c=min(MATCOLS(I),(int)w->Data());
3797	int i,j;
3798	for(i=r;i>0;i--)
3799	{
3800	for(j=c;j>0;j--)
3801	{
3802	MATELEM(m,i,j)=MATELEM(I,i,j);
3803	MATELEM(I,i,j)=NULL;
3804	}
3805	}
3806	idDelete((ideal *)&I);
3807	res->data = (char *)m;
3808	return FALSE;
3809	}
3810	static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
3811	{
3812	assumeStdFlag(v);
3813	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
3814	0,(int)w->Data());
3815	return FALSE;
3816	}
3817	static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
3818	{
3819	assumeStdFlag(v);
3820	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
3821	0,(int)w->Data());
3822	return FALSE;
3823	}
3824	#ifdef OLD_RES
3825	static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
3826	{
3827	int maxl=(int)v->Data();
3828	int l=0;
3829	resolvente r;
3830	intvec **weights=NULL;
3831	int wmaxl=maxl;
3832	maxl--;
3833	if ((maxl==-1) && (iiOp!=MRES_CMD))
3834	maxl = pVariables-1;
3835	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
3836	{
3837	if (BTEST1(28))
3838	{
3839	r=syMinRes((ideal)u->Data(),maxl,&l,iiOp==MRES_CMD);
3840	}
3841	else
3842	{
3843	intvec * iv=(intvec*)atGet(u,"isHomog");
3844	if (iv!=NULL)
3845	{
3846	weights = (intvec*)Alloc0(sizeof(intvec));
3847	weights[0] = ivCopy(iv);
3848	l=1;
3849	}
3850	r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
3851	}
3852	}
3853	else
3854	r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
3855	if (r==NULL) return TRUE;
3856	int t3=u->Typ();
3857	iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
3858	return FALSE;
3859	return TRUE;
3860	}
3861	#endif
3862	static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
3863	{
3864	int yes;
3865	jjSTATUS2(res, u, v);
3866	yes = (strcmp((char ) res->data, (char ) w->Data()) == 0);
3867	FreeL((ADDRESS) res->data);
3868	res->data = (void *) yes;
3869	return FALSE;
3870	}
3871
3872	/=================== operations with 3 args.: table =================/
3873	struct sValCmd3 dArith3[]=
3874	{
3875	// operations:
3876	// proc cmd res arg1 arg2 arg3
3877	{jjBRACK_S, '[', STRING_CMD, STRING_CMD, INT_CMD, INT_CMD }
3878	,{jjBRACK_Im, '[', INT_CMD, INTMAT_CMD, INT_CMD, INT_CMD }
3879	,{jjBRACK_Ma_I_IV, '[', INT_CMD, INTMAT_CMD, INT_CMD, INTVEC_CMD }
3880	,{jjBRACK_Ma_IV_I, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INT_CMD }
3881	,{jjBRACK_Ma_IV_IV, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
3882	,{jjBRACK_Ma, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INT_CMD }
3883	,{jjBRACK_Ma_I_IV, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INTVEC_CMD }
3884	,{jjBRACK_Ma_IV_I, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INT_CMD }
3885	,{jjBRACK_Ma_IV_IV, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
3886	,{jjPROC3, '(', ANY_TYPE, PROC_CMD, DEF_CMD, DEF_CMD }
3887	,{atATTRIB3, ATTRIB_CMD, NONE, IDHDL, STRING_CMD, DEF_CMD }
3888	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, MATRIX_CMD }
3889	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD, MATRIX_CMD }
3890	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, MATRIX_CMD }
3891	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, MATRIX_CMD }
3892	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD }
3893	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD }
3894	,{jjELIMIN_HILB, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
3895	,{jjFIND3, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, INT_CMD }
3896	,{jjCALL3MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
3897	//,{jjCALL3MANY, INTERSECT_CMD, NONE, DEF_CMD, DEF_CMD, DEF_CMD }
3898	,{lInsert3, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, INT_CMD }
3899	,{jjCALL3MANY, INTVEC_CMD, INTVEC_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
3900	,{jjJET_P_IV, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INTVEC_CMD }
3901	,{jjJET_ID_IV, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD }
3902	,{jjJET_P_IV, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, INTVEC_CMD }
3903	,{jjJET_ID_IV, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD }
3904	,{mpKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, IDEAL_CMD }
3905	,{jjCALL3MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
3906	,{jjMATRIX_Id, MATRIX_CMD, MATRIX_CMD, IDEAL_CMD, INT_CMD, INT_CMD }
3907	,{jjMATRIX_Mo, MATRIX_CMD, MATRIX_CMD, MODUL_CMD, INT_CMD, INT_CMD }
3908	,{jjMATRIX_Ma, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, INT_CMD }
3909	,{jjCALL3MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
3910	#ifdef OLD_RES
3911	,{jjRES3, MRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
3912	,{jjRES3, MRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
3913	#endif
3914	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ANY_TYPE }
3915	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE, ANY_TYPE }
3916	,{jjRANDOM_Im, RANDOM_CMD, INTMAT_CMD, INT_CMD, INT_CMD, INT_CMD }
3917	,{jjREDUCE3_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, INT_CMD }
3918	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, INT_CMD }
3919	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, INT_CMD }
3920	,{jjREDUCE3_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD }
3921	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, INT_CMD }
3922	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD }
3923	#ifdef OLD_RES
3924	,{jjRES3, RES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
3925	,{jjRES3, RES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
3926	#endif
3927	#ifdef HAVE_FACTORY
3928	,{jjRESULTANT, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD }
3929	#else
3930	,{jjWRONG3, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD }
3931	#endif
3932	#ifdef OLD_RES
3933	,{jjRES3, SRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
3934	,{jjRES3, SRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
3935	#endif
3936	,{jjSTATUS3, STATUS_CMD, INT_CMD, LINK_CMD, STRING_CMD, STRING_CMD}
3937	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD }
3938	,{jjSUBST_P, SUBST_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, POLY_CMD }
3939	,{jjSUBST_Id, SUBST_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, POLY_CMD }
3940	,{jjSUBST_Id, SUBST_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, POLY_CMD }
3941	,{jjSUBST_Id, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD }
3942	,{jjCALL3MANY, SYSTEM_CMD, NONE, STRING_CMD, DEF_CMD, DEF_CMD }
3943	,{NULL, 0, 0, 0, 0, 0 }
3944	};
3945	/=================== operations with many arg.: static proc =================/
3946	static BOOLEAN jjCALL1ARG(leftv res, leftv v)
3947	{
3948	return iiExprArith1(res,v,iiOp);
3949	}
3950	static BOOLEAN jjCALL2ARG(leftv res, leftv u)
3951	{
3952	leftv v=u->next;
3953	u->next=NULL;
3954	BOOLEAN b=iiExprArith2(res,u,iiOp,v);
3955	u->next=v;
3956	return b;
3957	}
3958	static BOOLEAN jjCALL3ARG(leftv res, leftv u)
3959	{
3960	leftv v = u->next;
3961	leftv w = v->next;
3962	u->next = NULL;
3963	v->next = NULL;
3964	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
3965	u->next = v;
3966	v->next = w;
3967	return b;
3968	}
3969
3970	static BOOLEAN jjCOEF_M(leftv res, leftv v)
3971	{
3972	if((v->Typ() != VECTOR_CMD)
3973	\|\| (v->next->Typ() != POLY_CMD)
3974	\|\| (v->next->next->Typ() != MATRIX_CMD)
3975	\|\| (v->next->next->next->Typ() != MATRIX_CMD))
3976	return TRUE;
3977	if (v->next->next->rtyp!=IDHDL) return TRUE;
3978	idhdl c=(idhdl)v->next->next->data;
3979	if (v->next->next->next->rtyp!=IDHDL) return TRUE;
3980	idhdl m=(idhdl)v->next->next->next->data;
3981	idDelete((ideal *)&(c->data.uideal));
3982	idDelete((ideal *)&(m->data.uideal));
3983	mpCoef2((poly)v->Data(),(poly)v->next->Data(),
3984	(matrix )&(c->data.umatrix),(matrix )&(m->data.umatrix));
3985	return FALSE;
3986	}
3987	static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
3988	{
3989	int s=1;
3990	leftv h=v;
3991	if (h!=NULL) s=exprlist_length(h);
3992	ideal id=idInit(s,1);
3993	int rank=1;
3994	int i=0;
3995	poly p=NULL;
3996	while (h!=NULL)
3997	{
3998	switch(h->Typ())
3999	{
4000	case POLY_CMD:
4001	{
4002	p=(poly)h->CopyD();
4003	break;
4004	}
4005	case INT_CMD:
4006	{
4007	number n=nInit((int)h->Data());
4008	if (!nIsZero(n))
4009	{
4010	p=pOne();
4011	pSetCoeff(p,n);
4012	}
4013	else
4014	{
4015	//p=NULL;
4016	nDelete(&n);
4017	}
4018	break;
4019	}
4020	case NUMBER_CMD:
4021	{
4022	number n=(number)h->CopyD();
4023	if (!nIsZero(n))
4024	{
4025	p=pOne();
4026	pSetCoeff(p,n);
4027	}
4028	else
4029	{
4030	//p=NULL;
4031	nDelete(&n);
4032	}
4033	break;
4034	}
4035	case VECTOR_CMD:
4036	{
4037	p=(poly)h->CopyD();
4038	if (iiOp!=MODUL_CMD)
4039	{
4040	idDelete(&id);
4041	pDelete(&p);
4042	return TRUE;
4043	}
4044	rank=max(rank,pMaxComp(p));
4045	break;
4046	}
4047	default:
4048	{
4049	idDelete(&id);
4050	return TRUE;
4051	}
4052	}
4053	if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4054	{
4055	pSetCompP(p,1);
4056	}
4057	id->m[i]=p;
4058	i++;
4059	h=h->next;
4060	}
4061	id->rank=rank;
4062	res->data=(char *)id;
4063	return FALSE;
4064	}
4065	static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4066	{
4067	leftv h=v;
4068	int l=v->listLength();
4069	resolvente r=(resolvente)Alloc0(l*sizeof(ideal));
4070	BOOLEAN copied=(BOOLEAN )Alloc0(l*sizeof(BOOLEAN));
4071	int t=0;
4072	// try to convert to IDEAL_CMD
4073	while (h!=NULL)
4074	{
4075	if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4076	{
4077	t=IDEAL_CMD;
4078	}
4079	else break;
4080	h=h->next;
4081	}
4082	// if failure, try MODUL_CMD
4083	if (t==0)
4084	{
4085	h=v;
4086	while (h!=NULL)
4087	{
4088	if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4089	{
4090	t=MODUL_CMD;
4091	}
4092	else break;
4093	h=h->next;
4094	}
4095	}
4096	// check for success in converting
4097	if (t==0)
4098	{
4099	WerrorS("cannot convert to ideal or module");
4100	return TRUE;
4101	}
4102	// call idMultSect
4103	h=v;
4104	int i=0;
4105	sleftv tmp;
4106	while (h!=NULL)
4107	{
4108	if (h->Typ()==t)
4109	{
4110	r[i]=(ideal)h->Data(); /no copy/
4111	h=h->next;
4112	}
4113	else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4114	{
4115	Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4116	Free((ADDRESS)r,l*sizeof(ideal));
4117	Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4118	return TRUE;
4119	}
4120	else
4121	{
4122	r[i]=(ideal)tmp.Data(); /now it's a copy/
4123	copied[i]=TRUE;
4124	h=tmp.next;
4125	}
4126	i++;
4127	}
4128	res->rtyp=t;
4129	res->data=(char *)idMultSect(r,i);
4130	while(i>0)
4131	{
4132	i--;
4133	if (copied[i]) idDelete(&(r[i]));
4134	}
4135	Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4136	Free((ADDRESS)r,l*sizeof(ideal));
4137	return FALSE;
4138	}
4139	static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4140	{
4141	int i=0;
4142	leftv h=v;
4143	if (h!=NULL) i=exprlist_length(h);
4144	intvec *iv=new intvec(i);
4145	i=0;
4146	while (h!=NULL)
4147	{
4148	if(h->Typ()==INT_CMD)
4149	{
4150	(*iv)[i]=(int)h->Data();
4151	}
4152	else
4153	{
4154	delete iv;
4155	return TRUE;
4156	}
4157	i++;
4158	h=h->next;
4159	}
4160	res->data=(char *)iv;
4161	return FALSE;
4162	}
4163	static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4164	{
4165	leftv v=u->next;
4166	BOOLEAN b;
4167	if(v==NULL)
4168	b=iiExprArith1(res,u,iiOp);
4169	else
4170	{
4171	u->next=NULL;
4172	b=iiExprArith2(res,u,iiOp,v);
4173	u->next=v;
4174	}
4175	return b;
4176	}
4177	static BOOLEAN jjLIST_PL(leftv res, leftv v)
4178	{
4179	int sl=0;
4180	if (v!=NULL) sl = v->listLength();
4181	lists L;
4182	if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4183	{
4184	L=syConvRes((syStrategy)v->Data());
4185	}
4186	else
4187	{
4188	L=(lists)Alloc(sizeof(slists));
4189	leftv h=NULL;
4190	int i;
4191	int rt;
4192
4193	L->Init(sl);
4194	for (i=0;i<sl;i++)
4195	{
4196	if (h!=NULL) { /* e.g. not in the first step:
4197	* h is the pointer to the old sleftv,
4198	* v is the pointer to the next sleftv
4199	* (in this moment) */
4200	h->next=v;
4201	}
4202	h=v;
4203	v=v->next;
4204	h->next=NULL;
4205	rt=h->Typ();
4206	if (rt==0)
4207	{
4208	L->Clean();
4209	Werror("`%s` is undefined",h->Name());
4210	return TRUE;
4211	}
4212	if ((rt==RING_CMD)\|\|(rt==QRING_CMD))
4213	{
4214	L->m[i].rtyp=rt;
4215	L->m[i].data=h->Data();
4216	((ring)L->m[i].data)->ref++;
4217	}
4218	else
4219	L->m[i].Copy(h);
4220	}
4221	}
4222	res->data=(char *)L;
4223	return FALSE;
4224	}
4225	static BOOLEAN jjNAMES0(leftv res, leftv v)
4226	{
4227	res->data=(void *)ipNameList(idroot);
4228	return FALSE;
4229	}
4230	static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4231	{
4232	if(v==NULL)
4233	{
4234	res->data=(char *)showOption();
4235	return FALSE;
4236	}
4237	res->rtyp=NONE;
4238	return setOption(res,v);
4239	}
4240	static BOOLEAN jjRESERVED0(leftv res, leftv v)
4241	{
4242	int i=1;
4243	loop
4244	{
4245	Print("%-20s",cmds[i].name);
4246	i++;
4247	if(cmds[i].name==NULL)
4248	break;
4249	if ((i%3)==1) PrintLn();
4250	}
4251	PrintLn();
4252	return FALSE;
4253	}
4254	static BOOLEAN jjSTRING_PL(leftv res, leftv v)
4255	{
4256	if ((v!=NULL)&&(v->next==NULL))
4257	return iiExprArith1(res,v,iiOp);
4258	int sl=0;
4259	leftv h=v,nachher;
4260	sleftv tmpR;
4261	BOOLEAN bo;
4262	char *sum=NULL;
4263	while(h!=NULL)
4264	{
4265	/* convert to string =================================*/
4266	nachher=h->next;
4267	h->next=NULL;
4268	bo=iiExprArith1(&tmpR,h,iiOp);
4269	if(bo)
4270	{
4271	h->next=nachher;
4272	FreeL(sum);
4273	return TRUE;
4274	}
4275	/* append to 'sum' =================================*/
4276	if(sum==NULL)
4277	{
4278	sum=(char *)tmpR.data;
4279	sl=strlen(sum);
4280	}
4281	else
4282	{
4283	int nl=strlen((char *)tmpR.data);
4284	char s=(char )AllocL(sl+nl+1);
4285	memcpy(s,sum,sl);
4286	memcpy(s+sl,(char *)tmpR.data,nl);
4287	s[sl+nl]='\0';
4288	sl+=nl;
4289	FreeL(sum);
4290	sum=s;
4291	}
4292	/* next sleftv =================================*/
4293	h->next=nachher;
4294	h=nachher;
4295	}
4296	if (sum==NULL) sum=mstrdup("");
4297	res->data=(char *)sum;
4298	return FALSE;
4299	}
4300	static BOOLEAN jjTEST(leftv res, leftv v)
4301	{
4302	do
4303	{
4304	if (v->Typ()!=INT_CMD)
4305	return TRUE;
4306	test_cmd((int)v->Data());
4307	v=v->next;
4308	}
4309	while (v!=NULL);
4310	return FALSE;
4311	}
4312
4313	static BOOLEAN jjSTATUS_M(leftv res, leftv v)
4314	{
4315	if ((v->Typ() != LINK_CMD) \|\|
4316	(v->next->Typ() != STRING_CMD) \|\|
4317	(v->next->next->Typ() != STRING_CMD) \|\|
4318	(v->next->next->next->Typ() != INT_CMD))
4319	return TRUE;
4320	jjSTATUS3(res, v, v->next, v->next->next);
4321	#if defined(HAVE_USLEEP)
4322	if (((int) res->data) == 0)
4323	{
4324	int i_s = (int) v->next->next->next->Data();
4325	if (i_s > 0)
4326	{
4327	usleep((int) v->next->next->next->Data());
4328	jjSTATUS3(res, v, v->next, v->next->next);
4329	}
4330	}
4331	#elif defined(HAVE_SLEEP)
4332	if (((int) res->data) == 0)
4333	{
4334	int i_s = (int) v->next->next->next->Data();
4335	if (i_s > 0)
4336	{
4337	sleep((is - 1)/1000000 + 1);
4338	jjSTATUS3(res, v, v->next, v->next->next);
4339	}
4340	}
4341	#endif
4342	return FALSE;
4343	}
4344
4345
4346	/=================== operations with many arg.: table =================/
4347	/* number_of_args: -1: any, -2: any >0, .. */
4348	struct sValCmdM dArithM[]=
4349	{
4350	// operations:
4351	// proc cmd res number_of_args
4352	{jjKLAMMER_PL, '(', ANY_TYPE, -2 }
4353	,{jjCALL2ARG, COEF_CMD, MATRIX_CMD, 2 }
4354	,{jjCOEF_M, COEF_CMD, NONE, 4 }
4355	,{jjDBPRINT, DBPRINT_CMD, NONE, -2 }
4356	,{jjCALL1ARG, IDEAL_CMD, IDEAL_CMD, 1 }
4357	,{jjIDEAL_PL, IDEAL_CMD, IDEAL_CMD, -1 }
4358	,{jjCALL2ARG, INTERSECT_CMD, IDEAL_CMD, 2 }
4359	,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD, -2 }
4360	,{jjCALL1ARG, INTVEC_CMD, INTVEC_CMD, 1 }
4361	,{jjINTVEC_PL, INTVEC_CMD, INTVEC_CMD, -1 }
4362	,{jjLIST_PL, LIST_CMD, LIST_CMD, -1 }
4363	,{jjCALL1ARG, MODUL_CMD, MODUL_CMD, 1 }
4364	,{jjIDEAL_PL, MODUL_CMD, MODUL_CMD, -1 }
4365	,{jjCALL1ARG, NAMES_CMD, LIST_CMD, 1 }
4366	,{jjNAMES0, NAMES_CMD, LIST_CMD, 0 }
4367	,{jjOPTION_PL, OPTION_CMD, STRING_CMD/or set by p/,-1 }
4368	,{jjCALL1ARG, RESERVEDNAME_CMD, INT_CMD, 1 }
4369	,{jjRESERVED0, RESERVEDNAME_CMD, NONE, 0 }
4370	,{jjSTRING_PL, STRING_CMD, STRING_CMD, -1 }
4371	,{jjSYSTEM, SYSTEM_CMD, NONE/or set by p/,-2 }
4372	,{jjTEST, TEST_CMD, NONE, -2 }
4373	,{iiWRITE, WRITE_CMD, NONE, -2 }
4374	,{jjCALL2ARG, STATUS_CMD, STRING_CMD, 2 }
4375	,{jjCALL3ARG, STATUS_CMD, INT_CMD, 3 }
4376	,{jjSTATUS_M, STATUS_CMD, INT_CMD, 4 }
4377	,{NULL, 0, 0, 0 }
4378	};
4379	#ifdef MDEBUG
4380	static Subexpr jjDBMakeSub(leftv e,char *f, int l)
4381	#else
4382	static Subexpr jjMakeSub(leftv e)
4383	#endif
4384	{
4385	// assume: e->Typ()==INT_CMD
4386	#ifdef MDEBUG
4387	Subexpr r=(Subexpr)mmDBAllocBlock0(sizeof(*r),f,l);
4388	#else
4389	Subexpr r=(Subexpr)Alloc0(sizeof(*r));
4390	#endif
4391	r->start =(int)e->Data();
4392	return r;
4393	}
4394
4395	/================ generating tables ============================/
4396	#ifdef GENTABLE
4397	extern struct sValAssign dAssign[];
4398	struct sValCmdTab dArithTab1[]={ {0,0}};
4399	#define JJTAB1LEN 0
4400	struct sValCmdTab dArithTab2[]={ {0,0}};
4401	#define JJTAB2LEN 0
4402	void ttGen1()
4403	{
4404	FILE *outfile = myfopen("iparith.inc","w");
4405	int i,j,l1=0,l2=0;
4406	currRing=(ring)Alloc(sizeof(*currRing));
4407	fprintf(outfile,
4408	"/****************************************\n"
4409	"* Computer Algebra System SINGULAR *\n"
4410	"****************************************/\n\n");
4411	/-------------------------------------------------------------------/
4412	fprintf(outfile,"// syntax table for Singular\n//\n");
4413	fprintf(outfile,"// - search for an exact match of the argument types\n");
4414	fprintf(outfile,"// - otherwise search for the first possibility\n");
4415	fprintf(outfile,"// with converted types of the arguments\n");
4416	fprintf(outfile,"// - otherwise report an error\n//\n");
4417
4418	int op;
4419	i=0;
4420	while ((op=dArith1[i].cmd)!=0)
4421	{
4422	if (dArith1[i].p==jjWRONG)
4423	fprintf(outfile,"// DUMMY ");
4424	char *s = iiTwoOps(op);
4425	fprintf(outfile,"// operation: %s (%s) -> %s\n",
4426	s,
4427	Tok2Cmdname(dArith1[i].arg),
4428	Tok2Cmdname(ABS(dArith1[i].res)));
4429	i++;
4430	}
4431	fprintf(outfile,"/---------------------------------------------/\n");
4432	i=0;
4433	while ((op=dArith2[i].cmd)!=0)
4434	{
4435	if (dArith2[i].p==jjWRONG2)
4436	fprintf(outfile,"// DUMMY ");
4437	char *s = iiTwoOps(op);
4438	fprintf(outfile,"// operation: %s (%s, %s) -> %s\n",
4439	s,
4440	Tok2Cmdname(dArith2[i].arg1),
4441	Tok2Cmdname(dArith2[i].arg2),
4442	Tok2Cmdname(dArith2[i].res));
4443	i++;
4444	}
4445	fprintf(outfile,"/---------------------------------------------/\n");
4446	i=0;
4447	while ((op=dArith3[i].cmd)!=0)
4448	{
4449	char *s = iiTwoOps(op);
4450	if (dArith3[i].p==jjWRONG3)
4451	fprintf(outfile,"// DUMMY ");
4452	fprintf(outfile,"// operation: %s (%s, %s, %s) -> %s\n",
4453	s,
4454	Tok2Cmdname(dArith3[i].arg1),
4455	Tok2Cmdname(dArith3[i].arg2),
4456	Tok2Cmdname(dArith3[i].arg3),
4457	Tok2Cmdname(dArith3[i].res));
4458	i++;
4459	}
4460	fprintf(outfile,"/---------------------------------------------/\n");
4461	i=0;
4462	while ((op=dArithM[i].cmd)!=0)
4463	{
4464	char *s = iiTwoOps(op);
4465	fprintf(outfile,"// operation: %s (...) -> %s",
4466	s,
4467	Tok2Cmdname(dArithM[i].res));
4468	switch(dArithM[i].number_of_args)
4469	{
4470	case -2:
4471	fprintf(outfile," ( number of arguments >0 )\n");
4472	break;
4473	case -1:
4474	fprintf(outfile," ( any number of arguments )\n");
4475	break;
4476	default:
4477	fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
4478	break;
4479	}
4480	i++;
4481	}
4482	fprintf(outfile,"/---------------------------------------------/\n");
4483	i=0;
4484	while ((op=dAssign[i].res)!=0)
4485	{
4486	fprintf(outfile,"// assign: %s = %s\n",
4487	Tok2Cmdname(op/dAssign[i].res/),
4488	Tok2Cmdname(dAssign[i].arg));
4489	i++;
4490	}
4491	/-------------------------------------------------------------------/
4492	fprintf(outfile,"/---------------------------------------------/\n");
4493	for (j=257;j<=MAX_TOK+1;j++)
4494	{
4495	for(i=257;i<=MAX_TOK+1;i++)
4496	{
4497	if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
4498	&& iiTestConvert(i,j))
4499	{
4500	fprintf(outfile,"// convert %s -> %s\n",
4501	Tok2Cmdname(i), Tok2Cmdname(j));
4502	if (j==ANY_TYPE) break;
4503	}
4504	}
4505	}
4506	fprintf(outfile,"/---------------------------------------------/\n");
4507	char ops[]="=><+*/[.^,%(;";
4508	for(i=0;ops[i]!='\0';i++)
4509	fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
4510	for (i=257;i<=MAX_TOK;i++)
4511	{
4512	char *s=iiTwoOps(i);
4513	if (s[0]!='$')
4514	{
4515	fprintf(outfile,"// token %d : %s\n", i, s);
4516	}
4517	}
4518	/-------------------------------------------------------------------/
4519	fprintf(outfile,"/--max. token: %d, gr: %d --/\n",MAX_TOK,UMINUS);
4520	/-------------------------------------------------------------------/
4521	fprintf(outfile,"/---------------------------------------------/\n");
4522	fprintf(outfile,
4523	"struct sValCmdTab dArithTab1[]=\n"
4524	"{\n");
4525	for (j=1;j<=MAX_TOK+1;j++)
4526	{
4527	for(i=0;dArith1[i].cmd!=0;i++)
4528	{
4529	if (dArith1[i].cmd==j)
4530	{
4531	fprintf(outfile," { %d,%d },\n",j,i);
4532	l1++;
4533	break;
4534	}
4535	}
4536	}
4537	fprintf(outfile," { 10000,0 }\n};\n");
4538	fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
4539	/-------------------------------------------------------------------/
4540	fprintf(outfile,
4541	"struct sValCmdTab dArithTab2[]=\n"
4542	"{\n");
4543	for (j=1;j<=MAX_TOK+1;j++)
4544	{
4545	for(i=0;dArith2[i].cmd!=0;i++)
4546	{
4547	if (dArith2[i].cmd==j)
4548	{
4549	fprintf(outfile," { %d,%d },\n",j,i);
4550	l2++;
4551	break;
4552	}
4553	}
4554	}
4555	fprintf(outfile," { 10000,0 }\n};\n");
4556	fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
4557	fclose(outfile);
4558	}
4559	/-------------------------------------------------------------------/
4560	void ttGen2()
4561	{
4562	FILE *outfile = myfopen("iparith.inc","a");
4563	fprintf(outfile,
4564	"/****************************************\n"
4565	"* Computer Algebra System SINGULAR *\n"
4566	"****************************************/\n\n");
4567	/-------------------------------------------------------------------/
4568	fprintf(outfile,"// identifier table for Singular\n//\n");
4569
4570	fprintf(outfile,
4571	"cmdnames cmds[] =\n"
4572	"{ // name-string alias tokval toktype\n"
4573	"{ \"$INVALID$\", 0, -1, 0},\n");
4574	int i=1;
4575	int m=-1;
4576	int id_nr=0;
4577	BOOLEAN f=FALSE;
4578	loop
4579	{
4580	while (cmds[i].tokval!=0)
4581	{
4582	if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
4583	{
4584	if(m==-1)
4585	{
4586	m=i;
4587	f=TRUE;
4588	}
4589	else if(strcmp(cmds[m].name,cmds[i].name)>0)
4590	{
4591	m=i;
4592	f=TRUE;
4593	}
4594	}
4595	i++;
4596	}
4597	if(f)
4598	{
4599	id_nr++;
4600	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
4601	fprintf(outfile," {\"%s\", %*d, %3d, ",cmds[m].name,
4602	20-strlen(cmds[m].name),
4603	cmds[m].alias,
4604	cmds[m].tokval);
4605	switch(cmds[m].toktype)
4606	{
4607	case CMD_1: fprintf(outfile,"CMD_1 },\n"); break;
4608	case CMD_2: fprintf(outfile,"CMD_2 },\n"); break;
4609	case CMD_3: fprintf(outfile,"CMD_3 },\n"); break;
4610	case CMD_12: fprintf(outfile,"CMD_12 },\n"); break;
4611	case CMD_123 : fprintf(outfile,"CMD_123 },\n"); break;
4612	case CMD_23: fprintf(outfile,"CMD_23 },\n"); break;
4613	case CMD_M: fprintf(outfile,"CMD_M },\n"); break;
4614	case SYSVAR: fprintf(outfile,"SYSVAR },\n"); break;
4615	case ROOT_DECL: fprintf(outfile,"ROOT_DECL },\n"); break;
4616	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
4617	case RING_DECL: fprintf(outfile,"RING_DECL },\n"); break;
4618	case NONE: fprintf(outfile,"NONE },\n"); break;
4619	default: if((cmds[m].toktype>' ')
4620	&&(cmds[m].toktype<127))
4621	{
4622	fprintf(outfile,"'%c' },\n",cmds[m].toktype);
4623	}
4624	else
4625	{
4626	fprintf(outfile,"%d },\n",cmds[m].toktype);
4627	}
4628	break;
4629	}
4630	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
4631	cmds[m].name=NULL;
4632	m=-1;
4633	i=1;
4634	f=FALSE;
4635	}
4636	else break;
4637	}
4638	fprintf(outfile,
4639	"/* list of scanner identifiers/only for feread/reservedName */\n");
4640	f=FALSE;
4641	i=1;m=-1;
4642	loop
4643	{
4644	while (cmds[i].tokval!=0)
4645	{
4646	if (cmds[i].name!=NULL)
4647	{
4648	if(m==-1)
4649	{
4650	m=i;
4651	f=TRUE;
4652	}
4653	else if(strcmp(cmds[m].name,cmds[i].name)>0)
4654	{
4655	m=i;
4656	f=TRUE;
4657	}
4658	}
4659	i++;
4660	}
4661	if(f)
4662	{
4663	fprintf(outfile," {\"%s\", %*d, -1, 0 },\n",cmds[m].name,
4664	20-strlen(cmds[m].name),
4665	0/cmds[m].alias/
4666	/-1 cmds[m].tokval/
4667	/0 cmds[m].toktype/);
4668	cmds[m].name=NULL;
4669	m=-1;
4670	i=1;
4671	f=FALSE;
4672	}
4673	else break;
4674	}
4675	fprintf(outfile,
4676	"/* end of list marker */\n"
4677	" { NULL, 0, 0, 0}\n"
4678	"};\n"
4679	"#ifdef HAVE_RTIMER\n"
4680	"#define LAST_IDENTIFIER %d\n"
4681	"#else\n"
4682	"#define LAST_IDENTIFIER %d\n"
4683	"#endif\n",id_nr,id_nr-1);
4684	fclose(outfile);
4685	}
4686	/-------------------------------------------------------------------/
4687	#if 0
4688	void ttGen3()
4689	{
4690	FILE *outfile = myfopen("mpsr_tok.inc","w");
4691	fprintf(outfile,
4692	"/****************************************\n"
4693	"* Computer Algebra System SINGULAR *\n"
4694	"****************************************/\n\n");
4695	/-------------------------------------------------------------------/
4696	fprintf(outfile,"// token table for Singular\n//\n");
4697
4698	fprintf(outfile,
4699	"short vtok[] =\n"
4700	"{\n");
4701	// operations with 1 arg: ===========================================
4702	int i=0;
4703	while (dArith1[i].cmd!=0)
4704	{
4705	if ((dArith1[i].p!=jjWRONG)
4706	&&((i==0)\|\|(dArith1[i].cmd!=dArith1[i-1].cmd)))
4707	{
4708	fprintf(outfile," %d,\n",dArith1[i].cmd);
4709	}
4710	i++;
4711	}
4712	// operations with 2 args: ===========================================
4713	i=0;
4714	while (dArith2[i].cmd!=0)
4715	{
4716	if ((dArith2[i].p!=jjWRONG2)
4717	&&((i==0)\|\|(dArith2[i].cmd!=dArith2[i-1].cmd)))
4718	{
4719	fprintf(outfile," %d,\n",dArith2[i].cmd);
4720	}
4721	i++;
4722	}
4723	// operations with 3 args: ===========================================
4724	i=0;
4725	while (dArith3[i].cmd!=0)
4726	{
4727	if (
4728	((i==0)\|\|(dArith3[i].cmd!=dArith3[i-1].cmd)))
4729	{
4730	fprintf(outfile," %d,\n",dArith3[i].cmd);
4731	}
4732	i++;
4733	}
4734	// operations with many args: ===========================================
4735	i=0;
4736	while (dArithM[i].cmd!=0)
4737	{
4738	if (
4739	((i==0)\|\|(dArithM[i].cmd!=dArithM[i-1].cmd)))
4740	{
4741	fprintf(outfile," %d,\n",dArithM[i].cmd);
4742	}
4743	i++;
4744	}
4745	// ====================================================================
4746	fprintf(outfile,
4747	"/* end of list marker */\n"
4748	" %d };\n",MAX_TOK);
4749	fclose(outfile);
4750	}
4751	#endif
4752	/-------------------------------------------------------------------/
4753	#else
4754	#include "iparith.inc"
4755	#endif
4756
4757	/=================== operations with 2 args. ============================/
4758
4759	BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
4760	{
4761	#ifndef GENTABLE
4762
4763	memset(res,0,sizeof(sleftv));
4764
4765	if (!errorreported)
4766	{
4767	#ifdef SIQ
4768	if (siq>0)
4769	{
4770	//Print("siq:%d\n",siq);
4771	command d=(command)Alloc0(sizeof(ip_command));
4772	memcpy(&d->arg1,a,sizeof(sleftv));
4773	memcpy(&d->arg2,b,sizeof(sleftv));
4774	d->argc=2;
4775	d->op=op;
4776	res->data=(char *)d;
4777	res->rtyp=COMMAND;
4778	return FALSE;
4779	}
4780	#endif
4781	int at=a->Typ();
4782	int bt=b->Typ();
4783	int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4784
4785	iiOp=op;
4786	while (dArith2[i].cmd==op)
4787	{
4788	if ((at==dArith2[i].arg1)
4789	&& (bt==dArith2[i].arg2))
4790	{
4791	res->rtyp=dArith2[i].res;
4792	if (dArith2[i].p(res,a,b))
4793	{
4794	break;// leave loop, goto error handling
4795	}
4796	a->CleanUp();
4797	b->CleanUp();
4798	//Print("op: %d,result typ:%d\n",op,res->rtyp);
4799	return FALSE;
4800	}
4801	i++;
4802	}
4803	// implicite type conversion ----------------------------------------------
4804	if (dArith2[i].cmd!=op)
4805	{
4806	int ai,bi;
4807	leftv an = (leftv)Alloc0(sizeof(sleftv));
4808	leftv bn = (leftv)Alloc0(sizeof(sleftv));
4809	BOOLEAN failed=FALSE;
4810	i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4811	//Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
4812	while (dArith2[i].cmd==op)
4813	{
4814	//Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
4815	if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
4816	{
4817	if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
4818	{
4819	res->rtyp=dArith2[i].res;
4820	failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
4821	\|\| (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
4822	\|\| (dArith2[i].p(res,an,bn)));
4823	// everything done, clean up temp. variables
4824	if (failed)
4825	{
4826	// leave loop, goto error handling
4827	break;
4828	}
4829	else
4830	{
4831	// everything ok, clean up and return
4832	an->CleanUp();
4833	bn->CleanUp();
4834	Free((ADDRESS)an,sizeof(sleftv));
4835	Free((ADDRESS)bn,sizeof(sleftv));
4836	a->CleanUp();
4837	b->CleanUp();
4838	return FALSE;
4839	}
4840	}
4841	}
4842	i++;
4843	}
4844	an->CleanUp();
4845	bn->CleanUp();
4846	Free((ADDRESS)an,sizeof(sleftv));
4847	Free((ADDRESS)bn,sizeof(sleftv));
4848	}
4849	// error handling ---------------------------------------------------
4850	const char *s=NULL;
4851	if (!errorreported)
4852	{
4853	if ((at==0) && (a->Name()!=sNoName))
4854	{
4855	s=a->Name();
4856	}
4857	else if ((bt==0) && (b->Name()!=sNoName))
4858	{
4859	s=b->Name();
4860	}
4861	if (s!=NULL)
4862	Werror("`%s` is not defined",s);
4863	else
4864	{
4865	i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
4866	s = iiTwoOps(op);
4867	if (proccall)
4868	{
4869	Werror("%s(`%s`,`%s`) is not supported"
4870	,s,Tok2Cmdname(at),Tok2Cmdname(bt));
4871	}
4872	else
4873	{
4874	Werror("`%s` %s `%s` is not supported"
4875	,Tok2Cmdname(at),s,Tok2Cmdname(bt));
4876	}
4877	if (BVERBOSE(V_SHOW_USE))
4878	{
4879	while (dArith2[i].cmd==op)
4880	{
4881	if(((at==dArith2[i].arg1)\|\|(bt==dArith2[i].arg2))
4882	&& (dArith2[i].res!=0)
4883	&& (dArith2[i].p!=jjWRONG2))
4884	{
4885	if (proccall)
4886	Werror("expected %s(`%s`,`%s`)"
4887	,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
4888	else
4889	Werror("expected `%s` %s `%s`"
4890	,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
4891	}
4892	i++;
4893	}
4894	}
4895	}
4896	}
4897	res->rtyp = UNKNOWN;
4898	}
4899	a->CleanUp();
4900	b->CleanUp();
4901	#endif
4902	return TRUE;
4903	}
4904
4905	/==================== operations with 1 arg. ===============================/
4906
4907	BOOLEAN iiExprArith1(leftv res, leftv a, int op)
4908	{
4909	#ifndef GENTABLE
4910	memset(res,0,sizeof(sleftv));
4911
4912	if (!errorreported)
4913	{
4914	#ifdef SIQ
4915	if (siq>0)
4916	{
4917	//Print("siq:%d\n",siq);
4918	command d=(command)Alloc0(sizeof(ip_command));
4919	memcpy(&d->arg1,a,sizeof(sleftv));
4920	d->op=op;
4921	d->argc=1;
4922	res->data=(char *)d;
4923	res->rtyp=COMMAND;
4924	return FALSE;
4925	}
4926	#endif
4927	int at=a->Typ();
4928	BOOLEAN failed=FALSE;
4929
4930	iiOp=op;
4931	int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
4932	while (dArith1[i].cmd==op)
4933	{
4934	if (at==dArith1[i].arg)
4935	{
4936	res->rtyp=dArith1[i].res;
4937	if (dArith1[i].res<0)
4938	{
4939	res->rtyp=-res->rtyp;
4940	#ifdef PROC_BUG
4941	dArith1[i].p(res,a);
4942	#else
4943	res->data=(char )((Proc1)dArith1[i].p)((char )a->Data());
4944	#endif
4945	}
4946	else if (dArith1[i].p(res,a))
4947	{
4948	break;// leave loop, goto error handling
4949	}
4950	if (a->Next()!=NULL)
4951	{
4952	res->next=(leftv)Alloc(sizeof(sleftv));
4953	failed=iiExprArith1(res->next,a->next,op);
4954	}
4955	a->CleanUp();
4956	return failed;
4957	}
4958	i++;
4959	}
4960	// implicite type conversion --------------------------------------------
4961	if (dArith1[i].cmd!=op)
4962	{
4963	int ai;
4964	leftv an = (leftv)Alloc0(sizeof(sleftv));
4965	i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
4966	//Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
4967	while (dArith1[i].cmd==op)
4968	{
4969	//Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
4970	if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
4971	{
4972	res->rtyp=dArith1[i].res;
4973	if (dArith1[i].res<0)
4974	{
4975	res->rtyp=-res->rtyp;
4976	failed= iiConvert(at,dArith1[i].arg,ai,a,an);
4977	if (!failed)
4978	{
4979	#ifdef PROC_BUG
4980	dArith1[i].p(res,a);
4981	#else
4982	res->data=(char )((Proc1)dArith1[i].p)((char )an->Data());
4983	#endif
4984	}
4985	}
4986	else
4987	{
4988	failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
4989	\|\| (dArith1[i].p(res,an)));
4990	}
4991	// everything done, clean up temp. variables
4992	if (failed)
4993	{
4994	// leave loop, goto error handling
4995	break;
4996	}
4997	else
4998	{
4999	// everything ok, clean up and return
5000	an->CleanUp();
5001	Free((ADDRESS)an,sizeof(sleftv));
5002	a->CleanUp();
5003	return FALSE;
5004	}
5005	}
5006	i++;
5007	}
5008	an->CleanUp();
5009	Free((ADDRESS)an,sizeof(sleftv));
5010	}
5011	// error handling
5012	if (!errorreported)
5013	{
5014	if ((at==0) && (a->Name()!=sNoName))
5015	{
5016	Werror("`%s` is not defined",a->Name());
5017	}
5018	else
5019	{
5020	i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
5021	char *s = iiTwoOps(op);
5022	Werror("%s(`%s`) is not supported"
5023	,s,Tok2Cmdname(at));
5024	if (BVERBOSE(V_SHOW_USE))
5025	{
5026	while (dArith1[i].cmd==op)
5027	{
5028	if ((dArith1[i].res!=0)
5029	&& (dArith1[i].p!=jjWRONG))
5030	Werror("expected %s(`%s`)"
5031	,s,Tok2Cmdname(dArith1[i].arg));
5032	i++;
5033	}
5034	}
5035	}
5036	}
5037	res->rtyp = UNKNOWN;
5038	}
5039	a->CleanUp();
5040	#endif
5041	return TRUE;
5042	}
5043
5044	/=================== operations with 3 args. ============================/
5045
5046	BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
5047	{
5048	#ifndef GENTABLE
5049	memset(res,0,sizeof(sleftv));
5050
5051	if (!errorreported)
5052	{
5053	#ifdef SIQ
5054	if (siq>0)
5055	{
5056	//Print("siq:%d\n",siq);
5057	command d=(command)Alloc0(sizeof(ip_command));
5058	memcpy(&d->arg1,a,sizeof(sleftv));
5059	memcpy(&d->arg2,b,sizeof(sleftv));
5060	memcpy(&d->arg3,c,sizeof(sleftv));
5061	d->op=op;
5062	d->argc=3;
5063	res->data=(char *)d;
5064	res->rtyp=COMMAND;
5065	return FALSE;
5066	}
5067	#endif
5068	int at=a->Typ();
5069	int bt=b->Typ();
5070	int ct=c->Typ();
5071
5072	iiOp=op;
5073	int i=0;
5074	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5075	while (dArith3[i].cmd==op)
5076	{
5077	if ((at==dArith3[i].arg1)
5078	&& (bt==dArith3[i].arg2)
5079	&& (ct==dArith3[i].arg3))
5080	{
5081	res->rtyp=dArith3[i].res;
5082	if (dArith3[i].p(res,a,b,c))
5083	{
5084	break;// leave loop, goto error handling
5085	}
5086	a->CleanUp();
5087	b->CleanUp();
5088	c->CleanUp();
5089	return FALSE;
5090	}
5091	i++;
5092	}
5093	// implicite type conversion ----------------------------------------------
5094	if (dArith3[i].cmd!=op)
5095	{
5096	int ai,bi,ci;
5097	leftv an = (leftv)Alloc0(sizeof(sleftv));
5098	leftv bn = (leftv)Alloc0(sizeof(sleftv));
5099	leftv cn = (leftv)Alloc0(sizeof(sleftv));
5100	BOOLEAN failed=FALSE;
5101	i=0;
5102	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5103	while (dArith3[i].cmd==op)
5104	{
5105	if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
5106	{
5107	if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
5108	{
5109	if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
5110	{
5111	res->rtyp=dArith3[i].res;
5112	failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
5113	\|\| (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
5114	\|\| (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
5115	\|\| (dArith3[i].p(res,an,bn,cn)));
5116	// everything done, clean up temp. variables
5117	if (failed)
5118	{
5119	// leave loop, goto error handling
5120	break;
5121	}
5122	else
5123	{
5124	// everything ok, clean up and return
5125	an->CleanUp();
5126	bn->CleanUp();
5127	cn->CleanUp();
5128	Free((ADDRESS)an,sizeof(sleftv));
5129	Free((ADDRESS)bn,sizeof(sleftv));
5130	Free((ADDRESS)cn,sizeof(sleftv));
5131	a->CleanUp();
5132	b->CleanUp();
5133	c->CleanUp();
5134	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5135	return FALSE;
5136	}
5137	}
5138	}
5139	}
5140	i++;
5141	}
5142	an->CleanUp();
5143	bn->CleanUp();
5144	cn->CleanUp();
5145	Free((ADDRESS)an,sizeof(sleftv));
5146	Free((ADDRESS)bn,sizeof(sleftv));
5147	Free((ADDRESS)cn,sizeof(sleftv));
5148	}
5149	// error handling ---------------------------------------------------
5150	if (!errorreported)
5151	{
5152	const char *s=NULL;
5153	if ((at==0) && (a->Name()!=sNoName))
5154	{
5155	s=a->Name();
5156	}
5157	else if ((bt==0) && (b->Name()!=sNoName))
5158	{
5159	s=b->Name();
5160	}
5161	else if ((ct==0) && (c->Name()!=sNoName))
5162	{
5163	s=c->Name();
5164	}
5165	if (s!=NULL)
5166	Werror("`%s` is not defined",s);
5167	else
5168	{
5169	i=0;
5170	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5171	char *s = iiTwoOps(op);
5172	Werror("%s(`%s`,`%s`,`%s`) is not supported"
5173	,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
5174	if (BVERBOSE(V_SHOW_USE))
5175	{
5176	while (dArith3[i].cmd==op)
5177	{
5178	if(((at==dArith3[i].arg1)
5179	\|\|(bt==dArith3[i].arg2)
5180	\|\|(ct==dArith3[i].arg3))
5181	&& (dArith3[i].res!=0))
5182	{
5183	Werror("expected %s(`%s`,`%s`,`%s`)"
5184	,s,Tok2Cmdname(dArith3[i].arg1)
5185	,Tok2Cmdname(dArith3[i].arg2)
5186	,Tok2Cmdname(dArith3[i].arg3));
5187	}
5188	i++;
5189	}
5190	}
5191	}
5192	}
5193	res->rtyp = UNKNOWN;
5194	}
5195	a->CleanUp();
5196	b->CleanUp();
5197	c->CleanUp();
5198	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5199	#endif
5200	return TRUE;
5201	}
5202	/==================== operations with many arg. ===============================/
5203
5204	BOOLEAN iiExprArithM(leftv res, leftv a, int op)
5205	{
5206	#ifndef GENTABLE
5207	memset(res,0,sizeof(sleftv));
5208
5209	if (!errorreported)
5210	{
5211	#ifdef SIQ
5212	if (siq>0)
5213	{
5214	//Print("siq:%d\n",siq);
5215	command d=(command)Alloc0(sizeof(ip_command));
5216	d->op=op;
5217	res->data=(char *)d;
5218	if (a!=NULL)
5219	{
5220	d->argc=a->listLength();
5221	// else : d->argc=0;
5222	memcpy(&d->arg1,a,sizeof(sleftv));
5223	switch(d->argc)
5224	{
5225	case 3:
5226	memcpy(&d->arg3,a->next->next,sizeof(sleftv));
5227	a->next->next->rtyp=0;
5228	a->next->next->data=NULL;
5229	a->next->next->name=NULL;
5230	a->next->next->attribute=NULL;
5231	case 2:
5232	memcpy(&d->arg2,a->next,sizeof(sleftv));
5233	a->next->rtyp=0;
5234	a->next->name=NULL;
5235	a->next->data=NULL;
5236	a->next->attribute=NULL;
5237	d->arg2.next=NULL;
5238	case 1:
5239	d->arg1.next=NULL;
5240	}
5241	if (d->argc>3) a->next=NULL;
5242	a->rtyp=0;
5243	a->data=NULL;
5244	a->name=NULL;
5245	a->CleanUp();
5246	}
5247	res->rtyp=COMMAND;
5248	return FALSE;
5249	}
5250	#endif
5251	BOOLEAN failed=FALSE;
5252	int args=0;
5253	if (a!=NULL) args=a->listLength();
5254
5255	iiOp=op;
5256	int i=0;
5257	while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
5258	int ii=i;
5259	while (dArithM[i].cmd==op)
5260	{
5261	if ((args==dArithM[i].number_of_args)
5262	\|\| (dArithM[i].number_of_args==-1)
5263	\|\| ((dArithM[i].number_of_args==-2)&&(args>0)))
5264	{
5265	res->rtyp=dArithM[i].res;
5266	if (dArithM[i].p(res,a))
5267	{
5268	break;// leave loop, goto error handling
5269	}
5270	if (a!=NULL) a->CleanUp();
5271	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5272	return failed;
5273	}
5274	i++;
5275	}
5276	// error handling
5277	if (!errorreported)
5278	{
5279	if ((a->rtyp==0) && (a->Name()!=sNoName))
5280	{
5281	Werror("`%s` is not defined",a->Name());
5282	}
5283	else
5284	{
5285	char *s = iiTwoOps(op);
5286	Werror("%s(...) is not supported",s);
5287	}
5288	}
5289	res->rtyp = UNKNOWN;
5290	}
5291	if (a!=NULL) a->CleanUp();
5292	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5293	#endif
5294	return TRUE;
5295	}
5296
5297	/=================== general utilities ============================/
5298	int IsCmd(char *n, int & tok)
5299	{
5300	int an=1;
5301	int i,v;
5302	#ifndef GENTABLE
5303	int en=LAST_IDENTIFIER;
5304
5305	loop
5306	{
5307	if(an>=en-1)
5308	{
5309	if (strcmp(n, cmds[an].name) == 0)
5310	{
5311	i=an;
5312	break;
5313	}
5314	else if (strcmp(n, cmds[en].name) == 0)
5315	{
5316	i=en;
5317	break;
5318	}
5319	else
5320	{
5321	return 0;
5322	}
5323	}
5324	i=(an+en)/2;
5325	v=strcmp(n,cmds[i].name);
5326	if(v<0)
5327	{
5328	en=i;
5329	}
5330	else if(v>0)
5331	{
5332	an=i;
5333	}
5334	else /v==0/
5335	{
5336	break;
5337	}
5338	}
5339	lastreserved=cmds[i].name;
5340	tok=cmds[i].tokval;
5341	if(cmds[i].alias==2)
5342	{
5343	Warn("outdated identifier `%s` used - please change your code",
5344	cmds[i].name);
5345	cmds[i].alias=1;
5346	}
5347	if (currRingHdl==NULL)
5348	{
5349	#ifdef SIQ
5350	if (siq<=0)
5351	{
5352	#endif
5353	if ((tok>=BEGIN_RING) && (tok<=END_RING))
5354	{
5355	Werror("no ring active");
5356	return 0;
5357	}
5358	#ifdef SIQ
5359	}
5360	#endif
5361	}
5362	if (!expected_parms)
5363	{
5364	switch (tok)
5365	{
5366	case IDEAL_CMD:
5367	case INT_CMD:
5368	case INTVEC_CMD:
5369	case MAP_CMD:
5370	case MATRIX_CMD:
5371	case MODUL_CMD:
5372	case POLY_CMD:
5373	case PROC_CMD:
5374	case RING_CMD:
5375	case STRING_CMD:
5376	cmdtok = tok;
5377	break;
5378	}
5379	}
5380	#endif
5381	return cmds[i].toktype;
5382	}
5383	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
5384	{
5385	#ifndef GENTABLE
5386	int a=0;
5387	int e=len;
5388	int p=len/2;
5389	while ( a!=e)
5390	{
5391	if (op==dArithTab[p].cmd) return dArithTab[p].start;
5392	else if (op<dArithTab[p].cmd)
5393	{ e=p; p=a+(e-a)/2;}
5394	else
5395	{ a=p; p=p+(e-p)/2; }
5396	}
5397	#endif
5398	return -1;
5399	}
5400

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

Download in other formats: