Context Navigation

source: git/Singular/iparith.cc @ b19380

spielwiese

Last change on this file since b19380 was b19380, checked in by Hans Schönemann <hannes@…>, 25 years ago
*hannes: fixed error message for maps git-svn-id: file:///usr/local/Singular/svn/trunk@2897 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 164.4 KB

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

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

Download in other formats: