Context Navigation

source: git/Singular/iparith.cc @ 1c452c

fieker-DuValspielwiese

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

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

Download in other formats: