Context Navigation

iparith.cc @ e514ee

spielwiese

Last change on this file since e514ee was e514ee, checked in by Hans Schönemann <hannes@…>, 24 years ago
* hannes; moved breakpoint from extra.cc to iparith.cc (new command breakpoint) git-svn-id: file:///usr/local/Singular/svn/trunk@3916 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 169.6 KB

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