Context Navigation

source: git/Singular/iparith.cc @ 7604db

spielwiese

Last change on this file since 7604db was 7604db, checked in by Olaf Bachmann <obachman@…>, 25 years ago
* print command git-svn-id: file:///usr/local/Singular/svn/trunk@2992 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 163.9 KB

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

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

Download in other formats: