Context Navigation

source: git/Singular/iparith.cc @ 4fc824e

spielwiese

Last change on this file since 4fc824e was 4fc824e, checked in by Hans Schönemann <hannes@…>, 23 years ago
hannes: syntax/package loading git-svn-id: file:///usr/local/Singular/svn/trunk@5344 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 182.0 KB

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

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

Download in other formats: