Context Navigation

iparith.cc @ 5d32fd

spielwiese

Last change on this file since 5d32fd was 5d32fd, checked in by Hans Schönemann <hannes@…>, 24 years ago
* hannes: move spectrum-stuff to a library and extra.cc, step I git-svn-id: file:///usr/local/Singular/svn/trunk@3917 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 169.3 KB

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