Context Navigation

source: git/Singular/iparith.cc @ 6123fa2

fieker-DuValspielwiese

Last change on this file since 6123fa2 was 2166ad3, checked in by Hans Schönemann <hannes@…>, 25 years ago
* hannes: CopyD inlined CopyD calls optimized (if the type is know, use CopyD(t) instead of CopyD()) subst(....) cleanup error fixed git-svn-id: file:///usr/local/Singular/svn/trunk@3618 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 169.0 KB

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

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

Download in other formats: