Context Navigation

source: git/Singular/iparith.cc @ 63be42

spielwiese

Last change on this file since 63be42 was e25d25, checked in by Hans Schönemann <hannes@…>, 26 years ago
* hannes: modified leadexp for vectors git-svn-id: file:///usr/local/Singular/svn/trunk@2505 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 154.8 KB

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

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

Download in other formats: