Context Navigation

iparith.cc @ 3095a1

spielwiese

Last change on this file since 3095a1 was 3095a1, checked in by Hans Schönemann <hannes@…>, 23 years ago
*hannes: repart/impart git-svn-id: file:///usr/local/Singular/svn/trunk@4886 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 176.2 KB

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