Context Navigation

iparith.cc @ 9489ed

spielwiese

Last change on this file since 9489ed was 9489ed, checked in by Wilfred Pohl <pohl@…>, 25 years ago
jjHIGHCORNER_M git-svn-id: file:///usr/local/Singular/svn/trunk@2951 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 165.0 KB

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