Context Navigation

source: git/Singular/iparith.cc @ f93850

fieker-DuValspielwiese

Last change on this file since f93850 was f93850, checked in by Hans Schönemann <hannes@…>, 24 years ago
*hannes: save options in lift git-svn-id: file:///usr/local/Singular/svn/trunk@4245 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 171.7 KB

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

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

Download in other formats: