Context Navigation

iparith.cc @ 88ec78a

spielwiese

Last change on this file since 88ec78a was 88ec78a, checked in by Hans Schönemann <hannes@…>, 16 years ago
*hannes: -bigint git-svn-id: file:///usr/local/Singular/svn/trunk@10151 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 243.4 KB

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