Context Navigation

source: git/Singular/iparith.cc @ 84db5bf

fieker-DuValspielwiese

Last change on this file since 84db5bf was 84db5bf, checked in by Hans Schönemann <hannes@…>, 25 years ago
*hannes: first parts of order optimization git-svn-id: file:///usr/local/Singular/svn/trunk@2717 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 160.6 KB

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

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

Download in other formats: