Context Navigation

source: git/Singular/iparith.cc @ a36a1a

spielwiese

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

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

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

Download in other formats: