Context Navigation

iparith.cc @ a3836d

spielwiese

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