Context Navigation

source: git/Singular/iparith.cc @ 0b4b97

fieker-DuValspielwiese

Last change on this file since 0b4b97 was 0b4b97, checked in by Hans Schönemann <hannes@…>, 25 years ago
*hannes: fetch extended git-svn-id: file:///usr/local/Singular/svn/trunk@3349 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 166.3 KB

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

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

Download in other formats: