Context Navigation

source: git/Singular/iparith.cc @ 0e1846

spielwiese

Last change on this file since 0e1846 was 0e1846, checked in by Olaf Bachmann <obachman@…>, 27 years ago
This commit was generated by cvs2svn to compensate for changes in r59, which included commits to RCS files with non-trunk default branches. git-svn-id: file:///usr/local/Singular/svn/trunk@60 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 140.6 KB

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

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

Download in other formats: