Context Navigation

source: git/Singular/iparith.cc @ c7f3b7

fieker-DuValspielwiese

Last change on this file since c7f3b7 was c7f3b7, checked in by Moritz Wenk <wenk@…>, 24 years ago
wenk: added new commands: simplex, convhull (mit Greuel abgesprochen) git-svn-id: file:///usr/local/Singular/svn/trunk@3951 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 169.1 KB

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

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

Download in other formats: