Context Navigation

source: git/Singular/iparith.cc @ cf74099

spielwiese

Last change on this file since cf74099 was cf74099, checked in by Hans Schönemann <hannes@…>, 24 years ago
* hannes: ring(cf,vars,ord)- construction (grammar.y iparith.cc ring.cc ring.h) feread.cc: change message, if dyn.loading failed git-svn-id: file:///usr/local/Singular/svn/trunk@3840 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 169.0 KB

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

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

Download in other formats: