Context Navigation

source: git/Singular/iparith.cc @ dded84

fieker-DuValspielwiese

Last change on this file since dded84 was dded84, checked in by Hans Schönemann <hannes@…>, 24 years ago
* hannes: fixed matrix size of U in divide if sm contains 0 at the end git-svn-id: file:///usr/local/Singular/svn/trunk@4263 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 171.9 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/* $Id: iparith.cc,v 1.207 2000-04-11 15:36:37 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	if (MATCOLS(U) != vl)
1495	{
1496	int mvl=min(vl,MATCOLS(U));
1497	matrix UU=mpNew(vl,vl);
1498	int i,j;
1499	for(i=mvl;i>0;i--)
1500	{
1501	for(j=mvl;j>0;j--)
1502	{
1503	MATELEM(UU,i,j)=MATELEM(U,i,j);
1504	MATELEM(U,i,j)=NULL;
1505	}
1506	}
1507	idDelete((ideal *)&U);
1508	U=UU;
1509	}
1510	lists L=(lists)AllocSizeOf(slists);
1511	L->Init(3);
1512	L->m[0].rtyp=MATRIX_CMD;
1513	L->m[0].data=(void *)T;
1514	L->m[1].rtyp=MATRIX_CMD;
1515	L->m[1].data=(void *)U;
1516	L->m[2].rtyp=u->Typ();
1517	L->m[2].data=(void *)R;
1518	res->data=(char *)L;
1519	return FALSE;
1520	}
1521	static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1522	{
1523	int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1524	int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1525
1526	while ( p1!=0 )
1527	{
1528	q=p0 / p1;
1529	r=p0 % p1;
1530	p0 = p1; p1 = r;
1531	r = g0 - g1 * q;
1532	g0 = g1; g1 = r;
1533	r = f0 - f1 * q;
1534	f0 = f1; f1 = r;
1535	}
1536	int a = f0;
1537	int b = g0;
1538	if ( (int)u->Data() < 0 ) a=-a;
1539	if ( (int)v->Data() < 0 ) b=-b;
1540	lists L=(lists)AllocSizeOf(slists);
1541	L->Init(3);
1542	L->m[0].rtyp=INT_CMD;
1543	L->m[0].data=(void *)p0;
1544	L->m[1].rtyp=INT_CMD;
1545	L->m[1].data=(void *)a;
1546	L->m[2].rtyp=INT_CMD;
1547	L->m[2].data=(void *)b;
1548	res->rtyp=LIST_CMD;
1549	res->data=(char *)L;
1550	return FALSE;
1551	}
1552	#ifdef HAVE_FACTORY
1553	static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1554	{
1555	res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL,
1556	(ideal)w->Data());
1557	setFlag(res,FLAG_STD);
1558	return FALSE;
1559	}
1560	#endif
1561	static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1562	{
1563	ring r=(ring)u->Data();
1564	idhdl w;
1565	int op=iiOp;
1566
1567	if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1568	{
1569	int *perm=NULL;
1570	int *par_perm=NULL;
1571	int par_perm_size=0;
1572	BOOLEAN bo;
1573	//if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1574	if (!nSetMap(r))
1575	{
1576	if (rEqual(r,currRing))
1577	{
1578	nMap=nCopy;
1579	}
1580	else
1581	// Allow imap/fetch to be make an exception only for:
1582	if ( (rField_is_Q_a(r) && // Q(a..) -> Q(a..) \|\| Q \|\| Zp \|\| Zp(a)
1583	(rField_is_Q() \|\| rField_is_Q_a() \|\|
1584	(rField_is_Zp() \|\| rField_is_Zp_a())))
1585	\|\|
1586	(rField_is_Zp_a(r) && // Zp(a..) -> Zp(a..) \|\| Zp
1587	(rField_is_Zp(currRing, rInternalChar(r)) \|\|
1588	rField_is_Zp_a(currRing, rInternalChar(r)))) )
1589	{
1590	par_perm_size=rPar(r);
1591	BITSET save_test=test;
1592	naSetChar(rInternalChar(r),TRUE,r->parameter,rPar(r));
1593	nSetChar(currRing,TRUE);
1594	test=save_test;
1595	}
1596	else
1597	{
1598	goto err_fetch;
1599	}
1600	}
1601	if ((iiOp!=FETCH_CMD) \|\| (r->N!=pVariables) \|\| (rPar(r)!=rPar(currRing)))
1602	{
1603	perm=(int )Alloc0((r->N+1)sizeof(int));
1604	if (par_perm_size!=0)
1605	par_perm=(int )Alloc0(par_perm_sizesizeof(int));
1606	op=IMAP_CMD;
1607	if (iiOp==IMAP_CMD)
1608	{
1609	maFindPerm(r->names, r->N, r->parameter, r->P,
1610	currRing->names,currRing->N,currRing->parameter, currRing->P,
1611	perm,par_perm, currRing->ch);
1612	}
1613	else
1614	{
1615	int i;
1616	if (par_perm_size!=0)
1617	for(i=0;i<min(rPar(r),rPar(currRing));i++) par_perm[i]=-(i+1);
1618	for(i=1;i<=min(r->N,pVariables);i++) perm[i]=i;
1619	}
1620	}
1621	if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1622	{
1623	int i;
1624	for(i=1;i<=min(r->N,pVariables);i++)
1625	{
1626	Print("// var nr %d: %s -> %s\n",i,r->names[i+1],currRing->names[i+1]);
1627	}
1628	for(i=1;i<=min(rPar(r),rPar(currRing));i++) // possibly empty loop
1629	{
1630	Print("// par nr %d: %s -> %s\n",
1631	i,r->parameter[i+1],currRing->parameter[i+1]);
1632	}
1633	}
1634	sleftv tmpW;
1635	memset(&tmpW,0,sizeof(sleftv));
1636	tmpW.rtyp=IDTYP(w);
1637	tmpW.data=IDDATA(w);
1638	if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1639	perm,par_perm,par_perm_size)))
1640	{
1641	Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1642	}
1643	if (perm!=NULL)
1644	Free((ADDRESS)perm,(r->N+1)*sizeof(int));
1645	if (par_perm!=NULL)
1646	Free((ADDRESS)par_perm,par_perm_size*sizeof(int));
1647	return bo;
1648	}
1649	else
1650	{
1651	Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1652	}
1653	return TRUE;
1654	err_fetch:
1655	Werror("no identity map from %s",u->Fullname());
1656	return TRUE;
1657	}
1658	static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1659	{
1660	/*4
1661	* look for the substring what in the string where
1662	* return the position of the first char of what in where
1663	* or 0
1664	*/
1665	char where=(char )u->Data();
1666	char what=(char )v->Data();
1667	char *found = strstr(where,what);
1668	if (found != NULL)
1669	{
1670	res->data=(char *)((found-where)+1);
1671	}
1672	/else res->data=NULL;/
1673	return FALSE;
1674	}
1675	static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1676	{
1677	int p0=ABS((int)u->Data()),p1=ABS((int)v->Data());
1678	int r;
1679
1680	while ( p1!=0 )
1681	{
1682	r=p0 % p1;
1683	p0 = p1; p1 = r;
1684	}
1685	res->rtyp=INT_CMD;
1686	res->data=(char *)p0;
1687	return FALSE;
1688	}
1689	static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1690	{
1691	assumeStdFlag(u);
1692	intvec module_w=(intvec)atGet(u,"isHomog");
1693	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1694	switch((int)v->Data())
1695	{
1696	case 1:
1697	res->data=(void *)iv;
1698	return FALSE;
1699	case 2:
1700	res->data=(void *)hSecondSeries(iv);
1701	delete iv;
1702	return FALSE;
1703	}
1704	WerrorS(feNotImplemented);
1705	delete iv;
1706	return TRUE;
1707	}
1708	static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
1709	{
1710	int i=pVar((poly)v->Data());
1711	if (i==0)
1712	{
1713	WerrorS("ringvar expected");
1714	return TRUE;
1715	}
1716	res->data = (char *)pHomogen((poly)u->Data(),i);
1717	return FALSE;
1718	}
1719	static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
1720	{
1721	int i=pVar((poly)v->Data());
1722	if (i==0)
1723	{
1724	WerrorS("ringvar expected");
1725	return TRUE;
1726	}
1727	res->data = (char *)idHomogen((ideal)u->Data(),i);
1728	return FALSE;
1729	}
1730	static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
1731	{
1732	assumeStdFlag(u);
1733	res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(v->Data()),
1734	currQuotient);
1735	return FALSE;
1736	}
1737	static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
1738	{
1739	res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
1740	setFlag(res,FLAG_STD);
1741	return FALSE;
1742	}
1743	static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
1744	{
1745	res->data = (char *)pJet((poly)u->Data(),(int)v->Data());
1746	return FALSE;
1747	}
1748	static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
1749	{
1750	res->data = (char *)idJet((ideal)u->Data(),(int)v->Data());
1751	return FALSE;
1752	}
1753	static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
1754	{
1755	assumeStdFlag(u);
1756	res->data = (char *)scKBase((int)v->Data(),
1757	(ideal)(u->Data()),currQuotient);
1758	return FALSE;
1759	}
1760	static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
1761	{
1762	return mpKoszul(res, u,v);
1763	}
1764	static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
1765	{
1766	sleftv h;
1767	memset(&h,0,sizeof(sleftv));
1768	h.rtyp=INT_CMD;
1769	h.data=(void *)IDELEMS((ideal)v->Data());
1770	return mpKoszul(res, &h, u, v);
1771	}
1772	static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
1773	{
1774	ideal m;
1775	BITSET save_test=test;
1776	int ul= IDELEMS((ideal)u->Data());
1777	int vl= IDELEMS((ideal)v->Data());
1778	m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
1779	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
1780	test=save_test;
1781	return FALSE;
1782	}
1783	static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
1784	{
1785	if ((v->rtyp!=IDHDL)\|\|(v->e!=NULL)) return TRUE;
1786	idhdl h=(idhdl)v->data;
1787	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
1788	res->data = (char *)idLiftStd((ideal)u->Data(),
1789	&(h->data.umatrix),testHomog);
1790	setFlag(res,FLAG_STD);
1791	return FALSE;
1792	}
1793	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
1794	{
1795	res->data = (char *)idMinors((matrix)u->Data(),(int)v->Data());
1796	return FALSE;
1797	}
1798	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
1799	{
1800	res->data = (char *)idModulo((ideal)u->Data(),(ideal)v->Data());
1801	return FALSE;
1802	}
1803	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
1804	{
1805	char opt=(char )v->Data();
1806	int mode=0;
1807	while(*opt!='\0')
1808	{
1809	if (*opt=='i') mode \|= PROT_I;
1810	else if (*opt=='o') mode \|= PROT_O;
1811	opt++;
1812	}
1813	monitor((char *)(u->Data()),mode);
1814	return FALSE;
1815	}
1816	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
1817	{
1818	idhdl h=(idhdl)u->data;
1819	int i=(int)v->Data();
1820	int p=0;
1821	if ((0<i)
1822	&& (IDRING(h)->parameter!=NULL)
1823	&& (i<=(p=rPar(IDRING(h)))))
1824	res->data=mstrdup(IDRING(h)->parameter[i-1]);
1825	else
1826	{
1827	Werror("par number %d out of range 1..%d",i,p);
1828	return TRUE;
1829	}
1830	return FALSE;
1831	}
1832	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
1833	{
1834	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
1835	hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
1836	idDelMultiples((ideal)(res->data));
1837	return FALSE;
1838	}
1839	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
1840	{
1841	int i=(int)u->Data();
1842	int j=(int)v->Data();
1843	#ifdef buildin_rand
1844	res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
1845	#else
1846	res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
1847	#endif
1848	return FALSE;
1849	}
1850	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
1851	{
1852	si_link l=(si_link)u->Data();
1853	leftv r=slRead(l,v);
1854	if (r==NULL)
1855	{
1856	const char *s;
1857	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
1858	else s=sNoName;
1859	Werror("cannot read from `%s`",s);
1860	return TRUE;
1861	}
1862	memcpy(res,r,sizeof(sleftv));
1863	FreeSizeOf((ADDRESS)r,sleftv);
1864	return FALSE;
1865	}
1866	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
1867	{
1868	assumeStdFlag(v);
1869	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
1870	return FALSE;
1871	}
1872	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
1873	{
1874	assumeStdFlag(v);
1875	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data());
1876	return FALSE;
1877	}
1878	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
1879	{
1880	int maxl=(int)v->Data();
1881	if (maxl<0)
1882	{
1883	WerrorS("length for res must not be negative");
1884	return TRUE;
1885	}
1886	int l=0;
1887	//resolvente r;
1888	syStrategy r;
1889	intvec **weights=NULL;
1890	int wmaxl=maxl;
1891	ideal u_id=(ideal)u->Data();
1892
1893	maxl--;
1894	if ((maxl==-1) && (iiOp!=MRES_CMD))
1895	maxl = pVariables-1;
1896	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
1897	{
1898	intvec * iv=(intvec*)atGet(u,"isHomog");
1899	r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
1900	}
1901	else if (iiOp==SRES_CMD)
1902	// r=sySchreyerResolvente(u_id,maxl+1,&l);
1903	r=sySchreyer(u_id,maxl+1);
1904	else if (iiOp == LRES_CMD)
1905	{
1906	int dummy;
1907	if((currQuotient!=NULL)\|\|
1908	(!idHomIdeal (u_id,NULL)))
1909	{
1910	WerrorS
1911	("`lres` not implemented for inhomogeneous input or qring");
1912	return TRUE;
1913	}
1914	r=syLaScala3(u_id,&dummy);
1915	}
1916	else
1917	{
1918	int dummy;
1919	if((currQuotient!=NULL)\|\|
1920	(!idHomIdeal (u_id,NULL)))
1921	{
1922	WerrorS
1923	("`hres` not implemented for inhomogeneous input or qring");
1924	return TRUE;
1925	}
1926	r=syHilb(u_id,&dummy);
1927	}
1928	if (r==NULL) return TRUE;
1929	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
1930	r->list_length=wmaxl;
1931	res->data=(void *)r;
1932	return FALSE;
1933	}
1934	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
1935	{
1936	ring r;
1937	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
1938	res->data = (char *)r;
1939	return (i==-1);
1940	}
1941	#define SIMPL_LMDIV 32
1942	#define SIMPL_LMEQ 16
1943	#define SIMPL_MULT 8
1944	#define SIMPL_EQU 4
1945	#define SIMPL_NULL 2
1946	#define SIMPL_NORM 1
1947	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
1948	{
1949	int sw = (int)v->Data();
1950	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
1951	ideal id = (ideal)u->CopyD(IDEAL_CMD);
1952	if (sw & SIMPL_LMDIV)
1953	{
1954	idDelDiv(id);
1955	}
1956	if (sw & SIMPL_LMEQ)
1957	{
1958	idDelLmEquals(id);
1959	}
1960	if (sw & SIMPL_NULL)
1961	{
1962	idSkipZeroes(id);
1963	}
1964	if (sw & SIMPL_NORM)
1965	{
1966	idNorm(id);
1967	}
1968	if (sw & SIMPL_MULT)
1969	{
1970	idDelMultiples(id);
1971	}
1972	else if(sw & SIMPL_EQU)
1973	{
1974	idDelEquals(id);
1975	}
1976	res->data = (char * )id;
1977	return FALSE;
1978	}
1979	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
1980	{
1981	res->data = mstrdup(slStatus((si_link) u->Data(), (char *) v->Data()));
1982	return FALSE;
1983	}
1984	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
1985	{
1986	int sw = (int)v->Data();
1987	// CopyD for POLY_CMD and VECTOR_CMD are identical:
1988	poly p = (poly)u->CopyD(POLY_CMD);
1989	if (sw & SIMPL_NORM)
1990	{
1991	pNorm(p);
1992	}
1993	res->data = (char * )p;
1994	return FALSE;
1995	}
1996	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
1997	{
1998	ideal result;
1999	intvec w=(intvec )atGet(u,"isHomog");
2000	tHomog hom=testHomog;
2001	if (w!=NULL)
2002	{
2003	w=ivCopy(w);
2004	hom=isHomog;
2005	}
2006	result=kStd((ideal)(u->Data()),currQuotient,hom,&w,(intvec *)v->Data());
2007	idSkipZeroes(result);
2008	res->data = (char *)result;
2009	setFlag(res,FLAG_STD);
2010	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
2011	return FALSE;
2012	}
2013	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2014	{
2015	ideal result;
2016	intvec w=(intvec )atGet(u,"isHomog");
2017	tHomog hom=testHomog;
2018	if (w!=NULL)
2019	{
2020	w=ivCopy(w);
2021	hom=isHomog;
2022	}
2023	ideal i1=(ideal)u->Data();
2024	ideal i0=idInit(1,i1->rank);
2025	i0->m[0]=(poly)v->Data();
2026	i1=idSimpleAdd(i1,i0);
2027	i0->m[0]=NULL;
2028	idDelete(&i0);
2029	BITSET save_test=test;
2030	test\|=Sy_bit(OPT_SB_1);
2031	result=kStd(i1,currQuotient,hom,&w);
2032	test=save_test;
2033	idDelete(&i1);
2034	idSkipZeroes(result);
2035	res->data = (char *)result;
2036	setFlag(res,FLAG_STD);
2037	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
2038	return FALSE;
2039	}
2040	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2041	{
2042	idhdl h=(idhdl)u->data;
2043	int i=(int)v->Data();
2044	if ((0<i) && (i<=IDRING(h)->N))
2045	res->data=mstrdup(IDRING(h)->names[i-1]);
2046	else
2047	{
2048	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2049	return TRUE;
2050	}
2051	return FALSE;
2052	}
2053	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2054	{
2055	res->data = (char *)mpWedge((matrix)u->Data(),(int)v->Data());
2056	return FALSE;
2057	}
2058	#define jjWRONG2 (proc2)jjWRONG
2059	#define jjWRONG3 (proc3)jjWRONG
2060	static BOOLEAN jjWRONG(leftv res, leftv u)
2061	{
2062	return TRUE;
2063	}
2064
2065	static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2066	{
2067	char * s=(char *)u->Data();
2068	if(strcmp(s, "with")==0)
2069	return jjLOAD(res, v, TRUE);
2070	WerrorS("invalid second argument");
2071	WerrorS("load(\"libname\" [,\"with\"]);");
2072	return TRUE;
2073	}
2074
2075	/=================== operations with 2 args.: table =================/
2076
2077	struct sValCmd2 dArith2[]=
2078	{
2079	// operations:
2080	// proc cmd res arg1 arg2
2081	{jjCOLCOL, COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD PROFILER}
2082	,{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD PROFILER}
2083	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2084	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2085	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2086	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2087	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2088	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD PROFILER}
2089	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
2090	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
2091	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD PROFILER}
2092	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2093	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD PROFILER}
2094	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2095	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD PROFILER}
2096	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2097	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
2098	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD PROFILER}
2099	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD PROFILER}
2100	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD PROFILER}
2101	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2102	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2103	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2104	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
2105	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
2106	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2107	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2108	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2109	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
2110	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD PROFILER}
2111	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2112	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2113	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD PROFILER}
2114	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2115	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2116	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD PROFILER}
2117	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2118	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD PROFILER}
2119	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD PROFILER}
2120	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD PROFILER}
2121	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2122	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
2123	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD PROFILER}
2124	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD PROFILER}
2125	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD PROFILER}
2126	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD PROFILER}
2127	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD PROFILER}
2128	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
2129	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2130	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD PROFILER}
2131	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2132	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD PROFILER}
2133	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD PROFILER}
2134	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
2135	,{jjTIMES_IV, '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD PROFILER}
2136	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2137	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2138	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2139	,{jjDIVMOD_I, '/', INT_CMD, INT_CMD, INT_CMD PROFILER}
2140	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2141	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2142	,{jjDIVMOD_I, INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2143	,{jjOP_IV_I, INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2144	,{jjOP_IV_I, INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2145	,{jjDIVMOD_I, '%', INT_CMD, INT_CMD, INT_CMD PROFILER}
2146	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2147	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2148	,{jjDIVMOD_I, INTMOD_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2149	,{jjOP_IV_I, INTMOD_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD PROFILER}
2150	,{jjOP_IV_I, INTMOD_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD PROFILER}
2151	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD PROFILER}
2152	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD PROFILER}
2153	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2154	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2155	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD PROFILER}
2156	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2157	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2158	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2159	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2160	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2161	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2162	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD PROFILER}
2163	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2164	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2165	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2166	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2167	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2168	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2169	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD PROFILER}
2170	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2171	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2172	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2173	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2174	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2175	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2176	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD PROFILER}
2177	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2178	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2179	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2180	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2181	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2182	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2183	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD PROFILER}
2184	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD PROFILER}
2185	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD PROFILER}
2186	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2187	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2188	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2189	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2190	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2191	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2192	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
2193	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
2194	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD PROFILER}
2195	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD PROFILER}
2196	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD PROFILER}
2197	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD PROFILER}
2198	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD PROFILER}
2199	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD PROFILER}
2200	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2201	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD PROFILER}
2202	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD PROFILER}
2203	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2204	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD PROFILER}
2205	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD PROFILER}
2206	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD PROFILER}
2207	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD PROFILER}
2208	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD PROFILER}
2209	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD PROFILER}
2210	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD PROFILER}
2211	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD PROFILER}
2212	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD PROFILER}
2213	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD PROFILER}
2214	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD PROFILER}
2215	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD PROFILER}
2216	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD PROFILER}
2217	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD PROFILER}
2218	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD PROFILER}
2219	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD PROFILER}
2220	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD PROFILER}
2221	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD PROFILER}
2222	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2223	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD PROFILER}
2224	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD PROFILER}
2225	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD PROFILER}
2226	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD PROFILER}
2227	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD PROFILER}
2228	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD PROFILER}
2229	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD PROFILER}
2230	// and the procedures with 2 arguments:
2231	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD PROFILER}
2232	,{jjWRONG2, BAREISS_CMD, 0, DEF_CMD, DEF_CMD PROFILER}
2233	,{syBetti2, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD PROFILER}
2234	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD PROFILER}
2235	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2236	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD PROFILER}
2237	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2238	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD PROFILER}
2239	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD PROFILER}
2240	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2241	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2242	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2243	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2244	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2245	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD PROFILER}
2246	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2247	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2248	,{jjDIVISION, DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2249	,{jjDIVISION, DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2250	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2251	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2252	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD PROFILER}
2253	#ifdef HAVE_FACTORY
2254	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD PROFILER}
2255	,{jjSQR_FREE_DEC,FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD PROFILER}
2256	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2257	#else
2258	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD PROFILER}
2259	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD PROFILER}
2260	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2261	#endif
2262	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE PROFILER}
2263	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE PROFILER}
2264	#ifdef HAVE_FGLM
2265	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD PROFILER}
2266	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD PROFILER}
2267	,{fglmQuotProc,FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2268	#else
2269	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD PROFILER}
2270	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD PROFILER}
2271	,{jjWRONG2, FGLMQUOT_CMD, IDEAL_CMD, POLY_CMD, IDEAL_CMD PROFILER}
2272	#endif
2273	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD PROFILER}
2274	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2275	#ifdef HAVE_FACTORY
2276	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2277	#else
2278	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2279	#endif
2280	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD PROFILER}
2281	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD PROFILER}
2282	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD PROFILER}
2283	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD PROFILER}
2284	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2285	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD PROFILER}
2286	,{jjRES, HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2287	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD PROFILER}
2288	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE PROFILER}
2289	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE PROFILER}
2290	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2291	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD PROFILER}
2292	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2293	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2294	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2295	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2296	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD PROFILER}
2297	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2298	,{jjJET_ID, JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD PROFILER}
2299	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2300	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2301	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD PROFILER}
2302	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD PROFILER}
2303	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD PROFILER}
2304	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2305	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2306	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD PROFILER}
2307	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD PROFILER}
2308	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD PROFILER}
2309	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2310	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD PROFILER}
2311	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD PROFILER}
2312	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2313	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2314	,{jjMONITOR2, MONITOR_CMD, NONE, STRING_CMD, STRING_CMD PROFILER}
2315	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2316	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2317	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2318	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2319	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD PROFILER}
2320	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD PROFILER}
2321	,{jjPRINT_FORMAT, PRINT_CMD, ANY_TYPE, DEF_CMD, STRING_CMD PROFILER}
2322	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2323	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2324	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2325	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD PROFILER}
2326	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD PROFILER}
2327	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD PROFILER}
2328	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD PROFILER}
2329	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD PROFILER}
2330	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD PROFILER}
2331	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD PROFILER}
2332	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD PROFILER}
2333	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2334	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2335	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2336	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2337	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD PROFILER}
2338	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD PROFILER}
2339	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD PROFILER}
2340	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2341	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD PROFILER}
2342	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD PROFILER}
2343	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD PROFILER}
2344	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD PROFILER}
2345	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD PROFILER}
2346	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD PROFILER}
2347	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD PROFILER}
2348	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD PROFILER}
2349	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD PROFILER}
2350	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD PROFILER}
2351	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD PROFILER}
2352	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD PROFILER}
2353	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD PROFILER}
2354	,{jjLOAD_E, LOAD_CMD, NONE, STRING_CMD, STRING_CMD PROFILER}
2355	,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD PROFILER}
2356	,{NULL, 0, 0, 0, 0 PROFILER}
2357	};
2358	/=================== operations with 1 arg.: static proc =================/
2359	static BOOLEAN jjDUMMY(leftv res, leftv u)
2360	{
2361	res->data = (char *)u->CopyD();
2362	return FALSE;
2363	}
2364	static BOOLEAN jjNULL(leftv res, leftv u)
2365	{
2366	return FALSE;
2367	}
2368	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2369	//{
2370	// res->data = (char *)((int)u->Data()+1);
2371	// return FALSE;
2372	//}
2373	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
2374	//{
2375	// res->data = (char *)((int)u->Data()-1);
2376	// return FALSE;
2377	//}
2378	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
2379	{
2380	if (IDTYP((idhdl)u->data)==INT_CMD)
2381	{
2382	if (iiOp==PLUSPLUS) IDINT((idhdl)u->data)++;
2383	else IDINT((idhdl)u->data)--;
2384	return FALSE;
2385	}
2386	return TRUE;
2387	}
2388	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
2389	{
2390	res->data = (char *)(-(int)u->Data());
2391	return FALSE;
2392	}
2393	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
2394	{
2395	number n=(number)u->CopyD(NUMBER_CMD);
2396	n=nNeg(n);
2397	res->data = (char *)n;
2398	return FALSE;
2399	}
2400	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
2401	{
2402	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
2403	return FALSE;
2404	}
2405	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
2406	{
2407	poly m1=pISet(-1);
2408	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
2409	return FALSE;
2410	}
2411	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
2412	{
2413	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
2414	(iv)=(-1);
2415	res->data = (char *)iv;
2416	return FALSE;
2417	}
2418	static BOOLEAN jjPROC1(leftv res, leftv u)
2419	{
2420	if ((u->rtyp!=IDHDL) \|\| (u->e!=NULL))
2421	return TRUE;
2422	#ifdef HAVE_NAMESPACES
2423	leftv sl = iiMake_proc((idhdl) u->data,u,NULL);
2424	#else /* HAVE_NAMESPACES */
2425	leftv sl = iiMake_proc((idhdl) u->data,NULL);
2426	#endif /* HAVE_NAMESPACES */
2427	if (sl==NULL)
2428	{
2429	return TRUE;
2430	}
2431	else
2432	{
2433	memcpy(res,sl,sizeof(sleftv));
2434	}
2435	return FALSE;
2436	}
2437	static BOOLEAN jjBAREISS(leftv res, leftv v)
2438	{
2439	//matrix m=(matrix)v->Data();
2440	//lists l=mpBareiss(m,FALSE);
2441	lists l=smCallNewBareiss((ideal)v->Data(),0,0);
2442	res->data = (char *)l;
2443	return FALSE;
2444	}
2445	static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
2446	{
2447	intvec m=(intvec )v->CopyD(INTMAT_CMD);
2448	ivTriangMat(m,1,1);
2449	res->data = (char *)m;
2450	return FALSE;
2451	}
2452	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
2453	{
2454	return iiExprArithM(res,u,iiOp);
2455	}
2456	static BOOLEAN jjCHAR(leftv res, leftv v)
2457	{
2458	res->data = (char *)rChar((ring)v->Data());
2459	return FALSE;
2460	}
2461	static BOOLEAN jjCOLS(leftv res, leftv v)
2462	{
2463	res->data = (char *)MATCOLS((matrix)(v->Data()));
2464	return FALSE;
2465	}
2466	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
2467	{
2468	res->data = (char )((intvec)(v->Data()))->cols();
2469	return FALSE;
2470	}
2471	static BOOLEAN jjCONTENT(leftv res, leftv v)
2472	{
2473	// CopyD for POLY_CMD and VECTOR_CMD are identical:
2474	poly p=(poly)v->CopyD(POLY_CMD);
2475	if (p!=NULL) pCleardenom(p);
2476	res->data = (char *)p;
2477	return FALSE;
2478	}
2479	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
2480	{
2481	res->data = (char *)nSize((number)v->Data());
2482	return FALSE;
2483	}
2484	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
2485	{
2486	lists l=(lists)v->Data();
2487	res->data = (char *)(l->nr+1);
2488	return FALSE;
2489	}
2490	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
2491	{
2492	matrix m=(matrix)v->Data();
2493	res->data = (char )(MATROWS(m)MATCOLS(m));
2494	return FALSE;
2495	}
2496	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
2497	{
2498	res->data = (char )((intvec)(v->Data()))->length();
2499	return FALSE;
2500	}
2501	static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
2502	{
2503	ring r=(ring)v->Data();
2504	int elems=-1;
2505	if (rField_is_Zp(r)\|\|rField_is_GF(r)) elems=rInternalChar(r);
2506	else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
2507	{
2508	elems=rInternalChar(r)*naParDeg(r->minpoly);
2509	}
2510	res->data = (char *)elems;
2511	return FALSE;
2512	}
2513	static BOOLEAN jjDEG(leftv res, leftv v)
2514	{
2515	int dummy;
2516	poly p=(poly)v->Data();
2517	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy);
2518	else res->data=(char *)-1;
2519	return FALSE;
2520	}
2521	static BOOLEAN jjDEGREE(leftv res, leftv v)
2522	{
2523	assumeStdFlag(v);
2524	scDegree((ideal)v->Data(),currQuotient);
2525	return FALSE;
2526	}
2527	static BOOLEAN jjDEFINED(leftv res, leftv v)
2528	{
2529	if ((v->rtyp==IDHDL)
2530	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
2531	{
2532	res->data=(void *)(IDLEV((idhdl)v->data)+1);
2533	}
2534	else if (v->rtyp!=0) res->data=(void *)(-1);
2535	return FALSE;
2536	}
2537	#ifdef HAVE_FACTORY
2538	static BOOLEAN jjDET(leftv res, leftv v)
2539	{
2540	int i,j;
2541	matrix m=(matrix)v->Data();
2542	if (currRing->parameter==NULL)
2543	{
2544	for(i=m->rows();i>0;i--)
2545	{
2546	for(j=m->cols();j>0;j--)
2547	{
2548	if((MATELEM(m,i,j)!=NULL)
2549	&& (!pIsConstant(MATELEM(m,i,j))))
2550	{
2551	goto nonconst;
2552	}
2553	}
2554	}
2555	res->data = (char *)singclap_det(m);
2556	return FALSE;
2557	}
2558	nonconst:
2559	ideal I=idMatrix2Module(mpCopy(m));
2560	// TBC: CHECK THIS (barei.tst)!!
2561	// ideal I=idMatrix2Module(m);
2562	// v->SetData(NULL);
2563	poly p=smCallDet(I);
2564	idDelete(&I);
2565	res ->data = (char *)p;
2566	return FALSE;
2567	}
2568	static BOOLEAN jjDET_I(leftv res, leftv v)
2569	{
2570	intvec * m=(intvec*)v->Data();
2571	int i,j;
2572	i=m->rows();j=m->cols();
2573	if(i==j)
2574	res->data = (char *)singclap_det_i(m);
2575	else
2576	{
2577	Werror("det of %d x %d intmat",i,j);
2578	return TRUE;
2579	}
2580	return FALSE;
2581	}
2582	static BOOLEAN jjDET_S(leftv res, leftv v)
2583	{
2584	ideal I=(ideal)v->Data();
2585	poly p=smCallDet(I);
2586	res->data = (char *)p;
2587	return FALSE;
2588	}
2589	#endif
2590	static BOOLEAN jjDIM(leftv res, leftv v)
2591	{
2592	assumeStdFlag(v);
2593	res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
2594	return FALSE;
2595	}
2596	static BOOLEAN jjDUMP(leftv res, leftv v)
2597	{
2598	si_link l = (si_link)v->Data();
2599	if (slDump(l))
2600	{
2601	const char *s;
2602	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2603	else s=sNoName;
2604	Werror("cannot dump to `%s`",s);
2605	return TRUE;
2606	}
2607	else
2608	return FALSE;
2609	}
2610	static BOOLEAN jjE(leftv res, leftv v)
2611	{
2612	res->data = (char *)pOne();
2613	pSetComp((poly)res->data,(int)v->Data());
2614	pSetm((poly)res->data);
2615	return FALSE;
2616	}
2617	#ifdef HAVE_FACTORY
2618	static BOOLEAN jjFACSTD(leftv res, leftv v)
2619	{
2620	res->data=(void *)kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
2621	setFlag(res,FLAG_STD);
2622	return FALSE;
2623	}
2624	#endif
2625	static BOOLEAN jjGETDUMP(leftv res, leftv v)
2626	{
2627	si_link l = (si_link)v->Data();
2628	if (slGetDump(l))
2629	{
2630	const char *s;
2631	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2632	else s=sNoName;
2633	Werror("cannot get dump from `%s`",s);
2634	return TRUE;
2635	}
2636	else
2637	return FALSE;
2638	}
2639	static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
2640	{
2641	assumeStdFlag(v);
2642	ideal I=(ideal)v->Data();
2643	res->data=(void *)iiHighCorner(I,0);
2644	return FALSE;
2645	}
2646	static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
2647	{
2648	assumeStdFlag(v);
2649	intvec w=(intvec)atGet(v,"isHomog");
2650	BOOLEAN delete_w=FALSE;
2651	ideal I=(ideal)v->Data();
2652	int i;
2653	poly p=NULL,po=NULL;
2654	int rk=idRankFreeModule(I);
2655	if (w==NULL)
2656	{
2657	w = NewIntvec1(rk);
2658	delete_w=TRUE;
2659	}
2660	for(i=rk;i>0;i--)
2661	{
2662	p=iiHighCorner(I,i);
2663	if (p==NULL)
2664	{
2665	Werror("module must be zero-dimensional");
2666	if (delete_w) delete w;
2667	return TRUE;
2668	}
2669	if (po==NULL)
2670	{
2671	po=p;
2672	}
2673	else
2674	{
2675	// now po!=NULL, p!=NULL
2676	int d=(pFDeg(po)-(w)[pGetComp(po)-1] - pFDeg(p)+(w)[i-1]);
2677	if (d==0)
2678	d=pComp0(po,p);
2679	if (d > 0)
2680	{
2681	pDelete(&p);
2682	}
2683	else // (d < 0)
2684	{
2685	pDelete(&po); po=p;
2686	}
2687	}
2688	}
2689	if (delete_w) delete w;
2690	res->data=(void *)po;
2691	return FALSE;
2692	}
2693	static BOOLEAN jjHILBERT(leftv res, leftv v)
2694	{
2695	assumeStdFlag(v);
2696	intvec module_w=(intvec)atGet(v,"isHomog");
2697	//scHilbertPoly((ideal)v->Data(),currQuotient);
2698	hLookSeries((ideal)v->Data(),module_w,currQuotient);
2699	return FALSE;
2700	}
2701	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
2702	{
2703	res->data=(void )hSecondSeries((intvec )v->Data());
2704	return FALSE;
2705	}
2706	static BOOLEAN jjHOMOG1(leftv res, leftv v)
2707	{
2708	intvec *w;
2709	res->data=(void *)idHomModule((ideal)v->Data(),currQuotient,&w);
2710	if ((v->rtyp==IDHDL)&&(w!=NULL))
2711	atSet((idhdl)v->data,mstrdup("isHomog"),w,INTVEC_CMD);
2712	return FALSE;
2713	}
2714	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
2715	{
2716	matrix mat=(matrix)v->CopyD(MATRIX_CMD);
2717	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
2718	MATROWS(mat)=1;
2719	mat->rank=1;
2720	res->data=(char *)mat;
2721	return FALSE;
2722	}
2723	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
2724	{
2725	map m=(map)v->CopyD(MAP_CMD);
2726	FreeL((ADDRESS)m->preimage);
2727	m->preimage=NULL;
2728	ideal I=(ideal)m;
2729	I->rank=1;
2730	res->data=(char *)I;
2731	return FALSE;
2732	}
2733	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
2734	{
2735	if (currRing!=NULL)
2736	{
2737	ring q=(ring)v->Data();
2738	if (rEqual(currRing, q, 0))
2739	{
2740	if (q->qideal==NULL)
2741	res->data=(char *)idInit(1,1);
2742	else
2743	res->data=(char *)idCopy(q->qideal);
2744	return FALSE;
2745	}
2746	}
2747	WerrorS("can only get ideal from identical qring");
2748	return TRUE;
2749	}
2750	static BOOLEAN jjIm2Iv(leftv res, leftv v)
2751	{
2752	intvec iv = (intvec )v->CopyD(INTMAT_CMD);
2753	iv->makeVector();
2754	res->data = iv;
2755	return FALSE;
2756	}
2757	static BOOLEAN jjINDEPSET(leftv res, leftv v)
2758	{
2759	assumeStdFlag(v);
2760	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
2761	return FALSE;
2762	}
2763	static BOOLEAN jjINTERRED(leftv res, leftv v)
2764	{
2765	ideal result=kInterRed((ideal)(v->Data()),currQuotient);
2766	//if (result==NULL) return TRUE;
2767	idSkipZeroes(result);
2768	res->data = result;
2769	return FALSE;
2770	}
2771	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
2772	{
2773	res->data = (char *)pVar((poly)v->Data());
2774	return FALSE;
2775	}
2776	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
2777	{
2778	res->data = (char )(rIsRingVar((char )v->Data())+1);
2779	return FALSE;
2780	}
2781	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
2782	{
2783	res->data = (char *)0;
2784	return FALSE;
2785	}
2786	static BOOLEAN jjJACOB_P(leftv res, leftv v)
2787	{
2788	ideal i=idInit(pVariables,1);
2789	int k;
2790	poly p=(poly)(v->Data());
2791	for (k=pVariables;k>0;k--)
2792	{
2793	i->m[k-1]=pDiff(p,k);
2794	}
2795	res->data = (char *)i;
2796	return FALSE;
2797	}
2798	static BOOLEAN jjKBASE(leftv res, leftv v)
2799	{
2800	assumeStdFlag(v);
2801	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
2802	return FALSE;
2803	}
2804	static BOOLEAN jjKLAMMER_LIB(leftv res, leftv u)
2805	{
2806	char * s=(char *)u->Data();
2807	return iiLibCmd(s);
2808	}
2809	#ifdef MDEBUG
2810	static BOOLEAN jjpHead(leftv res, leftv v)
2811	{
2812	res->data=(char *)pHead((poly)v->Data());
2813	return FALSE;
2814	}
2815	#endif
2816	static BOOLEAN jjL2R(leftv res, leftv v)
2817	{
2818	res->data=(char *)syConvList((lists)v->Data());
2819	if (res->data != NULL)
2820	return FALSE;
2821	else
2822	return TRUE;
2823	}
2824	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
2825	{
2826	poly p=(poly)v->Data();
2827	if (p==NULL)
2828	{
2829	res->data=(char *)nInit(0);
2830	}
2831	else
2832	{
2833	res->data=(char *)nCopy(pGetCoeff(p));
2834	}
2835	return FALSE;
2836	}
2837	static BOOLEAN jjLEADEXP(leftv res, leftv v)
2838	{
2839	poly p=(poly)v->Data();
2840	int s=pVariables;
2841	if (v->Typ()==VECTOR_CMD) s++;
2842	intvec *iv=NewIntvec1(s);
2843	if (p!=NULL)
2844	{
2845	for(int i = pVariables;i;i--)
2846	{
2847	(*iv)[i-1]=pGetExp(p,i);
2848	}
2849	if (s!=pVariables)
2850	(*iv)[pVariables]=pGetComp(p);
2851	}
2852	res->data=(char *)iv;
2853	return FALSE;
2854	}
2855	static BOOLEAN jjLEADMONOM(leftv res, leftv v)
2856	{
2857	poly p=(poly)v->Data();
2858	if (p == NULL)
2859	{
2860	res->data = (char*) NULL;
2861	}
2862	else
2863	{
2864	poly lm = pCopy1(p);
2865	pSetCoeff(lm, nInit(1));
2866	res->data = (char*) lm;
2867	}
2868	return FALSE;
2869	}
2870	static BOOLEAN jjLIB(leftv res, leftv v)
2871	{
2872	return iiLibCmd((char *)v->CopyD(STRING_CMD));
2873	}
2874	static BOOLEAN jjMEMORY(leftv res, leftv v)
2875	{
2876	#ifdef MM_COUNT
2877	switch(((int)v->Data()))
2878	{
2879	case 0:
2880	res->data = (char *)mmMemUsed();
2881	break;
2882	case 1:
2883	res->data = (char *)mmMemAlloc();
2884	break;
2885	#ifdef HAVE_SBRK
2886	case 2:
2887	res->data = (char *)mmMemPhysical();
2888	break;
2889	#endif
2890	default:
2891	mmPrintStat();
2892	res->data = (char *)0;
2893	}
2894	return FALSE;
2895	#else
2896	res->data = (char *)0;
2897	return FALSE;
2898	#endif
2899	}
2900	static BOOLEAN jjMONITOR1(leftv res, leftv v)
2901	{
2902	monitor((char *)(v->Data()),PROT_I);
2903	return FALSE;
2904	}
2905	static BOOLEAN jjMSTD(leftv res, leftv v)
2906	{
2907	res->data=(void *)min_std((ideal)v->Data(),currQuotient,testHomog,NULL);
2908	return FALSE;
2909	}
2910	static BOOLEAN jjMULT(leftv res, leftv v)
2911	{
2912	assumeStdFlag(v);
2913	res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
2914	return FALSE;
2915	}
2916	static BOOLEAN jjNAMEOF(leftv res, leftv v)
2917	{
2918	res->data = (char *)v->name;
2919	if (res->data==NULL) res->data=mstrdup("");
2920	v->name=NULL;
2921	return FALSE;
2922	}
2923	static BOOLEAN jjNAMES(leftv res, leftv v)
2924	{
2925	res->data=ipNameList(((ring)v->Data())->idroot);
2926	return FALSE;
2927	}
2928	static BOOLEAN jjNVARS(leftv res, leftv v)
2929	{
2930	res->data = (char *)(((ring)(v->Data()))->N);
2931	return FALSE;
2932	}
2933	static BOOLEAN jjOpenClose(leftv res, leftv v)
2934	{
2935	si_link l=(si_link)v->Data();
2936	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
2937	else return slClose(l);
2938	}
2939	static BOOLEAN jjORD(leftv res, leftv v)
2940	{
2941	poly p=(poly)v->Data();
2942	res->data=(char *)( p==NULL ? -1 : pFDeg(p) );
2943	return FALSE;
2944	}
2945	static BOOLEAN jjPAR1(leftv res, leftv v)
2946	{
2947	int i=(int)v->Data();
2948	int p=0;
2949	p=rPar(currRing);
2950	if ((0<i) && (i<=p))
2951	{
2952	res->data=(char *)nPar(i);
2953	}
2954	else
2955	{
2956	Werror("par number %d out of range 1..%d",i,p);
2957	return TRUE;
2958	}
2959	return FALSE;
2960	}
2961	static BOOLEAN jjPARDEG(leftv res, leftv v)
2962	{
2963	res->data = (char *)nParDeg((number)v->Data());
2964	return FALSE;
2965	}
2966	static BOOLEAN jjPARSTR1(leftv res, leftv v)
2967	{
2968	if (currRing==NULL)
2969	{
2970	WerrorS("no ring active");
2971	return TRUE;
2972	}
2973	int i=(int)v->Data();
2974	int p=0;
2975	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
2976	res->data=mstrdup(currRing->parameter[i-1]);
2977	else
2978	{
2979	Werror("par number %d out of range 1..%d",i,p);
2980	return TRUE;
2981	}
2982	return FALSE;
2983	}
2984	static BOOLEAN jjP2I(leftv res, leftv v)
2985	{
2986	poly p=(poly)v->Data();
2987	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
2988	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
2989	{
2990	WerrorS("poly must be constant");
2991	return TRUE;
2992	}
2993	res->data = (char *)nInt(pGetCoeff(p));
2994	return FALSE;
2995	}
2996	static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
2997	{
2998	map mapping=(map)v->Data();
2999	syMake(res,mstrdup(mapping->preimage));
3000	return FALSE;
3001	}
3002	static BOOLEAN jjPRIME(leftv res, leftv v)
3003	{
3004	int i = IsPrime((int)(v->Data()));
3005	res->data = (char *)(i > 1 ? i : 2);
3006	return FALSE;
3007	}
3008	static BOOLEAN jjPRUNE(leftv res, leftv v)
3009	{
3010	res->data = (char *)idMinEmbedding((ideal)v->Data());
3011	return FALSE;
3012	}
3013	static BOOLEAN jjP2N(leftv res, leftv v)
3014	{
3015	number n;
3016	poly p;
3017	if (((p=(poly)v->Data())!=NULL)
3018	&& (pIsConstant(p)))
3019	{
3020	n=nCopy(pGetCoeff(p));
3021	}
3022	else
3023	{
3024	n=nInit(0);
3025	}
3026	res->data = (char *)n;
3027	return FALSE;
3028	}
3029	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3030	{
3031	char s= (char )v->Data();
3032	int i = 1;
3033	int l = strlen(s);
3034	while (cmds[i].tokval!=0)
3035	{
3036	if (strcmp(s, cmds[i].name) == 0)
3037	{
3038	res->data = (char *)1;
3039	return FALSE;
3040	}
3041	i++;
3042	}
3043	//res->data = (char *)0;
3044	return FALSE;
3045	}
3046	static BOOLEAN jjREAD(leftv res, leftv v)
3047	{
3048	return jjREAD2(res,v,NULL);
3049	}
3050	static BOOLEAN jjREGULARITY(leftv res, leftv v)
3051	{
3052	res->data = (char *)iiRegularity((lists)v->Data());
3053	return FALSE;
3054	}
3055	static BOOLEAN jjROWS(leftv res, leftv v)
3056	{
3057	ideal i = (ideal)v->Data();
3058	res->data = (char *)i->rank;
3059	return FALSE;
3060	}
3061	static BOOLEAN jjROWS_IV(leftv res, leftv v)
3062	{
3063	res->data = (char )((intvec)(v->Data()))->rows();
3064	return FALSE;
3065	}
3066	static BOOLEAN jjRPAR(leftv res, leftv v)
3067	{
3068	res->data = (char *)rPar(((ring)v->Data()));
3069	return FALSE;
3070	}
3071	static BOOLEAN jjSTD(leftv res, leftv v)
3072	{
3073	ideal result;
3074	intvec w=(intvec )atGet(v,"isHomog");
3075	tHomog hom=testHomog;
3076	if (w!=NULL)
3077	{
3078	w=ivCopy(w);
3079	hom=isHomog;
3080	}
3081	//if (hasFlag(v,FLAG_STD))
3082	// result=stdred((ideal)v->Data(),currQuotient,hom,&w);
3083	//else
3084	result=kStd((ideal)(v->Data()),currQuotient,hom,&w);
3085	idSkipZeroes(result);
3086	res->data = (char *)result;
3087	setFlag(res,FLAG_STD);
3088	if (w!=NULL) atSet(res,mstrdup("isHomog"),w,INTVEC_CMD);
3089	return FALSE;
3090	}
3091	static BOOLEAN jjSort_Id(leftv res, leftv v)
3092	{
3093	res->data = (char *)idSort((ideal)v->Data());
3094	return FALSE;
3095	}
3096	static BOOLEAN jjSYZYGY(leftv res, leftv v)
3097	{
3098	intvec *w=NULL;
3099	res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
3100	if (w!=NULL) delete w;
3101	return FALSE;
3102	}
3103	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
3104	{
3105	res->data = (char )ivTrace((intvec)(v->Data()));
3106	return FALSE;
3107	}
3108	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
3109	{
3110	res->data = (char )ivTranp((intvec)(v->Data()));
3111	return FALSE;
3112	}
3113	static BOOLEAN jjTYPEOF(leftv res, leftv v)
3114	{
3115	switch ((int)v->data)
3116	{
3117	case INT_CMD: res->data=mstrdup("int"); break;
3118	case POLY_CMD: res->data=mstrdup("poly"); break;
3119	case VECTOR_CMD: res->data=mstrdup("vector"); break;
3120	case STRING_CMD: res->data=mstrdup("string"); break;
3121	case INTVEC_CMD: res->data=mstrdup("intvec"); break;
3122	case IDEAL_CMD: res->data=mstrdup("ideal"); break;
3123	case MATRIX_CMD: res->data=mstrdup("matrix"); break;
3124	case MODUL_CMD: res->data=mstrdup("module"); break;
3125	case MAP_CMD: res->data=mstrdup("map"); break;
3126	case PROC_CMD: res->data=mstrdup("proc"); break;
3127	case RING_CMD: res->data=mstrdup("ring"); break;
3128	case QRING_CMD: res->data=mstrdup("qring"); break;
3129	case INTMAT_CMD: res->data=mstrdup("intmat"); break;
3130	case NUMBER_CMD: res->data=mstrdup("number"); break;
3131	case LIST_CMD: res->data=mstrdup("list"); break;
3132	case PACKAGE_CMD: res->data=mstrdup("package"); break;
3133	case LINK_CMD: res->data=mstrdup("link"); break;
3134	case RESOLUTION_CMD:res->data=mstrdup("resolution");break;
3135	case DEF_CMD:
3136	case NONE: res->data=mstrdup("none"); break;
3137	default: res->data=mstrdup("?unknown type?");
3138	}
3139	return FALSE;
3140	}
3141	static BOOLEAN jjVAR1(leftv res, leftv v)
3142	{
3143	int i=(int)v->Data();
3144	if ((0<i) && (i<=currRing->N))
3145	{
3146	poly p=pOne();
3147	pSetExp(p,i,1);
3148	pSetm(p);
3149	res->data=(char *)p;
3150	}
3151	else
3152	{
3153	Werror("var number %d out of range 1..%d",i,currRing->N);
3154	return TRUE;
3155	}
3156	return FALSE;
3157	}
3158	static BOOLEAN jjVARSTR1(leftv res, leftv v)
3159	{
3160	if (currRing==NULL)
3161	{
3162	WerrorS("no ring active");
3163	return TRUE;
3164	}
3165	int i=(int)v->Data();
3166	if ((0<i) && (i<=currRing->N))
3167	res->data=mstrdup(currRing->names[i-1]);
3168	else
3169	{
3170	Werror("var number %d out of range 1..%d",i,currRing->N);
3171	return TRUE;
3172	}
3173	return FALSE;
3174	}
3175	static BOOLEAN jjVDIM(leftv res, leftv v)
3176	{
3177	assumeStdFlag(v);
3178	res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
3179	return FALSE;
3180	}
3181
3182	static BOOLEAN jjLOAD1(leftv res, leftv v)
3183	{
3184	return jjLOAD(res, v);
3185	}
3186
3187	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
3188	{
3189	char * s=mstrdup((char *)v->Data());
3190	char libnamebuf[256];
3191	lib_types LT = type_of_LIB(s, libnamebuf);
3192	BOOLEAN result = TRUE;
3193	#ifdef HAVE_DYNAMIC_LOADING
3194	extern BOOLEAN load_modules(char newlib, char fullpath, BOOLEAN tellerror);
3195	#endif /* HAVE_DYNAMIC_LOADING */
3196
3197	switch(LT)
3198	{
3199	default:
3200	case LT_NONE:
3201	Werror("%s: unknown type", s);
3202	break;
3203
3204	case LT_SINGULAR:
3205	#ifdef HAVE_NAMESPACES
3206	result = iiLibCmd(s, autoexport);
3207	#else
3208	result = iiLibCmd(s);
3209	#endif
3210	break;
3211
3212	case LT_ELF:
3213	#ifdef HAVE_DYNAMIC_LOADING
3214	result = load_modules(s, libnamebuf, autoexport);
3215	#else /* HAVE_DYNAMIC_LOADING */
3216	WerrorS("Dynamic modules are not supported by this version of Singular");
3217	#endif /* HAVE_DYNAMIC_LOADING */
3218	break;
3219
3220	case LT_HPUX:
3221	#ifdef HAVE_DYNAMIC_LOADING
3222	result = load_modules(s, libnamebuf, autoexport);
3223	#else /* HAVE_DYNAMIC_LOADING */
3224	WerrorS("Dynamic modules are not supported by this version of Singular");
3225	#endif /* HAVE_DYNAMIC_LOADING */
3226	break;
3227	}
3228	return result;
3229	}
3230
3231	/=================== operations with 1 arg.: table =================/
3232
3233	#ifdef INIT_BUG
3234	#define XS(A) -((short)A)
3235	#define jjstrlen (proc1)1
3236	#define jjpLength (proc1)2
3237	#define jjidElem (proc1)3
3238	#define jjmpDetBareiss (proc1)4
3239	#define jjidFreeModule (proc1)5
3240	#define jjidVec2Ideal (proc1)6
3241	#define jjrCharStr (proc1)7
3242	#ifndef MDEBUG
3243	#define jjpHead (proc1)8
3244	#endif
3245	#define jjidHead (proc1)9
3246	#define jjidMaxIdeal (proc1)10
3247	#define jjidMinBase (proc1)11
3248	#define jjsyMinBase (proc1)12
3249	#define jjpMaxComp (proc1)13
3250	#define jjmpTrace (proc1)14
3251	#define jjmpTransp (proc1)15
3252	#define jjrOrdStr (proc1)16
3253	#define jjrVarStr (proc1)18
3254	#define jjrParStr (proc1)19
3255	#define jjCOUNT_RES (proc1)22
3256	#define jjDIM_R (proc1)23
3257	#define jjMINRES_R (proc1)24
3258	#define jjidTransp (proc1)25
3259
3260	extern struct sValCmd1 dArith1[];
3261	void jjInitTab1()
3262	{
3263	int i=0;
3264	for (;dArith1[i].cmd!=0;i++)
3265	{
3266	if (dArith1[i].res<0)
3267	{
3268	switch ((int)dArith1[i].p)
3269	{
3270	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
3271	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
3272	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
3273	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
3274	#ifndef HAVE_FACTORY
3275	case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
3276	#endif
3277	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
3278	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
3279	#ifndef MDEBUG
3280	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
3281	#endif
3282	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
3283	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
3284	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
3285	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
3286	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxComp; break;
3287	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
3288	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
3289	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
3290	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
3291	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
3292	case (int)jjCOUNT_RES: dArith1[i].p=(proc1)syLength; break;
3293	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
3294	case (int)jjMINRES_R: dArith1[i].p=(proc1)syMinimize; break;
3295	case (int)jjidTransp: dArith1[i].p=(proc1)idTransp; break;
3296	#ifdef GENTABLE
3297	default: Werror("missing proc1-definition for %d",(int)dArith1[i].p);
3298	#endif
3299	}
3300	}
3301	}
3302	}
3303	#else
3304	#if defined(PROC_BUG)
3305	#define XS(A) A
3306	static BOOLEAN jjstrlen(leftv res, leftv v)
3307	{
3308	res->data = (char )strlen((char )v->Data());
3309	return FALSE;
3310	}
3311	static BOOLEAN jjpLength(leftv res, leftv v)
3312	{
3313	res->data = (char *)pLength((poly)v->Data());
3314	return FALSE;
3315	}
3316	static BOOLEAN jjidElem(leftv res, leftv v)
3317	{
3318	res->data = (char *)idElem((ideal)v->Data());
3319	return FALSE;
3320	}
3321	static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
3322	{
3323	res->data = (char *)mpDetBareiss((matrix)v->Data());
3324	return FALSE;
3325	}
3326	static BOOLEAN jjidFreeModule(leftv res, leftv v)
3327	{
3328	res->data = (char *)idFreeModule((int)v->Data());
3329	return FALSE;
3330	}
3331	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
3332	{
3333	res->data = (char *)idVec2Ideal((poly)v->Data());
3334	return FALSE;
3335	}
3336	static BOOLEAN jjrCharStr(leftv res, leftv v)
3337	{
3338	res->data = rCharStr((ring)v->Data());
3339	return FALSE;
3340	}
3341	#ifndef MDEBUG
3342	static BOOLEAN jjpHead(leftv res, leftv v)
3343	{
3344	res->data = (char *)pHead((poly)v->Data());
3345	return FALSE;
3346	}
3347	#endif
3348	static BOOLEAN jjidHead(leftv res, leftv v)
3349	{
3350	res->data = (char *)idHead((ideal)v->Data());
3351	return FALSE;
3352	}
3353	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
3354	{
3355	res->data = (char *)idMaxIdeal((int)v->Data());
3356	return FALSE;
3357	}
3358	static BOOLEAN jjidMinBase(leftv res, leftv v)
3359	{
3360	res->data = (char *)idMinBase((ideal)v->Data());
3361	return FALSE;
3362	}
3363	static BOOLEAN jjsyMinBase(leftv res, leftv v)
3364	{
3365	res->data = (char *)syMinBase((ideal)v->Data());
3366	return FALSE;
3367	}
3368	static BOOLEAN jjpMaxComp(leftv res, leftv v)
3369	{
3370	res->data = (char *)pMaxComp((poly)v->Data());
3371	return FALSE;
3372	}
3373	static BOOLEAN jjmpTrace(leftv res, leftv v)
3374	{
3375	res->data = (char *)mpTrace((matrix)v->Data());
3376	return FALSE;
3377	}
3378	static BOOLEAN jjmpTransp(leftv res, leftv v)
3379	{
3380	res->data = (char *)mpTransp((matrix)v->Data());
3381	return FALSE;
3382	}
3383	static BOOLEAN jjrOrdStr(leftv res, leftv v)
3384	{
3385	res->data = rOrdStr((ring)v->Data());
3386	return FALSE;
3387	}
3388	static BOOLEAN jjrVarStr(leftv res, leftv v)
3389	{
3390	res->data = rVarStr((ring)v->Data());
3391	return FALSE;
3392	}
3393	static BOOLEAN jjrParStr(leftv res, leftv v)
3394	{
3395	res->data = rParStr((ring)v->Data());
3396	return FALSE;
3397	}
3398	static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
3399	{
3400	res->data=(char *)syLength((syStrategy)v->Data());
3401	return FALSE;
3402	}
3403	static BOOLEAN jjDIM_R(leftv res, leftv v)
3404	{
3405	res->data = (char *)syDim((syStrategy)v->Data());
3406	return FALSE;
3407	}
3408	static BOOLEAN jjMINRES_R(leftv res, leftv v)
3409	{
3410	res->data=(char *)syMinimize((syStrategy)v->Data());
3411	return FALSE;
3412	}
3413	static BOOLEAN jjidTransp(leftv res, leftv v)
3414	{
3415	res->data = (char *)idTransp((ideal)v->Data());
3416	return FALSE;
3417	}
3418	#else
3419	#define XS(A) -((short)A)
3420	#define jjstrlen (proc1)strlen
3421	#define jjpLength (proc1)pLength
3422	#define jjidElem (proc1)idElem
3423	#define jjmpDetBareiss (proc1)mpDetBareiss
3424	#define jjidFreeModule (proc1)idFreeModule
3425	#define jjidVec2Ideal (proc1)idVec2Ideal
3426	#define jjrCharStr (proc1)rCharStr
3427	#ifndef MDEBUG
3428	#define jjpHead (proc1)pHead
3429	#endif
3430	#define jjidHead (proc1)idHead
3431	#define jjidMaxIdeal (proc1)idMaxIdeal
3432	#define jjidMinBase (proc1)idMinBase
3433	#define jjsyMinBase (proc1)syMinBase
3434	#define jjpMaxComp (proc1)pMaxComp
3435	#define jjmpTrace (proc1)mpTrace
3436	#define jjmpTransp (proc1)mpTransp
3437	#define jjrOrdStr (proc1)rOrdStr
3438	#define jjrVarStr (proc1)rVarStr
3439	#define jjrParStr (proc1)rParStr
3440	#define jjCOUNT_RES (proc1)syLength
3441	#define jjDIM_R (proc1)syDim
3442	#define jjMINRES_R (proc1)syMinimize
3443	#define jjidTransp (proc1)idTransp
3444	#endif
3445	#endif
3446	static BOOLEAN jjnInt(leftv res, leftv u)
3447	{
3448	number n=(number)u->CopyD(NUMBER_CMD);
3449	res->data=(char *)nInt(n);
3450	nDelete(&n);
3451	return FALSE;
3452	}
3453	#define s short
3454	struct sValCmd1 dArith1[]=
3455	{
3456	// operations:
3457	// proc cmd res arg
3458	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD }
3459	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD }
3460	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL }
3461	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL }
3462	,{jjUMINUS_I, '-', INT_CMD, INT_CMD }
3463	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD }
3464	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD }
3465	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD }
3466	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD }
3467	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD }
3468	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD }
3469	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD }
3470	,{jjKLAMMER_LIB,'(', NONE, STRING_CMD }
3471	// and the procedures with 1 argument:
3472	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD }
3473	,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD }
3474	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MODUL_CMD }
3475	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD }
3476	,{syBetti1, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD }
3477	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD }
3478	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD }
3479	#ifdef HAVE_FACTORY
3480	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD }
3481	#else
3482	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD }
3483	#endif
3484	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD }
3485	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3486	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD }
3487	,{jjWRONG, COLS_CMD, 0, VECTOR_CMD }
3488	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD }
3489	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD }
3490	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD }
3491	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD }
3492	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD }
3493	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD }
3494	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD }
3495	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD }
3496	,{jjCOUNT_RES, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD }
3497	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD }
3498	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD }
3499	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD }
3500	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD }
3501	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD }
3502	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD }
3503	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD }
3504	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD }
3505	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD }
3506	,{jjCOUNT_RG, COUNT_CMD, INT_CMD, RING_CMD }
3507	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD }
3508	,{jjWRONG, DEF_CMD, 0, ANY_TYPE }
3509	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD }
3510	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD }
3511	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD }
3512	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD }
3513	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD }
3514	#ifdef HAVE_FACTORY
3515	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD }
3516	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD }
3517	,{jjDET_S, DET_CMD, POLY_CMD, MODUL_CMD }
3518	#else
3519	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD }
3520	,{jjmpDetBareiss,DET_CMD, XS(POLY_CMD), MATRIX_CMD }
3521	#endif
3522	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD }
3523	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD }
3524	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD }
3525	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD }
3526	,{jjE, E_CMD, VECTOR_CMD, INT_CMD }
3527	,{jjERROR, ERROR_CMD, NONE, STRING_CMD }
3528	#ifdef HAVE_FACTORY
3529	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD }
3530	#else
3531	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD }
3532	#endif
3533	#ifdef HAVE_FGLM
3534	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD}
3535	#else
3536	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD}
3537	#endif
3538	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD }
3539	#ifdef HAVE_FACTORY
3540	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD }
3541	#else
3542	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD }
3543	#endif
3544	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD }
3545	,{jjHIGHCORNER, HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD }
3546	,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD }
3547	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD }
3548	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD }
3549	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD }
3550	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD }
3551	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD }
3552	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD }
3553	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD }
3554	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD }
3555	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD }
3556	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD }
3557	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD }
3558	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD }
3559	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD }
3560	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD }
3561	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD }
3562	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD }
3563	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD }
3564	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD }
3565	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD }
3566	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD }
3567	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD }
3568	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD }
3569	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE }
3570	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD }
3571	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD }
3572	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD }
3573	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD }
3574	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL }
3575	#ifdef MDEBUG
3576	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD }
3577	#else
3578	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD }
3579	#endif
3580	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD }
3581	#ifdef MDEBUG
3582	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD }
3583	#else
3584	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD }
3585	#endif
3586	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD }
3587	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD }
3588	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD }
3589	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD }
3590	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD }
3591	,{jjLEADMONOM, LEADMONOM_CMD, POLY_CMD, POLY_CMD }
3592	,{jjLEADMONOM, LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD }
3593	,{jjLIB, LIB_CMD, NONE, STRING_CMD }
3594	,{jjDUMMY, LINK_CMD, LINK_CMD, LINK_CMD}
3595	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD }
3596	,{jjWRONG, MAP_CMD, 0, ANY_TYPE}
3597	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD }
3598	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD }
3599	,{jjMEMORY, MEMORY_CMD, INT_CMD, INT_CMD }
3600	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD }
3601	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD }
3602	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD }
3603	,{jjMINRES_R, MINRES_CMD, XS(RESOLUTION_CMD), RESOLUTION_CMD }
3604	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD }
3605	,{jjMONITOR1, MONITOR_CMD, NONE, STRING_CMD }
3606	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD }
3607	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD }
3608	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD }
3609	,{jjMSTD, MSTD_CMD, LIST_CMD, MODUL_CMD }
3610	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE }
3611	,{jjNAMES, NAMES_CMD, LIST_CMD, PACKAGE_CMD }
3612	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD }
3613	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD }
3614	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD }
3615	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD }
3616	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD }
3617	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD }
3618	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD }
3619	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD }
3620	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD }
3621	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD }
3622	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD }
3623	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD }
3624	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD }
3625	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD }
3626	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD }
3627	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD }
3628	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD }
3629	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3630	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD }
3631	,{jjPREIMAGE_R, PREIMAGE_CMD, RING_CMD, MAP_CMD }
3632	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD }
3633	,{jjPRINT, PRINT_CMD, NONE, LIST_CMD}
3634	,{jjPRINT, PRINT_CMD, NONE, DEF_CMD}
3635	,{jjPRUNE, PRUNE_CMD, MODUL_CMD, MODUL_CMD }
3636	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD }
3637	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD }
3638	,{jjWRONG, QRING_CMD, 0, ANY_TYPE}
3639	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD }
3640	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD }
3641	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD }
3642	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD }
3643	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD }
3644	,{jjDUMMY, RING_CMD, RING_CMD, RING_CMD}
3645	,{jjWRONG, ROWS_CMD, 0, POLY_CMD }
3646	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD }
3647	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD }
3648	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD }
3649	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD }
3650	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD }
3651	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD }
3652	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD }
3653	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD }
3654	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD }
3655	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD }
3656	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD }
3657	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD }
3658	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD }
3659	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD }
3660	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD }
3661	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD }
3662	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD }
3663	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD }
3664	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD }
3665	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD }
3666	,{jjidTransp, TRANSPOSE_CMD, XS(MODUL_CMD), MODUL_CMD }
3667	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE }
3668	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD }
3669	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD }
3670	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD }
3671	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD }
3672	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD }
3673	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD }
3674	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD }
3675	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD }
3676	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD }
3677	,{jjLOAD1, LOAD_CMD, NONE, STRING_CMD }
3678	,{loNewtonP, NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD}
3679	,{NULL, 0, 0, 0}
3680	};
3681	#undef s
3682	/=================== operations with 3 args.: static proc =================/
3683	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
3684	{
3685	char s= (char )u->Data();
3686	int r = (int)v->Data();
3687	int c = (int)w->Data();
3688	int l = strlen(s);
3689
3690	if ( (r<1) \|\| (r>l) \|\| (c<0) )
3691	{
3692	Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
3693	return TRUE;
3694	}
3695	res->data = (char *)AllocL(c+1);
3696	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
3697	return FALSE;
3698	}
3699	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
3700	{
3701	intvec iv = (intvec )u->Data();
3702	int r = (int)v->Data();
3703	int c = (int)w->Data();
3704	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
3705	{
3706	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
3707	r,c,u->Fullname(),iv->rows(),iv->cols());
3708	return TRUE;
3709	}
3710	res->data=u->data;
3711	u->data=NULL;
3712	res->rtyp=u->rtyp;
3713	u->rtyp=0;
3714	res->name=u->name;
3715	u->name=NULL;
3716	Subexpr e=jjMakeSub(v);
3717	e->next=jjMakeSub(w);
3718	if (u->e==NULL) res->e=e;
3719	else
3720	{
3721	Subexpr h=u->e;
3722	while (h->next!=NULL) h=h->next;
3723	h->next=e;
3724	res->e=u->e;
3725	u->e=NULL;
3726	}
3727	return FALSE;
3728	}
3729	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
3730	{
3731	matrix m= (matrix)u->Data();
3732	int r = (int)v->Data();
3733	int c = (int)w->Data();
3734	//Print("gen. elem %d, %d\n",r,c);
3735	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
3736	{
3737	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
3738	MATROWS(m),MATCOLS(m));
3739	return TRUE;
3740	}
3741	res->data=u->data;
3742	u->data=NULL;
3743	res->rtyp=u->rtyp;
3744	u->rtyp=0;
3745	res->name=u->name;
3746	u->name=NULL;
3747	Subexpr e=jjMakeSub(v);
3748	e->next=jjMakeSub(w);
3749	if (u->e==NULL)
3750	res->e=e;
3751	else
3752	{
3753	Subexpr h=u->e;
3754	while (h->next!=NULL) h=h->next;
3755	h->next=e;
3756	res->e=u->e;
3757	u->e=NULL;
3758	}
3759	return FALSE;
3760	}
3761	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
3762	{
3763	sleftv t;
3764	sleftv ut;
3765	leftv p=NULL;
3766	intvec iv=(intvec )w->Data();
3767	int l;
3768	BOOLEAN nok;
3769
3770	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3771	{
3772	WerrorS("cannot build expression lists from unnamed objects");
3773	return TRUE;
3774	}
3775	memcpy(&ut,u,sizeof(ut));
3776	memset(&t,0,sizeof(t));
3777	t.rtyp=INT_CMD;
3778	for (l=0;l< iv->length(); l++)
3779	{
3780	t.data=(char )(iv)[l];
3781	if (p==NULL)
3782	{
3783	p=res;
3784	}
3785	else
3786	{
3787	p->next=(leftv)Alloc0SizeOf(sleftv);
3788	p=p->next;
3789	}
3790	memcpy(u,&ut,sizeof(ut));
3791	if (u->Typ() == MATRIX_CMD)
3792	nok=jjBRACK_Ma(p,u,v,&t);
3793	else /* INTMAT_CMD */
3794	nok=jjBRACK_Im(p,u,v,&t);
3795	if (nok)
3796	{
3797	while (res->next!=NULL)
3798	{
3799	p=res->next->next;
3800	FreeSizeOf((ADDRESS)res->next,sleftv);
3801	// res->e aufraeumen !!!!
3802	res->next=p;
3803	}
3804	return TRUE;
3805	}
3806	}
3807	return FALSE;
3808	}
3809	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
3810	{
3811	sleftv t;
3812	sleftv ut;
3813	leftv p=NULL;
3814	intvec iv=(intvec )v->Data();
3815	int l;
3816	BOOLEAN nok;
3817
3818	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3819	{
3820	WerrorS("cannot build expression lists from unnamed objects");
3821	return TRUE;
3822	}
3823	memcpy(&ut,u,sizeof(ut));
3824	memset(&t,0,sizeof(t));
3825	t.rtyp=INT_CMD;
3826	for (l=0;l< iv->length(); l++)
3827	{
3828	t.data=(char )((iv)[l]);
3829	if (p==NULL)
3830	{
3831	p=res;
3832	}
3833	else
3834	{
3835	p->next=(leftv)Alloc0SizeOf(sleftv);
3836	p=p->next;
3837	}
3838	memcpy(u,&ut,sizeof(ut));
3839	if (u->Typ() == MATRIX_CMD)
3840	nok=jjBRACK_Ma(p,u,&t,w);
3841	else /* INTMAT_CMD */
3842	nok=jjBRACK_Im(p,u,&t,w);
3843	if (nok)
3844	{
3845	while (res->next!=NULL)
3846	{
3847	p=res->next->next;
3848	FreeSizeOf((ADDRESS)res->next,sleftv);
3849	// res->e aufraeumen !!
3850	res->next=p;
3851	}
3852	return TRUE;
3853	}
3854	}
3855	return FALSE;
3856	}
3857	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
3858	{
3859	sleftv t1,t2,ut;
3860	leftv p=NULL;
3861	intvec vv=(intvec )v->Data();
3862	intvec wv=(intvec )w->Data();
3863	int vl;
3864	int wl;
3865	BOOLEAN nok;
3866
3867	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
3868	{
3869	WerrorS("cannot build expression lists from unnamed objects");
3870	return TRUE;
3871	}
3872	memcpy(&ut,u,sizeof(ut));
3873	memset(&t1,0,sizeof(sleftv));
3874	memset(&t2,0,sizeof(sleftv));
3875	t1.rtyp=INT_CMD;
3876	t2.rtyp=INT_CMD;
3877	for (vl=0;vl< vv->length(); vl++)
3878	{
3879	t1.data=(char )((vv)[vl]);
3880	for (wl=0;wl< wv->length(); wl++)
3881	{
3882	t2.data=(char )((wv)[wl]);
3883	if (p==NULL)
3884	{
3885	p=res;
3886	}
3887	else
3888	{
3889	p->next=(leftv)Alloc0SizeOf(sleftv);
3890	p=p->next;
3891	}
3892	memcpy(u,&ut,sizeof(ut));
3893	if (u->Typ() == MATRIX_CMD)
3894	nok=jjBRACK_Ma(p,u,&t1,&t2);
3895	else /* INTMAT_CMD */
3896	nok=jjBRACK_Im(p,u,&t1,&t2);
3897	if (nok)
3898	{
3899	res->CleanUp();
3900	return TRUE;
3901	}
3902	}
3903	}
3904	return FALSE;
3905	}
3906	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
3907	{
3908	v->next=(leftv)AllocSizeOf(sleftv);
3909	memcpy(v->next,w,sizeof(sleftv));
3910	BOOLEAN r=iiExprArith2(res,u,'(',v);
3911	v->rtyp=0; v->data=NULL;
3912	w->rtyp=0; w->data=NULL;
3913	return r;
3914	}
3915	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
3916	{
3917	u->next=(leftv)AllocSizeOf(sleftv);
3918	memcpy(u->next,v,sizeof(sleftv));
3919	u->next->next=(leftv)AllocSizeOf(sleftv);
3920	memcpy(u->next->next,w,sizeof(sleftv));
3921	BOOLEAN r=iiExprArithM(res,u,iiOp);
3922	v->rtyp=0; v->data=NULL; // iiExprArithM did the CleanUp
3923	w->rtyp=0; w->data=NULL;
3924	return r;
3925	}
3926	static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
3927	{
3928	lists l=smCallNewBareiss((ideal)u->Data(),(int)v->Data(),(int)w->Data());
3929	res->data = (char *)l;
3930	return FALSE;
3931	}
3932	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
3933	{
3934	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
3935	{
3936	WerrorS("3rd argument must be a name of a matrix");
3937	return TRUE;
3938	}
3939	ideal i=(ideal)u->Data();
3940	int rank=(int)i->rank;
3941	BOOLEAN r=jjCOEFFS_Id(res,u,v);
3942	if (r) return TRUE;
3943	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3944	return FALSE;
3945	}
3946	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
3947	{
3948	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
3949	(ideal)(v->Data()),(poly)(w->Data()));
3950	return FALSE;
3951	}
3952	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
3953	{
3954	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
3955	{
3956	WerrorS("3rd argument must be a name of a matrix");
3957	return TRUE;
3958	}
3959	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3960	poly p=(poly)u->CopyD(POLY_CMD);
3961	ideal i=idInit(1,1);
3962	i->m[0]=p;
3963	sleftv t;
3964	memset(&t,0,sizeof(t));
3965	t.data=(char *)i;
3966	t.rtyp=IDEAL_CMD;
3967	int rank=1;
3968	if (u->Typ()==VECTOR_CMD)
3969	{
3970	i->rank=rank=pMaxComp(p);
3971	t.rtyp=MODUL_CMD;
3972	}
3973	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
3974	t.CleanUp();
3975	if (r) return TRUE;
3976	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
3977	return FALSE;
3978	}
3979	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
3980	{
3981	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
3982	(intvec *)w->Data());
3983	setFlag(res,FLAG_STD);
3984	return FALSE;
3985	}
3986	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
3987	{
3988	/*4
3989	* look for the substring what in the string where
3990	* starting at position n
3991	* return the position of the first char of what in where
3992	* or 0
3993	*/
3994	int n=(int)w->Data();
3995	char where=(char )u->Data();
3996	char what=(char )v->Data();
3997	char *found;
3998	if ((1>n)\|\|(n>(int)strlen(where)))
3999	{
4000	Werror("start position %d out of range",n);
4001	return TRUE;
4002	}
4003	found = strchr(where+n-1,*what);
4004	if (*(what+1)!='\0')
4005	{
4006	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
4007	{
4008	found=strchr(found+1,*what);
4009	}
4010	}
4011	if (found != NULL)
4012	{
4013	res->data=(char *)((found-where)+1);
4014	}
4015	return FALSE;
4016	}
4017	static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
4018	{
4019	assumeStdFlag(u);
4020	intvec module_w=(intvec )atGet(u,"isHomog");
4021	intvec wdegree=(intvec)w->Data();
4022	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
4023	switch((int)v->Data())
4024	{
4025	case 1:
4026	res->data=(void *)iv;
4027	return FALSE;
4028	case 2:
4029	res->data=(void *)hSecondSeries(iv);
4030	delete iv;
4031	return FALSE;
4032	}
4033	WerrorS(feNotImplemented);
4034	delete iv;
4035	return TRUE;
4036	}
4037	static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
4038	{
4039	intvec* im= NewIntvec3((int)v->Data(),(int)w->Data(), 0);
4040	intvec* arg = (intvec*) u->Data();
4041	int i, n = min(im->cols()im->rows(), arg->cols()arg->rows());
4042
4043	for (i=0; i<n; i++)
4044	{
4045	(im)[i] = (arg)[i];
4046	}
4047
4048	res->data = (char *)im;
4049	return FALSE;
4050	}
4051	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
4052	{
4053	short iw=iv2array((intvec )w->Data());
4054	res->data = (char *)pJetW((poly)u->Data(),(int)v->Data(),iw);
4055	Free((ADDRESS)iw,(pVariables+1)*sizeof(short));
4056	return FALSE;
4057	}
4058	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
4059	{
4060	res->data = (char *)idJetW((ideal)u->Data(),(int)v->Data(),
4061	(intvec *)w->Data());
4062	return FALSE;
4063	}
4064	static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
4065	{
4066	assumeStdFlag(w);
4067	res->data = (char *)idMinors(
4068	(matrix)u->Data(),(int)v->Data(),(ideal)w->Data());
4069	return FALSE;
4070	}
4071	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
4072	{
4073	idhdl h;
4074	ring rr;
4075	map mapping;
4076
4077	if ((v->name==NULL) \|\| (w->name==NULL))
4078	{
4079	WerrorS("2nd/3rd arguments must have names");
4080	return TRUE;
4081	}
4082	rr=(ring)u->Data();
4083	const char *ring_name=u->Name();
4084	if ((h=rr->idroot->get(v->name,myynest))!=NULL)
4085	{
4086	if (h->typ==MAP_CMD)
4087	{
4088	mapping=IDMAP(h);
4089	idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
4090	if ((preim_ring==NULL)
4091	\|\| (IDRING(preim_ring)!=currRing))
4092	{
4093	Werror("preimage ring `%s` is not the basering",mapping->preimage);
4094	return TRUE;
4095	}
4096	}
4097	else if (h->typ==IDEAL_CMD)
4098	{
4099	mapping=IDMAP(h);
4100	}
4101	else
4102	{
4103	Werror("`%s` is no map nor ideal",IDID(h));
4104	return TRUE;
4105	}
4106	}
4107	else
4108	{
4109	Werror("`%s` is not defined in `%s`",v->name,ring_name);
4110	return TRUE;
4111	}
4112	if ((h=rr->idroot->get(w->name,myynest))!=NULL)
4113	{
4114	if (h->typ==IDEAL_CMD)
4115	{
4116	res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
4117	}
4118	else
4119	{
4120	Werror("`%s` is no ideal",IDID(h));
4121	return TRUE;
4122	}
4123	}
4124	else
4125	{
4126	Werror("`%s` is not defined in `%s`",w->name,ring_name);
4127	return TRUE;
4128	}
4129	return FALSE;
4130	}
4131	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
4132	{
4133	int di, k;
4134	int i=(int)u->Data();
4135	int r=(int)v->Data();
4136	int c=(int)w->Data();
4137	intvec *iv = NewIntvec3(r, c, 0);
4138	if (iv->rows()==0)
4139	{
4140	delete iv;
4141	return TRUE;
4142	}
4143	if (i!=0)
4144	{
4145	if (i<0) i = -i;
4146	di = 2 * i + 1;
4147	for (k=0; k<iv->length(); k++)
4148	{
4149	#ifdef buildin_rand
4150	(*iv)[k] = ((siRand() % di) - i);
4151	#else
4152	(*iv)[k] = ((rand() % di) - i);
4153	#endif
4154	}
4155	}
4156	res->data = (char *)iv;
4157	return FALSE;
4158	}
4159	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
4160	int &ringvar, poly &monomexpr)
4161	{
4162	monomexpr=(poly)w->Data();
4163	if (pLength(monomexpr)>1)
4164	{
4165	Werror("`%s` substitutes a ringvar only by a term",
4166	Tok2Cmdname(SUBST_CMD));
4167	return TRUE;
4168	}
4169	if (!(ringvar=pVar((poly)v->Data())))
4170	{
4171	WerrorS("ringvar expected");
4172	return TRUE;
4173	}
4174	return FALSE;
4175	}
4176	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
4177	{
4178	int ringvar;
4179	poly monomexpr;
4180	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4181	if (nok) return TRUE;
4182	res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
4183	return FALSE;
4184	}
4185	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
4186	{
4187	int ringvar;
4188	poly monomexpr;
4189	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
4190	if (nok) return TRUE;
4191	res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
4192	return FALSE;
4193	}
4194	// we do not want to have jjSUBST_Id_X inlined:
4195	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
4196	int input_type);
4197	static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
4198	{
4199	return jjSUBST_Id_X(res,u,v,w,INT_CMD);
4200	}
4201	static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
4202	{
4203	return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
4204	}
4205	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
4206	{
4207	sleftv tmp;
4208	memset(&tmp,0,sizeof(tmp));
4209	// do not check the result, conversion form int/number to poly works always
4210	iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
4211	BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
4212	tmp.CleanUp();
4213	return b;
4214	}
4215	static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
4216	{
4217	matrix m=mpNew((int)v->Data(),(int)w->Data());
4218	ideal I=(ideal)u->CopyD(IDEAL_CMD);
4219	int i=min(IDELEMS(I),(int)v->Data()*(int)w->Data());
4220	//for(i=i-1;i>=0;i--)
4221	//{
4222	// m->m[i]=I->m[i];
4223	// I->m[i]=NULL;
4224	//}
4225	memcpy4(m->m,I->m,i*sizeof(poly));
4226	memset(I->m,0,i*sizeof(poly));
4227	idDelete(&I);
4228	res->data = (char *)m;
4229	return FALSE;
4230	}
4231	static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
4232	{
4233	res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
4234	(int)v->Data(),(int)w->Data());
4235	return FALSE;
4236	}
4237	static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
4238	{
4239	matrix m=mpNew((int)v->Data(),(int)w->Data());
4240	matrix I=(matrix)u->CopyD(MATRIX_CMD);
4241	int r=min(MATROWS(I),(int)v->Data());
4242	int c=min(MATCOLS(I),(int)w->Data());
4243	int i,j;
4244	for(i=r;i>0;i--)
4245	{
4246	for(j=c;j>0;j--)
4247	{
4248	MATELEM(m,i,j)=MATELEM(I,i,j);
4249	MATELEM(I,i,j)=NULL;
4250	}
4251	}
4252	idDelete((ideal *)&I);
4253	res->data = (char *)m;
4254	return FALSE;
4255	}
4256	static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
4257	{
4258	if (w->rtyp!=IDHDL) return TRUE;
4259	BITSET save_test=test;
4260	int ul= IDELEMS((ideal)u->Data());
4261	int vl= IDELEMS((ideal)v->Data());
4262	ideal m
4263	= idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
4264	FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
4265	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
4266	test=save_test;
4267	return FALSE;
4268	}
4269	static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
4270	{
4271	assumeStdFlag(v);
4272	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
4273	0,(int)w->Data());
4274	return FALSE;
4275	}
4276	static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
4277	{
4278	assumeStdFlag(v);
4279	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
4280	0,(int)w->Data());
4281	return FALSE;
4282	}
4283	#ifdef OLD_RES
4284	static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
4285	{
4286	int maxl=(int)v->Data();
4287	int l=0;
4288	resolvente r;
4289	intvec **weights=NULL;
4290	int wmaxl=maxl;
4291	maxl--;
4292	if ((maxl==-1) && (iiOp!=MRES_CMD))
4293	maxl = pVariables-1;
4294	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
4295	{
4296	intvec * iv=(intvec*)atGet(u,"isHomog");
4297	if (iv!=NULL)
4298	{
4299	weights = (intvec**)Alloc0SizeOf(void_ptr);
4300	weights[0] = ivCopy(iv);
4301	l=1;
4302	}
4303	r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
4304	}
4305	else
4306	r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
4307	if (r==NULL) return TRUE;
4308	int t3=u->Typ();
4309	iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
4310	return FALSE;
4311	return TRUE;
4312	}
4313	#endif
4314	static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
4315	{
4316	res->data=(void *)rInit(u,v,w);
4317	return (res->data==NULL);
4318	}
4319	static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
4320	{
4321	int yes;
4322	jjSTATUS2(res, u, v);
4323	yes = (strcmp((char ) res->data, (char ) w->Data()) == 0);
4324	FreeL((ADDRESS) res->data);
4325	res->data = (void *) yes;
4326	return FALSE;
4327	}
4328	static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
4329	{
4330	ideal result;
4331	intvec ww=(intvec )atGet(u,"isHomog");
4332	tHomog hom=testHomog;
4333	if (ww!=NULL)
4334	{
4335	ww=ivCopy(ww);
4336	hom=isHomog;
4337	}
4338	result=kStd((ideal)(u->Data()),
4339	currQuotient,
4340	hom,
4341	&ww, // module weights
4342	(intvec *)v->Data(), // hilbert series
4343	0,0, // syzComp, newIdeal
4344	(intvec *)w->Data()); // weights of vars
4345	idSkipZeroes(result);
4346	res->data = (char *)result;
4347	setFlag(res,FLAG_STD);
4348	if (ww!=NULL) atSet(res,mstrdup("isHomog"),ww,INTVEC_CMD);
4349	return FALSE;
4350	}
4351
4352	/=================== operations with 3 args.: table =================/
4353	struct sValCmd3 dArith3[]=
4354	{
4355	// operations:
4356	// proc cmd res arg1 arg2 arg3
4357	{jjBRACK_S, '[', STRING_CMD, STRING_CMD, INT_CMD, INT_CMD }
4358	,{jjBRACK_Im, '[', INT_CMD, INTMAT_CMD, INT_CMD, INT_CMD }
4359	,{jjBRACK_Ma_I_IV, '[', INT_CMD, INTMAT_CMD, INT_CMD, INTVEC_CMD }
4360	,{jjBRACK_Ma_IV_I, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INT_CMD }
4361	,{jjBRACK_Ma_IV_IV, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INTVEC_CMD }
4362	,{jjBRACK_Ma, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INT_CMD }
4363	,{jjBRACK_Ma_I_IV, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INTVEC_CMD }
4364	,{jjBRACK_Ma_IV_I, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INT_CMD }
4365	,{jjBRACK_Ma_IV_IV, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INTVEC_CMD }
4366	,{jjPROC3, '(', ANY_TYPE, PROC_CMD, DEF_CMD, DEF_CMD }
4367	,{atATTRIB3, ATTRIB_CMD, NONE, IDHDL, STRING_CMD, DEF_CMD }
4368	,{jjBAREISS3, BAREISS_CMD,LIST_CMD, MODUL_CMD, INT_CMD, INT_CMD }
4369	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, MATRIX_CMD }
4370	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD, MATRIX_CMD }
4371	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, MATRIX_CMD }
4372	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, MATRIX_CMD }
4373	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD }
4374	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD }
4375	,{jjELIMIN_HILB, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD }
4376	,{jjFIND3, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, INT_CMD }
4377	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD }
4378	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD }
4379	,{jjCALL3MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
4380	//,{jjCALL3MANY, INTERSECT_CMD, NONE, DEF_CMD, DEF_CMD, DEF_CMD }
4381	,{lInsert3, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, INT_CMD }
4382	,{jjINTMAT3, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD, INT_CMD }
4383	,{jjCALL3MANY, INTVEC_CMD, INTVEC_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
4384	,{jjJET_P_IV, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INTVEC_CMD }
4385	,{jjJET_ID_IV, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD }
4386	,{jjJET_P_IV, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, INTVEC_CMD }
4387	,{jjJET_ID_IV, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD }
4388	,{mpKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, IDEAL_CMD }
4389	,{jjCALL3MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
4390	,{jjMATRIX_Id, MATRIX_CMD, MATRIX_CMD, IDEAL_CMD, INT_CMD, INT_CMD }
4391	,{jjMATRIX_Mo, MATRIX_CMD, MATRIX_CMD, MODUL_CMD, INT_CMD, INT_CMD }
4392	,{jjMATRIX_Ma, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, INT_CMD }
4393	,{jjMINOR3, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD}
4394	,{jjCALL3MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
4395	#ifdef OLD_RES
4396	,{jjRES3, MRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
4397	,{jjRES3, MRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
4398	#endif
4399	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD }
4400	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD }
4401	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ANY_TYPE }
4402	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE, ANY_TYPE }
4403	,{jjRANDOM_Im, RANDOM_CMD, INTMAT_CMD, INT_CMD, INT_CMD, INT_CMD }
4404	,{jjREDUCE3_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, INT_CMD }
4405	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, INT_CMD }
4406	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, INT_CMD }
4407	,{jjREDUCE3_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD }
4408	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, INT_CMD }
4409	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD }
4410	#ifdef OLD_RES
4411	,{jjRES3, RES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
4412	,{jjRES3, RES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
4413	#endif
4414	#ifdef HAVE_FACTORY
4415	,{jjRESULTANT, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD }
4416	#else
4417	,{jjWRONG3, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD }
4418	#endif
4419	,{jjRING3, RING_CMD, RING_CMD, DEF_CMD, DEF_CMD, DEF_CMD }
4420	#ifdef OLD_RES
4421	,{jjRES3, SRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE }
4422	,{jjRES3, SRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE }
4423	#endif
4424	,{jjSTATUS3, STATUS_CMD, INT_CMD, LINK_CMD, STRING_CMD, STRING_CMD}
4425	,{jjSTD_HILB_W, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD, INTVEC_CMD}
4426	,{jjSTD_HILB_W, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD, INTVEC_CMD}
4427	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD }
4428	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD }
4429	,{jjSUBST_P, SUBST_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, POLY_CMD }
4430	,{jjSUBST_Id, SUBST_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, POLY_CMD }
4431	,{jjSUBST_Id, SUBST_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, POLY_CMD }
4432	,{jjSUBST_Id, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD }
4433	,{jjSUBST_Id_I, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, INT_CMD }
4434	,{jjSUBST_Id_N, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, NUMBER_CMD }
4435	,{jjCALL3MANY, SYSTEM_CMD, NONE, STRING_CMD, DEF_CMD, DEF_CMD }
4436	,{nuLagSolve, LAGSOLVE_CMD,LIST_CMD, POLY_CMD, INT_CMD, INT_CMD }
4437	,{nuVanderSys, VANDER_CMD, POLY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD }
4438	,{NULL, 0, 0, 0, 0, 0 }
4439	};
4440	/=================== operations with many arg.: static proc =================/
4441	static BOOLEAN jjBREAK0(leftv res, leftv v)
4442	{
4443	sdb_show_bp();
4444	return FALSE;
4445	}
4446	static BOOLEAN jjBREAK1(leftv res, leftv v)
4447	{
4448	if(v->Typ()==PROC_CMD)
4449	{
4450	int lineno=0;
4451	if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
4452	{
4453	lineno=(int)v->next->Data();
4454	}
4455	return sdb_set_breakpoint(v->Name(),lineno);
4456	}
4457	return TRUE;
4458	}
4459	static BOOLEAN jjCALL1ARG(leftv res, leftv v)
4460	{
4461	return iiExprArith1(res,v,iiOp);
4462	}
4463	static BOOLEAN jjCALL2ARG(leftv res, leftv u)
4464	{
4465	leftv v=u->next;
4466	u->next=NULL;
4467	BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
4468	u->next=v;
4469	return b;
4470	}
4471	static BOOLEAN jjCALL3ARG(leftv res, leftv u)
4472	{
4473	leftv v = u->next;
4474	leftv w = v->next;
4475	u->next = NULL;
4476	v->next = NULL;
4477	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4478	u->next = v;
4479	v->next = w;
4480	return b;
4481	}
4482
4483	static BOOLEAN jjCOEF_M(leftv res, leftv v)
4484	{
4485	if((v->Typ() != VECTOR_CMD)
4486	\|\| (v->next->Typ() != POLY_CMD)
4487	\|\| (v->next->next->Typ() != MATRIX_CMD)
4488	\|\| (v->next->next->next->Typ() != MATRIX_CMD))
4489	return TRUE;
4490	if (v->next->next->rtyp!=IDHDL) return TRUE;
4491	idhdl c=(idhdl)v->next->next->data;
4492	if (v->next->next->next->rtyp!=IDHDL) return TRUE;
4493	idhdl m=(idhdl)v->next->next->next->data;
4494	idDelete((ideal *)&(c->data.uideal));
4495	idDelete((ideal *)&(m->data.uideal));
4496	mpCoef2((poly)v->Data(),(poly)v->next->Data(),
4497	(matrix )&(c->data.umatrix),(matrix )&(m->data.umatrix));
4498	return FALSE;
4499	}
4500	static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
4501	{
4502	int s=1;
4503	leftv h=v;
4504	if (h!=NULL) s=exprlist_length(h);
4505	ideal id=idInit(s,1);
4506	int rank=1;
4507	int i=0;
4508	poly p;
4509	while (h!=NULL)
4510	{
4511	switch(h->Typ())
4512	{
4513	case POLY_CMD:
4514	{
4515	p=(poly)h->CopyD(POLY_CMD);
4516	break;
4517	}
4518	case INT_CMD:
4519	{
4520	number n=nInit((int)h->Data());
4521	if (!nIsZero(n))
4522	{
4523	p=pOne();
4524	pSetCoeff(p,n);
4525	}
4526	else
4527	{
4528	p=NULL;
4529	nDelete(&n);
4530	}
4531	break;
4532	}
4533	case NUMBER_CMD:
4534	{
4535	number n=(number)h->CopyD(NUMBER_CMD);
4536	if (!nIsZero(n))
4537	{
4538	p=pOne();
4539	pSetCoeff(p,n);
4540	}
4541	else
4542	{
4543	p=NULL;
4544	nDelete(&n);
4545	}
4546	break;
4547	}
4548	case VECTOR_CMD:
4549	{
4550	p=(poly)h->CopyD(VECTOR_CMD);
4551	if (iiOp!=MODUL_CMD)
4552	{
4553	idDelete(&id);
4554	pDelete(&p);
4555	return TRUE;
4556	}
4557	rank=max(rank,pMaxComp(p));
4558	break;
4559	}
4560	default:
4561	{
4562	idDelete(&id);
4563	return TRUE;
4564	}
4565	}
4566	if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
4567	{
4568	pSetCompP(p,1);
4569	}
4570	id->m[i]=p;
4571	i++;
4572	h=h->next;
4573	}
4574	id->rank=rank;
4575	res->data=(char *)id;
4576	return FALSE;
4577	}
4578	static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
4579	{
4580	leftv h=v;
4581	int l=v->listLength();
4582	resolvente r=(resolvente)Alloc0(l*sizeof(ideal));
4583	BOOLEAN copied=(BOOLEAN )Alloc0(l*sizeof(BOOLEAN));
4584	int t=0;
4585	// try to convert to IDEAL_CMD
4586	while (h!=NULL)
4587	{
4588	if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
4589	{
4590	t=IDEAL_CMD;
4591	}
4592	else break;
4593	h=h->next;
4594	}
4595	// if failure, try MODUL_CMD
4596	if (t==0)
4597	{
4598	h=v;
4599	while (h!=NULL)
4600	{
4601	if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
4602	{
4603	t=MODUL_CMD;
4604	}
4605	else break;
4606	h=h->next;
4607	}
4608	}
4609	// check for success in converting
4610	if (t==0)
4611	{
4612	WerrorS("cannot convert to ideal or module");
4613	return TRUE;
4614	}
4615	// call idMultSect
4616	h=v;
4617	int i=0;
4618	sleftv tmp;
4619	while (h!=NULL)
4620	{
4621	if (h->Typ()==t)
4622	{
4623	r[i]=(ideal)h->Data(); /no copy/
4624	h=h->next;
4625	}
4626	else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
4627	{
4628	Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4629	Free((ADDRESS)r,l*sizeof(ideal));
4630	Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
4631	return TRUE;
4632	}
4633	else
4634	{
4635	r[i]=(ideal)tmp.Data(); /now it's a copy/
4636	copied[i]=TRUE;
4637	h=tmp.next;
4638	}
4639	i++;
4640	}
4641	res->rtyp=t;
4642	res->data=(char *)idMultSect(r,i);
4643	while(i>0)
4644	{
4645	i--;
4646	if (copied[i]) idDelete(&(r[i]));
4647	}
4648	Free((ADDRESS)copied,l*sizeof(BOOLEAN));
4649	Free((ADDRESS)r,l*sizeof(ideal));
4650	return FALSE;
4651	}
4652	static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
4653	{
4654	int i=0;
4655	leftv h=v;
4656	if (h!=NULL) i=exprlist_length(h);
4657	intvec *iv=NewIntvec1(i);
4658	i=0;
4659	while (h!=NULL)
4660	{
4661	if(h->Typ()==INT_CMD)
4662	{
4663	(*iv)[i]=(int)h->Data();
4664	}
4665	else
4666	{
4667	delete iv;
4668	return TRUE;
4669	}
4670	i++;
4671	h=h->next;
4672	}
4673	res->data=(char *)iv;
4674	return FALSE;
4675	}
4676	static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
4677	{
4678	if ((yyInRingConstruction)
4679	&& ((strcmp(u->Name(),"real")==0) \|\| (strcmp(u->Name(),"complex")==0)))
4680	{
4681	memcpy(res,u,sizeof(sleftv));
4682	memset(u,0,sizeof(sleftv));
4683	return FALSE;
4684	}
4685	leftv v=u->next;
4686	BOOLEAN b;
4687	if(v==NULL)
4688	b=iiExprArith1(res,u,iiOp);
4689	else
4690	{
4691	u->next=NULL;
4692	b=iiExprArith2(res,u,iiOp,v);
4693	u->next=v;
4694	}
4695	return b;
4696	}
4697	static BOOLEAN jjLIST_PL(leftv res, leftv v)
4698	{
4699	int sl=0;
4700	if (v!=NULL) sl = v->listLength();
4701	lists L;
4702	if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
4703	{
4704	L=syConvRes((syStrategy)v->Data());
4705	}
4706	else
4707	{
4708	L=(lists)AllocSizeOf(slists);
4709	leftv h=NULL;
4710	int i;
4711	int rt;
4712
4713	L->Init(sl);
4714	for (i=0;i<sl;i++)
4715	{
4716	if (h!=NULL) { /* e.g. not in the first step:
4717	* h is the pointer to the old sleftv,
4718	* v is the pointer to the next sleftv
4719	* (in this moment) */
4720	h->next=v;
4721	}
4722	h=v;
4723	v=v->next;
4724	h->next=NULL;
4725	rt=h->Typ();
4726	if (rt==0)
4727	{
4728	L->Clean();
4729	Werror("`%s` is undefined",h->Fullname());
4730	return TRUE;
4731	}
4732	if ((rt==RING_CMD)\|\|(rt==QRING_CMD))
4733	{
4734	L->m[i].rtyp=rt;
4735	L->m[i].data=h->Data();
4736	((ring)L->m[i].data)->ref++;
4737	}
4738	else
4739	L->m[i].Copy(h);
4740	}
4741	}
4742	res->data=(char *)L;
4743	return FALSE;
4744	}
4745	static BOOLEAN jjNAMES0(leftv res, leftv v)
4746	{
4747	res->data=(void *)ipNameList(IDROOT);
4748	return FALSE;
4749	}
4750	static BOOLEAN jjOPTION_PL(leftv res, leftv v)
4751	{
4752	if(v==NULL)
4753	{
4754	res->data=(char *)showOption();
4755	return FALSE;
4756	}
4757	res->rtyp=NONE;
4758	return setOption(res,v);
4759	}
4760	static BOOLEAN jjRESERVED0(leftv res, leftv v)
4761	{
4762	int i=1;
4763	loop
4764	{
4765	Print("%-20s",cmds[i].name);
4766	i++;
4767	if(cmds[i].name==NULL)
4768	break;
4769	if ((i%3)==1) PrintLn();
4770	}
4771	PrintLn();
4772	return FALSE;
4773	}
4774	static BOOLEAN jjSTRING_PL(leftv res, leftv v)
4775	{
4776	if (v == NULL)
4777	{
4778	res->data = mstrdup("");
4779	return FALSE;
4780	}
4781	int n = v->listLength();
4782	if (n == 1)
4783	{
4784	res->data = v->String();
4785	return FALSE;
4786	}
4787
4788	char slist = (char) Alloc(nsizeof(char));
4789	int i, j;
4790
4791	for (i=0, j=0; i<n; i++, v = v ->next)
4792	{
4793	slist[i] = v->String();
4794	assume(slist[i] != NULL);
4795	j+=strlen(slist[i]);
4796	}
4797	char* s = (char) AllocL((j+1)sizeof(char));
4798	*s='\0';
4799	for (i=0;i<n;i++)
4800	{
4801	strcat(s, slist[i]);
4802	FreeL(slist[i]);
4803	}
4804	Free(slist, nsizeof(char));
4805	res->data = s;
4806	return FALSE;
4807	}
4808	static BOOLEAN jjTEST(leftv res, leftv v)
4809	{
4810	do
4811	{
4812	if (v->Typ()!=INT_CMD)
4813	return TRUE;
4814	test_cmd((int)v->Data());
4815	v=v->next;
4816	}
4817	while (v!=NULL);
4818	return FALSE;
4819	}
4820
4821	#ifndef __MWERKS__
4822	static BOOLEAN jjSTATUS_M(leftv res, leftv v)
4823	{
4824	if ((v->Typ() != LINK_CMD) \|\|
4825	(v->next->Typ() != STRING_CMD) \|\|
4826	(v->next->next->Typ() != STRING_CMD) \|\|
4827	(v->next->next->next->Typ() != INT_CMD))
4828	return TRUE;
4829	jjSTATUS3(res, v, v->next, v->next->next);
4830	#if defined(HAVE_USLEEP)
4831	if (((int) res->data) == 0)
4832	{
4833	int i_s = (int) v->next->next->next->Data();
4834	if (i_s > 0)
4835	{
4836	usleep((int) v->next->next->next->Data());
4837	jjSTATUS3(res, v, v->next, v->next->next);
4838	}
4839	}
4840	#elif defined(HAVE_SLEEP)
4841	if (((int) res->data) == 0)
4842	{
4843	int i_s = (int) v->next->next->next->Data();
4844	if (i_s > 0)
4845	{
4846	sleep((is - 1)/1000000 + 1);
4847	jjSTATUS3(res, v, v->next, v->next->next);
4848	}
4849	}
4850	#endif
4851	return FALSE;
4852	}
4853	#endif
4854	static BOOLEAN jjSUBST_M(leftv res, leftv u)
4855	{
4856	leftv v = u->next;
4857	leftv w = v->next;
4858	leftv rest = w->next;
4859
4860	u->next = NULL;
4861	v->next = NULL;
4862	w->next = NULL;
4863	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
4864	if ((rest!=NULL) && (!b))
4865	{
4866	sleftv tmp_res;
4867	leftv tmp_next=res->next;
4868	res->next=rest;
4869	memset(&tmp_res,0,sizeof(tmp_res));
4870	b = iiExprArithM(&tmp_res,res,iiOp);
4871	memcpy(res,&tmp_res,sizeof(tmp_res));
4872	res->next=tmp_next;
4873	}
4874	u->next = v;
4875	v->next = w;
4876	// rest was w->next, but is already cleaned
4877	return b;
4878	}
4879
4880	#ifdef HAVE_NAMESPACES
4881	static BOOLEAN jjIMPORTFROM(leftv res, leftv v);
4882
4883	static BOOLEAN jjEXPORTTO(leftv res, leftv v)
4884	{
4885	BOOLEAN nok=TRUE;
4886	leftv u=v;
4887	if(u->rtyp==NSHDL)
4888	{
4889	namehdl ns = (namehdl)(u->data);
4890	idhdl h = namespaceroot->root->get(ns->name, 0, TRUE);
4891	//Print("Export to '%s', lev %d\n", ns->name, ns->myynest);
4892	while(v->next!=NULL)
4893	{
4894	nok = iiInternalExport(v->next, ns->myynest, h);
4895	if(nok) { return nok; }
4896
4897	v = v->next;
4898	}
4899	return FALSE;
4900	}
4901	if(u->Typ()==PACKAGE_CMD)
4902	{
4903	//PrintS("export to package\n");
4904	while(v->next!=NULL)
4905	{
4906	nok = iiInternalExport(v->next, 0, u->data);
4907	if(nok) return nok;
4908	v = v->next;
4909	}
4910	return FALSE;
4911	}
4912	return TRUE;
4913	}
4914	#endif /* HAVE_NAMESPACES */
4915	#ifdef HAVE_NAMESPACES
4916	static BOOLEAN jjIMPORTFROM(leftv res, leftv v)
4917	{
4918	BOOLEAN nok=FALSE;
4919	PrintS("jjIMPORT_FROM()\n");
4920	if(v->rtyp==NSHDL)
4921	{
4922	PrintS("Import from toplevel\n");
4923	//While-schleife!!!
4924	return FALSE;
4925	}
4926	if(v->Typ()==PACKAGE_CMD)
4927	{
4928	Print("Import from package %s\n", v->name);
4929	while(v->next!=NULL)
4930	{
4931	//nok = iiInternalImport(v->next, 0, v->data);
4932	if(nok) return nok;
4933	v = v->next;
4934	}
4935	return FALSE;
4936	}
4937	return TRUE;
4938	}
4939	#endif
4940	#ifdef HAVE_NAMESPACES
4941	static BOOLEAN jjUNLOAD(leftv res, leftv v)
4942	{
4943	if(v->Typ()==PACKAGE_CMD)
4944	{
4945	char *typ;
4946	idhdl h = (idhdl)v->data;
4947	package d=(package)v->Data();
4948	switch (d->language)
4949	{
4950	case LANG_C:
4951	typ="object";
4952	break;
4953	case LANG_SINGULAR:
4954	case LANG_NONE:
4955	default:
4956	killhdl(h);
4957	}
4958	return FALSE;
4959	}
4960	return TRUE;
4961	}
4962	#endif
4963	/=================== operations with many arg.: table =================/
4964	/* number_of_args: -1: any, -2: any >0, .. */
4965	struct sValCmdM dArithM[]=
4966	{
4967	// operations:
4968	// proc cmd res number_of_args
4969	{jjKLAMMER_PL, '(', ANY_TYPE, -2 }
4970	,{jjBREAK0, BREAKPOINT_CMD, NONE, 0 }
4971	,{jjBREAK1, BREAKPOINT_CMD, NONE, -2 }
4972	,{jjCALL2ARG, COEF_CMD, MATRIX_CMD, 2 }
4973	,{jjCOEF_M, COEF_CMD, NONE, 4 }
4974	,{jjDBPRINT, DBPRINT_CMD, NONE, -2 }
4975	,{jjCALL1ARG, IDEAL_CMD, IDEAL_CMD, 1 }
4976	,{jjIDEAL_PL, IDEAL_CMD, IDEAL_CMD, -1 }
4977	,{jjCALL2ARG, INTERSECT_CMD, IDEAL_CMD, 2 }
4978	,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD, -2 }
4979	,{jjCALL1ARG, INTVEC_CMD, INTVEC_CMD, 1 }
4980	,{jjINTVEC_PL, INTVEC_CMD, INTVEC_CMD, -1 }
4981	,{jjLIST_PL, LIST_CMD, LIST_CMD, -1 }
4982	,{jjCALL1ARG, MODUL_CMD, MODUL_CMD, 1 }
4983	,{jjIDEAL_PL, MODUL_CMD, MODUL_CMD, -1 }
4984	,{jjCALL1ARG, NAMES_CMD, LIST_CMD, 1 }
4985	,{jjNAMES0, NAMES_CMD, LIST_CMD, 0 }
4986	,{jjOPTION_PL, OPTION_CMD, STRING_CMD/or set by p/,-1 }
4987	,{jjCALL1ARG, RESERVEDNAME_CMD, INT_CMD, 1 }
4988	,{jjRESERVED0, RESERVEDNAME_CMD, NONE, 0 }
4989	,{jjSTRING_PL, STRING_CMD, STRING_CMD, -1 }
4990	,{jjCALL3ARG, SUBST_CMD, NONE/set by p/, 3 }
4991	,{jjSUBST_M, SUBST_CMD, NONE/set by p/, -2 }
4992	,{jjSYSTEM, SYSTEM_CMD, NONE/or set by p/,-2 }
4993	,{jjTEST, TEST_CMD, NONE, -2 }
4994	,{iiWRITE, WRITE_CMD, NONE, -2 }
4995	,{jjCALL2ARG, STATUS_CMD, STRING_CMD, 2 }
4996	,{jjCALL3ARG, STATUS_CMD, INT_CMD, 3 }
4997	#ifndef __MWERKS__
4998	,{jjSTATUS_M, STATUS_CMD, INT_CMD, 4 }
4999	#endif
5000	#ifdef HAVE_NAMESPACES
5001	,{jjIMPORTFROM,IMPORTFROM_CMD, ANY_TYPE, -2 }
5002	,{jjEXPORTTO, EXPORTTO_CMD, NONE, -2 }
5003	,{jjUNLOAD, UNLOAD_CMD, NONE, -2 }
5004	#endif /* HAVE_NAMESPACES */
5005	,{loSimplex, SIMPLEX_CMD, LIST_CMD, 6 }
5006	,{nuUResSolve, URSOLVE_CMD, LIST_CMD, 4 }
5007	,{NULL, 0, 0, 0 }
5008	};
5009	#ifdef MDEBUG
5010	static Subexpr jjDBMakeSub(leftv e,char *f, int l)
5011	#else
5012	static Subexpr jjMakeSub(leftv e)
5013	#endif
5014	{
5015	// assume: e->Typ()==INT_CMD
5016	#ifdef MDEBUG
5017	Subexpr r=(Subexpr)mmDBAllocBlock0(sizeof(*r),f,l);
5018	#else
5019	Subexpr r=(Subexpr)Alloc0SizeOf(sSubexpr);
5020	#endif
5021	r->start =(int)e->Data();
5022	return r;
5023	}
5024
5025	/================ generating tables ============================/
5026	#ifdef GENTABLE
5027	extern struct sValAssign dAssign[];
5028	struct sValCmdTab dArithTab1[]={ {0,0}};
5029	#define JJTAB1LEN 0
5030	struct sValCmdTab dArithTab2[]={ {0,0}};
5031	#define JJTAB2LEN 0
5032	void ttGen1()
5033	{
5034	FILE *outfile = myfopen("iparith.inc","w");
5035	int i,j,l1=0,l2=0;
5036	currRing=(ring)AllocSizeOf(sip_sring);
5037	fprintf(outfile,
5038	"/****************************************\n"
5039	"* Computer Algebra System SINGULAR *\n"
5040	"****************************************/\n\n");
5041	/-------------------------------------------------------------------/
5042	fprintf(outfile,"// syntax table for Singular\n//\n");
5043	fprintf(outfile,"// - search for an exact match of the argument types\n");
5044	fprintf(outfile,"// - otherwise search for the first possibility\n");
5045	fprintf(outfile,"// with converted types of the arguments\n");
5046	fprintf(outfile,"// - otherwise report an error\n//\n");
5047
5048	int op;
5049	i=0;
5050	while ((op=dArith1[i].cmd)!=0)
5051	{
5052	if (dArith1[i].p==jjWRONG)
5053	fprintf(outfile,"// DUMMY ");
5054	char *s = iiTwoOps(op);
5055	fprintf(outfile,"// operation: %s (%s) -> %s\n",
5056	s,
5057	Tok2Cmdname(dArith1[i].arg),
5058	Tok2Cmdname(ABS(dArith1[i].res)));
5059	i++;
5060	}
5061	fprintf(outfile,"/---------------------------------------------/\n");
5062	i=0;
5063	while ((op=dArith2[i].cmd)!=0)
5064	{
5065	if (dArith2[i].p==jjWRONG2)
5066	fprintf(outfile,"// DUMMY ");
5067	char *s = iiTwoOps(op);
5068	fprintf(outfile,"// operation: %s (%s, %s) -> %s\n",
5069	s,
5070	Tok2Cmdname(dArith2[i].arg1),
5071	Tok2Cmdname(dArith2[i].arg2),
5072	Tok2Cmdname(dArith2[i].res));
5073	i++;
5074	}
5075	fprintf(outfile,"/---------------------------------------------/\n");
5076	i=0;
5077	while ((op=dArith3[i].cmd)!=0)
5078	{
5079	char *s = iiTwoOps(op);
5080	if (dArith3[i].p==jjWRONG3)
5081	fprintf(outfile,"// DUMMY ");
5082	fprintf(outfile,"// operation: %s (%s, %s, %s) -> %s\n",
5083	s,
5084	Tok2Cmdname(dArith3[i].arg1),
5085	Tok2Cmdname(dArith3[i].arg2),
5086	Tok2Cmdname(dArith3[i].arg3),
5087	Tok2Cmdname(dArith3[i].res));
5088	i++;
5089	}
5090	fprintf(outfile,"/---------------------------------------------/\n");
5091	i=0;
5092	while ((op=dArithM[i].cmd)!=0)
5093	{
5094	char *s = iiTwoOps(op);
5095	fprintf(outfile,"// operation: %s (...) -> %s",
5096	s,
5097	Tok2Cmdname(dArithM[i].res));
5098	switch(dArithM[i].number_of_args)
5099	{
5100	case -2:
5101	fprintf(outfile," ( number of arguments >0 )\n");
5102	break;
5103	case -1:
5104	fprintf(outfile," ( any number of arguments )\n");
5105	break;
5106	default:
5107	fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
5108	break;
5109	}
5110	i++;
5111	}
5112	fprintf(outfile,"/---------------------------------------------/\n");
5113	i=0;
5114	while ((op=dAssign[i].res)!=0)
5115	{
5116	fprintf(outfile,"// assign: %s = %s\n",
5117	Tok2Cmdname(op/dAssign[i].res/),
5118	Tok2Cmdname(dAssign[i].arg));
5119	i++;
5120	}
5121	/-------------------------------------------------------------------/
5122	fprintf(outfile,"/---------------------------------------------/\n");
5123	for (j=257;j<=MAX_TOK+1;j++)
5124	{
5125	for(i=257;i<=MAX_TOK+1;i++)
5126	{
5127	if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
5128	&& iiTestConvert(i,j))
5129	{
5130	fprintf(outfile,"// convert %s -> %s\n",
5131	Tok2Cmdname(i), Tok2Cmdname(j));
5132	if (j==ANY_TYPE) break;
5133	}
5134	}
5135	}
5136	fprintf(outfile,"/---------------------------------------------/\n");
5137	char ops[]="=><+*/[.^,%(;";
5138	for(i=0;ops[i]!='\0';i++)
5139	fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
5140	for (i=257;i<=MAX_TOK;i++)
5141	{
5142	char *s=iiTwoOps(i);
5143	if (s[0]!='$')
5144	{
5145	fprintf(outfile,"// token %d : %s\n", i, s);
5146	}
5147	}
5148	/-------------------------------------------------------------------/
5149	fprintf(outfile,"/--max. token: %d, gr: %d --/\n",MAX_TOK,UMINUS);
5150	/-------------------------------------------------------------------/
5151	fprintf(outfile,"/---------------------------------------------/\n");
5152	fprintf(outfile,
5153	"struct sValCmdTab dArithTab1[]=\n"
5154	"{\n");
5155	for (j=1;j<=MAX_TOK+1;j++)
5156	{
5157	for(i=0;dArith1[i].cmd!=0;i++)
5158	{
5159	if (dArith1[i].cmd==j)
5160	{
5161	fprintf(outfile," { %d,%d },\n",j,i);
5162	l1++;
5163	break;
5164	}
5165	}
5166	}
5167	fprintf(outfile," { 10000,0 }\n};\n");
5168	fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
5169	/-------------------------------------------------------------------/
5170	fprintf(outfile,
5171	"struct sValCmdTab dArithTab2[]=\n"
5172	"{\n");
5173	for (j=1;j<=MAX_TOK+1;j++)
5174	{
5175	for(i=0;dArith2[i].cmd!=0;i++)
5176	{
5177	if (dArith2[i].cmd==j)
5178	{
5179	fprintf(outfile," { %d,%d },\n",j,i);
5180	l2++;
5181	break;
5182	}
5183	}
5184	}
5185	fprintf(outfile," { 10000,0 }\n};\n");
5186	fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
5187	fclose(outfile);
5188	}
5189	/-------------------------------------------------------------------/
5190	void ttGen2()
5191	{
5192	FILE *outfile = myfopen("iparith.inc","a");
5193	fprintf(outfile,
5194	"/****************************************\n"
5195	"* Computer Algebra System SINGULAR *\n"
5196	"****************************************/\n\n");
5197	/-------------------------------------------------------------------/
5198	fprintf(outfile,"// identifier table for Singular\n//\n");
5199
5200	fprintf(outfile,
5201	"cmdnames cmds[] =\n"
5202	"{ // name-string alias tokval toktype\n"
5203	"{ \"$INVALID$\", 0, -1, 0},\n");
5204	int i=1;
5205	int m=-1;
5206	int id_nr=0;
5207	BOOLEAN f=FALSE;
5208	loop
5209	{
5210	while (cmds[i].tokval!=0)
5211	{
5212	if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
5213	{
5214	if(m==-1)
5215	{
5216	m=i;
5217	f=TRUE;
5218	}
5219	else if(strcmp(cmds[m].name,cmds[i].name)>0)
5220	{
5221	m=i;
5222	f=TRUE;
5223	}
5224	}
5225	i++;
5226	}
5227	if(f)
5228	{
5229	id_nr++;
5230	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
5231	fprintf(outfile," {\"%s\", %*d, %3d, ",cmds[m].name,
5232	20-strlen(cmds[m].name),
5233	cmds[m].alias,
5234	cmds[m].tokval);
5235	switch(cmds[m].toktype)
5236	{
5237	case CMD_1: fprintf(outfile,"CMD_1 },\n"); break;
5238	case CMD_2: fprintf(outfile,"CMD_2 },\n"); break;
5239	case CMD_3: fprintf(outfile,"CMD_3 },\n"); break;
5240	case CMD_12: fprintf(outfile,"CMD_12 },\n"); break;
5241	case CMD_123 : fprintf(outfile,"CMD_123 },\n"); break;
5242	case CMD_23: fprintf(outfile,"CMD_23 },\n"); break;
5243	case CMD_M: fprintf(outfile,"CMD_M },\n"); break;
5244	case SYSVAR: fprintf(outfile,"SYSVAR },\n"); break;
5245	case ROOT_DECL: fprintf(outfile,"ROOT_DECL },\n"); break;
5246	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
5247	case RING_DECL: fprintf(outfile,"RING_DECL },\n"); break;
5248	case NONE: fprintf(outfile,"NONE },\n"); break;
5249	default: if((cmds[m].toktype>' ')
5250	&&(cmds[m].toktype<127))
5251	{
5252	fprintf(outfile,"'%c' },\n",cmds[m].toktype);
5253	}
5254	else
5255	{
5256	fprintf(outfile,"%d },\n",cmds[m].toktype);
5257	}
5258	break;
5259	}
5260	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
5261	cmds[m].name=NULL;
5262	m=-1;
5263	i=1;
5264	f=FALSE;
5265	}
5266	else break;
5267	}
5268	fprintf(outfile,
5269	"/* list of scanner identifiers/only for feread/reservedName */\n");
5270	f=FALSE;
5271	i=1;m=-1;
5272	loop
5273	{
5274	while (cmds[i].tokval!=0)
5275	{
5276	if (cmds[i].name!=NULL)
5277	{
5278	if(m==-1)
5279	{
5280	m=i;
5281	f=TRUE;
5282	}
5283	else if(strcmp(cmds[m].name,cmds[i].name)>0)
5284	{
5285	m=i;
5286	f=TRUE;
5287	}
5288	}
5289	i++;
5290	}
5291	if(f)
5292	{
5293	fprintf(outfile," {\"%s\", %*d, -1, 0 },\n",cmds[m].name,
5294	20-strlen(cmds[m].name),
5295	0/cmds[m].alias/
5296	/-1 cmds[m].tokval/
5297	/0 cmds[m].toktype/);
5298	cmds[m].name=NULL;
5299	m=-1;
5300	i=1;
5301	f=FALSE;
5302	}
5303	else break;
5304	}
5305	fprintf(outfile,
5306	"/* end of list marker */\n"
5307	" { NULL, 0, 0, 0}\n"
5308	"};\n"
5309	"#ifdef HAVE_RTIMER\n"
5310	"#define LAST_IDENTIFIER %d\n"
5311	"#else\n"
5312	"#define LAST_IDENTIFIER %d\n"
5313	"#endif\n",id_nr,id_nr-1);
5314	fclose(outfile);
5315	}
5316	/-------------------------------------------------------------------/
5317	#if 0
5318	void ttGen3()
5319	{
5320	FILE *outfile = myfopen("mpsr_tok.inc","w");
5321	fprintf(outfile,
5322	"/****************************************\n"
5323	"* Computer Algebra System SINGULAR *\n"
5324	"****************************************/\n\n");
5325	/-------------------------------------------------------------------/
5326	fprintf(outfile,"// token table for Singular\n//\n");
5327
5328	fprintf(outfile,
5329	"short vtok[] =\n"
5330	"{\n");
5331	// operations with 1 arg: ===========================================
5332	int i=0;
5333	while (dArith1[i].cmd!=0)
5334	{
5335	if ((dArith1[i].p!=jjWRONG)
5336	&&((i==0)\|\|(dArith1[i].cmd!=dArith1[i-1].cmd)))
5337	{
5338	fprintf(outfile," %d,\n",dArith1[i].cmd);
5339	}
5340	i++;
5341	}
5342	// operations with 2 args: ===========================================
5343	i=0;
5344	while (dArith2[i].cmd!=0)
5345	{
5346	if ((dArith2[i].p!=jjWRONG2)
5347	&&((i==0)\|\|(dArith2[i].cmd!=dArith2[i-1].cmd)))
5348	{
5349	fprintf(outfile," %d,\n",dArith2[i].cmd);
5350	}
5351	i++;
5352	}
5353	// operations with 3 args: ===========================================
5354	i=0;
5355	while (dArith3[i].cmd!=0)
5356	{
5357	if (
5358	((i==0)\|\|(dArith3[i].cmd!=dArith3[i-1].cmd)))
5359	{
5360	fprintf(outfile," %d,\n",dArith3[i].cmd);
5361	}
5362	i++;
5363	}
5364	// operations with many args: ===========================================
5365	i=0;
5366	while (dArithM[i].cmd!=0)
5367	{
5368	if (
5369	((i==0)\|\|(dArithM[i].cmd!=dArithM[i-1].cmd)))
5370	{
5371	fprintf(outfile," %d,\n",dArithM[i].cmd);
5372	}
5373	i++;
5374	}
5375	// ====================================================================
5376	fprintf(outfile,
5377	"/* end of list marker */\n"
5378	" %d };\n",MAX_TOK);
5379	fclose(outfile);
5380	}
5381	#endif
5382	/-------------------------------------------------------------------/
5383	#else
5384	#include "iparith.inc"
5385	#endif
5386
5387	/=================== operations with 2 args. ============================/
5388
5389	BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
5390	{
5391	#ifndef GENTABLE
5392	memset(res,0,sizeof(sleftv));
5393
5394	if (!errorreported)
5395	{
5396	#ifdef SIQ
5397	if (siq>0)
5398	{
5399	//Print("siq:%d\n",siq);
5400	command d=(command)Alloc0SizeOf(ip_command);
5401	memcpy(&d->arg1,a,sizeof(sleftv));
5402	memcpy(&d->arg2,b,sizeof(sleftv));
5403	d->argc=2;
5404	d->op=op;
5405	res->data=(char *)d;
5406	res->rtyp=COMMAND;
5407	return FALSE;
5408	}
5409	#endif
5410	int at=a->Typ();
5411	int bt=b->Typ();
5412	int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
5413	int index=i;
5414
5415	iiOp=op;
5416	while (dArith2[i].cmd==op)
5417	{
5418	if ((at==dArith2[i].arg1)
5419	&& (bt==dArith2[i].arg2))
5420	{
5421	res->rtyp=dArith2[i].res;
5422	if (dArith2[i].p(res,a,b))
5423	{
5424	break;// leave loop, goto error handling
5425	}
5426	a->CleanUp();
5427	b->CleanUp();
5428	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5429	return FALSE;
5430	}
5431	i++;
5432	}
5433	// implicite type conversion ----------------------------------------------
5434	if (dArith2[i].cmd!=op)
5435	{
5436	int ai,bi;
5437	leftv an = (leftv)Alloc0SizeOf(sleftv);
5438	leftv bn = (leftv)Alloc0SizeOf(sleftv);
5439	BOOLEAN failed=FALSE;
5440	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
5441	//Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
5442	while (dArith2[i].cmd==op)
5443	{
5444	//Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5445	if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
5446	{
5447	if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
5448	{
5449	res->rtyp=dArith2[i].res;
5450	failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
5451	\|\| (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
5452	\|\| (dArith2[i].p(res,an,bn)));
5453	// everything done, clean up temp. variables
5454	if (failed)
5455	{
5456	// leave loop, goto error handling
5457	break;
5458	}
5459	else
5460	{
5461	// everything ok, clean up and return
5462	an->CleanUp();
5463	bn->CleanUp();
5464	FreeSizeOf((ADDRESS)an,sleftv);
5465	FreeSizeOf((ADDRESS)bn,sleftv);
5466	a->CleanUp();
5467	b->CleanUp();
5468	return FALSE;
5469	}
5470	}
5471	}
5472	i++;
5473	}
5474	an->CleanUp();
5475	bn->CleanUp();
5476	FreeSizeOf((ADDRESS)an,sleftv);
5477	FreeSizeOf((ADDRESS)bn,sleftv);
5478	}
5479	// error handling ---------------------------------------------------
5480	const char *s=NULL;
5481	if (!errorreported)
5482	{
5483	if ((at==0) && (a->Fullname()!=sNoName))
5484	{
5485	s=a->Fullname();
5486	}
5487	else if ((bt==0) && (b->Fullname()!=sNoName))
5488	{
5489	s=b->Fullname();
5490	}
5491	if (s!=NULL)
5492	Werror("`%s` is not defined",s);
5493	else
5494	{
5495	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
5496	s = iiTwoOps(op);
5497	if (proccall)
5498	{
5499	Werror("%s(`%s`,`%s`) is not supported"
5500	,s,Tok2Cmdname(at),Tok2Cmdname(bt));
5501	}
5502	else
5503	{
5504	Werror("`%s` %s `%s` is not supported"
5505	,Tok2Cmdname(at),s,Tok2Cmdname(bt));
5506	}
5507	if (BVERBOSE(V_SHOW_USE))
5508	{
5509	while (dArith2[i].cmd==op)
5510	{
5511	if(((at==dArith2[i].arg1)\|\|(bt==dArith2[i].arg2))
5512	&& (dArith2[i].res!=0)
5513	&& (dArith2[i].p!=jjWRONG2))
5514	{
5515	if (proccall)
5516	Werror("expected %s(`%s`,`%s`)"
5517	,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
5518	else
5519	Werror("expected `%s` %s `%s`"
5520	,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
5521	}
5522	i++;
5523	}
5524	}
5525	}
5526	}
5527	res->rtyp = UNKNOWN;
5528	}
5529	a->CleanUp();
5530	b->CleanUp();
5531	#endif
5532	return TRUE;
5533	}
5534
5535	/==================== operations with 1 arg. ===============================/
5536
5537	BOOLEAN iiExprArith1(leftv res, leftv a, int op)
5538	{
5539	#ifndef GENTABLE
5540	memset(res,0,sizeof(sleftv));
5541
5542	if (!errorreported)
5543	{
5544	#ifdef SIQ
5545	if (siq>0)
5546	{
5547	//Print("siq:%d\n",siq);
5548	command d=(command)Alloc0SizeOf(ip_command);
5549	memcpy(&d->arg1,a,sizeof(sleftv));
5550	d->op=op;
5551	d->argc=1;
5552	res->data=(char *)d;
5553	res->rtyp=COMMAND;
5554	return FALSE;
5555	}
5556	#endif
5557	int at=a->Typ();
5558	BOOLEAN failed=FALSE;
5559
5560	iiOp=op;
5561	int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
5562	int ti = i;
5563	while (dArith1[i].cmd==op)
5564	{
5565	if (at==dArith1[i].arg)
5566	{
5567	int r=res->rtyp=dArith1[i].res;
5568	if (r<0)
5569	{
5570	res->rtyp=-r;
5571	#ifdef PROC_BUG
5572	dArith1[i].p(res,a);
5573	#else
5574	res->data=(char )((Proc1)dArith1[i].p)((char )a->Data());
5575	#endif
5576	}
5577	else if (dArith1[i].p(res,a))
5578	{
5579	break;// leave loop, goto error handling
5580	}
5581	if (a->Next()!=NULL)
5582	{
5583	res->next=(leftv)AllocSizeOf(sleftv);
5584	failed=iiExprArith1(res->next,a->next,op);
5585	}
5586	a->CleanUp();
5587	return failed;
5588	}
5589	i++;
5590	}
5591	// implicite type conversion --------------------------------------------
5592	if (dArith1[i].cmd!=op)
5593	{
5594	leftv an = (leftv)Alloc0SizeOf(sleftv);
5595	i=ti;
5596	//Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
5597	while (dArith1[i].cmd==op)
5598	{
5599	int ai;
5600	//Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
5601	if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
5602	{
5603	int r=res->rtyp=dArith1[i].res;
5604	if (r<0)
5605	{
5606	res->rtyp=-r;
5607	failed= iiConvert(at,dArith1[i].arg,ai,a,an);
5608	if (!failed)
5609	{
5610	#ifdef PROC_BUG
5611	dArith1[i].p(res,a);
5612	#else
5613	res->data=(char )((Proc1)dArith1[i].p)((char )an->Data());
5614	#endif
5615	}
5616	}
5617	else
5618	{
5619	failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
5620	\|\| (dArith1[i].p(res,an)));
5621	}
5622	// everything done, clean up temp. variables
5623	if (failed)
5624	{
5625	// leave loop, goto error handling
5626	break;
5627	}
5628	else
5629	{
5630	if (an->Next() != NULL)
5631	{
5632	res->next = (leftv)AllocSizeOf(sleftv);
5633	failed=iiExprArith1(res->next,an->next,op);
5634	}
5635	// everything ok, clean up and return
5636	an->CleanUp();
5637	FreeSizeOf((ADDRESS)an,sleftv);
5638	a->CleanUp();
5639	return failed;
5640	}
5641	}
5642	i++;
5643	}
5644	an->CleanUp();
5645	FreeSizeOf((ADDRESS)an,sleftv);
5646	}
5647	// error handling
5648	if (!errorreported)
5649	{
5650	if ((at==0) && (a->Fullname()!=sNoName))
5651	{
5652	Werror("`%s` is not defined",a->Fullname());
5653	}
5654	else
5655	{
5656	i=ti;
5657	char *s = iiTwoOps(op);
5658	Werror("%s(`%s`) is not supported"
5659	,s,Tok2Cmdname(at));
5660	if (BVERBOSE(V_SHOW_USE))
5661	{
5662	while (dArith1[i].cmd==op)
5663	{
5664	if ((dArith1[i].res!=0)
5665	&& (dArith1[i].p!=jjWRONG))
5666	Werror("expected %s(`%s`)"
5667	,s,Tok2Cmdname(dArith1[i].arg));
5668	i++;
5669	}
5670	}
5671	}
5672	}
5673	res->rtyp = UNKNOWN;
5674	}
5675	a->CleanUp();
5676	#endif
5677	return TRUE;
5678	}
5679
5680	/=================== operations with 3 args. ============================/
5681
5682	BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
5683	{
5684	#ifndef GENTABLE
5685	memset(res,0,sizeof(sleftv));
5686
5687	if (!errorreported)
5688	{
5689	#ifdef SIQ
5690	if (siq>0)
5691	{
5692	//Print("siq:%d\n",siq);
5693	command d=(command)Alloc0SizeOf(ip_command);
5694	memcpy(&d->arg1,a,sizeof(sleftv));
5695	memcpy(&d->arg2,b,sizeof(sleftv));
5696	memcpy(&d->arg3,c,sizeof(sleftv));
5697	d->op=op;
5698	d->argc=3;
5699	res->data=(char *)d;
5700	res->rtyp=COMMAND;
5701	return FALSE;
5702	}
5703	#endif
5704	int at=a->Typ();
5705	int bt=b->Typ();
5706	int ct=c->Typ();
5707
5708	iiOp=op;
5709	int i=0;
5710	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5711	while (dArith3[i].cmd==op)
5712	{
5713	if ((at==dArith3[i].arg1)
5714	&& (bt==dArith3[i].arg2)
5715	&& (ct==dArith3[i].arg3))
5716	{
5717	res->rtyp=dArith3[i].res;
5718	if (dArith3[i].p(res,a,b,c))
5719	{
5720	break;// leave loop, goto error handling
5721	}
5722	a->CleanUp();
5723	b->CleanUp();
5724	c->CleanUp();
5725	return FALSE;
5726	}
5727	i++;
5728	}
5729	// implicite type conversion ----------------------------------------------
5730	if (dArith3[i].cmd!=op)
5731	{
5732	int ai,bi,ci;
5733	leftv an = (leftv)Alloc0SizeOf(sleftv);
5734	leftv bn = (leftv)Alloc0SizeOf(sleftv);
5735	leftv cn = (leftv)Alloc0SizeOf(sleftv);
5736	BOOLEAN failed=FALSE;
5737	i=0;
5738	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5739	while (dArith3[i].cmd==op)
5740	{
5741	if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
5742	{
5743	if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
5744	{
5745	if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
5746	{
5747	res->rtyp=dArith3[i].res;
5748	failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
5749	\|\| (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
5750	\|\| (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
5751	\|\| (dArith3[i].p(res,an,bn,cn)));
5752	// everything done, clean up temp. variables
5753	if (failed)
5754	{
5755	// leave loop, goto error handling
5756	break;
5757	}
5758	else
5759	{
5760	// everything ok, clean up and return
5761	an->CleanUp();
5762	bn->CleanUp();
5763	cn->CleanUp();
5764	FreeSizeOf((ADDRESS)an,sleftv);
5765	FreeSizeOf((ADDRESS)bn,sleftv);
5766	FreeSizeOf((ADDRESS)cn,sleftv);
5767	a->CleanUp();
5768	b->CleanUp();
5769	c->CleanUp();
5770	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5771	return FALSE;
5772	}
5773	}
5774	}
5775	}
5776	i++;
5777	}
5778	an->CleanUp();
5779	bn->CleanUp();
5780	cn->CleanUp();
5781	FreeSizeOf((ADDRESS)an,sleftv);
5782	FreeSizeOf((ADDRESS)bn,sleftv);
5783	FreeSizeOf((ADDRESS)cn,sleftv);
5784	}
5785	// error handling ---------------------------------------------------
5786	if (!errorreported)
5787	{
5788	const char *s=NULL;
5789	if ((at==0) && (a->Fullname()!=sNoName))
5790	{
5791	s=a->Fullname();
5792	}
5793	else if ((bt==0) && (b->Fullname()!=sNoName))
5794	{
5795	s=b->Fullname();
5796	}
5797	else if ((ct==0) && (c->Fullname()!=sNoName))
5798	{
5799	s=c->Fullname();
5800	}
5801	if (s!=NULL)
5802	Werror("`%s` is not defined",s);
5803	else
5804	{
5805	i=0;
5806	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
5807	char *s = iiTwoOps(op);
5808	Werror("%s(`%s`,`%s`,`%s`) is not supported"
5809	,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
5810	if (BVERBOSE(V_SHOW_USE))
5811	{
5812	while (dArith3[i].cmd==op)
5813	{
5814	if(((at==dArith3[i].arg1)
5815	\|\|(bt==dArith3[i].arg2)
5816	\|\|(ct==dArith3[i].arg3))
5817	&& (dArith3[i].res!=0))
5818	{
5819	Werror("expected %s(`%s`,`%s`,`%s`)"
5820	,s,Tok2Cmdname(dArith3[i].arg1)
5821	,Tok2Cmdname(dArith3[i].arg2)
5822	,Tok2Cmdname(dArith3[i].arg3));
5823	}
5824	i++;
5825	}
5826	}
5827	}
5828	}
5829	res->rtyp = UNKNOWN;
5830	}
5831	a->CleanUp();
5832	b->CleanUp();
5833	c->CleanUp();
5834	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5835	#endif
5836	return TRUE;
5837	}
5838	/==================== operations with many arg. ===============================/
5839
5840	BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
5841	{
5842	// cnt = 0: all
5843	// cnt = 1: only first one
5844	leftv next;
5845	BOOLEAN failed = TRUE;
5846	if(v==NULL) return failed;
5847	res->rtyp = LIST_CMD;
5848	if(cnt) v->next = NULL;
5849	next = v->next; // saving next-pointer
5850	failed = jjLIST_PL(res, v);
5851	v->next = next; // writeback next-pointer
5852	return failed;
5853	}
5854
5855	BOOLEAN iiExprArithM(leftv res, leftv a, int op)
5856	{
5857	#ifndef GENTABLE
5858	memset(res,0,sizeof(sleftv));
5859
5860	if (!errorreported)
5861	{
5862	#ifdef SIQ
5863	if (siq>0)
5864	{
5865	//Print("siq:%d\n",siq);
5866	command d=(command)Alloc0SizeOf(ip_command);
5867	d->op=op;
5868	res->data=(char *)d;
5869	if (a!=NULL)
5870	{
5871	d->argc=a->listLength();
5872	// else : d->argc=0;
5873	memcpy(&d->arg1,a,sizeof(sleftv));
5874	switch(d->argc)
5875	{
5876	case 3:
5877	memcpy(&d->arg3,a->next->next,sizeof(sleftv));
5878	a->next->next->rtyp=0;
5879	a->next->next->data=NULL;
5880	a->next->next->name=NULL;
5881	a->next->next->attribute=NULL;
5882	case 2:
5883	memcpy(&d->arg2,a->next,sizeof(sleftv));
5884	a->next->rtyp=0;
5885	a->next->name=NULL;
5886	a->next->data=NULL;
5887	a->next->attribute=NULL;
5888	d->arg2.next=NULL;
5889	case 1:
5890	d->arg1.next=NULL;
5891	}
5892	if (d->argc>3) a->next=NULL;
5893	a->rtyp=0;
5894	a->data=NULL;
5895	a->name=NULL;
5896	a->CleanUp();
5897	}
5898	res->rtyp=COMMAND;
5899	return FALSE;
5900	}
5901	#endif
5902	BOOLEAN failed=FALSE;
5903	int args=0;
5904	if (a!=NULL) args=a->listLength();
5905
5906	iiOp=op;
5907	int i=0;
5908	while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
5909	int ii=i;
5910	while (dArithM[i].cmd==op)
5911	{
5912	if ((args==dArithM[i].number_of_args)
5913	\|\| (dArithM[i].number_of_args==-1)
5914	\|\| ((dArithM[i].number_of_args==-2)&&(args>0)))
5915	{
5916	res->rtyp=dArithM[i].res;
5917	if (dArithM[i].p(res,a))
5918	{
5919	break;// leave loop, goto error handling
5920	}
5921	if (a!=NULL) a->CleanUp();
5922	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5923	return failed;
5924	}
5925	i++;
5926	}
5927	// error handling
5928	if (!errorreported)
5929	{
5930	if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
5931	{
5932	Werror("`%s` is not defined",a->Fullname());
5933	}
5934	else
5935	{
5936	char *s = iiTwoOps(op);
5937	Werror("%s(...) is not supported",s);
5938	}
5939	}
5940	res->rtyp = UNKNOWN;
5941	}
5942	if (a!=NULL) a->CleanUp();
5943	//Print("op: %d,result typ:%d\n",op,res->rtyp);
5944	#endif
5945	return TRUE;
5946	}
5947
5948	/=================== general utilities ============================/
5949	int IsCmd(char *n, int & tok)
5950	{
5951	int an=1;
5952	int i,v;
5953	#ifndef GENTABLE
5954	int en=LAST_IDENTIFIER;
5955
5956	loop
5957	{
5958	if(an>=en-1)
5959	{
5960	if (strcmp(n, cmds[an].name) == 0)
5961	{
5962	i=an;
5963	break;
5964	}
5965	else if ((an!=en) && (strcmp(n, cmds[en].name) == 0))
5966	{
5967	i=en;
5968	break;
5969	}
5970	else
5971	{
5972	return 0;
5973	}
5974	}
5975	i=(an+en)/2;
5976	if (n < (cmds[i].name))
5977	{
5978	en=i-1;
5979	}
5980	else if (n > (cmds[i].name))
5981	{
5982	an=i+1;
5983	}
5984	else
5985	{
5986	v=strcmp(n,cmds[i].name);
5987	if(v<0)
5988	{
5989	en=i-1;
5990	}
5991	else if(v>0)
5992	{
5993	an=i+1;
5994	}
5995	else /v==0/
5996	{
5997	break;
5998	}
5999	}
6000	}
6001	lastreserved=cmds[i].name;
6002	tok=cmds[i].tokval;
6003	if(cmds[i].alias==2)
6004	{
6005	Warn("outdated identifier `%s` used - please change your code",
6006	cmds[i].name);
6007	cmds[i].alias=1;
6008	}
6009	if (currRingHdl==NULL)
6010	{
6011	#ifdef SIQ
6012	if (siq<=0)
6013	{
6014	#endif
6015	if ((tok>=BEGIN_RING) && (tok<=END_RING))
6016	{
6017	WerrorS("no ring active");
6018	return 0;
6019	}
6020	#ifdef SIQ
6021	}
6022	#endif
6023	}
6024	if (!expected_parms)
6025	{
6026	switch (tok)
6027	{
6028	case IDEAL_CMD:
6029	case INT_CMD:
6030	case INTVEC_CMD:
6031	case MAP_CMD:
6032	case MATRIX_CMD:
6033	case MODUL_CMD:
6034	case POLY_CMD:
6035	case PROC_CMD:
6036	case RING_CMD:
6037	case STRING_CMD:
6038	cmdtok = tok;
6039	break;
6040	}
6041	}
6042	#endif
6043	return cmds[i].toktype;
6044	}
6045	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
6046	{
6047	#ifndef GENTABLE
6048	int a=0;
6049	int e=len;
6050	int p=len/2;
6051	do
6052	{
6053	if (op==dArithTab[p].cmd) return dArithTab[p].start;
6054	if (op<dArithTab[p].cmd) e=p-1;
6055	else a = p+1;
6056	p=a+(e-a)/2;
6057	}
6058	while ( a <= e);
6059
6060	#endif
6061	assume(0);
6062	return 0;
6063	}
6064

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

Download in other formats: