Context Navigation

source: git/Singular/iparith.cc @ 050348

fieker-DuValspielwiese

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

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

Download in other formats: