Context Navigation

source: git/Singular/iparith.cc @ fc681b

spielwiese

Last change on this file since fc681b was fc681b, checked in by Hans Schönemann <hannes@…>, 15 years ago
*hannes: better err. mesg. git-svn-id: file:///usr/local/Singular/svn/trunk@11390 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 255.1 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/* $Id: iparith.cc,v 1.496 2009-02-13 11:40:12 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	#ifdef HAVE_RINGS
36	#include "rmodulon.h"
37	#include "rmodulo2m.h"
38	#include "rintegers.h"
39	#endif
40	#include "numbers.h"
41	#include "stairc.h"
42	#include "maps.h"
43	#include "maps_ip.h"
44	#include "syz.h"
45	#include "weight.h"
46	#include "ipconv.h"
47	#include "ipprint.h"
48	#include "attrib.h"
49	#include "silink.h"
50	#include "sparsmat.h"
51	#include "units.h"
52	#include "janet.h"
53	#include "GMPrat.h"
54	#include "tgb.h"
55	#include "walkProc.h"
56	#include "mod_raw.h"
57	#ifdef HAVE_FACTORY
58	#include "clapsing.h"
59	#include "kstdfac.h"
60	#endif /* HAVE_FACTORY */
61	#ifdef HAVE_FGLM
62	#include "fglm.h"
63	#endif /* HAVE_FGLM */
64	#define HAVE_INTERPOLATION
65	#ifdef HAVE_INTERPOLATION
66	#include "interpolation.h"
67	#endif
68
69	#include "ipshell.h"
70	#include "mpr_inout.h"
71
72	#ifdef HAVE_PLURAL
73	#include "gring.h"
74	#include "sca.h"
75	#define ALLOW_PLURAL ,1
76	#define ALLOW_PLURAL_N 1
77	#define NO_PLURAL ,0
78	#define NO_PLURAL_N 0
79	#define COMM_PLURAL ,2
80	#define COMM_PLURAL_N 2
81	#else /* HAVE_PLURAL */
82	#define ALLOW_PLURAL
83	#define NO_PLURAL
84	#define COMM_PLURAL
85	#endif /* HAVE_PLURAL */
86
87	/=============== types =====================/
88	struct sValCmdTab
89	{
90	short cmd;
91	short start;
92	};
93
94	typedef sValCmdTab jjValCmdTab[];
95
96	/* ifdef GENTABLE: definitions are in ipshell.h */
97	#ifndef GENTABLE
98	typedef char * (Proc1)(char );
99	struct sValCmd1
100	{
101	proc1 p;
102	short cmd;
103	short res;
104	short arg;
105	#ifdef HAVE_PLURAL
106	short valid_for_plural;
107	# endif /* HAVE_PLURAL */
108	};
109
110	typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
111	struct sValCmd2
112	{
113	proc2 p;
114	short cmd;
115	short res;
116	short arg1;
117	short arg2;
118	#ifdef HAVE_PLURAL
119	short valid_for_plural;
120	# endif /* HAVE_PLURAL */
121	};
122
123	typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
124	struct sValCmd3
125	{
126	proc3 p;
127	short cmd;
128	short res;
129	short arg1;
130	short arg2;
131	short arg3;
132	#ifdef HAVE_PLURAL
133	short valid_for_plural;
134	# endif /* HAVE_PLURAL */
135	};
136	struct sValCmdM
137	{
138	proc1 p;
139	short cmd;
140	short res;
141	short number_of_args; /* -1: any, -2: any >0, .. */
142	#ifdef HAVE_PLURAL
143	short valid_for_plural;
144	# endif /* HAVE_PLURAL */
145	};
146	#endif /* GENTABLE */
147
148	typedef struct
149	{
150	cmdnames sCmds; /< array of existing commands /
151	#ifndef GENTABLE
152	struct sValCmd1 *psValCmd1;
153	struct sValCmd2 *psValCmd2;
154	struct sValCmd3 *psValCmd3;
155	struct sValCmdM *psValCmdM;
156	#endif /* GENTABLE */
157	int nCmdUsed; /*< number of commands used /
158	int nCmdAllocated; /*< number of commands-slots allocated /
159	int nLastIdentifier; /*< valid indentifieres are slot 1..nLastIdentifier /
160	} SArithBase;
161
162	/---------------------------------------------------------------------
163	* File scope Variables (Variables share by several functions in
164	* the same file )
165	*
166	---------------------------------------------------------------------/
167	static SArithBase sArithBase; /*< Base entry for arithmetic /
168
169	/---------------------------------------------------------------------
170	* Extern Functions declarations
171	*
172	---------------------------------------------------------------------/
173	static int _gentable_sort_cmds(const void a, const void b);
174	extern int iiArithRemoveCmd(char *szName);
175	extern int iiArithAddCmd(const char *szName, short nAlias, short nTokval,
176	short nToktype, short nPos=-1);
177
178	/============= proc =======================/
179	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
180	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
181	#ifdef MDEBUG
182	#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
183	static Subexpr jjDBMakeSub(leftv e,const char *f,const int l);
184	#else
185	static Subexpr jjMakeSub(leftv e);
186	#endif
187
188	/============= vars ======================/
189	extern int cmdtok;
190	extern BOOLEAN expected_parms;
191
192	#define ii_div_by_0 "div. by 0"
193	#define ii_not_for_plural "not implemented for non-commutative rings"
194
195	int iiOp; /* the current operation*/
196
197	#ifdef GENTABLE
198	cmdnames cmds[] =
199	{ // name-string alias tokval toktype
200	{ "$INVALID$", 0, -1, 0},
201	{ "and", 0, '&' , LOGIC_OP},
202	{ "attrib", 0, ATTRIB_CMD , CMD_123},
203	{ "bareiss", 0, BAREISS_CMD , CMD_123},
204	{ "betti", 0, BETTI_CMD , CMD_12},
205	{ "bigint", 0, BIGINT_CMD , ROOT_DECL},
206	#ifdef HAVE_PLURAL
207	{ "bracket", 0, BRACKET_CMD , CMD_2},
208	#endif
209	{ "break", 0, BREAK_CMD , BREAK_CMD},
210	{ "breakpoint", 0, BREAKPOINT_CMD , CMD_M},
211	{ "char", 0, CHARACTERISTIC_CMD ,CMD_1},
212	{ "char_series", 0, CHAR_SERIES_CMD , CMD_1},
213	{ "charstr", 0, CHARSTR_CMD , CMD_1},
214	{ "chinrem", 0, CHINREM_CMD , CMD_2},
215	{ "cleardenom", 0, CONTENT_CMD , CMD_1},
216	{ "close", 0, CLOSE_CMD , CMD_1},
217	{ "coef", 0, COEF_CMD , CMD_M},
218	{ "coeffs", 0, COEFFS_CMD , CMD_23},
219	{ "continue", 0, CONTINUE_CMD , CONTINUE_CMD},
220	{ "contract", 0, CONTRACT_CMD , CMD_2},
221	{ "convhull", 0, NEWTONPOLY_CMD, CMD_1},
222	{ "dbprint", 0, DBPRINT_CMD , CMD_M},
223	{ "def", 0, DEF_CMD , ROOT_DECL},
224	{ "defined", 0, DEFINED_CMD , CMD_1},
225	{ "deg", 0, DEG_CMD , CMD_12},
226	{ "degree", 0, DEGREE_CMD , CMD_1},
227	{ "delete", 0, DELETE_CMD , CMD_2},
228	{ "det", 0, DET_CMD , CMD_1},
229	{ "diff", 0, DIFF_CMD , CMD_2},
230	{ "dim", 0, DIM_CMD , CMD_1},
231	{ "div", 0, INTDIV_CMD , MULDIV_OP},
232	{ "division", 0, DIVISION_CMD , CMD_M},
233	{ "dump", 0, DUMP_CMD, CMD_1},
234	{ "extgcd", 0, EXTGCD_CMD , CMD_2},
235	{ "EXTGCD", 2, EXTGCD_CMD , CMD_2},
236	{ "ERROR", 0, ERROR_CMD , CMD_1},
237	{ "eliminate", 0, ELIMINATION_CMD, CMD_23},
238	{ "else", 0, ELSE_CMD , ELSE_CMD},
239	#ifdef HAVE_PLURAL
240	{ "envelope", 0, ENVELOPE_CMD , CMD_1},
241	#endif
242	{ "eval", 0, EVAL , EVAL},
243	{ "example", 0, EXAMPLE_CMD , EXAMPLE_CMD},
244	{ "execute", 0, EXECUTE_CMD , CMD_1},
245	{ "export", 0, EXPORT_CMD , EXPORT_CMD},
246	{ "exportto", 0, EXPORTTO_CMD , CMD_2},
247	{ "factorize", 0, FAC_CMD , CMD_12},
248	{ "fetch", 0, FETCH_CMD , CMD_2},
249	{ "fglm", 0, FGLM_CMD , CMD_2},
250	{ "fglmquot", 0, FGLMQUOT_CMD, CMD_2},
251	{ "find", 0, FIND_CMD , CMD_23},
252	{ "finduni", 0, FINDUNI_CMD, CMD_1},
253	{ "forif", 0, IF_CMD , IF_CMD},
254	{ "freemodule", 0, FREEMODULE_CMD , CMD_1},
255	{ "facstd", 0, FACSTD_CMD , CMD_12},
256	{ "frwalk", 0, FWALK_CMD , CMD_23},
257	{ "gen", 0, E_CMD , CMD_1},
258	{ "getdump", 0, GETDUMP_CMD, CMD_1},
259	{ "gcd", 0, GCD_CMD , CMD_2},
260	{ "GCD", 2, GCD_CMD , CMD_2},
261	{ "hilb", 0, HILBERT_CMD , CMD_123},
262	{ "highcorner", 0, HIGHCORNER_CMD, CMD_1},
263	{ "homog", 0, HOMOG_CMD , CMD_123},
264	{ "hres", 0, HRES_CMD , CMD_2},
265	{ "ideal", 0, IDEAL_CMD , IDEAL_CMD},
266	{ "if", 0, IF_CMD , IF_CMD},
267	{ "imap", 0, IMAP_CMD , CMD_2},
268	{ "impart", 0, IMPART_CMD , CMD_1},
269	{ "importfrom", 0, IMPORTFROM_CMD , CMD_2},
270	{ "indepSet", 0, INDEPSET_CMD , CMD_12},
271	{ "insert", 0, INSERT_CMD , CMD_23},
272	{ "int", 0, INT_CMD , ROOT_DECL},
273	#ifdef HAVE_INTERPOLATION
274	{ "interpolation",0,INTERPOLATE_CMD , CMD_2},
275	#endif
276	{ "interred", 0, INTERRED_CMD , CMD_1},
277	{ "intersect", 0, INTERSECT_CMD , CMD_M},
278	{ "intmat", 0, INTMAT_CMD , INTMAT_CMD},
279	{ "intvec", 0, INTVEC_CMD , ROOT_DECL_LIST},
280	{ "jacob", 0, JACOB_CMD , CMD_1},
281	{ "janet", 0, JANET_CMD , CMD_12},
282	{ "jet", 0, JET_CMD , CMD_M},
283	{ "kbase", 0, KBASE_CMD , CMD_12},
284	{ "keepring", 0, KEEPRING_CMD , KEEPRING_CMD},
285	{ "kernel", 0, KERNEL_CMD , CMD_2},
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", 2, NCALGEBRA_CMD , CMD_2},
326	{ "nc_algebra", 0, NC_ALGEBRA_CMD , CMD_2},
327	#endif
328	{ "ncols", 0, COLS_CMD , CMD_1},
329	{ "not", 0, NOT , NOT},
330	{ "npars", 0, NPARS_CMD , CMD_1},
331	#ifdef OLD_RES
332	{ "nres", 0, RES_CMD , CMD_23},
333	#else
334	{ "nres", 0, RES_CMD , CMD_2},
335	#endif
336	{ "nrows", 0, ROWS_CMD , CMD_1},
337	{ "number", 0, NUMBER_CMD , RING_DECL},
338	{ "nvars", 0, NVARS_CMD , CMD_1},
339	{ "open", 0, OPEN_CMD , CMD_1},
340	#ifdef HAVE_PLURAL
341	{ "oppose", 0, OPPOSE_CMD , CMD_2},
342	{ "opposite", 0, OPPOSITE_CMD , CMD_1},
343	#endif
344	{ "option", 0, OPTION_CMD , CMD_M},
345	{ "or", 0, '\|' , LOGIC_OP},
346	{ "ord", 0, ORD_CMD , CMD_1},
347	{ "ordstr", 0, ORDSTR_CMD , CMD_1},
348	{ "package", 0, PACKAGE_CMD , ROOT_DECL},
349	{ "par", 0, PAR_CMD , CMD_1},
350	{ "parameter", 0, PARAMETER , PARAMETER},
351	{ "pardeg", 0, PARDEG_CMD , CMD_1},
352	{ "parstr", 0, PARSTR_CMD , CMD_12},
353	{ "poly", 0, POLY_CMD , RING_DECL},
354	{ "preimage", 0, PREIMAGE_CMD , CMD_13},
355	{ "prime", 0, PRIME_CMD , CMD_1},
356	{ "print", 0, PRINT_CMD , CMD_12},
357	{ "prune", 0, PRUNE_CMD , CMD_1},
358	{ "proc", 0, PROC_CMD , PROC_CMD},
359	{ "qhweight", 0, QHWEIGHT_CMD , CMD_1},
360	{ "qring", 0, QRING_CMD , ROOT_DECL},
361	{ "quote", 0, QUOTE , QUOTE},
362	{ "quotient", 0, QUOTIENT_CMD , CMD_2},
363	{ "random", 0, RANDOM_CMD , CMD_23},
364	{ "read", 0, READ_CMD , CMD_12},
365	{ "reduce", 0, REDUCE_CMD , CMD_M},
366	{ "regularity", 0, REGULARITY_CMD , CMD_1},
367	{ "repart", 0, REPART_CMD , CMD_1},
368	{ "reservedName",0, RESERVEDNAME_CMD , CMD_M},
369	{ "resolution", 0, RESOLUTION_CMD , RING_DECL},
370	{ "resultant", 0, RESULTANT_CMD, CMD_3},
371	{ "return", 0, RETURN , RETURN},
372	{ "RETURN", 0, END_GRAMMAR , RETURN},
373	{ "ring", 0, RING_CMD , RING_CMD},
374	{ "ringlist", 0, RINGLIST_CMD , CMD_1},
375	{ "rvar", 0, IS_RINGVAR , CMD_1},
376	{ "setring", 0, SETRING_CMD , SETRING_CMD},
377	{ "simplex", 0, SIMPLEX_CMD, CMD_M},
378	{ "simplify", 0, SIMPLIFY_CMD , CMD_2},
379	{ "size", 0, COUNT_CMD , CMD_1},
380	{ "slimgb", 0, SLIM_GB_CMD , CMD_1},
381	{ "sortvec", 0, SORTVEC_CMD , CMD_1},
382	{ "sqrfree", 0, SQR_FREE_CMD , CMD_1},
383	#ifdef OLD_RES
384	{ "sres", 0, SRES_CMD , CMD_23},
385	#else /* OLD_RES */
386	{ "sres", 0, SRES_CMD , CMD_2},
387	#endif /* OLD_RES */
388	{ "status", 0, STATUS_CMD, CMD_M},
389	{ "std", 0, STD_CMD , CMD_M},
390	{ "string", 0, STRING_CMD , ROOT_DECL_LIST},
391	{ "subst", 0, SUBST_CMD , CMD_M},
392	{ "system", 0, SYSTEM_CMD, CMD_M},
393	{ "syz", 0, SYZYGY_CMD , CMD_1},
394	{ "test", 0, TEST_CMD , CMD_M},
395	{ "trace", 0, TRACE_CMD , CMD_1},
396	{ "transpose", 0, TRANSPOSE_CMD , CMD_1},
397	#ifdef HAVE_PLURAL
398	{ "twostd", 0, TWOSTD_CMD , CMD_1},
399	#endif /* HAVE_PLURAL */
400	{ "type", 0, TYPE_CMD , TYPE_CMD},
401	{ "typeof", 0, TYPEOF_CMD , CMD_1},
402	{ "univariate", 0, UNIVARIATE_CMD, CMD_1},
403	{ "uressolve", 0, URSOLVE_CMD, CMD_M},
404	{ "vandermonde", 0, VANDER_CMD, CMD_3},
405	{ "var", 0, VAR_CMD , CMD_1},
406	{ "variables", 0, VARIABLES_CMD, CMD_1},
407	{ "varstr", 0, VARSTR_CMD , CMD_12},
408	{ "vdim", 0, VDIM_CMD , CMD_1},
409	{ "vector", 0, VECTOR_CMD , RING_DECL},
410	{ "wedge", 0, WEDGE_CMD , CMD_2},
411	{ "weight", 0, WEIGHT_CMD , CMD_1},
412	{ "whileif", 0, IF_CMD , IF_CMD},
413	{ "write", 0, WRITE_CMD , CMD_M},
414	/* delete for next version:*/
415	{ "IN", 1, LEAD_CMD , CMD_1},
416	{ "NF", 1, REDUCE_CMD , CMD_M},
417	{ "multiplicity",1, MULTIPLICITY_CMD , CMD_1},
418	{ "verbose", 2, OPTION_CMD , CMD_M},
419	// { "rank", 1, ROWS_CMD , CMD_1},
420	// { "Current", 0, -1 , SYSVAR},
421	// { "Top", 0, -1 , SYSVAR},
422	// { "Up", 0, -1 , SYSVAR},
423
424	/* set sys vars*/
425	{ "degBound", 0, VMAXDEG , SYSVAR},
426	{ "echo", 0, VECHO , SYSVAR},
427	{ "minpoly", 0, VMINPOLY , SYSVAR},
428	{ "multBound", 0, VMAXMULT , SYSVAR},
429	{ "noether", 0, VNOETHER , SYSVAR},
430	{ "pagelength", 0, VPAGELENGTH , SYSVAR},
431	{ "pagewidth", 0, VCOLMAX , SYSVAR},
432	{ "printlevel", 0, VPRINTLEVEL , SYSVAR},
433	{ "short", 0, VSHORTOUT , SYSVAR},
434	{ "timer", 0, VTIMER , SYSVAR},
435	{ "rtimer", 0, VRTIMER, SYSVAR},
436	{ "TRACE", 0, TRACE , SYSVAR},
437	{ "voice", 0, VOICE , SYSVAR},
438
439	/* other reserved words:scanner.l */
440	{ "pause", 2, -1 , 0},
441	{ "while", 0, -1 , 0},
442	{ "for", 0, -1 , 0},
443	{ "help", 0, -1 , 0},
444	{ "newline", 0, -1 , 0},
445	{ "exit", 0, -1 , 0},
446	{ "quit", 0, -1 , 0},
447	/* end of list marker */
448	{ NULL, 0, 0, 0}
449	};
450	#endif /* GENTABLE */
451
452	/=================== operations with 2 args.: static proc =================/
453	static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
454	{
455	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
456	int bb = (int)(long)(v->Data());
457	if (errorreported) return TRUE;
458	switch (iiOp)
459	{
460	case '+': (*aa) += bb; break;
461	case '-': (*aa) -= bb; break;
462	case '': (aa) *= bb; break;
463	case '/':
464	case INTDIV_CMD: (*aa) /= bb; break;
465	case '%':
466	case INTMOD_CMD: (*aa) %= bb; break;
467	}
468	res->data=(char *)aa;
469	return FALSE;
470	}
471	static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
472	{
473	return jjOP_IV_I(res,v,u);
474	}
475	static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
476	{
477	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
478	int bb = (int)(long)(v->Data());
479	int i=si_min(aa->rows(),aa->cols());
480	switch (iiOp)
481	{
482	case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
483	break;
484	case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
485	break;
486	}
487	res->data=(char *)aa;
488	return FALSE;
489	}
490	static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
491	{
492	return jjOP_IM_I(res,v,u);
493	}
494	static BOOLEAN jjCOLON(leftv res, leftv u, leftv v)
495	{
496	int l=(int)(long)v->Data();
497	if (l>0)
498	{
499	int d=(int)(long)u->Data();
500	intvec *vv=new intvec(l);
501	int i;
502	for(i=0;i<l;i++) { (*vv)[i]=d; }
503	res->data=(char *)vv;
504	}
505	return (l<=0);
506	}
507	static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
508	{
509	res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
510	return FALSE;
511	}
512	static void jjEQUAL_REST(leftv res,leftv u,leftv v);
513	static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
514	{
515	intvec* a = (intvec * )(u->Data());
516	intvec* b = (intvec * )(v->Data());
517	int r=a->compare(b);
518	switch (iiOp)
519	{
520	case '<':
521	res->data = (char *) (r<0);
522	break;
523	case '>':
524	res->data = (char *) (r>0);
525	break;
526	case LE:
527	res->data = (char *) (r<=0);
528	break;
529	case GE:
530	res->data = (char *) (r>=0);
531	break;
532	case EQUAL_EQUAL:
533	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
534	res->data = (char *) (r==0);
535	break;
536	}
537	jjEQUAL_REST(res,u,v);
538	if(r==-2) { WerrorS("size incompatible"); return TRUE; }
539	return FALSE;
540	}
541	static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
542	{
543	intvec* a = (intvec * )(u->Data());
544	int b = (int)(long)(v->Data());
545	int r=a->compare(b);
546	switch (iiOp)
547	{
548	case '<':
549	res->data = (char *) (r<0);
550	break;
551	case '>':
552	res->data = (char *) (r>0);
553	break;
554	case LE:
555	res->data = (char *) (r<=0);
556	break;
557	case GE:
558	res->data = (char *) (r>=0);
559	break;
560	case EQUAL_EQUAL:
561	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
562	res->data = (char *) (r==0);
563	break;
564	}
565	jjEQUAL_REST(res,u,v);
566	return FALSE;
567	}
568	static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
569	{
570	poly p=(poly)u->Data();
571	poly q=(poly)v->Data();
572	int r=pCmp(p,q);
573	if (r==0)
574	{
575	number h=nSub(pGetCoeff(p),pGetCoeff(q));
576	/* compare lead coeffs */
577	r = -1+nIsZero(h)+2nGreaterZero(h); / -1: <, 0:==, 1: > */
578	nDelete(&h);
579	}
580	else if (p==NULL)
581	{
582	if (q==NULL)
583	{
584	/* compare 0, 0 */
585	r=0;
586	}
587	else if(pIsConstant(q))
588	{
589	/* compare 0, const */
590	r = 1-2nGreaterZero(pGetCoeff(q)); / -1: <, 1: > */
591	}
592	}
593	else if (q==NULL)
594	{
595	if (pIsConstant(p))
596	{
597	/* compare const, 0 */
598	r = -1+2nGreaterZero(pGetCoeff(p)); / -1: <, 1: > */
599	}
600	}
601	switch (iiOp)
602	{
603	case '<':
604	res->data = (char *) (r < 0);
605	break;
606	case '>':
607	res->data = (char *) (r > 0);
608	break;
609	case LE:
610	res->data = (char *) (r <= 0);
611	break;
612	case GE:
613	res->data = (char *) (r >= 0);
614	break;
615	//case EQUAL_EQUAL:
616	//case NOTEQUAL: /* negation handled by jjEQUAL_REST */
617	// res->data = (char *) (r == 0);
618	// break;
619	}
620	jjEQUAL_REST(res,u,v);
621	return FALSE;
622	}
623	static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
624	{
625	char* a = (char * )(u->Data());
626	char* b = (char * )(v->Data());
627	int result = strcmp(a,b);
628	switch (iiOp)
629	{
630	case '<':
631	res->data = (char *) (result < 0);
632	break;
633	case '>':
634	res->data = (char *) (result > 0);
635	break;
636	case LE:
637	res->data = (char *) (result <= 0);
638	break;
639	case GE:
640	res->data = (char *) (result >= 0);
641	break;
642	case EQUAL_EQUAL:
643	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
644	res->data = (char *) (result == 0);
645	break;
646	}
647	jjEQUAL_REST(res,u,v);
648	return FALSE;
649	}
650	static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
651	{
652	if (u->Next()!=NULL)
653	{
654	u=u->next;
655	res->next = (leftv)omAllocBin(sleftv_bin);
656	return iiExprArith2(res->next,u,iiOp,v);
657	}
658	else if (v->Next()!=NULL)
659	{
660	v=v->next;
661	res->next = (leftv)omAllocBin(sleftv_bin);
662	return iiExprArith2(res->next,u,iiOp,v);
663	}
664	return FALSE;
665	}
666	static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
667	{
668	int b=(int)(long)u->Data();
669	int e=(int)(long)v->Data();
670	int rc = 1;
671	BOOLEAN overflow=FALSE;
672	if (e >= 0)
673	{
674	if (b==0)
675	{
676	rc=(e==0);
677	}
678	else
679	{
680	int oldrc;
681	while ((e--)!=0)
682	{
683	oldrc=rc;
684	rc *= b;
685	if (!overflow)
686	{
687	if(rc/b!=oldrc) overflow=TRUE;
688	}
689	}
690	if (overflow)
691	WarnS("int overflow(^), result may be wrong");
692	}
693	res->data = (char *)((long)rc);
694	if (u!=NULL) return jjOP_REST(res,u,v);
695	return FALSE;
696	}
697	else
698	{
699	WerrorS("exponent must be non-negative");
700	return TRUE;
701	}
702	}
703	static BOOLEAN jjPOWER_BI(leftv res, leftv u, leftv v)
704	{
705	int e=(int)(long)v->Data();
706	number n=(number)u->Data();
707	if (e>=0)
708	{
709	nlPower(n,e,(number*)&res->data);
710	}
711	else
712	{
713	WerrorS("exponent must be non-negative");
714	return TRUE;
715	}
716	if (u!=NULL) return jjOP_REST(res,u,v);
717	return FALSE;
718	}
719	static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
720	{
721	int e=(int)(long)v->Data();
722	number n=(number)u->Data();
723	int d=0;
724	if (e<0)
725	{
726	n=nInvers(n);
727	e=-e;
728	d=1;
729	}
730	nPower(n,e,(number*)&res->data);
731	if (d) nDelete(&n);
732	if (u!=NULL) return jjOP_REST(res,u,v);
733	return FALSE;
734	}
735	static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
736	{
737	res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)(long)v->Data());
738	if (u!=NULL) return jjOP_REST(res,u,v);
739	return errorreported; /* pPower may set errorreported via Werror */
740	}
741	static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
742	{
743	res->data = (char *)idPower((ideal)(u->Data()),(int)(long)(v->Data()));
744	if (u!=NULL) return jjOP_REST(res,u,v);
745	return FALSE;
746	}
747	static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
748	{
749	u=u->next;
750	v=v->next;
751	if (u==NULL)
752	{
753	if (v==NULL) return FALSE; /* u==NULL, v==NULL */
754	if (iiOp=='-') /* u==NULL, v<>NULL, iiOp=='-'*/
755	{
756	do
757	{
758	if (res->next==NULL)
759	res->next = (leftv)omAlloc0Bin(sleftv_bin);
760	leftv tmp_v=v->next;
761	v->next=NULL;
762	BOOLEAN b=iiExprArith1(res->next,v,'-');
763	v->next=tmp_v;
764	if (b)
765	return TRUE;
766	v=tmp_v;
767	res=res->next;
768	} while (v!=NULL);
769	return FALSE;
770	}
771	loop /* u==NULL, v<>NULL, iiOp=='+' */
772	{
773	res->next = (leftv)omAlloc0Bin(sleftv_bin);
774	res=res->next;
775	res->data = v->CopyD();
776	res->rtyp = v->Typ();
777	v=v->next;
778	if (v==NULL) return FALSE;
779	}
780	}
781	if (v!=NULL) /* u<>NULL, v<>NULL */
782	{
783	do
784	{
785	res->next = (leftv)omAlloc0Bin(sleftv_bin);
786	leftv tmp_u=u->next; u->next=NULL;
787	leftv tmp_v=v->next; v->next=NULL;
788	BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
789	u->next=tmp_u;
790	v->next=tmp_v;
791	if (b)
792	return TRUE;
793	u=tmp_u;
794	v=tmp_v;
795	res=res->next;
796	} while ((u!=NULL) && (v!=NULL));
797	return FALSE;
798	}
799	loop /* u<>NULL, v==NULL */
800	{
801	res->next = (leftv)omAlloc0Bin(sleftv_bin);
802	res=res->next;
803	res->data = u->CopyD();
804	res->rtyp = u->Typ();
805	u=u->next;
806	if (u==NULL) return FALSE;
807	}
808	}
809	static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
810	{
811	#ifdef HAVE_NS
812	idhdl packhdl;
813	switch(u->Typ())
814	{
815	case 0:
816	Print("%s of type 'ANY'. Trying load.\n", v->name);
817	if(iiTryLoadLib(u, u->name))
818	{
819	Werror("'%s' no such package", u->name);
820	return TRUE;
821	}
822	syMake(u,u->name,NULL);
823	// else: use next case !!! no break !!!
824	case PACKAGE_CMD:
825	packhdl = (idhdl)u->data;
826	if((!IDPACKAGE(packhdl)->loaded)
827	&& (IDPACKAGE(packhdl)->language > LANG_TOP))
828	{
829	//if(iiReLoadLib(packhdl))
830	// Werror("unable to reload package '%s'", IDID(packhdl));
831	Werror("'%s' not loaded", u->name);
832	return TRUE;
833	}
834	if(v->rtyp == IDHDL)
835	{
836	v->name = omStrDup(v->name);
837	}
838	v->req_packhdl=IDPACKAGE(packhdl);
839	v->packhdl=IDPACKAGE(packhdl);
840	syMake(v, v->name, packhdl);
841	memcpy(res, v, sizeof(sleftv));
842	memset(v, 0, sizeof(sleftv));
843	break;
844	case DEF_CMD:
845	break;
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	matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
896	res->data = (char *)(mpAdd(A , B));
897	if (res->data==NULL)
898	{
899	Werror("matrix size not compatible(%dx%d, %dx%d)",
900	MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
901	return TRUE;
902	}
903	return jjPLUSMINUS_Gen(res,u,v);
904	}
905	static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
906	{
907	matrix m=(matrix)u->Data();
908	matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
909	if (iiOp=='+')
910	res->data = (char *)mpAdd(m , p);
911	else
912	res->data = (char *)mpSub(m , p);
913	idDelete((ideal *)&p);
914	return jjPLUSMINUS_Gen(res,u,v);
915	}
916	static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
917	{
918	return jjPLUS_MA_P(res,v,u);
919	}
920	static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
921	{
922	char* a = (char * )(u->Data());
923	char* b = (char * )(v->Data());
924	char* r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
925	strcpy(r,a);
926	strcat(r,b);
927	res->data=r;
928	return jjPLUSMINUS_Gen(res,u,v);
929	}
930	static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
931	{
932	res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
933	return jjPLUSMINUS_Gen(res,u,v);
934	}
935	static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
936	{
937	unsigned int a=(unsigned int)(unsigned long)u->Data();
938	unsigned int b=(unsigned int)(unsigned long)v->Data();
939	unsigned int c=a-b;
940	if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
941	{
942	WarnS("int overflow(-), result may be wrong");
943	}
944	res->data = (char *)((long)c);
945	return jjPLUSMINUS_Gen(res,u,v);
946	}
947	static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
948	{
949	res->data = (char *)(nlSub((number)u->Data(), (number)v->Data()));
950	return jjPLUSMINUS_Gen(res,u,v);
951	}
952	static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
953	{
954	res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
955	return jjPLUSMINUS_Gen(res,u,v);
956	}
957	static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
958	{
959	res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
960	return jjPLUSMINUS_Gen(res,u,v);
961	}
962	static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
963	{
964	res->data = (char )ivSub((intvec)(u->Data()), (intvec*)(v->Data()));
965	if (res->data==NULL)
966	{
967	WerrorS("intmat size not compatible");
968	return TRUE;
969	}
970	return jjPLUSMINUS_Gen(res,u,v);
971	}
972	static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
973	{
974	matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
975	res->data = (char *)(mpSub(A , B));
976	if (res->data==NULL)
977	{
978	Werror("matrix size not compatible(%dx%d, %dx%d)",
979	MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
980	return TRUE;
981	}
982	return jjPLUSMINUS_Gen(res,u,v);
983	return FALSE;
984	}
985	static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
986	{
987	int a=(int)(long)u->Data();
988	int b=(int)(long)v->Data();
989	int c=a * b;
990	if ((b!=0) && (c/b !=a))
991	WarnS("int overflow(*), result may be wrong");
992	res->data = (char *)((long)c);
993	if ((u->Next()!=NULL) \|\| (v->Next()!=NULL))
994	return jjOP_REST(res,u,v);
995	return FALSE;
996	}
997	static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
998	{
999	res->data = (char *)(nlMult( (number)u->Data(), (number)v->Data()));
1000	if ((v->next!=NULL) \|\| (u->next!=NULL))
1001	return jjOP_REST(res,u,v);
1002	return FALSE;
1003	}
1004	static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
1005	{
1006	res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
1007	number n=(number)res->data;
1008	nNormalize(n);
1009	res->data=(char *)n;
1010	if ((v->next!=NULL) \|\| (u->next!=NULL))
1011	return jjOP_REST(res,u,v);
1012	return FALSE;
1013	}
1014	static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
1015	{
1016	poly a;
1017	poly b;
1018	if (v->next==NULL)
1019	{
1020	a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
1021	if (u->next==NULL)
1022	{
1023	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
1024	res->data = (char *)(pMult( a, b));
1025	pNormalize((poly)res->data);
1026	return FALSE;
1027	}
1028	// u->next exists: copy v
1029	b=pCopy((poly)v->Data());
1030	res->data = (char *)(pMult( a, b));
1031	pNormalize((poly)res->data);
1032	return jjOP_REST(res,u,v);
1033	}
1034	// v->next exists: copy u
1035	a=pCopy((poly)u->Data());
1036	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
1037	res->data = (char *)(pMult( a, b));
1038	pNormalize((poly)res->data);
1039	return jjOP_REST(res,u,v);
1040	}
1041	static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
1042	{
1043	res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
1044	idNormalize((ideal)res->data);
1045	if ((v->next!=NULL) \|\| (u->next!=NULL))
1046	return jjOP_REST(res,u,v);
1047	return FALSE;
1048	}
1049	static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
1050	{
1051	res->data = (char )ivMult((intvec)(u->Data()), (intvec*)(v->Data()));
1052	if (res->data==NULL)
1053	{
1054	WerrorS("intmat size not compatible");
1055	return TRUE;
1056	}
1057	if ((v->next!=NULL) \|\| (u->next!=NULL))
1058	return jjOP_REST(res,u,v);
1059	return FALSE;
1060	}
1061	static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
1062	{
1063	poly p=(poly)v->CopyD(POLY_CMD);
1064	int r=pMaxComp(p);/* recompute the rank for the case idealvector/
1065	ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1066	if (r>0) I->rank=r;
1067	idNormalize(I);
1068	res->data = (char *)I;
1069	return FALSE;
1070	}
1071	static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
1072	{
1073	return jjTIMES_MA_P1(res,v,u);
1074	}
1075	static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
1076	{
1077	number n=(number)v->CopyD(NUMBER_CMD);
1078	poly p=pOne();
1079	pSetCoeff(p,n);
1080	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1081	idNormalize((ideal)res->data);
1082	return FALSE;
1083	}
1084	static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
1085	{
1086	return jjTIMES_MA_N1(res,v,u);
1087	}
1088	static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
1089	{
1090	res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data());
1091	idNormalize((ideal)res->data);
1092	return FALSE;
1093	}
1094	static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1095	{
1096	return jjTIMES_MA_I1(res,v,u);
1097	}
1098	static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1099	{
1100	matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
1101	res->data = (char *)mpMult(A,B);
1102	if (res->data==NULL)
1103	{
1104	Werror("matrix size not compatible(%dx%d, %dx%d)",
1105	MATROWS(A),MATCOLS(A),MATROWS(B),MATCOLS(B));
1106	return TRUE;
1107	}
1108	idNormalize((ideal)res->data);
1109	if ((v->next!=NULL) \|\| (u->next!=NULL))
1110	return jjOP_REST(res,u,v);
1111	return FALSE;
1112	}
1113	static BOOLEAN jjGE_BI(leftv res, leftv u, leftv v)
1114	{
1115	number h=nlSub((number)u->Data(),(number)v->Data());
1116	res->data = (char *) (nlGreaterZero(h)\|\|(nlIsZero(h)));
1117	nlDelete(&h,NULL);
1118	return FALSE;
1119	}
1120	static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1121	{
1122	res->data = (char *)((int)((long)u->Data()) >= (int)((long)v->Data()));
1123	return FALSE;
1124	}
1125	static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1126	{
1127	number h=nSub((number)u->Data(),(number)v->Data());
1128	res->data = (char *) (nGreaterZero(h)\|\|(nIsZero(h)));
1129	nDelete(&h);
1130	return FALSE;
1131	}
1132	static BOOLEAN jjGT_BI(leftv res, leftv u, leftv v)
1133	{
1134	number h=nlSub((number)u->Data(),(number)v->Data());
1135	res->data = (char *) (nlGreaterZero(h)&&(!nlIsZero(h)));
1136	nlDelete(&h,NULL);
1137	return FALSE;
1138	}
1139	static BOOLEAN jjGT_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 jjGT_N(leftv res, leftv u, leftv v)
1145	{
1146	number h=nSub((number)u->Data(),(number)v->Data());
1147	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1148	nDelete(&h);
1149	return FALSE;
1150	}
1151	static BOOLEAN jjLE_BI(leftv res, leftv u, leftv v)
1152	{
1153	return jjGE_BI(res,v,u);
1154	}
1155	static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1156	{
1157	res->data = (char *)((int)((long)u->Data()) <= (int)((long)v->Data()));
1158	return FALSE;
1159	}
1160	static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1161	{
1162	return jjGE_N(res,v,u);
1163	}
1164	static BOOLEAN jjLT_BI(leftv res, leftv u, leftv v)
1165	{
1166	return jjGT_BI(res,v,u);
1167	}
1168	static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1169	{
1170	res->data = (char *)((int)((long)u->Data()) < (int)((long)v->Data()));
1171	return FALSE;
1172	}
1173	static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1174	{
1175	return jjGT_N(res,v,u);
1176	}
1177	static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1178	{
1179	int a= (int)(long)u->Data();
1180	int b= (int)(long)v->Data();
1181	if (b==0)
1182	{
1183	WerrorS(ii_div_by_0);
1184	return TRUE;
1185	}
1186	int bb=ABS(b);
1187	int c=a%bb;
1188	if(c<0) c+=bb;
1189	int r=0;
1190	switch (iiOp)
1191	{
1192	case INTMOD_CMD:
1193	r=c; break;
1194	case '%':
1195	r= (a % b); break;
1196	case INTDIV_CMD:
1197	r=((a-c) /b); break;
1198	case '/':
1199	r= (a / b); break;
1200	}
1201	res->data=(void *)((long)r);
1202	return FALSE;
1203	}
1204	static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
1205	{
1206	number q=(number)v->Data();
1207	if (nlIsZero(q))
1208	{
1209	WerrorS(ii_div_by_0);
1210	return TRUE;
1211	}
1212	q = nlIntDiv((number)u->Data(),q);
1213	nlNormalize(q);
1214	res->data = (char *)q;
1215	return FALSE;
1216	}
1217	static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1218	{
1219	number q=(number)v->Data();
1220	if (nIsZero(q))
1221	{
1222	WerrorS(ii_div_by_0);
1223	return TRUE;
1224	}
1225	q = nDiv((number)u->Data(),q);
1226	nNormalize(q);
1227	res->data = (char *)q;
1228	return FALSE;
1229	}
1230	static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1231	{
1232	poly q=(poly)v->Data();
1233	if (q==NULL)
1234	{
1235	WerrorS(ii_div_by_0);
1236	return TRUE;
1237	}
1238	poly p=(poly)(u->Data());
1239	if (p==NULL)
1240	{
1241	res->data=NULL;
1242	return FALSE;
1243	}
1244	if (pNext(q)!=NULL)
1245	{
1246	#ifdef HAVE_FACTORY
1247	if(pGetComp(p)==0)
1248	{
1249	res->data=(void)(singclap_pdivide(p /(poly)(u->Data())*/ ,
1250	q /(poly)(v->Data())/ ));
1251	}
1252	else
1253	{
1254	int comps=pMaxComp(p);
1255	ideal I=idInit(comps,1);
1256	p=pCopy(p);
1257	poly h;
1258	int i;
1259	// conversion to a list of polys:
1260	while (p!=NULL)
1261	{
1262	i=pGetComp(p)-1;
1263	h=pNext(p);
1264	pNext(p)=NULL;
1265	pSetComp(p,0);
1266	I->m[i]=pAdd(I->m[i],p);
1267	p=h;
1268	}
1269	// division and conversion to vector:
1270	h=NULL;
1271	p=NULL;
1272	for(i=comps-1;i>=0;i--)
1273	{
1274	if (I->m[i]!=NULL)
1275	{
1276	h=singclap_pdivide(I->m[i],q);
1277	pSetCompP(h,i+1);
1278	p=pAdd(p,h);
1279	}
1280	}
1281	idDelete(&I);
1282	res->data=(void *)p;
1283	}
1284	#else /* HAVE_FACTORY */
1285	WerrorS("division only by a monomial");
1286	return TRUE;
1287	#endif /* HAVE_FACTORY */
1288	}
1289	else
1290	{
1291	res->data = (char *)pDivideM(pCopy(p),pHead(q));
1292	}
1293	pNormalize((poly)res->data);
1294	return FALSE;
1295	}
1296	static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1297	{
1298	poly q=(poly)v->Data();
1299	if (q==NULL)
1300	{
1301	WerrorS(ii_div_by_0);
1302	return TRUE;
1303	}
1304	matrix m=(matrix)(u->Data());
1305	int r=m->rows();
1306	int c=m->cols();
1307	matrix mm=mpNew(r,c);
1308	int i,j;
1309	for(i=r;i>0;i--)
1310	{
1311	for(j=c;j>0;j--)
1312	{
1313	if (pNext(q)!=NULL)
1314	{
1315	#ifdef HAVE_FACTORY
1316	MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1317	q /(poly)(v->Data())/ );
1318	#else /* HAVE_FACTORY */
1319	WerrorS("division only by a monomial");
1320	return TRUE;
1321	#endif /* HAVE_FACTORY */
1322	}
1323	else
1324	MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1325	}
1326	}
1327	idNormalize((ideal)mm);
1328	res->data=(char *)mm;
1329	return FALSE;
1330	}
1331	static BOOLEAN jjEQUAL_BI(leftv res, leftv u, leftv v)
1332	{
1333	res->data = (char *)((long)nlEqual((number)u->Data(),(number)v->Data()));
1334	jjEQUAL_REST(res,u,v);
1335	return FALSE;
1336	}
1337	static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1338	{
1339	res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1340	jjEQUAL_REST(res,u,v);
1341	return FALSE;
1342	}
1343	static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1344	{
1345	res->data = (char *)((long)mpEqual((matrix)u->Data(),(matrix)v->Data()));
1346	jjEQUAL_REST(res,u,v);
1347	return FALSE;
1348	}
1349	static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1350	{
1351	res->data = (char *)((long)nEqual((number)u->Data(),(number)v->Data()));
1352	jjEQUAL_REST(res,u,v);
1353	return FALSE;
1354	}
1355	static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1356	{
1357	poly p=(poly)u->Data();
1358	poly q=(poly)v->Data();
1359	res->data = (char *) ((long)pEqualPolys(p,q));
1360	jjEQUAL_REST(res,u,v);
1361	return FALSE;
1362	}
1363	static void jjEQUAL_REST(leftv res,leftv u,leftv v)
1364	{
1365	if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1366	{
1367	int save_iiOp=iiOp;
1368	if (iiOp==NOTEQUAL)
1369	iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
1370	else
1371	iiExprArith2(res,u->next,iiOp,v->next);
1372	iiOp=save_iiOp;
1373	}
1374	if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1375	}
1376	static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1377	{
1378	res->data = (char *)((long)u->Data() && (long)v->Data());
1379	return FALSE;
1380	}
1381	static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1382	{
1383	res->data = (char *)((long)u->Data() \|\| (long)v->Data());
1384	return FALSE;
1385	}
1386	static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1387	{
1388	res->rtyp=u->rtyp; u->rtyp=0;
1389	res->data=u->data; u->data=NULL;
1390	res->name=u->name; u->name=NULL;
1391	res->attribute=u->attribute; u->attribute=NULL;
1392	res->e=u->e; u->e=NULL;
1393	if (res->e==NULL) res->e=jjMakeSub(v);
1394	else
1395	{
1396	Subexpr sh=res->e;
1397	while (sh->next != NULL) sh=sh->next;
1398	sh->next=jjMakeSub(v);
1399	}
1400	return FALSE;
1401	}
1402	static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1403	{
1404	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
1405	{
1406	WerrorS("indexed object must have a name");
1407	return TRUE;
1408	}
1409	intvec * iv=(intvec *)v->Data();
1410	leftv p=NULL;
1411	int i;
1412	sleftv t;
1413	memset(&t,0,sizeof(t));
1414	t.rtyp=INT_CMD;
1415	for (i=0;i<iv->length(); i++)
1416	{
1417	t.data=(char )((long)(iv)[i]);
1418	if (p==NULL)
1419	{
1420	p=res;
1421	}
1422	else
1423	{
1424	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1425	p=p->next;
1426	}
1427	p->rtyp=IDHDL;
1428	p->data=u->data;
1429	p->name=u->name;
1430	p->flag=u->flag;
1431	p->attribute=u->attribute;
1432	p->e=jjMakeSub(&t);
1433	}
1434	u->rtyp=0;
1435	u->data=NULL;
1436	u->name=NULL;
1437	return FALSE;
1438	}
1439	static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1440	{
1441	poly p=(poly)u->Data();
1442	int i=(int)(long)v->Data();
1443	int j=0;
1444	while (p!=NULL)
1445	{
1446	j++;
1447	if (j==i)
1448	{
1449	res->data=(char *)pHead(p);
1450	return FALSE;
1451	}
1452	pIter(p);
1453	}
1454	return FALSE;
1455	}
1456	static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1457	{
1458	poly p=(poly)u->Data();
1459	poly r=NULL;
1460	intvec iv=(intvec )v->CopyD(INTVEC_CMD);
1461	int i;
1462	int sum=0;
1463	for(i=iv->length()-1;i>=0;i--)
1464	sum+=(*iv)[i];
1465	int j=0;
1466	while ((p!=NULL) && (sum>0))
1467	{
1468	j++;
1469	for(i=iv->length()-1;i>=0;i--)
1470	{
1471	if (j==(*iv)[i])
1472	{
1473	r=pAdd(r,pHead(p));
1474	sum-=j;
1475	(*iv)[i]=0;
1476	break;
1477	}
1478	}
1479	pIter(p);
1480	}
1481	delete iv;
1482	res->data=(char *)r;
1483	return FALSE;
1484	}
1485	static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1486	{
1487	poly p=(poly)u->CopyD(VECTOR_CMD);
1488	poly r=p; // pointer to the beginning of component i
1489	poly o=NULL;
1490	int i=(int)(long)v->Data();
1491	while (p!=NULL)
1492	{
1493	if (pGetComp(p)!=i)
1494	{
1495	if (r==p) r=pNext(p);
1496	if (o!=NULL)
1497	{
1498	pDeleteLm(&pNext(o));
1499	p=pNext(o);
1500	}
1501	else
1502	pDeleteLm(&p);
1503	}
1504	else
1505	{
1506	pSetComp(p, 0);
1507	o=p;
1508	p=pNext(o);
1509	}
1510	}
1511	res->data=(char *)r;
1512	return FALSE;
1513	}
1514	static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1515	{
1516	poly p=(poly)u->CopyD(VECTOR_CMD);
1517	if (p!=NULL)
1518	{
1519	poly r=pOne();
1520	poly hp=r;
1521	intvec iv=(intvec )v->Data();
1522	int i;
1523	loop
1524	{
1525	for(i=0;i<iv->length();i++)
1526	{
1527	if (pGetComp(p)==(*iv)[i])
1528	{
1529	poly h;
1530	pSplit(p,&h);
1531	pNext(hp)=p;
1532	p=h;
1533	pIter(hp);
1534	break;
1535	}
1536	}
1537	if (p==NULL) break;
1538	if (i==iv->length())
1539	{
1540	pDeleteLm(&p);
1541	if (p==NULL) break;
1542	}
1543	}
1544	pDeleteLm(&r);
1545	res->data=(char *)r;
1546	}
1547	return FALSE;
1548	}
1549	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v);
1550	static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1551	{
1552	if(u->name==NULL) return TRUE;
1553	char * nn = (char *)omAlloc(strlen(u->name) + 14);
1554	sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1555	omFree((ADDRESS)u->name);
1556	u->name=NULL;
1557	char *n=omStrDup(nn);
1558	omFree((ADDRESS)nn);
1559	syMake(res,n);
1560	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1561	return FALSE;
1562	}
1563	static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1564	{
1565	intvec * iv=(intvec *)v->Data();
1566	leftv p=NULL;
1567	int i;
1568	long slen = strlen(u->name) + 14;
1569	char n = (char) omAlloc(slen);
1570
1571	for (i=0;i<iv->length(); i++)
1572	{
1573	if (p==NULL)
1574	{
1575	p=res;
1576	}
1577	else
1578	{
1579	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1580	p=p->next;
1581	}
1582	sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1583	syMake(p,omStrDup(n));
1584	}
1585	omFree((ADDRESS)u->name);
1586	u->name = NULL;
1587	omFreeSize(n, slen);
1588	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1589	return FALSE;
1590	}
1591	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
1592	{
1593	leftv tmp=(leftv)omAllocBin(sleftv_bin);
1594	memset(tmp,0,sizeof(sleftv));
1595	BOOLEAN b;
1596	if (v->Typ()==INTVEC_CMD)
1597	b=jjKLAMMER_IV(tmp,u,v);
1598	else
1599	b=jjKLAMMER(tmp,u,v);
1600	if (b)
1601	{
1602	omFreeBin(tmp,sleftv_bin);
1603	return TRUE;
1604	}
1605	leftv h=res;
1606	while (h->next!=NULL) h=h->next;
1607	h->next=tmp;
1608	return FALSE;
1609	}
1610	BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1611	{
1612	void *d;
1613	Subexpr e;
1614	int typ;
1615	BOOLEAN t=FALSE;
1616	if (u->rtyp!=IDHDL)
1617	{
1618	idrec tmp_proc;
1619	tmp_proc.id="_auto";
1620	tmp_proc.typ=PROC_CMD;
1621	tmp_proc.data.pinf=(procinfo *)u->Data();
1622	tmp_proc.ref=1;
1623	d=u->data; u->data=(void *)&tmp_proc;
1624	e=u->e; u->e=NULL;
1625	t=TRUE;
1626	typ=u->rtyp; u->rtyp=IDHDL;
1627	}
1628	#ifdef HAVE_NS
1629	leftv sl;
1630	if (u->req_packhdl==currPack)
1631	sl = iiMake_proc((idhdl)u->data,NULL,v);
1632	else
1633	sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1634	#else /* HAVE_NS */
1635	leftv sl = iiMake_proc((idhdl)u->data,v);
1636	#endif /* HAVE_NS */
1637	if (t)
1638	{
1639	u->rtyp=typ;
1640	u->data=d;
1641	u->e=e;
1642	}
1643	if (sl==NULL)
1644	{
1645	return TRUE;
1646	}
1647	else
1648	{
1649	memcpy(res,sl,sizeof(sleftv));
1650	}
1651	return FALSE;
1652	}
1653	static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1654	{
1655	//Print("try to map %s with %s\n",$3.Name(),$1.Name());
1656	leftv sl=NULL;
1657	if ((v->e==NULL)&&(v->name!=NULL))
1658	{
1659	map m=(map)u->Data();
1660	sl=iiMap(m,v->name);
1661	}
1662	else
1663	{
1664	Werror("%s(<name>) expected",u->Name());
1665	}
1666	if (sl==NULL) return TRUE;
1667	memcpy(res,sl,sizeof(sleftv));
1668	omFreeBin((ADDRESS)sl, sleftv_bin);
1669	return FALSE;
1670	}
1671	static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1672	{
1673	u->next=(leftv)omAllocBin(sleftv_bin);
1674	memcpy(u->next,v,sizeof(sleftv));
1675	BOOLEAN r=iiExprArithM(res,u,iiOp);
1676	v->Init();
1677	// iiExprArithM did the CleanUp
1678	return r;
1679	}
1680	static BOOLEAN jjCHINREM_BI(leftv res, leftv u, leftv v)
1681	{
1682	intvec c=(intvec)u->Data();
1683	intvec* p=(intvec*)v->Data();
1684	int rl=p->length();
1685	number x=(number )omAlloc(rl*sizeof(number));
1686	number q=(number )omAlloc(rl*sizeof(number));
1687	int i;
1688	for(i=rl-1;i>=0;i--)
1689	{
1690	q[i]=nlInit((*p)[i]);
1691	x[i]=nlInit((*c)[i]);
1692	}
1693	number n=nlChineseRemainder(x,q,rl);
1694	for(i=rl-1;i>=0;i--)
1695	{
1696	nlDelete(&(q[i]),currRing);
1697	nlDelete(&(x[i]),currRing);
1698	}
1699	omFree(x); omFree(q);
1700	res->data=(char *)n;
1701	return FALSE;
1702	}
1703	#if 0
1704	static BOOLEAN jjCHINREM_P(leftv res, leftv u, leftv v)
1705	{
1706	lists c=(lists)u->CopyD(); // list of poly
1707	intvec* p=(intvec*)v->Data();
1708	int rl=p->length();
1709	poly r=NULL,h, result=NULL;
1710	number x=(number )omAlloc(rl*sizeof(number));
1711	number q=(number )omAlloc(rl*sizeof(number));
1712	int i;
1713	for(i=rl-1;i>=0;i--)
1714	{
1715	q[i]=nlInit((*p)[i]);
1716	}
1717	loop
1718	{
1719	for(i=rl-1;i>=0;i--)
1720	{
1721	if (c->m[i].Typ()!=POLY_CMD)
1722	{
1723	Werror("poly expected at pos %d",i+1);
1724	for(i=rl-1;i>=0;i--)
1725	{
1726	nlDelete(&(q[i]),currRing);
1727	}
1728	omFree(x); omFree(q); // delete c
1729	return TRUE;
1730	}
1731	h=((poly)c->m[i].Data());
1732	if (r==NULL) r=h;
1733	else if (pLmCmp(r,h)==-1) r=h;
1734	}
1735	if (r==NULL) break;
1736	for(i=rl-1;i>=0;i--)
1737	{
1738	h=((poly)c->m[i].Data());
1739	if (pLmCmp(r,h)==0)
1740	{
1741	x[i]=pGetCoeff(h);
1742	h=pLmFreeAndNext(h);
1743	c->m[i].data=(char*)h;
1744	}
1745	else
1746	x[i]=nlInit(0);
1747	}
1748	number n=nlChineseRemainder(x,q,rl);
1749	for(i=rl-1;i>=0;i--)
1750	{
1751	nlDelete(&(x[i]),currRing);
1752	}
1753	h=pHead(r);
1754	pSetCoeff(h,n);
1755	result=pAdd(result,h);
1756	}
1757	for(i=rl-1;i>=0;i--)
1758	{
1759	nlDelete(&(q[i]),currRing);
1760	}
1761	omFree(x); omFree(q);
1762	res->data=(char *)result;
1763	return FALSE;
1764	}
1765	#endif
1766	static BOOLEAN jjCHINREM_ID(leftv res, leftv u, leftv v)
1767	{
1768	lists c=(lists)u->CopyD(); // list of ideal
1769	intvec* p=(intvec*)v->Data();
1770	int rl=p->length();
1771	poly r=NULL,h;
1772	ideal result;
1773	ideal x=(ideal )omAlloc(rl*sizeof(ideal));
1774	int i;
1775	for(i=rl-1;i>=0;i--)
1776	{
1777	if (c->m[i].Typ()!=IDEAL_CMD)
1778	{
1779	Werror("ideal expected at pos %d",i+1);
1780	omFree(x); // delete c
1781	return TRUE;
1782	}
1783	x[i]=((ideal)c->m[i].Data());
1784	}
1785	number q=(number )omAlloc(rl*sizeof(number));
1786	for(i=rl-1;i>=0;i--)
1787	{
1788	q[i]=nlInit((*p)[i]);
1789	}
1790	result=idChineseRemainder(x,q,rl);
1791	for(i=rl-1;i>=0;i--)
1792	{
1793	nlDelete(&(q[i]),currRing);
1794	}
1795	omFree(q);
1796	res->data=(char *)result;
1797	return FALSE;
1798	}
1799	static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1800	{
1801	poly p=(poly)v->Data();
1802	if ((p==NULL)\|\|(pNext(p)!=NULL)) return TRUE;
1803	res->data=(char )mpCoeffProc((poly)u->Data(),p /(poly)v->Data()*/);
1804	return FALSE;
1805	}
1806	static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1807	{
1808	int i=pVar((poly)v->Data());
1809	if (i==0)
1810	{
1811	WerrorS("ringvar expected");
1812	return TRUE;
1813	}
1814	res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1815	return FALSE;
1816	}
1817	static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1818	{
1819	poly p = pInit();
1820	int i;
1821	for (i=1; i<=pVariables; i++)
1822	{
1823	pSetExp(p, i, 1);
1824	}
1825	pSetm(p);
1826	res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1827	(ideal)(v->Data()), p);
1828	pDelete(&p);
1829	return FALSE;
1830	}
1831	static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1832	{
1833	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1834	return FALSE;
1835	}
1836	static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1837	{
1838	short iv=iv2array((intvec )v->Data());
1839	ideal I=(ideal)u->Data();
1840	int d=-1;
1841	int i;
1842	for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)pDegW(I->m[i],iv));
1843	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1844	res->data = (char *)((long)d);
1845	return FALSE;
1846	}
1847	static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1848	{
1849	short iv=iv2array((intvec )v->Data());
1850	res->data = (char *)pDegW((poly)u->Data(),iv);
1851	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1852	return FALSE;
1853	}
1854	static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1855	{
1856	int i=pVar((poly)v->Data());
1857	if (i==0)
1858	{
1859	WerrorS("ringvar expected");
1860	return TRUE;
1861	}
1862	res->data=(char *)pDiff((poly)(u->Data()),i);
1863	return FALSE;
1864	}
1865	static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1866	{
1867	int i=pVar((poly)v->Data());
1868	if (i==0)
1869	{
1870	WerrorS("ringvar expected");
1871	return TRUE;
1872	}
1873	res->data=(char *)idDiff((matrix)(u->Data()),i);
1874	return FALSE;
1875	}
1876	static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1877	{
1878	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1879	return FALSE;
1880	}
1881	static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1882	{
1883	assumeStdFlag(v);
1884	if(currQuotient==NULL)
1885	res->data = (char *)((long)scDimInt((ideal)(v->Data()),(ideal)w->Data()));
1886	else
1887	{
1888	ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1889	res->data = (char *)((long)scDimInt((ideal)(v->Data()),q));
1890	idDelete(&q);
1891	}
1892	return FALSE;
1893	}
1894	static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1895	{
1896	ideal vi=(ideal)v->Data();
1897	int vl= IDELEMS(vi);
1898	ideal ui=(ideal)u->Data();
1899	int ul= IDELEMS(ui);
1900	ideal R; matrix U;
1901	ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1902	// now make sure that all matices have the corect size:
1903	matrix T = idModule2formatedMatrix(m,vl,ul);
1904	if (MATCOLS(U) != ul)
1905	{
1906	int mul=si_min(ul,MATCOLS(U));
1907	matrix UU=mpNew(ul,ul);
1908	int i,j;
1909	for(i=mul;i>0;i--)
1910	{
1911	for(j=mul;j>0;j--)
1912	{
1913	MATELEM(UU,i,j)=MATELEM(U,i,j);
1914	MATELEM(U,i,j)=NULL;
1915	}
1916	}
1917	idDelete((ideal *)&U);
1918	U=UU;
1919	}
1920	lists L=(lists)omAllocBin(slists_bin);
1921	L->Init(3);
1922	L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)T;
1923	L->m[1].rtyp=u->Typ(); L->m[1].data=(void *)R;
1924	L->m[2].rtyp=MATRIX_CMD; L->m[2].data=(void *)U;
1925	res->data=(char *)L;
1926	return FALSE;
1927	}
1928	static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1929	{
1930	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1931	//setFlag(res,FLAG_STD);
1932	return FALSE;
1933	}
1934	static BOOLEAN jjELIMIN_IV(leftv res, leftv u, leftv v)
1935	{
1936	poly p=pOne();
1937	intvec iv=(intvec)v->Data();
1938	for(int i=iv->length()-1; i>=0; i--)
1939	{
1940	pSetExp(p,(*iv)[i],1);
1941	}
1942	pSetm(p);
1943	res->data=(char *)idElimination((ideal)u->Data(),p);
1944	pLmDelete(&p);
1945	//setFlag(res,FLAG_STD);
1946	return FALSE;
1947	}
1948	static BOOLEAN jjEXPORTTO(leftv res, leftv u, leftv v)
1949	{
1950	#ifdef HAVE_NS
1951	//Print("exportto %s -> %s\n",v->Name(),u->Name() );
1952	return iiExport(v,0,(idhdl)u->data);
1953	#else /* HAVE_NS */
1954	return TRUE;
1955	#endif /* HAVE_NS */
1956	}
1957	static BOOLEAN jjERROR(leftv res, leftv u)
1958	{
1959	WerrorS((char *)u->Data());
1960	return TRUE;
1961	}
1962	static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1963	{
1964	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1965	int p0=ABS(uu),p1=ABS(vv);
1966	int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1967
1968	while ( p1!=0 )
1969	{
1970	q=p0 / p1;
1971	r=p0 % p1;
1972	p0 = p1; p1 = r;
1973	r = g0 - g1 * q;
1974	g0 = g1; g1 = r;
1975	r = f0 - f1 * q;
1976	f0 = f1; f1 = r;
1977	}
1978	int a = f0;
1979	int b = g0;
1980	if ( uu /(int)(long)u->Data()/ < 0 ) a=-a;
1981	if ( vv /(int)(long)v->Data()/ < 0 ) b=-b;
1982	lists L=(lists)omAllocBin(slists_bin);
1983	L->Init(3);
1984	L->m[0].rtyp=INT_CMD; L->m[0].data=(void *)(long)p0;
1985	L->m[1].rtyp=INT_CMD; L->m[1].data=(void *)(long)a;
1986	L->m[2].rtyp=INT_CMD; L->m[2].data=(void *)(long)b;
1987	res->rtyp=LIST_CMD;
1988	res->data=(char *)L;
1989	return FALSE;
1990	}
1991	#ifdef HAVE_FACTORY
1992	static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1993	{
1994	poly r,pa,pb;
1995	BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1996	if (ret) return TRUE;
1997	lists L=(lists)omAllocBin(slists_bin);
1998	L->Init(3);
1999	res->data=(char *)L;
2000	L->m[0].data=(void *)r;
2001	L->m[0].rtyp=POLY_CMD;
2002	L->m[1].data=(void *)pa;
2003	L->m[1].rtyp=POLY_CMD;
2004	L->m[2].data=(void *)pb;
2005	L->m[2].rtyp=POLY_CMD;
2006	return FALSE;
2007	}
2008	extern int singclap_factorize_retry;
2009	static BOOLEAN jjFAC_P2(leftv res, leftv u,leftv dummy)
2010	{
2011	intvec *v=NULL;
2012	int sw=(int)(long)dummy->Data();
2013	int fac_sw=sw;
2014	if ((sw<0)\|\|(sw>2)) fac_sw=1;
2015	singclap_factorize_retry=0;
2016	ideal f=singclap_factorize((poly)(u->CopyD()), &v, fac_sw);
2017	if (f==NULL)
2018	return TRUE;
2019	switch(sw)
2020	{
2021	case 0:
2022	case 2:
2023	{
2024	lists l=(lists)omAllocBin(slists_bin);
2025	l->Init(2);
2026	l->m[0].rtyp=IDEAL_CMD;
2027	l->m[0].data=(void *)f;
2028	l->m[1].rtyp=INTVEC_CMD;
2029	l->m[1].data=(void *)v;
2030	res->data=(void *)l;
2031	res->rtyp=LIST_CMD;
2032	return FALSE;
2033	}
2034	case 1:
2035	res->data=(void *)f;
2036	return FALSE;
2037	case 3:
2038	{
2039	poly p=f->m[0];
2040	int i=IDELEMS(f);
2041	f->m[0]=NULL;
2042	while(i>1)
2043	{
2044	i--;
2045	p=pMult(p,f->m[i]);
2046	f->m[i]=NULL;
2047	}
2048	res->data=(void *)p;
2049	res->rtyp=POLY_CMD;
2050	}
2051	return FALSE;
2052	}
2053	WerrorS("invalid switch");
2054	return TRUE;
2055	}
2056	static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
2057	{
2058	ideal_list p,h;
2059	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
2060	p=h;
2061	int l=0;
2062	while (p!=NULL) { p=p->next;l++; }
2063	lists L=(lists)omAllocBin(slists_bin);
2064	L->Init(l);
2065	l=0;
2066	while(h!=NULL)
2067	{
2068	L->m[l].data=(char *)h->d;
2069	L->m[l].rtyp=IDEAL_CMD;
2070	p=h->next;
2071	omFreeSize(h,sizeof(*h));
2072	h=p;
2073	l++;
2074	}
2075	res->data=(void *)L;
2076	return FALSE;
2077	}
2078	#endif /* HAVE_FACTORY */
2079	static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
2080	{
2081	ring r=(ring)u->Data();
2082	idhdl w;
2083	int op=iiOp;
2084	nMapFunc nMap;
2085
2086	if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
2087	{
2088	int *perm=NULL;
2089	int *par_perm=NULL;
2090	int par_perm_size=0;
2091	BOOLEAN bo;
2092	//if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
2093	if ((nMap=nSetMap(r))==NULL)
2094	{
2095	if (rEqual(r,currRing))
2096	{
2097	nMap=nCopy;
2098	}
2099	else
2100	// Allow imap/fetch to be make an exception only for:
2101	if ( (rField_is_Q_a(r) && // Q(a..) -> Q(a..) \|\| Q \|\| Zp \|\| Zp(a)
2102	(rField_is_Q() \|\| rField_is_Q_a() \|\|
2103	(rField_is_Zp() \|\| rField_is_Zp_a())))
2104	\|\|
2105	(rField_is_Zp_a(r) && // Zp(a..) -> Zp(a..) \|\| Zp
2106	(rField_is_Zp(currRing, rInternalChar(r)) \|\|
2107	rField_is_Zp_a(currRing, rInternalChar(r)))) )
2108	{
2109	par_perm_size=rPar(r);
2110	BITSET save_test=test;
2111	naSetChar(rInternalChar(r),r);
2112	nSetChar(currRing);
2113	test=save_test;
2114	}
2115	else
2116	{
2117	goto err_fetch;
2118	}
2119	}
2120	if ((iiOp!=FETCH_CMD) \|\| (r->N!=pVariables) \|\| (rPar(r)!=rPar(currRing)))
2121	{
2122	perm=(int )omAlloc0((r->N+1)sizeof(int));
2123	if (par_perm_size!=0)
2124	par_perm=(int )omAlloc0(par_perm_sizesizeof(int));
2125	op=IMAP_CMD;
2126	if (iiOp==IMAP_CMD)
2127	{
2128	maFindPerm(r->names, r->N, r->parameter, r->P,
2129	currRing->names,currRing->N,currRing->parameter, currRing->P,
2130	perm,par_perm, currRing->ch);
2131	}
2132	else
2133	{
2134	int i;
2135	if (par_perm_size!=0)
2136	for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
2137	for(i=si_min(r->N,pVariables);i>0;i--) perm[i]=i;
2138	}
2139	}
2140	if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
2141	{
2142	int i;
2143	for(i=0;i<si_min(r->N,pVariables);i++)
2144	{
2145	Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
2146	}
2147	for(i=0;i<si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
2148	{
2149	Print("// par nr %d: %s -> %s\n",
2150	i,r->parameter[i],currRing->parameter[i]);
2151	}
2152	}
2153	sleftv tmpW;
2154	memset(&tmpW,0,sizeof(sleftv));
2155	tmpW.rtyp=IDTYP(w);
2156	tmpW.data=IDDATA(w);
2157	if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
2158	perm,par_perm,par_perm_size,nMap)))
2159	{
2160	Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
2161	}
2162	if (perm!=NULL)
2163	omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
2164	if (par_perm!=NULL)
2165	omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
2166	return bo;
2167	}
2168	else
2169	{
2170	Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
2171	}
2172	return TRUE;
2173	err_fetch:
2174	Werror("no identity map from %s",u->Fullname());
2175	return TRUE;
2176	}
2177	static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
2178	{
2179	/*4
2180	* look for the substring what in the string where
2181	* return the position of the first char of what in where
2182	* or 0
2183	*/
2184	char where=(char )u->Data();
2185	char what=(char )v->Data();
2186	char *found = strstr(where,what);
2187	if (found != NULL)
2188	{
2189	res->data=(char *)((found-where)+1);
2190	}
2191	/else res->data=NULL;/
2192	return FALSE;
2193	}
2194	static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
2195	{
2196	res->data=(char *)fractalWalkProc(u,v);
2197	setFlag( res, FLAG_STD );
2198	return FALSE;
2199	}
2200	static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
2201	{
2202	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
2203	int p0=ABS(uu),p1=ABS(vv);
2204	int r;
2205	while ( p1!=0 )
2206	{
2207	r=p0 % p1;
2208	p0 = p1; p1 = r;
2209	}
2210	res->rtyp=INT_CMD;
2211	res->data=(char *)(long)p0;
2212	return FALSE;
2213	}
2214	static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
2215	{
2216	number a=(number) u->Data();
2217	number b=(number) v->Data();
2218	if (nlIsZero(a))
2219	{
2220	if (nlIsZero(b)) res->data=(char *)nlInit(1);
2221	else res->data=(char *)nlCopy(b);
2222	}
2223	else
2224	{
2225	if (nlIsZero(b)) res->data=(char *)nlCopy(a);
2226	else res->data=(char *)nlGcd(a, b, NULL);
2227	}
2228	return FALSE;
2229	}
2230	static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
2231	{
2232	number a=(number) u->Data();
2233	number b=(number) v->Data();
2234	if (nIsZero(a))
2235	{
2236	if (nIsZero(b)) res->data=(char *)nInit(1);
2237	else res->data=(char *)nCopy(b);
2238	}
2239	else
2240	{
2241	if (nIsZero(b)) res->data=(char *)nCopy(a);
2242	else res->data=(char *)nGcd(a, b, currRing);
2243	}
2244	return FALSE;
2245	}
2246	#ifdef HAVE_FACTORY
2247	static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
2248	{
2249	res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
2250	(poly)(v->CopyD(POLY_CMD)));
2251	return FALSE;
2252	}
2253	#endif /* HAVE_FACTORY */
2254	static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
2255	{
2256	assumeStdFlag(u);
2257	intvec module_w=(intvec)atGet(u,"isHomog",INTVEC_CMD);
2258	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
2259	switch((int)(long)v->Data())
2260	{
2261	case 1:
2262	res->data=(void *)iv;
2263	return FALSE;
2264	case 2:
2265	res->data=(void *)hSecondSeries(iv);
2266	delete iv;
2267	return FALSE;
2268	}
2269	WerrorS(feNotImplemented);
2270	delete iv;
2271	return TRUE;
2272	}
2273	static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
2274	{
2275	int i=pVar((poly)v->Data());
2276	if (i==0)
2277	{
2278	WerrorS("ringvar expected");
2279	return TRUE;
2280	}
2281	poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2282	int d=pWTotaldegree(p);
2283	pLmDelete(p);
2284	if (d==1)
2285	res->data = (char *)pHomogen((poly)u->Data(),i);
2286	else
2287	WerrorS("variable must have weight 1");
2288	return (d!=1);
2289	}
2290	static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
2291	{
2292	int i=pVar((poly)v->Data());
2293	if (i==0)
2294	{
2295	WerrorS("ringvar expected");
2296	return TRUE;
2297	}
2298	poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2299	int d=pWTotaldegree(p);
2300	pLmDelete(p);
2301	if (d==1)
2302	res->data = (char *)idHomogen((ideal)u->Data(),i);
2303	else
2304	WerrorS("variable must have weight 1");
2305	return (d!=1);
2306	}
2307	static BOOLEAN jjHOMOG1_W(leftv res, leftv v, leftv u)
2308	{
2309	intvec *w=new intvec(rVar(currRing));
2310	intvec vw=(intvec)u->Data();
2311	ideal v_id=(ideal)v->Data();
2312	pFDegProc save_FDeg=pFDeg;
2313	pLDegProc save_LDeg=pLDeg;
2314	BOOLEAN save_pLexOrder=pLexOrder;
2315	pLexOrder=FALSE;
2316	kHomW=vw;
2317	kModW=w;
2318	pSetDegProcs(kHomModDeg);
2319	res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
2320	pLexOrder=save_pLexOrder;
2321	kHomW=NULL;
2322	kModW=NULL;
2323	pRestoreDegProcs(save_FDeg,save_LDeg);
2324	if (w!=NULL) delete w;
2325	return FALSE;
2326	}
2327	static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
2328	{
2329	assumeStdFlag(u);
2330	res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2331	currQuotient);
2332	return FALSE;
2333	}
2334	static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
2335	{
2336	res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2337	setFlag(res,FLAG_STD);
2338	return FALSE;
2339	}
2340	static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2341	{
2342	return jjStdJanetBasis(res,u,(int)(long)v->Data());
2343	}
2344	static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2345	{
2346	res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2347	return FALSE;
2348	}
2349	static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2350	{
2351	res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
2352	return FALSE;
2353	}
2354	static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2355	{
2356	assumeStdFlag(u);
2357	intvec w_u=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2358	res->data = (char *)scKBase((int)(long)v->Data(),
2359	(ideal)(u->Data()),currQuotient, w_u);
2360	if (w_u!=NULL)
2361	{
2362	atSet(res,omStrDup("isHomog"),ivCopy(w_u),INTVEC_CMD);
2363	}
2364	return FALSE;
2365	}
2366	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w);
2367	static BOOLEAN jjKERNEL(leftv res, leftv u, leftv v)
2368	{
2369	return jjPREIMAGE(res,u,v,NULL);
2370	}
2371	static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2372	{
2373	return mpKoszul(res, u,v);
2374	}
2375	static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2376	{
2377	sleftv h;
2378	memset(&h,0,sizeof(sleftv));
2379	h.rtyp=INT_CMD;
2380	h.data=(void *)(long)IDELEMS((ideal)v->Data());
2381	return mpKoszul(res, u, &h, v);
2382	}
2383	static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2384	{
2385	ideal m;
2386	BITSET save_test=test;
2387	int ul= IDELEMS((ideal)u->Data());
2388	int vl= IDELEMS((ideal)v->Data());
2389	m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
2390	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
2391	test=save_test;
2392	return FALSE;
2393	}
2394	static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2395	{
2396	if ((v->rtyp!=IDHDL)\|\|(v->e!=NULL)) return TRUE;
2397	idhdl h=(idhdl)v->data;
2398	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2399	res->data = (char *)idLiftStd((ideal)u->Data(),
2400	&(h->data.umatrix),testHomog);
2401	setFlag(res,FLAG_STD);
2402	return FALSE;
2403	}
2404	static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2405	{
2406	char * s=(char *)u->Data();
2407	if(strcmp(s, "with")==0)
2408	return jjLOAD(res, v, TRUE);
2409	WerrorS("invalid second argument");
2410	WerrorS("load(\"libname\" [,\"with\"]);");
2411	return TRUE;
2412	}
2413	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2414	{
2415	res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2416	return (res->data==NULL);
2417	}
2418	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2419	{
2420	intvec w_u=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2421	tHomog hom=testHomog;
2422	if (w_u!=NULL)
2423	{
2424	w_u=ivCopy(w_u);
2425	hom=isHomog;
2426	}
2427	intvec w_v=(intvec )atGet(v,"isHomog",INTVEC_CMD);
2428	if (w_v!=NULL)
2429	{
2430	w_v=ivCopy(w_v);
2431	hom=isHomog;
2432	}
2433	if ((w_u!=NULL) && (w_v==NULL))
2434	w_v=ivCopy(w_u);
2435	if ((w_v!=NULL) && (w_u==NULL))
2436	w_u=ivCopy(w_v);
2437	ideal u_id=(ideal)u->Data();
2438	ideal v_id=(ideal)v->Data();
2439	if (w_u!=NULL)
2440	{
2441	if ((*w_u).compare((w_v))!=0)
2442	{
2443	WarnS("incompatible weights");
2444	delete w_u; w_u=NULL;
2445	hom=testHomog;
2446	}
2447	else
2448	{
2449	if ((!idTestHomModule(u_id,currQuotient,w_v))
2450	\|\| (!idTestHomModule(v_id,currQuotient,w_v)))
2451	{
2452	WarnS("wrong weights");
2453	delete w_u; w_u=NULL;
2454	hom=testHomog;
2455	}
2456	}
2457	}
2458	res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2459	if (w_u!=NULL)
2460	{
2461	atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2462	}
2463	delete w_v;
2464	return FALSE;
2465	}
2466	static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2467	{
2468	number q=(number)v->Data();
2469	if (nlIsZero(q))
2470	{
2471	WerrorS(ii_div_by_0);
2472	return TRUE;
2473	}
2474	res->data =(char *) nlIntMod((number)u->Data(),q);
2475	return FALSE;
2476	}
2477	static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2478	{
2479	number q=(number)v->Data();
2480	if (nIsZero(q))
2481	{
2482	WerrorS(ii_div_by_0);
2483	return TRUE;
2484	}
2485	res->data =(char *) nIntMod((number)u->Data(),q);
2486	return FALSE;
2487	}
2488	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v);
2489	static BOOLEAN jjMONITOR1(leftv res, leftv v)
2490	{
2491	return jjMONITOR2(res,v,NULL);
2492	}
2493	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2494	{
2495	#if 0
2496	char opt=(char )v->Data();
2497	int mode=0;
2498	while(*opt!='\0')
2499	{
2500	if (*opt=='i') mode \|= PROT_I;
2501	else if (*opt=='o') mode \|= PROT_O;
2502	opt++;
2503	}
2504	monitor((char *)(u->Data()),mode);
2505	#else
2506	si_link l=(si_link)u->Data();
2507	if (slOpen(l,SI_LINK_WRITE)) return TRUE;
2508	if(strcmp(l->m->type,"ASCII")!=0)
2509	{
2510	Werror("ASCII link required, not `%s`",l->m->type);
2511	slClose(l);
2512	return TRUE;
2513	}
2514	SI_LINK_SET_CLOSE_P(l); // febase handles the FILE*
2515	char *opt;
2516	if (v==NULL) opt="i";
2517	else opt=(char *)v->Data();
2518	int mode=0;
2519	while(*opt!='\0')
2520	{
2521	if (*opt=='i') mode \|= PROT_I;
2522	else if (*opt=='o') mode \|= PROT_O;
2523	opt++;
2524	}
2525	if (((FILE*)l->data) == stdin) monitor(NULL,0);
2526	else monitor((FILE *)l->data,mode);
2527	return FALSE;
2528	#endif
2529	}
2530	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2531	{
2532	idhdl h=(idhdl)u->data;
2533	int i=(int)(long)v->Data();
2534	int p=0;
2535	if ((0<i)
2536	&& (IDRING(h)->parameter!=NULL)
2537	&& (i<=(p=rPar(IDRING(h)))))
2538	res->data=omStrDup(IDRING(h)->parameter[i-1]);
2539	else
2540	{
2541	Werror("par number %d out of range 1..%d",i,p);
2542	return TRUE;
2543	}
2544	return FALSE;
2545	}
2546	#ifdef HAVE_PLURAL
2547	static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2548	{
2549	if (iiOp==NCALGEBRA_CMD)
2550	{
2551	return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2552	}
2553	else
2554	{
2555	ring r=rCopy(currRing);
2556	BOOLEAN result=nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),r);
2557	res->data=r;
2558	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2559	return result;
2560	}
2561	}
2562	static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2563	{
2564	if (iiOp==NCALGEBRA_CMD)
2565	{
2566	return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2567	}
2568	else
2569	{
2570	ring r=rCopy(currRing);
2571	BOOLEAN result=nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,r);
2572	res->data=r;
2573	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2574	return result;
2575	}
2576	}
2577	static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2578	{
2579	if (iiOp==NCALGEBRA_CMD)
2580	{
2581	return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2582	}
2583	else
2584	{
2585	ring r=rCopy(currRing);
2586	BOOLEAN result=nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),r);
2587	res->data=r;
2588	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2589	return result;
2590	}
2591	}
2592	static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2593	{
2594	if (iiOp==NCALGEBRA_CMD)
2595	{
2596	return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2597	}
2598	else
2599	{
2600	ring r=rCopy(currRing);
2601	BOOLEAN result=nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,r);
2602	res->data=r;
2603	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
2604	return result;
2605	}
2606	}
2607	static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2608	{
2609	if (rIsPluralRing(currRing))
2610	{
2611	poly p = (poly)a->CopyD(POLY_CMD);
2612	poly q = (poly)b->Data();
2613	res->data = nc_p_Bracket_qq(p,q);
2614	}
2615	else res->data=NULL;
2616	return FALSE;
2617	}
2618	static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2619	{
2620	/* number, poly, vector, ideal, module, matrix */
2621	ring r = (ring)a->Data();
2622	if (r == currRing)
2623	{
2624	res->data = b->Data();
2625	res->rtyp = b->rtyp;
2626	return FALSE;
2627	}
2628	if (!rIsLikeOpposite(currRing, r))
2629	{
2630	Werror("%s is not an opposite ring to current ring",a->Fullname());
2631	return TRUE;
2632	}
2633	idhdl w;
2634	if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2635	{
2636	int argtype = IDTYP(w);
2637	switch (argtype)
2638	{
2639	case NUMBER_CMD:
2640	{
2641	/* since basefields are equal, we can apply nCopy */
2642	res->data = nCopy((number)IDDATA(w));
2643	res->rtyp = argtype;
2644	break;
2645	}
2646	case POLY_CMD:
2647	case VECTOR_CMD:
2648	{
2649	poly q = (poly)IDDATA(w);
2650	res->data = pOppose(r,q);
2651	res->rtyp = argtype;
2652	break;
2653	}
2654	case IDEAL_CMD:
2655	case MODUL_CMD:
2656	{
2657	ideal Q = (ideal)IDDATA(w);
2658	res->data = idOppose(r,Q);
2659	res->rtyp = argtype;
2660	break;
2661	}
2662	case MATRIX_CMD:
2663	{
2664	ring save = currRing;
2665	rChangeCurrRing(r);
2666	matrix m = (matrix)IDDATA(w);
2667	ideal Q = idMatrix2Module(mpCopy(m));
2668	rChangeCurrRing(save);
2669	ideal S = idOppose(r,Q);
2670	id_Delete(&Q, r);
2671	res->data = idModule2Matrix(S);
2672	res->rtyp = argtype;
2673	break;
2674	}
2675	default:
2676	{
2677	WerrorS("unsupported type in oppose");
2678	return TRUE;
2679	}
2680	}
2681	}
2682	else
2683	{
2684	Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2685	return TRUE;
2686	}
2687	return FALSE;
2688	}
2689	#endif /* HAVE_PLURAL */
2690
2691	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2692	{
2693	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2694	hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2695	idDelMultiples((ideal)(res->data));
2696	return FALSE;
2697	}
2698	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2699	{
2700	int i=(int)(long)u->Data();
2701	int j=(int)(long)v->Data();
2702	#ifdef buildin_rand
2703	res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
2704	#else /* buildin_rand */
2705	res->data =(char *)(long)((i > j) ? i : (rand() % (j-i+1)) + i);
2706	#endif /* buildin_rand */
2707	return FALSE;
2708	}
2709	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2710	{
2711	si_link l=(si_link)u->Data();
2712	leftv r=slRead(l,v);
2713	if (r==NULL)
2714	{
2715	const char *s;
2716	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2717	else s=sNoName;
2718	Werror("cannot read from `%s`",s);
2719	return TRUE;
2720	}
2721	memcpy(res,r,sizeof(sleftv));
2722	omFreeBin((ADDRESS)r, sleftv_bin);
2723	return FALSE;
2724	}
2725	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2726	{
2727	assumeStdFlag(v);
2728	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2729	return FALSE;
2730	}
2731	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2732	{
2733	assumeStdFlag(v);
2734	ideal ui=(ideal)u->Data();
2735	idTest(ui);
2736	ideal vi=(ideal)v->Data();
2737	idTest(vi);
2738	res->data = (char *)kNF(vi,currQuotient,ui);
2739	return FALSE;
2740	}
2741	#if 0
2742	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2743	{
2744	int maxl=(int)(long)v->Data();
2745	if (maxl<0)
2746	{
2747	WerrorS("length for res must not be negative");
2748	return TRUE;
2749	}
2750	int l=0;
2751	//resolvente r;
2752	syStrategy r;
2753	intvec *weights=NULL;
2754	int wmaxl=maxl;
2755	ideal u_id=(ideal)u->Data();
2756
2757	maxl--;
2758	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2759	{
2760	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2761	if (currQuotient!=NULL)
2762	{
2763	Warn(
2764	"full resolution in a qring may be infinite, setting max length to %d",
2765	maxl+1);
2766	}
2767	}
2768	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2769	if (weights!=NULL)
2770	{
2771	if (!idTestHomModule(u_id,currQuotient,weights))
2772	{
2773	WarnS("wrong weights given:");weights->show();PrintLn();
2774	weights=NULL;
2775	}
2776	}
2777	intvec *ww=NULL;
2778	int add_row_shift=0;
2779	if (weights!=NULL)
2780	{
2781	ww=ivCopy(weights);
2782	add_row_shift = ww->min_in();
2783	(*ww) -= add_row_shift;
2784	}
2785	else
2786	idHomModule(u_id,currQuotient,&ww);
2787	weights=ww;
2788
2789	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2790	{
2791	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2792	}
2793	else if (iiOp==SRES_CMD)
2794	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2795	r=sySchreyer(u_id,maxl+1);
2796	else if (iiOp == LRES_CMD)
2797	{
2798	int dummy;
2799	if((currQuotient!=NULL)\|\|
2800	(!idHomIdeal (u_id,NULL)))
2801	{
2802	WerrorS
2803	("`lres` not implemented for inhomogeneous input or qring");
2804	return TRUE;
2805	}
2806	r=syLaScala3(u_id,&dummy);
2807	}
2808	else if (iiOp == KRES_CMD)
2809	{
2810	int dummy;
2811	if((currQuotient!=NULL)\|\|
2812	(!idHomIdeal (u_id,NULL)))
2813	{
2814	WerrorS
2815	("`kres` not implemented for inhomogeneous input or qring");
2816	return TRUE;
2817	}
2818	r=syKosz(u_id,&dummy);
2819	}
2820	else
2821	{
2822	int dummy;
2823	if((currQuotient!=NULL)\|\|
2824	(!idHomIdeal (u_id,NULL)))
2825	{
2826	WerrorS
2827	("`hres` not implemented for inhomogeneous input or qring");
2828	return TRUE;
2829	}
2830	r=syHilb(u_id,&dummy);
2831	}
2832	if (r==NULL) return TRUE;
2833	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2834	r->list_length=wmaxl;
2835	res->data=(void *)r;
2836	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2837	{
2838	intvec *w=ivCopy(r->weights[0]);
2839	if (weights!=NULL) (*w) += add_row_shift;
2840	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2841	w=NULL;
2842	}
2843	else
2844	{
2845	//#if 0
2846	// need to set weights for ALL components (sres)
2847	if (weights!=NULL)
2848	{
2849	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2850	r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2851	(r->weights)[0] = ivCopy(weights);
2852	}
2853	//#endif
2854	}
2855	if (ww!=NULL) { delete ww; ww=NULL; }
2856	return FALSE;
2857	}
2858	#else
2859	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2860	{
2861	int maxl=(int)(long)v->Data();
2862	if (maxl<0)
2863	{
2864	WerrorS("length for res must not be negative");
2865	return TRUE;
2866	}
2867	int l=0;
2868	//resolvente r;
2869	syStrategy r;
2870	intvec *weights=NULL;
2871	int wmaxl=maxl;
2872	ideal u_id=(ideal)u->Data();
2873
2874	maxl--;
2875	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2876	{
2877	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2878	if (currQuotient!=NULL)
2879	{
2880	Warn(
2881	"full resolution in a qring may be infinite, setting max length to %d",
2882	maxl+1);
2883	}
2884	}
2885	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2886	if (weights!=NULL)
2887	{
2888	if (!idTestHomModule(u_id,currQuotient,weights))
2889	{
2890	WarnS("wrong weights given:");weights->show();PrintLn();
2891	weights=NULL;
2892	}
2893	}
2894	intvec *ww=NULL;
2895	int add_row_shift=0;
2896	if (weights!=NULL)
2897	{
2898	ww=ivCopy(weights);
2899	add_row_shift = ww->min_in();
2900	(*ww) -= add_row_shift;
2901	}
2902	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2903	{
2904	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2905	}
2906	else if (iiOp==SRES_CMD)
2907	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2908	r=sySchreyer(u_id,maxl+1);
2909	else if (iiOp == LRES_CMD)
2910	{
2911	int dummy;
2912	if((currQuotient!=NULL)\|\|
2913	(!idHomIdeal (u_id,NULL)))
2914	{
2915	WerrorS
2916	("`lres` not implemented for inhomogeneous input or qring");
2917	return TRUE;
2918	}
2919	r=syLaScala3(u_id,&dummy);
2920	}
2921	else if (iiOp == KRES_CMD)
2922	{
2923	int dummy;
2924	if((currQuotient!=NULL)\|\|
2925	(!idHomIdeal (u_id,NULL)))
2926	{
2927	WerrorS
2928	("`kres` not implemented for inhomogeneous input or qring");
2929	return TRUE;
2930	}
2931	r=syKosz(u_id,&dummy);
2932	}
2933	else
2934	{
2935	int dummy;
2936	if((currQuotient!=NULL)\|\|
2937	(!idHomIdeal (u_id,NULL)))
2938	{
2939	WerrorS
2940	("`hres` not implemented for inhomogeneous input or qring");
2941	return TRUE;
2942	}
2943	r=syHilb(u_id,&dummy);
2944	}
2945	if (r==NULL) return TRUE;
2946	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2947	r->list_length=wmaxl;
2948	res->data=(void *)r;
2949	if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2950	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2951	{
2952	ww=ivCopy(r->weights[0]);
2953	if (weights!=NULL) (*ww) += add_row_shift;
2954	atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2955	}
2956	else
2957	{
2958	if (weights!=NULL)
2959	{
2960	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2961	}
2962	}
2963	return FALSE;
2964	}
2965	#endif
2966	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2967	{
2968	ring r;
2969	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2970	res->data = (char *)r;
2971	return (i==-1);
2972	}
2973	#define SIMPL_LMDIV 32
2974	#define SIMPL_LMEQ 16
2975	#define SIMPL_MULT 8
2976	#define SIMPL_EQU 4
2977	#define SIMPL_NULL 2
2978	#define SIMPL_NORM 1
2979	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2980	{
2981	int sw = (int)(long)v->Data();
2982	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2983	ideal id = (ideal)u->CopyD(IDEAL_CMD);
2984	if (sw & SIMPL_LMDIV)
2985	{
2986	idDelDiv(id);
2987	}
2988	if (sw & SIMPL_LMEQ)
2989	{
2990	idDelLmEquals(id);
2991	}
2992	if (sw & SIMPL_MULT)
2993	{
2994	idDelMultiples(id);
2995	}
2996	else if(sw & SIMPL_EQU)
2997	{
2998	idDelEquals(id);
2999	}
3000	if (sw & SIMPL_NULL)
3001	{
3002	idSkipZeroes(id);
3003	}
3004	if (sw & SIMPL_NORM)
3005	{
3006	idNorm(id);
3007	}
3008	res->data = (char * )id;
3009	return FALSE;
3010	}
3011	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
3012	{
3013	res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
3014	return FALSE;
3015	}
3016	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
3017	{
3018	int sw = (int)(long)v->Data();
3019	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3020	poly p = (poly)u->CopyD(POLY_CMD);
3021	if (sw & SIMPL_NORM)
3022	{
3023	pNorm(p);
3024	}
3025	res->data = (char * )p;
3026	return FALSE;
3027	}
3028	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
3029	{
3030	ideal result;
3031	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
3032	tHomog hom=testHomog;
3033	ideal u_id=(ideal)(u->Data());
3034	if (w!=NULL)
3035	{
3036	if (!idTestHomModule(u_id,currQuotient,w))
3037	{
3038	WarnS("wrong weights:");w->show();PrintLn();
3039	w=NULL;
3040	}
3041	else
3042	{
3043	w=ivCopy(w);
3044	hom=isHomog;
3045	}
3046	}
3047	result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
3048	idSkipZeroes(result);
3049	res->data = (char *)result;
3050	setFlag(res,FLAG_STD);
3051	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3052	return FALSE;
3053	}
3054	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
3055	{
3056	ideal result;
3057	assumeStdFlag(u);
3058	ideal i1=(ideal)(u->Data());
3059	ideal i0;
3060	int r=v->Typ();
3061	if ((/v->Typ()/r==POLY_CMD) \|\|(r==VECTOR_CMD))
3062	{
3063	i0=idInit(1,i1->rank);
3064	i0->m[0]=(poly)v->Data();
3065	}
3066	else /IDEAL/
3067	{
3068	i0=(ideal)v->CopyD();
3069	}
3070	int ii0=idElem(i0); /* size of i0 */
3071	i1=idSimpleAdd(i1,i0);
3072	memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3073	idDelete(&i0);
3074	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
3075	tHomog hom=testHomog;
3076
3077	if (w!=NULL)
3078	{
3079	if (!idTestHomModule(i1,currQuotient,w))
3080	{
3081	// no warnung: this is legal, if i in std(i,p)
3082	// is homogeneous, but p not
3083	w=NULL;
3084	}
3085	else
3086	{
3087	w=ivCopy(w);
3088	hom=isHomog;
3089	}
3090	}
3091	BITSET save_test=test;
3092	test\|=Sy_bit(OPT_SB_1);
3093	/* IDELEMS(il)-ii0 appears to be the position of the first element of il that
3094	does not belong to the input ideal */
3095	result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-ii0);
3096	test=save_test;
3097	idDelete(&i1);
3098	idSkipZeroes(result);
3099	res->data = (char *)result;
3100	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
3101	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3102	return FALSE;
3103	}
3104	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
3105	{
3106	idhdl h=(idhdl)u->data;
3107	int i=(int)(long)v->Data();
3108	if ((0<i) && (i<=IDRING(h)->N))
3109	res->data=omStrDup(IDRING(h)->names[i-1]);
3110	else
3111	{
3112	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
3113	return TRUE;
3114	}
3115	return FALSE;
3116	}
3117	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
3118	{
3119	res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
3120	return FALSE;
3121	}
3122	#define jjWRONG2 (proc2)jjWRONG
3123	#define jjWRONG3 (proc3)jjWRONG
3124	static BOOLEAN jjWRONG(leftv res, leftv u)
3125	{
3126	return TRUE;
3127	}
3128
3129	/=================== operations with 2 args.: table =================/
3130
3131	struct sValCmd2 dArith2[]=
3132	{
3133	// operations:
3134	// proc cmd res arg1 arg2 plural
3135	{jjCOLCOL, COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3136	,{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3137	,{jjPLUS_BI, '+', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3138	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3139	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3140	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3141	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3142	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3143	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
3144	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3145	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3146	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3147	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3148	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
3149	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3150	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
3151	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3152	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3153	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
3154	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
3155	,{jjRSUM, '+', QRING_CMD, QRING_CMD, RING_CMD ALLOW_PLURAL}
3156	,{jjRSUM, '+', QRING_CMD, RING_CMD, QRING_CMD ALLOW_PLURAL}
3157	,{jjRSUM, '+', QRING_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
3158	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3159	,{jjMINUS_BI, '-', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3160	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3161	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3162	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3163	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3164	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3165	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3166	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3167	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3168	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3169	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3170	,{jjTIMES_BI, '*', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3171	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3172	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3173	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD ALLOW_PLURAL}
3174	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3175	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3176	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
3177	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3178	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD ALLOW_PLURAL}
3179	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD NO_PLURAL}
3180	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
3181	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3182	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3183	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
3184	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
3185	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
3186	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3187	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
3188	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3189	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3190	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
3191	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3192	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
3193	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
3194	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3195	,{jjTIMES_IV, '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
3196	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3197	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3198	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3199	,{jjDIV_Ma, '/', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3200	,{jjDIVMOD_I, '/', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3201	,{jjDIV_BI, '/', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3202	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3203	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3204	,{jjDIVMOD_I, INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3205	,{jjDIV_BI, INTDIV_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3206	,{jjOP_IV_I, INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3207	,{jjOP_IV_I, INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3208	,{jjDIVMOD_I, '%', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3209	,{jjMOD_BI, '%', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3210	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3211	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3212	,{jjMOD_N, '%', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3213	,{jjDIVMOD_I, INTMOD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3214	,{jjMOD_BI, INTMOD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3215	,{jjOP_IV_I, INTMOD_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3216	,{jjOP_IV_I, INTMOD_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
3217	,{jjMOD_N, INTMOD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3218	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3219	,{jjPOWER_BI, '^', BIGINT_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
3220	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
3221	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3222	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3223	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3224	,{jjLE_BI, LE, INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3225	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3226	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3227	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3228	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3229	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3230	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3231	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3232	,{jjLT_BI, '<', INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3233	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3234	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3235	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3236	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3237	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3238	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3239	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3240	,{jjGE_BI, GE, INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3241	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3242	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3243	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3244	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3245	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3246	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3247	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3248	,{jjGT_BI, '>', INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3249	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3250	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3251	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3252	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3253	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3254	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3255	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3256	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3257	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3258	,{jjEQUAL_BI, EQUAL_EQUAL, INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3259	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3260	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3261	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3262	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3263	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3264	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3265	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3266	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3267	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3268	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3269	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
3270	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3271	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3272	,{jjEQUAL_BI, NOTEQUAL, INT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3273	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3274	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3275	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3276	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
3277	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3278	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
3279	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
3280	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3281	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3282	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
3283	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3284	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3285	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
3286	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3287	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3288	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD ALLOW_PLURAL}
3289	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
3290	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3291	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
3292	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
3293	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
3294	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD ALLOW_PLURAL}
3295	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
3296	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3297	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
3298	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3299	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3300	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
3301	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
3302	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
3303	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
3304	,{jjCOLON, ':', INTVEC_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3305	// and the procedures with 2 arguments:
3306	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD ALLOW_PLURAL}
3307	,{jjWRONG2, BAREISS_CMD, 0, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3308	,{jjBETTI2, BETTI_CMD, INTMAT_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3309	,{syBetti2, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
3310	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3311	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3312	#ifdef HAVE_PLURAL
3313	,{jjBRACKET, BRACKET_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3314	#endif
3315	,{jjCHINREM_BI,CHINREM_CMD, BIGINT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
3316	//,{jjCHINREM_P, CHINREM_CMD, POLY_CMD, LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
3317	,{jjCHINREM_ID,CHINREM_CMD, IDEAL_CMD, LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
3318	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3319	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3320	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3321	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3322	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3323	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3324	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
3325	,{jjDEG_IV, DEG_CMD, INT_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
3326	,{jjDEG_M_IV, DEG_CMD, INT_CMD, MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
3327	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
3328	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3329	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3330	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3331	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3332	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3333	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
3334	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3335	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD NO_PLURAL}
3336	,{jjDIVISION, DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3337	,{jjDIVISION, DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
3338	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3339	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3340	,{jjELIMIN_IV, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
3341	,{jjELIMIN_IV, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
3342	,{jjEXPORTTO, EXPORTTO_CMD, NONE, PACKAGE_CMD, IDHDL ALLOW_PLURAL}
3343	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3344	#ifdef HAVE_FACTORY
3345	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3346	,{jjFAC_P2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3347	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3348	#else
3349	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3350	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3351	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3352	#endif
3353	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3354	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3355	#ifdef HAVE_FGLM
3356	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3357	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3358	,{fglmQuotProc,FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD NO_PLURAL}
3359	#else
3360	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3361	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3362	,{jjWRONG2, FGLMQUOT_CMD, IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
3363	#endif
3364	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3365	,{jjFWALK, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3366	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3367	,{jjGCD_N, GCD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3368	,{jjGCD_BI, GCD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3369	#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
3370	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3371	#else
3372	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3373	#endif
3374	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3375	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3376	,{jjHOMOG1_W, HOMOG_CMD, INT_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
3377	,{jjHOMOG1_W, HOMOG_CMD, INT_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
3378	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3379	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3380	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3381	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3382	,{jjRES, HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3383	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3384	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3385	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3386	,{jjIMPORTFROM,IMPORTFROM_CMD, NONE, PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
3387	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3388	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
3389	#ifdef HAVE_INTERPOLATION
3390	,{jjINTERPOLATION,INTERPOLATE_CMD,IDEAL_CMD, LIST_CMD, INTVEC_CMD NO_PLURAL}
3391	#endif
3392	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3393	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3394	,{jjJanetBasis2, JANET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3395	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3396	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3397	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3398	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3399	,{jjJET_ID, JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3400	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3401	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3402	,{jjKERNEL, KERNEL_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE ALLOW_PLURAL}
3403	,{jjKERNEL, KERNEL_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3404	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD ALLOW_PLURAL}
3405	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD NO_PLURAL}
3406	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
3407	,{jjRES, KRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3408	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3409	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3410	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
3411	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
3412	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3413	,{jjLOAD_E, LOAD_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3414	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3415	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3416	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3417	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3418	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3419	,{jjMONITOR2, MONITOR_CMD, NONE, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3420	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3421	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3422	,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3423	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3424	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3425	//,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3426	#ifdef HAVE_PLURAL
3427	,{jjPlural_num_poly, NCALGEBRA_CMD,NONE, POLY_CMD, POLY_CMD NO_PLURAL}
3428	,{jjPlural_num_mat, NCALGEBRA_CMD,NONE, POLY_CMD, MATRIX_CMD NO_PLURAL}
3429	,{jjPlural_mat_poly, NCALGEBRA_CMD,NONE, MATRIX_CMD, POLY_CMD NO_PLURAL}
3430	,{jjPlural_mat_mat, NCALGEBRA_CMD,NONE, MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3431	,{jjPlural_num_poly, NC_ALGEBRA_CMD,RING_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3432	,{jjPlural_num_mat, NC_ALGEBRA_CMD,RING_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
3433	,{jjPlural_mat_poly, NC_ALGEBRA_CMD,RING_CMD, MATRIX_CMD, POLY_CMD NO_PLURAL}
3434	,{jjPlural_mat_mat, NC_ALGEBRA_CMD,RING_CMD, MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3435	#endif
3436	#ifdef HAVE_PLURAL
3437	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, RING_CMD, DEF_CMD ALLOW_PLURAL}
3438	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, QRING_CMD, DEF_CMD ALLOW_PLURAL}
3439	#endif
3440	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3441	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3442	,{jjPRINT_FORMAT, PRINT_CMD, ANY_TYPE, DEF_CMD, STRING_CMD ALLOW_PLURAL}
3443	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3444	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3445	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3446	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3447	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3448	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
3449	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3450	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3451	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3452	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3453	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3454	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3455	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3456	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3457	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3458	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3459	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3460	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3461	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3462	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3463	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3464	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3465	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3466	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3467	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3468	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3469	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD ALLOW_PLURAL}
3470	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3471	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3472	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD NO_PLURAL}
3473	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD NO_PLURAL}
3474	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3475	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3476	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3477	,{NULL, 0, 0, 0, 0 NO_PLURAL}
3478	};
3479	/=================== operations with 1 arg.: static proc =================/
3480	static BOOLEAN jjDUMMY(leftv res, leftv u)
3481	{
3482	res->data = (char *)u->CopyD();
3483	return FALSE;
3484	}
3485	static BOOLEAN jjNULL(leftv res, leftv u)
3486	{
3487	return FALSE;
3488	}
3489	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3490	//{
3491	// res->data = (char *)((int)(long)u->Data()+1);
3492	// return FALSE;
3493	//}
3494	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3495	//{
3496	// res->data = (char *)((int)(long)u->Data()-1);
3497	// return FALSE;
3498	//}
3499	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3500	{
3501	if (IDTYP((idhdl)u->data)==INT_CMD)
3502	{
3503	int i=IDINT((idhdl)u->data);
3504	if (iiOp==PLUSPLUS) i++;
3505	else i--;
3506	IDDATA((idhdl)u->data)=(char *)(long)i;
3507	return FALSE;
3508	}
3509	return TRUE;
3510	}
3511	static BOOLEAN jjUMINUS_BI(leftv res, leftv u)
3512	{
3513	number n=(number)u->CopyD(BIGINT_CMD);
3514	n=nlNeg(n);
3515	res->data = (char *)n;
3516	return FALSE;
3517	}
3518	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3519	{
3520	res->data = (char *)(-(long)u->Data());
3521	return FALSE;
3522	}
3523	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3524	{
3525	number n=(number)u->CopyD(NUMBER_CMD);
3526	n=nNeg(n);
3527	res->data = (char *)n;
3528	return FALSE;
3529	}
3530	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3531	{
3532	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3533	return FALSE;
3534	}
3535	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3536	{
3537	poly m1=pISet(-1);
3538	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3539	return FALSE;
3540	}
3541	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3542	{
3543	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
3544	(iv)=(-1);
3545	res->data = (char *)iv;
3546	return FALSE;
3547	}
3548	static BOOLEAN jjPROC1(leftv res, leftv u)
3549	{
3550	return jjPROC(res,u,NULL);
3551	}
3552	static BOOLEAN jjBAREISS(leftv res, leftv v)
3553	{
3554	//matrix m=(matrix)v->Data();
3555	//lists l=mpBareiss(m,FALSE);
3556	intvec *iv;
3557	ideal m;
3558	smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3559	lists l=(lists)omAllocBin(slists_bin);
3560	l->Init(2);
3561	l->m[0].rtyp=MODUL_CMD;
3562	l->m[1].rtyp=INTVEC_CMD;
3563	l->m[0].data=(void *)m;
3564	l->m[1].data=(void *)iv;
3565	res->data = (char *)l;
3566	return FALSE;
3567	}
3568	//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3569	//{
3570	// intvec m=(intvec )v->CopyD(INTMAT_CMD);
3571	// ivTriangMat(m);
3572	// res->data = (char *)m;
3573	// return FALSE;
3574	//}
3575	static BOOLEAN jjBI2N(leftv res, leftv u)
3576	{
3577	if (rField_is_Q())
3578	{
3579	res->data=u->CopyD();
3580	return FALSE;
3581	}
3582	else
3583	{
3584	BOOLEAN bo=FALSE;
3585	number n=(number)u->CopyD();
3586	if (rField_is_Zp())
3587	{
3588	res->data=(void *)npMap0(n);
3589	}
3590	else if (rField_is_Q_a())
3591	{
3592	res->data=(void *)naMap00(n);
3593	}
3594	else if (rField_is_Zp_a())
3595	{
3596	res->data=(void *)naMap0P(n);
3597	}
3598	#ifdef HAVE_RINGS
3599	else if (rField_is_Ring_Z())
3600	{
3601	res->data=(void *)nrzMapQ(n);
3602	}
3603	else if (rField_is_Ring_ModN())
3604	{
3605	res->data=(void *)nrnMapQ(n);
3606	}
3607	else if (rField_is_Ring_PtoM())
3608	{
3609	res->data=(void *)nrnMapQ(n);
3610	}
3611	else if (rField_is_Ring_2toM())
3612	{
3613	res->data=(void *)nr2mMapQ(n);
3614	}
3615	#endif
3616	else
3617	{
3618	WerrorS("cannot convert bigint to this field");
3619	bo=TRUE;
3620	}
3621	nlDelete(&n,NULL);
3622	return bo;
3623	}
3624	}
3625	static BOOLEAN jjBI2P(leftv res, leftv u)
3626	{
3627	sleftv tmp;
3628	BOOLEAN bo=jjBI2N(&tmp,u);
3629	if (!bo)
3630	{
3631	number n=(number) tmp.data;
3632	if (nIsZero(n)) { res->data=NULL;nDelete(&n); }
3633	else
3634	{
3635	poly p=pOne();
3636	pSetCoeff(p,n);
3637	res->data=(void *)p;
3638	}
3639	}
3640	return bo;
3641	}
3642	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3643	{
3644	return iiExprArithM(res,u,iiOp);
3645	}
3646	static BOOLEAN jjCHAR(leftv res, leftv v)
3647	{
3648	res->data = (char *)(long)rChar((ring)v->Data());
3649	return FALSE;
3650	}
3651	static BOOLEAN jjCOLS(leftv res, leftv v)
3652	{
3653	res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3654	return FALSE;
3655	}
3656	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3657	{
3658	res->data = (char )(long)((intvec)(v->Data()))->cols();
3659	return FALSE;
3660	}
3661	static BOOLEAN jjCONTENT(leftv res, leftv v)
3662	{
3663	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3664	poly p=(poly)v->CopyD(POLY_CMD);
3665	if (p!=NULL) pCleardenom(p);
3666	res->data = (char *)p;
3667	return FALSE;
3668	}
3669	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3670	{
3671	res->data = (char *)(long)nSize((number)v->Data());
3672	return FALSE;
3673	}
3674	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3675	{
3676	lists l=(lists)v->Data();
3677	res->data = (char *)(long)(l->nr+1);
3678	return FALSE;
3679	}
3680	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3681	{
3682	matrix m=(matrix)v->Data();
3683	res->data = (char )(long)(MATROWS(m)MATCOLS(m));
3684	return FALSE;
3685	}
3686	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3687	{
3688	res->data = (char )(long)((intvec)(v->Data()))->length();
3689	return FALSE;
3690	}
3691	static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3692	{
3693	ring r=(ring)v->Data();
3694	int elems=-1;
3695	if (rField_is_Zp(r)\|\|rField_is_GF(r)) elems=rInternalChar(r);
3696	else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3697	{
3698	#ifdef HAVE_FACTORY
3699	extern int ipower ( int b, int n ); /* factory/cf_util */
3700	elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3701	#else
3702	elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3703	#endif
3704	}
3705	res->data = (char *)(long)elems;
3706	return FALSE;
3707	}
3708	static BOOLEAN jjDEG(leftv res, leftv v)
3709	{
3710	int dummy;
3711	poly p=(poly)v->Data();
3712	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3713	else res->data=(char *)-1;
3714	return FALSE;
3715	}
3716	static BOOLEAN jjDEG_M(leftv res, leftv u)
3717	{
3718	ideal I=(ideal)u->Data();
3719	int d=-1;
3720	int dummy;
3721	int i;
3722	for(i=IDELEMS(I)-1;i>=0;i--)
3723	if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3724	res->data = (char *)(long)d;
3725	return FALSE;
3726	}
3727	static BOOLEAN jjDEGREE(leftv res, leftv v)
3728	{
3729	assumeStdFlag(v);
3730	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3731	scDegree((ideal)v->Data(),module_w,currQuotient);
3732	return FALSE;
3733	}
3734	static BOOLEAN jjDEFINED(leftv res, leftv v)
3735	{
3736	if ((v->rtyp==IDHDL)
3737	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
3738	{
3739	res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3740	}
3741	else if (v->rtyp!=0) res->data=(void *)(-1);
3742	return FALSE;
3743	}
3744	#ifdef HAVE_FACTORY
3745	static BOOLEAN jjDET(leftv res, leftv v)
3746	{
3747	matrix m=(matrix)v->Data();
3748	poly p;
3749	if (smCheckDet((ideal)m,m->cols(),TRUE))
3750	{
3751	ideal I=idMatrix2Module(mpCopy(m));
3752	p=smCallDet(I);
3753	idDelete(&I);
3754	}
3755	else
3756	p=singclap_det(m);
3757	res ->data = (char *)p;
3758	return FALSE;
3759	}
3760	static BOOLEAN jjDET_I(leftv res, leftv v)
3761	{
3762	intvec * m=(intvec*)v->Data();
3763	int i,j;
3764	i=m->rows();j=m->cols();
3765	if(i==j)
3766	res->data = (char *)(long)singclap_det_i(m);
3767	else
3768	{
3769	Werror("det of %d x %d intmat",i,j);
3770	return TRUE;
3771	}
3772	return FALSE;
3773	}
3774	static BOOLEAN jjDET_S(leftv res, leftv v)
3775	{
3776	ideal I=(ideal)v->Data();
3777	poly p;
3778	if (IDELEMS(I)<1) return TRUE;
3779	if (smCheckDet(I,IDELEMS(I),FALSE))
3780	{
3781	matrix m=idModule2Matrix(idCopy(I));
3782	p=singclap_det(m);
3783	idDelete((ideal *)&m);
3784	}
3785	else
3786	p=smCallDet(I);
3787	res->data = (char *)p;
3788	return FALSE;
3789	}
3790	#endif
3791	static BOOLEAN jjDIM(leftv res, leftv v)
3792	{
3793	assumeStdFlag(v);
3794	res->data = (char *)(long)scDimInt((ideal)(v->Data()),currQuotient);
3795	return FALSE;
3796	}
3797	static BOOLEAN jjDUMP(leftv res, leftv v)
3798	{
3799	si_link l = (si_link)v->Data();
3800	if (slDump(l))
3801	{
3802	const char *s;
3803	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3804	else s=sNoName;
3805	Werror("cannot dump to `%s`",s);
3806	return TRUE;
3807	}
3808	else
3809	return FALSE;
3810	}
3811	static BOOLEAN jjE(leftv res, leftv v)
3812	{
3813	res->data = (char *)pOne();
3814	int co=(int)(long)v->Data();
3815	if (co>0)
3816	{
3817	pSetComp((poly)res->data,co);
3818	pSetm((poly)res->data);
3819	}
3820	else WerrorS("argument of gen must be positive");
3821	return (co<=0);
3822	}
3823	static BOOLEAN jjEXECUTE(leftv res, leftv v)
3824	{
3825	char * d = (char *)v->Data();
3826	char * s = (char *)omAlloc(strlen(d) + 13);
3827	strcpy( s, (char *)d);
3828	strcat( s, "\n;RETURN();\n");
3829	newBuffer(s,BT_execute);
3830	return yyparse();
3831	}
3832	#ifdef HAVE_FACTORY
3833	static BOOLEAN jjFACSTD(leftv res, leftv v)
3834	{
3835	ideal_list p,h;
3836	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3837	p=h;
3838	int l=0;
3839	while (p!=NULL) { p=p->next;l++; }
3840	lists L=(lists)omAllocBin(slists_bin);
3841	L->Init(l);
3842	l=0;
3843	while(h!=NULL)
3844	{
3845	L->m[l].data=(char *)h->d;
3846	L->m[l].rtyp=IDEAL_CMD;
3847	p=h->next;
3848	omFreeSize(h,sizeof(*h));
3849	h=p;
3850	l++;
3851	}
3852	res->data=(void *)L;
3853	return FALSE;
3854	}
3855	static BOOLEAN jjFAC_P(leftv res, leftv u)
3856	{
3857	intvec *v=NULL;
3858	singclap_factorize_retry=0;
3859	ideal f=singclap_factorize((poly)(u->CopyD()), &v, 0);
3860	if (f==NULL) return TRUE;
3861	ivTest(v);
3862	lists l=(lists)omAllocBin(slists_bin);
3863	l->Init(2);
3864	l->m[0].rtyp=IDEAL_CMD;
3865	l->m[0].data=(void *)f;
3866	l->m[1].rtyp=INTVEC_CMD;
3867	l->m[1].data=(void *)v;
3868	res->data=(void *)l;
3869	return FALSE;
3870	}
3871	#endif
3872	static BOOLEAN jjGETDUMP(leftv res, leftv v)
3873	{
3874	si_link l = (si_link)v->Data();
3875	if (slGetDump(l))
3876	{
3877	const char *s;
3878	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3879	else s=sNoName;
3880	Werror("cannot get dump from `%s`",s);
3881	return TRUE;
3882	}
3883	else
3884	return FALSE;
3885	}
3886	static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3887	{
3888	assumeStdFlag(v);
3889	ideal I=(ideal)v->Data();
3890	res->data=(void *)iiHighCorner(I,0);
3891	return FALSE;
3892	}
3893	static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3894	{
3895	assumeStdFlag(v);
3896	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3897	BOOLEAN delete_w=FALSE;
3898	ideal I=(ideal)v->Data();
3899	int i;
3900	poly p=NULL,po=NULL;
3901	int rk=idRankFreeModule(I);
3902	if (w==NULL)
3903	{
3904	w = new intvec(rk);
3905	delete_w=TRUE;
3906	}
3907	for(i=rk;i>0;i--)
3908	{
3909	p=iiHighCorner(I,i);
3910	if (p==NULL)
3911	{
3912	WerrorS("module must be zero-dimensional");
3913	if (delete_w) delete w;
3914	return TRUE;
3915	}
3916	if (po==NULL)
3917	{
3918	po=p;
3919	}
3920	else
3921	{
3922	// now po!=NULL, p!=NULL
3923	int d=(pFDeg(po,currRing)-(w)[pGetComp(po)-1] - pFDeg(p,currRing)+(w)[i-1]);
3924	if (d==0)
3925	d=pLmCmp(po,p);
3926	if (d > 0)
3927	{
3928	pDelete(&p);
3929	}
3930	else // (d < 0)
3931	{
3932	pDelete(&po); po=p;
3933	}
3934	}
3935	}
3936	if (delete_w) delete w;
3937	res->data=(void *)po;
3938	return FALSE;
3939	}
3940	static BOOLEAN jjHILBERT(leftv res, leftv v)
3941	{
3942	assumeStdFlag(v);
3943	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3944	//scHilbertPoly((ideal)v->Data(),currQuotient);
3945	hLookSeries((ideal)v->Data(),module_w,currQuotient);
3946	return FALSE;
3947	}
3948	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3949	{
3950	res->data=(void )hSecondSeries((intvec )v->Data());
3951	return FALSE;
3952	}
3953	static BOOLEAN jjHOMOG1(leftv res, leftv v)
3954	{
3955	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3956	ideal v_id=(ideal)v->Data();
3957	if (w==NULL)
3958	{
3959	res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
3960	if (res->data!=NULL)
3961	{
3962	if (v->rtyp==IDHDL)
3963	{
3964	char *isHomog=omStrDup("isHomog");
3965	if (v->e==NULL)
3966	atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3967	else
3968	atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3969	}
3970	else if (w!=NULL) delete w;
3971	} // if res->data==NULL then w==NULL
3972	}
3973	else
3974	{
3975	res->data=(void *)(long)idTestHomModule(v_id,currQuotient,w);
3976	if((res->data==NULL) && (v->rtyp==IDHDL))
3977	{
3978	if (v->e==NULL)
3979	atKill((idhdl)(v->data),"isHomog");
3980	else
3981	atKill((idhdl)(v->LData()),"isHomog");
3982	}
3983	}
3984	return FALSE;
3985	}
3986	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3987	{
3988	matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3989	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3990	if (IDELEMS((ideal)mat)==0)
3991	{
3992	idDelete((ideal *)&mat);
3993	mat=(matrix)idInit(1,1);
3994	}
3995	else
3996	{
3997	MATROWS(mat)=1;
3998	mat->rank=1;
3999	idTest((ideal)mat);
4000	}
4001	res->data=(char *)mat;
4002	return FALSE;
4003	}
4004	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
4005	{
4006	map m=(map)v->CopyD(MAP_CMD);
4007	omFree((ADDRESS)m->preimage);
4008	m->preimage=NULL;
4009	ideal I=(ideal)m;
4010	I->rank=1;
4011	res->data=(char *)I;
4012	return FALSE;
4013	}
4014	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
4015	{
4016	if (currRing!=NULL)
4017	{
4018	ring q=(ring)v->Data();
4019	if (rSamePolyRep(currRing, q))
4020	{
4021	if (q->qideal==NULL)
4022	res->data=(char *)idInit(1,1);
4023	else
4024	res->data=(char *)idCopy(q->qideal);
4025	return FALSE;
4026	}
4027	}
4028	WerrorS("can only get ideal from identical qring");
4029	return TRUE;
4030	}
4031	static BOOLEAN jjIm2Iv(leftv res, leftv v)
4032	{
4033	intvec iv = (intvec )v->CopyD(INTMAT_CMD);
4034	iv->makeVector();
4035	res->data = iv;
4036	return FALSE;
4037	}
4038	static BOOLEAN jjIMPART(leftv res, leftv v)
4039	{
4040	res->data = (char *)nImPart((number)v->Data());
4041	return FALSE;
4042	}
4043	static BOOLEAN jjINDEPSET(leftv res, leftv v)
4044	{
4045	assumeStdFlag(v);
4046	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
4047	return FALSE;
4048	}
4049	static BOOLEAN jjINTERRED(leftv res, leftv v)
4050	{
4051	ideal result=kInterRed((ideal)(v->Data()), currQuotient);
4052	if (TEST_OPT_PROT) { PrintLn(); mflush(); }
4053	res->data = result;
4054	return FALSE;
4055	}
4056	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
4057	{
4058	res->data = (char *)(long)pVar((poly)v->Data());
4059	return FALSE;
4060	}
4061	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
4062	{
4063	res->data = (char )(long)(r_IsRingVar((char )v->Data(), currRing)+1);
4064	return FALSE;
4065	}
4066	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
4067	{
4068	res->data = (char *)0;
4069	return FALSE;
4070	}
4071	static BOOLEAN jjJACOB_P(leftv res, leftv v)
4072	{
4073	ideal i=idInit(pVariables,1);
4074	int k;
4075	poly p=(poly)(v->Data());
4076	for (k=pVariables;k>0;k--)
4077	{
4078	i->m[k-1]=pDiff(p,k);
4079	}
4080	res->data = (char *)i;
4081	return FALSE;
4082	}
4083	/*2
4084	* compute Jacobi matrix of a module/matrix
4085	* Jacobi(M) := ( diff(Mt,var(1))\|, ... ,\| diff(Mt,var(pVariables)) ),
4086	* where Mt := transpose(M)
4087	* Note that this is consistent with the current conventions for jacob in Singular,
4088	* whereas M2 computes its transposed.
4089	*/
4090	static BOOLEAN jjJACOB_M(leftv res, leftv a)
4091	{
4092	ideal id = (ideal)a->Data();
4093	id = idTransp(id);
4094	int W = IDELEMS(id);
4095
4096	ideal result = idInit(W * pVariables, id->rank);
4097	poly *p = result->m;
4098
4099	for( int v = 1; v <= pVariables; v++ )
4100	{
4101	poly* q = id->m;
4102	for( int i = 0; i < W; i++, p++, q++ )
4103	p = pDiff( q, v );
4104	}
4105	idDelete(&id);
4106
4107	res->data = (char *)result;
4108	return FALSE;
4109	}
4110
4111
4112	static BOOLEAN jjKBASE(leftv res, leftv v)
4113	{
4114	assumeStdFlag(v);
4115	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
4116	return FALSE;
4117	}
4118	#ifdef MDEBUG
4119	static BOOLEAN jjpHead(leftv res, leftv v)
4120	{
4121	res->data=(char *)pHead((poly)v->Data());
4122	return FALSE;
4123	}
4124	#endif
4125	static BOOLEAN jjL2R(leftv res, leftv v)
4126	{
4127	res->data=(char *)syConvList((lists)v->Data());
4128	if (res->data != NULL)
4129	return FALSE;
4130	else
4131	return TRUE;
4132	}
4133	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
4134	{
4135	poly p=(poly)v->Data();
4136	if (p==NULL)
4137	{
4138	res->data=(char *)nInit(0);
4139	}
4140	else
4141	{
4142	res->data=(char *)nCopy(pGetCoeff(p));
4143	}
4144	return FALSE;
4145	}
4146	static BOOLEAN jjLEADEXP(leftv res, leftv v)
4147	{
4148	poly p=(poly)v->Data();
4149	int s=pVariables;
4150	if (v->Typ()==VECTOR_CMD) s++;
4151	intvec *iv=new intvec(s);
4152	if (p!=NULL)
4153	{
4154	for(int i = pVariables;i;i--)
4155	{
4156	(*iv)[i-1]=pGetExp(p,i);
4157	}
4158	if (s!=pVariables)
4159	(*iv)[pVariables]=pGetComp(p);
4160	}
4161	res->data=(char *)iv;
4162	return FALSE;
4163	}
4164	static BOOLEAN jjLEADMONOM(leftv res, leftv v)
4165	{
4166	poly p=(poly)v->Data();
4167	if (p == NULL)
4168	{
4169	res->data = (char*) NULL;
4170	}
4171	else
4172	{
4173	poly lm = pLmInit(p);
4174	pSetCoeff(lm, nInit(1));
4175	res->data = (char*) lm;
4176	}
4177	return FALSE;
4178	}
4179	static BOOLEAN jjLISTRING(leftv res, leftv v)
4180	{
4181	ring r=rCompose((lists)v->Data());
4182	if (r==NULL) return TRUE;
4183	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
4184	res->data=(char *)r;
4185	return FALSE;
4186	}
4187	#if SIZEOF_LONG == 8
4188	static number jjLONG2N(long d)
4189	{
4190	int i=(int)d;
4191	if ((long)i == d)
4192	{
4193	return nlInit(i);
4194	}
4195	else
4196	{
4197	number z=(number)omAllocBin(rnumber_bin);
4198	#if defined(LDEBUG)
4199	z->debug=123456;
4200	#endif
4201	mpz_init_set_si(&z->z,d);
4202	return z;
4203	}
4204	}
4205	#else
4206	#define jjLONG2N(D) nlInit((int)D)
4207	#endif
4208	static BOOLEAN jjMEMORY(leftv res, leftv v)
4209	{
4210	omUpdateInfo();
4211	long d;
4212	switch(((int)(long)v->Data()))
4213	{
4214	case 0:
4215	res->data=(char *)jjLONG2N(om_Info.UsedBytes);
4216	break;
4217	case 1:
4218	res->data = (char *)jjLONG2N(om_Info.CurrentBytesSystem);
4219	break;
4220	case 2:
4221	res->data = (char *)jjLONG2N(om_Info.MaxBytesSystem);
4222	break;
4223	default:
4224	omPrintStats(stdout);
4225	omPrintInfo(stdout);
4226	omPrintBinStats(stdout);
4227	res->data = (char *)0;
4228	res->rtyp = NONE;
4229	}
4230	return FALSE;
4231	res->data = (char *)0;
4232	return FALSE;
4233	}
4234	#if SIZEOF_LONG == 8
4235	static number jjBI2N(long d)
4236	{
4237	if (d<((long)INT_MAX)) return nlInit((int)d);
4238	else
4239	{
4240	number n=nlRInit(0);
4241	mpz_set_si(&n->z,d);
4242	return n;
4243	}
4244	}
4245	#endif
4246	//static BOOLEAN jjMONITOR1(leftv res, leftv v)
4247	//{
4248	// return jjMONITOR2(res,v,NULL);
4249	//}
4250	static BOOLEAN jjMSTD(leftv res, leftv v)
4251	{
4252	int t=v->Typ();
4253	ideal r,m;
4254	r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
4255	lists l=(lists)omAllocBin(slists_bin);
4256	l->Init(2);
4257	l->m[0].rtyp=t;
4258	l->m[0].data=(char *)r;
4259	setFlag(&(l->m[0]),FLAG_STD);
4260	l->m[1].rtyp=t;
4261	l->m[1].data=(char *)m;
4262	res->data=(char *)l;
4263	return FALSE;
4264	}
4265	static BOOLEAN jjMULT(leftv res, leftv v)
4266	{
4267	assumeStdFlag(v);
4268	res->data = (char *)(long)scMultInt((ideal)(v->Data()),currQuotient);
4269	return FALSE;
4270	}
4271	static BOOLEAN jjMINRES_R(leftv res, leftv v)
4272	{
4273	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
4274	res->data=(char *)syMinimize((syStrategy)v->Data());
4275	if (weights!=NULL)
4276	atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
4277	return FALSE;
4278	}
4279	static BOOLEAN jjN2BI(leftv res, leftv v)
4280	{
4281	number n,i; i=(number)v->Data();
4282	if (rField_is_Zp())
4283	{
4284	if (((long)i)>(npPrimeM>>1))
4285	n=nlInit((int)(((long)i)-npPrimeM));
4286	else
4287	n=nlInit((int)(long)i);
4288	}
4289	else if (rField_is_Q()) n=nlBigInt(i);
4290	#ifdef HAVE_RINGS
4291	else if (rField_is_Ring_Z() \|\| rField_is_Ring_ModN() \|\| rField_is_Ring_PtoM()) n=nlMapGMP(i);
4292	else if (rField_is_Ring_2toM()) n=nlInit((unsigned long) i);
4293	#endif
4294	else goto err;
4295	res->data=(void *)n;
4296	return FALSE;
4297	err:
4298	WerrorS("cannot convert to bigint"); return TRUE;
4299	}
4300	static BOOLEAN jjNAMEOF(leftv res, leftv v)
4301	{
4302	res->data = (char *)v->name;
4303	if (res->data==NULL) res->data=omStrDup("");
4304	v->name=NULL;
4305	return FALSE;
4306	}
4307	static BOOLEAN jjNAMES(leftv res, leftv v)
4308	{
4309	res->data=ipNameList(((ring)v->Data())->idroot);
4310	return FALSE;
4311	}
4312	static BOOLEAN jjNVARS(leftv res, leftv v)
4313	{
4314	res->data = (char *)(long)(((ring)(v->Data()))->N);
4315	return FALSE;
4316	}
4317	static BOOLEAN jjOpenClose(leftv res, leftv v)
4318	{
4319	si_link l=(si_link)v->Data();
4320	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
4321	else return slClose(l);
4322	}
4323	static BOOLEAN jjORD(leftv res, leftv v)
4324	{
4325	poly p=(poly)v->Data();
4326	res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
4327	return FALSE;
4328	}
4329	static BOOLEAN jjPAR1(leftv res, leftv v)
4330	{
4331	int i=(int)(long)v->Data();
4332	int p=0;
4333	p=rPar(currRing);
4334	if ((0<i) && (i<=p))
4335	{
4336	res->data=(char *)nPar(i);
4337	}
4338	else
4339	{
4340	Werror("par number %d out of range 1..%d",i,p);
4341	return TRUE;
4342	}
4343	return FALSE;
4344	}
4345	static BOOLEAN jjPARDEG(leftv res, leftv v)
4346	{
4347	res->data = (char *)(long)nParDeg((number)v->Data());
4348	return FALSE;
4349	}
4350	static BOOLEAN jjPARSTR1(leftv res, leftv v)
4351	{
4352	if (currRing==NULL)
4353	{
4354	WerrorS("no ring active");
4355	return TRUE;
4356	}
4357	int i=(int)(long)v->Data();
4358	int p=0;
4359	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
4360	res->data=omStrDup(currRing->parameter[i-1]);
4361	else
4362	{
4363	Werror("par number %d out of range 1..%d",i,p);
4364	return TRUE;
4365	}
4366	return FALSE;
4367	}
4368	static BOOLEAN jjP2I(leftv res, leftv v)
4369	{
4370	poly p=(poly)v->Data();
4371	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
4372	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
4373	{
4374	WerrorS("poly must be constant");
4375	return TRUE;
4376	}
4377	res->data = (char *)(long)nInt(pGetCoeff(p));
4378	return FALSE;
4379	}
4380	static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
4381	{
4382	map mapping=(map)v->Data();
4383	syMake(res,omStrDup(mapping->preimage));
4384	return FALSE;
4385	}
4386	static BOOLEAN jjPRIME(leftv res, leftv v)
4387	{
4388	int i = IsPrime((int)(long)(v->Data()));
4389	res->data = (char *)(long)(i > 1 ? i : 2);
4390	return FALSE;
4391	}
4392	static BOOLEAN jjPRUNE(leftv res, leftv v)
4393	{
4394	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4395	ideal v_id=(ideal)v->Data();
4396	if (w!=NULL)
4397	{
4398	if (!idTestHomModule(v_id,currQuotient,w))
4399	{
4400	WarnS("wrong weights");
4401	w=NULL;
4402	// and continue at the non-homog case below
4403	}
4404	else
4405	{
4406	w=ivCopy(w);
4407	intvec **ww=&w;
4408	res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
4409	atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
4410	return FALSE;
4411	}
4412	}
4413	res->data = (char *)idMinEmbedding(v_id);
4414	return FALSE;
4415	}
4416	static BOOLEAN jjP2N(leftv res, leftv v)
4417	{
4418	number n;
4419	poly p;
4420	if (((p=(poly)v->Data())!=NULL)
4421	&& (pIsConstant(p)))
4422	{
4423	n=nCopy(pGetCoeff(p));
4424	}
4425	else
4426	{
4427	n=nInit(0);
4428	}
4429	res->data = (char *)n;
4430	return FALSE;
4431	}
4432	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
4433	{
4434	char s= (char )v->Data();
4435	int i = 1;
4436	int l = strlen(s);
4437	for(i=0; i<sArithBase.nCmdUsed; i++)
4438	{
4439	//Print("test %d, >>%s<<, tab:>>%s<<\n",i,s,sArithBase.sCmds[i].name);
4440	if (strcmp(s, sArithBase.sCmds[i].name) == 0)
4441	{
4442	res->data = (char *)1;
4443	return FALSE;
4444	}
4445	}
4446	//res->data = (char *)0;
4447	return FALSE;
4448	}
4449	static BOOLEAN jjREAD(leftv res, leftv v)
4450	{
4451	return jjREAD2(res,v,NULL);
4452	}
4453	static BOOLEAN jjREGULARITY(leftv res, leftv v)
4454	{
4455	res->data = (char *)(long)iiRegularity((lists)v->Data());
4456	return FALSE;
4457	}
4458	static BOOLEAN jjREPART(leftv res, leftv v)
4459	{
4460	res->data = (char *)nRePart((number)v->Data());
4461	return FALSE;
4462	}
4463	static BOOLEAN jjRINGLIST(leftv res, leftv v)
4464	{
4465	ring r=(ring)v->Data();
4466	if (r!=NULL)
4467	res->data = (char *)rDecompose((ring)v->Data());
4468	return (r==NULL)\|\|(res->data==NULL);
4469	}
4470	static BOOLEAN jjROWS(leftv res, leftv v)
4471	{
4472	ideal i = (ideal)v->Data();
4473	res->data = (char *)i->rank;
4474	return FALSE;
4475	}
4476	static BOOLEAN jjROWS_IV(leftv res, leftv v)
4477	{
4478	res->data = (char )(long)((intvec)(v->Data()))->rows();
4479	return FALSE;
4480	}
4481	static BOOLEAN jjRPAR(leftv res, leftv v)
4482	{
4483	res->data = (char *)(long)rPar(((ring)v->Data()));
4484	return FALSE;
4485	}
4486	static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4487	{
4488	#ifdef HAVE_PLURAL
4489	const bool bIsSCA = rIsSCA(currRing);
4490	#else
4491	const bool bIsSCA = false;
4492	#endif
4493
4494	if ((currQuotient!=NULL) && !bIsSCA)
4495	{
4496	WerrorS("qring not supported by slimgb at the moment");
4497	return TRUE;
4498	}
4499	if (rHasLocalOrMixedOrdering_currRing())
4500	{
4501	WerrorS("ordering must be global for slimgb");
4502	return TRUE;
4503	}
4504	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
4505	tHomog hom=testHomog;
4506	ideal u_id=(ideal)u->Data();
4507	if (w!=NULL)
4508	{
4509	if (!idTestHomModule(u_id,currQuotient,w))
4510	{
4511	WarnS("wrong weights");
4512	w=NULL;
4513	}
4514	else
4515	{
4516	w=ivCopy(w);
4517	hom=isHomog;
4518	}
4519	}
4520
4521	assume(u_id->rank>=idRankFreeModule(u_id));
4522	res->data=(char *)t_rep_gb(currRing,
4523	u_id,u_id->rank);
4524	//res->data=(char *)t_rep_gb(currRing, u_id);
4525
4526	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4527	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4528	return FALSE;
4529	}
4530	static BOOLEAN jjSTD(leftv res, leftv v)
4531	{
4532	ideal result;
4533	ideal v_id=(ideal)v->Data();
4534	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4535	tHomog hom=testHomog;
4536	if (w!=NULL)
4537	{
4538	if (!idTestHomModule(v_id,currQuotient,w))
4539	{
4540	WarnS("wrong weights");
4541	w=NULL;
4542	}
4543	else
4544	{
4545	hom=isHomog;
4546	w=ivCopy(w);
4547	}
4548	}
4549	result=kStd(v_id,currQuotient,hom,&w);
4550	idSkipZeroes(result);
4551	res->data = (char *)result;
4552	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4553	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4554	return FALSE;
4555	}
4556	static BOOLEAN jjSort_Id(leftv res, leftv v)
4557	{
4558	res->data = (char *)idSort((ideal)v->Data());
4559	return FALSE;
4560	}
4561	#ifdef HAVE_FACTORY
4562	extern int singclap_factorize_retry;
4563	static BOOLEAN jjSQR_FREE(leftv res, leftv u)
4564	{
4565	intvec *v=NULL;
4566	singclap_factorize_retry=0;
4567	ideal f=singclap_sqrfree((poly)(u->CopyD()));
4568	if (f==NULL)
4569	return TRUE;
4570	res->data=(void *)f;
4571	return FALSE;
4572	}
4573	#endif
4574	#if 1
4575	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4576	{
4577	intvec *w=NULL;
4578	res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4579	if (w!=NULL) delete w;
4580	return FALSE;
4581	}
4582	#else
4583	// activate, if idSyz handle module weights correctly !
4584	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4585	{
4586	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4587	ideal v_id=(ideal)v->Data();
4588	tHomog hom=testHomog;
4589	int add_row_shift=0;
4590	if (w!=NULL)
4591	{
4592	w=ivCopy(w);
4593	add_row_shift=w->min_in();
4594	(*w)-=add_row_shift;
4595	if (idTestHomModule(v_id,currQuotient,w))
4596	hom=isHomog;
4597	else
4598	{
4599	//WarnS("wrong weights");
4600	delete w; w=NULL;
4601	hom=testHomog;
4602	}
4603	}
4604	res->data = (char *)idSyzygies(v_id,hom,&w);
4605	if (w!=NULL)
4606	{
4607	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4608	}
4609	return FALSE;
4610	}
4611	#endif
4612	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4613	{
4614	res->data = (char )(long)ivTrace((intvec)(v->Data()));
4615	return FALSE;
4616	}
4617	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4618	{
4619	res->data = (char )ivTranp((intvec)(v->Data()));
4620	return FALSE;
4621	}
4622	#ifdef HAVE_PLURAL
4623	static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4624	{
4625	ring r = (ring)a->Data();
4626	if (rIsPluralRing(r))
4627	{
4628	res->data = rOpposite(r);
4629	}
4630	else res->data = rCopy(r);
4631	return FALSE;
4632	}
4633	static BOOLEAN jjENVELOPE(leftv res, leftv a)
4634	{
4635	ring r = (ring)a->Data();
4636	if (rIsPluralRing(r))
4637	{
4638	// ideal i;
4639	// if (a->rtyp == QRING_CMD)
4640	// {
4641	// i = r->qideal;
4642	// r->qideal = NULL;
4643	// }
4644	ring s = rEnvelope(r);
4645	// if (a->rtyp == QRING_CMD)
4646	// {
4647	// ideal is = idOppose(r,i); /* twostd? */
4648	// is = idAdd(is,i);
4649	// s->qideal = i;
4650	// }
4651	res->data = s;
4652	}
4653	else res->data = rCopy(r);
4654	return FALSE;
4655	}
4656	static BOOLEAN jjTWOSTD(leftv res, leftv a)
4657	{
4658	if (rIsPluralRing(currRing)) res->data=(ideal)twostd((ideal)a->Data());
4659	else res->data=(ideal)a->CopyD();
4660	setFlag(res,FLAG_STD);
4661	setFlag(res,FLAG_TWOSTD);
4662	return FALSE;
4663	}
4664	#endif
4665
4666	static BOOLEAN jjTYPEOF(leftv res, leftv v)
4667	{
4668	switch ((int)(long)v->data)
4669	{
4670	case INT_CMD: res->data=omStrDup("int"); break;
4671	case POLY_CMD: res->data=omStrDup("poly"); break;
4672	case VECTOR_CMD: res->data=omStrDup("vector"); break;
4673	case STRING_CMD: res->data=omStrDup("string"); break;
4674	case INTVEC_CMD: res->data=omStrDup("intvec"); break;
4675	case IDEAL_CMD: res->data=omStrDup("ideal"); break;
4676	case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4677	case MODUL_CMD: res->data=omStrDup("module"); break;
4678	case MAP_CMD: res->data=omStrDup("map"); break;
4679	case PROC_CMD: res->data=omStrDup("proc"); break;
4680	case RING_CMD: res->data=omStrDup("ring"); break;
4681	case QRING_CMD: res->data=omStrDup("qring"); break;
4682	case INTMAT_CMD: res->data=omStrDup("intmat"); break;
4683	case NUMBER_CMD: res->data=omStrDup("number"); break;
4684	case BIGINT_CMD: res->data=omStrDup("bigint"); break;
4685	case LIST_CMD: res->data=omStrDup("list"); break;
4686	case PACKAGE_CMD: res->data=omStrDup("package"); break;
4687	case LINK_CMD: res->data=omStrDup("link"); break;
4688	case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4689	case DEF_CMD:
4690	case NONE: res->data=omStrDup("none"); break;
4691	default: res->data=omStrDup("?unknown type?");
4692	}
4693	return FALSE;
4694	}
4695	static BOOLEAN jjUNIVARIATE(leftv res, leftv v)
4696	{
4697	res->data=(char *)pIsUnivariate((poly)v->Data());
4698	return FALSE;
4699	}
4700	static BOOLEAN jjVAR1(leftv res, leftv v)
4701	{
4702	int i=(int)(long)v->Data();
4703	if ((0<i) && (i<=currRing->N))
4704	{
4705	poly p=pOne();
4706	pSetExp(p,i,1);
4707	pSetm(p);
4708	res->data=(char *)p;
4709	}
4710	else
4711	{
4712	Werror("var number %d out of range 1..%d",i,currRing->N);
4713	return TRUE;
4714	}
4715	return FALSE;
4716	}
4717	static BOOLEAN jjVARSTR1(leftv res, leftv v)
4718	{
4719	if (currRing==NULL)
4720	{
4721	WerrorS("no ring active");
4722	return TRUE;
4723	}
4724	int i=(int)(long)v->Data();
4725	if ((0<i) && (i<=currRing->N))
4726	res->data=omStrDup(currRing->names[i-1]);
4727	else
4728	{
4729	Werror("var number %d out of range 1..%d",i,currRing->N);
4730	return TRUE;
4731	}
4732	return FALSE;
4733	}
4734	static BOOLEAN jjVDIM(leftv res, leftv v)
4735	{
4736	assumeStdFlag(v);
4737	res->data = (char *)(long)scMult0Int((ideal)v->Data(),currQuotient);
4738	return FALSE;
4739	}
4740
4741	static BOOLEAN jjLOAD1(leftv res, leftv v)
4742	{
4743	return jjLOAD(res, v,iiOp==LIB_CMD);
4744	}
4745	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4746	{
4747	#ifdef HAVE_NS
4748	char * s=(char *)v->CopyD();
4749	char libnamebuf[256];
4750	lib_types LT = type_of_LIB(s, libnamebuf);
4751	#ifdef HAVE_DYNAMIC_LOADING
4752	extern BOOLEAN load_modules(char newlib, char fullpath, BOOLEAN autoexport);
4753	#endif /* HAVE_DYNAMIC_LOADING */
4754	switch(LT)
4755	{
4756	default:
4757	case LT_NONE:
4758	Werror("%s: unknown type", s);
4759	break;
4760	case LT_NOTFOUND:
4761	Werror("cannot open %s", s);
4762	break;
4763
4764	case LT_SINGULAR:
4765	{
4766	char *plib = iiConvName(s);
4767	idhdl pl = IDROOT->get(plib,0);
4768	if (pl==NULL)
4769	{
4770	pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4771	IDPACKAGE(pl)->language = LANG_SINGULAR;
4772	IDPACKAGE(pl)->libname=omStrDup(plib);
4773	}
4774	else if (IDTYP(pl)!=PACKAGE_CMD)
4775	{
4776	Werror("can not create package `%s`",plib);
4777	omFree(plib);
4778	return TRUE;
4779	}
4780	package savepack=currPack;
4781	currPack=IDPACKAGE(pl);
4782	IDPACKAGE(pl)->loaded=TRUE;
4783	char libnamebuf[256];
4784	FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4785	BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4786	currPack=savepack;
4787	IDPACKAGE(pl)->loaded=(!bo);
4788	return bo;
4789	}
4790	case LT_MACH_O:
4791	case LT_ELF:
4792	case LT_HPUX:
4793	#ifdef HAVE_DYNAMIC_LOADING
4794	return load_modules(s, libnamebuf, autoexport);
4795	#else /* HAVE_DYNAMIC_LOADING */
4796	WerrorS("Dynamic modules are not supported by this version of Singular");
4797	break;
4798	#endif /* HAVE_DYNAMIC_LOADING */
4799	}
4800	#endif
4801	return TRUE;
4802	}
4803
4804	/=================== operations with 1 arg.: table =================/
4805
4806	#ifdef INIT_BUG
4807	#define XS(A) -((short)A)
4808	#define jjstrlen (proc1)1
4809	#define jjpLength (proc1)2
4810	#define jjidElem (proc1)3
4811	#define jjmpDetBareiss (proc1)4
4812	#define jjidFreeModule (proc1)5
4813	#define jjidVec2Ideal (proc1)6
4814	#define jjrCharStr (proc1)7
4815	#ifndef MDEBUG
4816	#define jjpHead (proc1)8
4817	#endif
4818	#define jjidHead (proc1)9
4819	#define jjidMaxIdeal (proc1)10
4820	#define jjidMinBase (proc1)11
4821	#define jjsyMinBase (proc1)12
4822	#define jjpMaxComp (proc1)13
4823	#define jjmpTrace (proc1)14
4824	#define jjmpTransp (proc1)15
4825	#define jjrOrdStr (proc1)16
4826	#define jjrVarStr (proc1)18
4827	#define jjrParStr (proc1)19
4828	#define jjCOUNT_RES (proc1)22
4829	#define jjDIM_R (proc1)23
4830	#define jjidTransp (proc1)24
4831
4832	extern struct sValCmd1 dArith1[];
4833	void jjInitTab1()
4834	{
4835	int i=0;
4836	for (;dArith1[i].cmd!=0;i++)
4837	{
4838	if (dArith1[i].res<0)
4839	{
4840	switch ((int)dArith1[i].p)
4841	{
4842	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
4843	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
4844	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
4845	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
4846	#ifndef HAVE_FACTORY
4847	case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4848	#endif
4849	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4850	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
4851	#ifndef MDEBUG
4852	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
4853	#endif
4854	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
4855	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
4856	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
4857	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
4858	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxCompProc; break;
4859	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
4860	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
4861	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
4862	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
4863	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
4864	case (int)jjCOUNT_RES: dArith1[i].p=(proc1)syLength; break;
4865	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
4866	case (int)jjidTransp: dArith1[i].p=(proc1)idTransp; break;
4867	#ifdef GENTABLE
4868	default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4869	#endif
4870	}
4871	}
4872	}
4873	}
4874	#else
4875	#if defined(PROC_BUG)
4876	#define XS(A) A
4877	static BOOLEAN jjstrlen(leftv res, leftv v)
4878	{
4879	res->data = (char )strlen((char )v->Data());
4880	return FALSE;
4881	}
4882	static BOOLEAN jjpLength(leftv res, leftv v)
4883	{
4884	res->data = (char *)pLength((poly)v->Data());
4885	return FALSE;
4886	}
4887	static BOOLEAN jjidElem(leftv res, leftv v)
4888	{
4889	res->data = (char *)idElem((ideal)v->Data());
4890	return FALSE;
4891	}
4892	static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4893	{
4894	res->data = (char *)mpDetBareiss((matrix)v->Data());
4895	return FALSE;
4896	}
4897	static BOOLEAN jjidFreeModule(leftv res, leftv v)
4898	{
4899	res->data = (char *)idFreeModule((int)(long)v->Data());
4900	return FALSE;
4901	}
4902	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4903	{
4904	res->data = (char *)idVec2Ideal((poly)v->Data());
4905	return FALSE;
4906	}
4907	static BOOLEAN jjrCharStr(leftv res, leftv v)
4908	{
4909	res->data = rCharStr((ring)v->Data());
4910	return FALSE;
4911	}
4912	#ifndef MDEBUG
4913	static BOOLEAN jjpHead(leftv res, leftv v)
4914	{
4915	res->data = (char *)pHead((poly)v->Data());
4916	return FALSE;
4917	}
4918	#endif
4919	static BOOLEAN jjidHead(leftv res, leftv v)
4920	{
4921	res->data = (char *)idHead((ideal)v->Data());
4922	return FALSE;
4923	}
4924	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4925	{
4926	res->data = (char *)idMaxIdeal((int)(long)v->Data());
4927	return FALSE;
4928	}
4929	static BOOLEAN jjidMinBase(leftv res, leftv v)
4930	{
4931	res->data = (char *)idMinBase((ideal)v->Data());
4932	return FALSE;
4933	}
4934	static BOOLEAN jjsyMinBase(leftv res, leftv v)
4935	{
4936	res->data = (char *)syMinBase((ideal)v->Data());
4937	return FALSE;
4938	}
4939	static BOOLEAN jjpMaxComp(leftv res, leftv v)
4940	{
4941	res->data = (char *)pMaxComp((poly)v->Data());
4942	return FALSE;
4943	}
4944	static BOOLEAN jjmpTrace(leftv res, leftv v)
4945	{
4946	res->data = (char *)mpTrace((matrix)v->Data());
4947	return FALSE;
4948	}
4949	static BOOLEAN jjmpTransp(leftv res, leftv v)
4950	{
4951	res->data = (char *)mpTransp((matrix)v->Data());
4952	return FALSE;
4953	}
4954	static BOOLEAN jjrOrdStr(leftv res, leftv v)
4955	{
4956	res->data = rOrdStr((ring)v->Data());
4957	return FALSE;
4958	}
4959	static BOOLEAN jjrVarStr(leftv res, leftv v)
4960	{
4961	res->data = rVarStr((ring)v->Data());
4962	return FALSE;
4963	}
4964	static BOOLEAN jjrParStr(leftv res, leftv v)
4965	{
4966	res->data = rParStr((ring)v->Data());
4967	return FALSE;
4968	}
4969	static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4970	{
4971	res->data=(char *)syLength((syStrategy)v->Data());
4972	return FALSE;
4973	}
4974	static BOOLEAN jjDIM_R(leftv res, leftv v)
4975	{
4976	res->data = (char *)syDim((syStrategy)v->Data());
4977	return FALSE;
4978	}
4979	static BOOLEAN jjidTransp(leftv res, leftv v)
4980	{
4981	res->data = (char *)idTransp((ideal)v->Data());
4982	return FALSE;
4983	}
4984	#else
4985	#define XS(A) -((short)A)
4986	#define jjstrlen (proc1)strlen
4987	#define jjpLength (proc1)pLength
4988	#define jjidElem (proc1)idElem
4989	#define jjmpDetBareiss (proc1)mpDetBareiss
4990	#define jjidFreeModule (proc1)idFreeModule
4991	#define jjidVec2Ideal (proc1)idVec2Ideal
4992	#define jjrCharStr (proc1)rCharStr
4993	#ifndef MDEBUG
4994	#define jjpHead (proc1)pHeadProc
4995	#endif
4996	#define jjidHead (proc1)idHead
4997	#define jjidMaxIdeal (proc1)idMaxIdeal
4998	#define jjidMinBase (proc1)idMinBase
4999	#define jjsyMinBase (proc1)syMinBase
5000	#define jjpMaxComp (proc1)pMaxCompProc
5001	#define jjmpTrace (proc1)mpTrace
5002	#define jjmpTransp (proc1)mpTransp
5003	#define jjrOrdStr (proc1)rOrdStr
5004	#define jjrVarStr (proc1)rVarStr
5005	#define jjrParStr (proc1)rParStr
5006	#define jjCOUNT_RES (proc1)syLength
5007	#define jjDIM_R (proc1)syDim
5008	#define jjidTransp (proc1)idTransp
5009	#endif
5010	#endif
5011	static BOOLEAN jjnInt(leftv res, leftv u)
5012	{
5013	number n=(number)u->Data();
5014	res->data=(char *)(long)nInt(n);
5015	return FALSE;
5016	}
5017	static BOOLEAN jjnlInt(leftv res, leftv u)
5018	{
5019	number n=(number)u->Data();
5020	res->data=(char *)(long)nlInt(n);
5021	return FALSE;
5022	}
5023	#define s short
5024	struct sValCmd1 dArith1[]=
5025	{
5026	// operations:
5027	// proc cmd res arg plural
5028	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD ALLOW_PLURAL}
5029	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD ALLOW_PLURAL}
5030	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL ALLOW_PLURAL}
5031	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL ALLOW_PLURAL}
5032	,{jjUMINUS_I, '-', INT_CMD, INT_CMD ALLOW_PLURAL}
5033	,{jjUMINUS_BI, '-', BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
5034	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
5035	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD ALLOW_PLURAL}
5036	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
5037	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
5038	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5039	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
5040	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD ALLOW_PLURAL}
5041	,{jjLOAD1, '(', NONE, STRING_CMD ALLOW_PLURAL}
5042	// and the procedures with 1 argument:
5043	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD ALLOW_PLURAL}
5044	//,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD NO_PLURAL}
5045	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
5046	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD ALLOW_PLURAL}
5047	,{syBetti1, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD ALLOW_PLURAL}
5048	,{jjBETTI, BETTI_CMD, INTMAT_CMD, IDEAL_CMD ALLOW_PLURAL}
5049	,{jjBETTI, BETTI_CMD, INTMAT_CMD, MODUL_CMD ALLOW_PLURAL}
5050	,{jjDUMMY, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
5051	,{jjN2BI, BIGINT_CMD, BIGINT_CMD, NUMBER_CMD ALLOW_PLURAL}
5052	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
5053	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
5054	#ifdef HAVE_FACTORY
5055	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
5056	#else
5057	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
5058	#endif
5059	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
5060	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
5061	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD ALLOW_PLURAL}
5062	//,{jjWRONG, COLS_CMD, 0, VECTOR_CMD ALLOW_PLURAL}
5063	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
5064	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
5065	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
5066	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5067	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
5068	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5069	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
5070	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
5071	,{jjCOUNT_RES, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD ALLOW_PLURAL}
5072	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD ALLOW_PLURAL}
5073	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD ALLOW_PLURAL}
5074	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
5075	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD ALLOW_PLURAL}
5076	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD ALLOW_PLURAL}
5077	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
5078	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5079	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5080	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD ALLOW_PLURAL}
5081	,{jjCOUNT_RG, COUNT_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
5082	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
5083	,{jjWRONG, DEF_CMD, 0, ANY_TYPE ALLOW_PLURAL}
5084	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
5085	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
5086	,{jjDEG_M, DEG_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
5087	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD NO_PLURAL}
5088	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD NO_PLURAL}
5089	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD ALLOW_PLURAL}
5090	#ifdef HAVE_FACTORY
5091	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5092	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
5093	,{jjDET_S, DET_CMD, POLY_CMD, MODUL_CMD NO_PLURAL}
5094	#else
5095	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5096	,{jjmpDetBareiss,DET_CMD, XS(POLY_CMD), MATRIX_CMD NO_PLURAL}
5097	#endif
5098	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
5099	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
5100	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
5101	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
5102	,{jjE, E_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
5103	,{jjEXECUTE, EXECUTE_CMD, NONE, STRING_CMD ALLOW_PLURAL}
5104	,{jjERROR, ERROR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
5105	#ifdef HAVE_FACTORY
5106	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
5107	#else
5108	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
5109	#endif
5110	#ifdef HAVE_FGLM
5111	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
5112	#else
5113	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
5114	#endif
5115	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD ALLOW_PLURAL}
5116	#ifdef HAVE_FACTORY
5117	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
5118	#else
5119	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
5120	#endif
5121	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
5122	,{jjHIGHCORNER, HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
5123	,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD NO_PLURAL}
5124	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD NO_PLURAL}
5125	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD NO_PLURAL}
5126	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
5127	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
5128	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
5129	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5130	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD ALLOW_PLURAL}
5131	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
5132	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD ALLOW_PLURAL}
5133	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD ALLOW_PLURAL}
5134	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD ALLOW_PLURAL}
5135	,{jjIMPART, IMPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
5136	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD NO_PLURAL}
5137	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5138	,{jjnlInt, INT_CMD, INT_CMD, BIGINT_CMD ALLOW_PLURAL}
5139	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
5140	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
5141	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5142	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5143	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
5144	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
5145	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
5146	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD ALLOW_PLURAL}
5147	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD ALLOW_PLURAL}
5148	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE ALLOW_PLURAL}
5149	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
5150	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD ALLOW_PLURAL}
5151	,{jjJACOB_M, JACOB_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5152	,{jjJanetBasis, JANET_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5153	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5154	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5155	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL ALLOW_PLURAL}
5156	#ifdef MDEBUG
5157	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5158	#else
5159	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD ALLOW_PLURAL}
5160	#endif
5161	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD ALLOW_PLURAL}
5162	#ifdef MDEBUG
5163	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
5164	#else
5165	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD ALLOW_PLURAL}
5166	#endif
5167	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
5168	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
5169	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD ALLOW_PLURAL}
5170	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD ALLOW_PLURAL}
5171	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD ALLOW_PLURAL}
5172	,{jjLEADMONOM, LEADMONOM_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5173	,{jjLEADMONOM, LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
5174	,{jjLOAD1, LIB_CMD, NONE, STRING_CMD ALLOW_PLURAL}
5175	,{jjDUMMY, LINK_CMD, LINK_CMD, LINK_CMD ALLOW_PLURAL}
5176	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
5177	,{jjWRONG, MAP_CMD, 0, ANY_TYPE ALLOW_PLURAL}
5178	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
5179	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD ALLOW_PLURAL}
5180	,{jjMEMORY, MEMORY_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
5181	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD NO_PLURAL}
5182	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD NO_PLURAL}
5183	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
5184	,{jjMINRES_R, MINRES_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
5185	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5186	,{jjMONITOR1, MONITOR_CMD, NONE, LINK_CMD ALLOW_PLURAL}
5187	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
5188	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
5189	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
5190	,{jjMSTD, MSTD_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
5191	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
5192	,{jjNAMES, NAMES_CMD, LIST_CMD, PACKAGE_CMD ALLOW_PLURAL}
5193	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
5194	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
5195	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
5196	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
5197	,{jjBI2N, NUMBER_CMD, NUMBER_CMD, BIGINT_CMD ALLOW_PLURAL}
5198	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
5199	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
5200	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
5201	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
5202	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD ALLOW_PLURAL}
5203	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
5204	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
5205	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
5206	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
5207	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
5208	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
5209	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5210	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
5211	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
5212	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
5213	,{jjBI2P, POLY_CMD, POLY_CMD, BIGINT_CMD ALLOW_PLURAL}
5214	,{jjPREIMAGE_R, PREIMAGE_CMD, RING_CMD, MAP_CMD NO_PLURAL}
5215	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
5216	,{jjPRINT, PRINT_CMD, NONE, LIST_CMD ALLOW_PLURAL}
5217	,{jjPRINT, PRINT_CMD, NONE, DEF_CMD ALLOW_PLURAL}
5218	,{jjPRUNE, PRUNE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5219	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
5220	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
5221	,{jjWRONG, QRING_CMD, 0, ANY_TYPE ALLOW_PLURAL}
5222	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD ALLOW_PLURAL}
5223	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD NO_PLURAL}
5224	,{jjREPART, REPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
5225	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD ALLOW_PLURAL}
5226	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD ALLOW_PLURAL}
5227	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
5228	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
5229	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
5230	,{jjDUMMY, RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
5231	,{jjLISTRING, RING_CMD, RING_CMD, LIST_CMD ALLOW_PLURAL}
5232	//,{jjWRONG, ROWS_CMD, 0, POLY_CMD ALLOW_PLURAL}
5233	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
5234	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
5235	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
5236	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5237	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
5238	,{jjSLIM_GB, SLIM_GB_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5239	,{jjSLIM_GB, SLIM_GB_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5240	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
5241	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
5242	,{jjSQR_FREE, SQR_FREE_CMD, IDEAL_CMD, POLY_CMD NO_PLURAL}
5243	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5244	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5245	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
5246	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD ALLOW_PLURAL}
5247	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
5248	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
5249	#ifdef HAVE_PLURAL
5250	,{jjENVELOPE, ENVELOPE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
5251	,{jjENVELOPE, ENVELOPE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
5252	,{jjOPPOSITE, OPPOSITE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
5253	,{jjOPPOSITE, OPPOSITE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
5254	,{jjTWOSTD, TWOSTD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5255	#endif
5256	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
5257	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD ALLOW_PLURAL}
5258	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
5259	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD ALLOW_PLURAL}
5260	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
5261	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
5262	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD ALLOW_PLURAL}
5263	,{jjidTransp, TRANSPOSE_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
5264	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
5265	,{jjUNIVARIATE, UNIVARIATE_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
5266	,{jjVARIABLES_P,VARIABLES_CMD, LIST_CMD, POLY_CMD ALLOW_PLURAL}
5267	,{jjVARIABLES_ID,VARIABLES_CMD, LIST_CMD, IDEAL_CMD ALLOW_PLURAL}
5268	,{jjVARIABLES_ID,VARIABLES_CMD, LIST_CMD, MATRIX_CMD ALLOW_PLURAL}
5269	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
5270	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
5271	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
5272	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
5273	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
5274	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
5275	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
5276	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
5277	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
5278	,{jjLOAD1, LOAD_CMD, NONE, STRING_CMD ALLOW_PLURAL}
5279	,{loNewtonP, NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
5280	,{NULL, 0, 0, 0 NO_PLURAL}
5281	};
5282	#undef s
5283	/=================== operations with 3 args.: static proc =================/
5284	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
5285	{
5286	char s= (char )u->Data();
5287	int r = (int)(long)v->Data();
5288	int c = (int)(long)w->Data();
5289	int l = strlen(s);
5290
5291	if ( (r<1) \|\| (r>l) \|\| (c<0) )
5292	{
5293	Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
5294	return TRUE;
5295	}
5296	res->data = (char *)omAlloc((long)(c+1));
5297	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
5298	return FALSE;
5299	}
5300	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
5301	{
5302	intvec iv = (intvec )u->Data();
5303	int r = (int)(long)v->Data();
5304	int c = (int)(long)w->Data();
5305	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
5306	{
5307	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
5308	r,c,u->Fullname(),iv->rows(),iv->cols());
5309	return TRUE;
5310	}
5311	res->data=u->data; u->data=NULL;
5312	res->rtyp=u->rtyp; u->rtyp=0;
5313	res->name=u->name; u->name=NULL;
5314	res->attribute=u->attribute; u->attribute=NULL;
5315	Subexpr e=jjMakeSub(v);
5316	e->next=jjMakeSub(w);
5317	if (u->e==NULL) res->e=e;
5318	else
5319	{
5320	Subexpr h=u->e;
5321	while (h->next!=NULL) h=h->next;
5322	h->next=e;
5323	res->e=u->e;
5324	u->e=NULL;
5325	}
5326	return FALSE;
5327	}
5328	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
5329	{
5330	matrix m= (matrix)u->Data();
5331	int r = (int)(long)v->Data();
5332	int c = (int)(long)w->Data();
5333	//Print("gen. elem %d, %d\n",r,c);
5334	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
5335	{
5336	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
5337	MATROWS(m),MATCOLS(m));
5338	return TRUE;
5339	}
5340	res->data=u->data; u->data=NULL;
5341	res->rtyp=u->rtyp; u->rtyp=0;
5342	res->name=u->name; u->name=NULL;
5343	res->attribute=u->attribute; u->attribute=NULL;
5344	Subexpr e=jjMakeSub(v);
5345	e->next=jjMakeSub(w);
5346	if (u->e==NULL)
5347	res->e=e;
5348	else
5349	{
5350	Subexpr h=u->e;
5351	while (h->next!=NULL) h=h->next;
5352	h->next=e;
5353	res->e=u->e;
5354	u->e=NULL;
5355	}
5356	return FALSE;
5357	}
5358	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
5359	{
5360	sleftv t;
5361	sleftv ut;
5362	leftv p=NULL;
5363	intvec iv=(intvec )w->Data();
5364	int l;
5365	BOOLEAN nok;
5366
5367	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
5368	{
5369	WerrorS("cannot build expression lists from unnamed objects");
5370	return TRUE;
5371	}
5372	memcpy(&ut,u,sizeof(ut));
5373	memset(&t,0,sizeof(t));
5374	t.rtyp=INT_CMD;
5375	for (l=0;l< iv->length(); l++)
5376	{
5377	t.data=(char )(long)((iv)[l]);
5378	if (p==NULL)
5379	{
5380	p=res;
5381	}
5382	else
5383	{
5384	p->next=(leftv)omAlloc0Bin(sleftv_bin);
5385	p=p->next;
5386	}
5387	memcpy(u,&ut,sizeof(ut));
5388	if (u->Typ() == MATRIX_CMD)
5389	nok=jjBRACK_Ma(p,u,v,&t);
5390	else /* INTMAT_CMD */
5391	nok=jjBRACK_Im(p,u,v,&t);
5392	if (nok)
5393	{
5394	while (res->next!=NULL)
5395	{
5396	p=res->next->next;
5397	omFreeBin((ADDRESS)res->next, sleftv_bin);
5398	// res->e aufraeumen !!!!
5399	res->next=p;
5400	}
5401	return TRUE;
5402	}
5403	}
5404	return FALSE;
5405	}
5406	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
5407	{
5408	sleftv t;
5409	sleftv ut;
5410	leftv p=NULL;
5411	intvec iv=(intvec )v->Data();
5412	int l;
5413	BOOLEAN nok;
5414
5415	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
5416	{
5417	WerrorS("cannot build expression lists from unnamed objects");
5418	return TRUE;
5419	}
5420	memcpy(&ut,u,sizeof(ut));
5421	memset(&t,0,sizeof(t));
5422	t.rtyp=INT_CMD;
5423	for (l=0;l< iv->length(); l++)
5424	{
5425	t.data=(char )(long)((iv)[l]);
5426	if (p==NULL)
5427	{
5428	p=res;
5429	}
5430	else
5431	{
5432	p->next=(leftv)omAlloc0Bin(sleftv_bin);
5433	p=p->next;
5434	}
5435	memcpy(u,&ut,sizeof(ut));
5436	if (u->Typ() == MATRIX_CMD)
5437	nok=jjBRACK_Ma(p,u,&t,w);
5438	else /* INTMAT_CMD */
5439	nok=jjBRACK_Im(p,u,&t,w);
5440	if (nok)
5441	{
5442	while (res->next!=NULL)
5443	{
5444	p=res->next->next;
5445	omFreeBin((ADDRESS)res->next, sleftv_bin);
5446	// res->e aufraeumen !!
5447	res->next=p;
5448	}
5449	return TRUE;
5450	}
5451	}
5452	return FALSE;
5453	}
5454	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
5455	{
5456	sleftv t1,t2,ut;
5457	leftv p=NULL;
5458	intvec vv=(intvec )v->Data();
5459	intvec wv=(intvec )w->Data();
5460	int vl;
5461	int wl;
5462	BOOLEAN nok;
5463
5464	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
5465	{
5466	WerrorS("cannot build expression lists from unnamed objects");
5467	return TRUE;
5468	}
5469	memcpy(&ut,u,sizeof(ut));
5470	memset(&t1,0,sizeof(sleftv));
5471	memset(&t2,0,sizeof(sleftv));
5472	t1.rtyp=INT_CMD;
5473	t2.rtyp=INT_CMD;
5474	for (vl=0;vl< vv->length(); vl++)
5475	{
5476	t1.data=(char )(long)((vv)[vl]);
5477	for (wl=0;wl< wv->length(); wl++)
5478	{
5479	t2.data=(char )(long)((wv)[wl]);
5480	if (p==NULL)
5481	{
5482	p=res;
5483	}
5484	else
5485	{
5486	p->next=(leftv)omAlloc0Bin(sleftv_bin);
5487	p=p->next;
5488	}
5489	memcpy(u,&ut,sizeof(ut));
5490	if (u->Typ() == MATRIX_CMD)
5491	nok=jjBRACK_Ma(p,u,&t1,&t2);
5492	else /* INTMAT_CMD */
5493	nok=jjBRACK_Im(p,u,&t1,&t2);
5494	if (nok)
5495	{
5496	res->CleanUp();
5497	return TRUE;
5498	}
5499	}
5500	}
5501	return FALSE;
5502	}
5503	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
5504	{
5505	v->next=(leftv)omAllocBin(sleftv_bin);
5506	memcpy(v->next,w,sizeof(sleftv));
5507	memset(w,0,sizeof(sleftv));
5508	return jjPROC(res,u,v);
5509	}
5510	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
5511	{
5512	u->next=(leftv)omAllocBin(sleftv_bin);
5513	memcpy(u->next,v,sizeof(sleftv));
5514	u->next->next=(leftv)omAllocBin(sleftv_bin);
5515	memcpy(u->next->next,w,sizeof(sleftv));
5516	BOOLEAN r=iiExprArithM(res,u,iiOp);
5517	v->Init();
5518	w->Init();
5519	//w->rtyp=0; w->data=NULL;
5520	// iiExprArithM did the CleanUp
5521	return r;
5522	}
5523	static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5524	{
5525	intvec *iv;
5526	ideal m;
5527	lists l=(lists)omAllocBin(slists_bin);
5528	int k=(int)(long)w->Data();
5529	if (k>=0)
5530	{
5531	smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
5532	l->Init(2);
5533	l->m[0].rtyp=MODUL_CMD;
5534	l->m[1].rtyp=INTVEC_CMD;
5535	l->m[0].data=(void *)m;
5536	l->m[1].data=(void *)iv;
5537	}
5538	else
5539	{
5540	m=smCallSolv((ideal)u->Data());
5541	l->Init(1);
5542	l->m[0].rtyp=IDEAL_CMD;
5543	l->m[0].data=(void *)m;
5544	}
5545	res->data = (char *)l;
5546	return FALSE;
5547	}
5548	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5549	{
5550	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5551	{
5552	WerrorS("3rd argument must be a name of a matrix");
5553	return TRUE;
5554	}
5555	ideal i=(ideal)u->Data();
5556	int rank=(int)i->rank;
5557	BOOLEAN r=jjCOEFFS_Id(res,u,v);
5558	if (r) return TRUE;
5559	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5560	return FALSE;
5561	}
5562	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5563	{
5564	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5565	(ideal)(v->Data()),(poly)(w->Data()));
5566	return FALSE;
5567	}
5568	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5569	{
5570	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5571	{
5572	WerrorS("3rd argument must be a name of a matrix");
5573	return TRUE;
5574	}
5575	// CopyD for POLY_CMD and VECTOR_CMD are identical:
5576	poly p=(poly)u->CopyD(POLY_CMD);
5577	ideal i=idInit(1,1);
5578	i->m[0]=p;
5579	sleftv t;
5580	memset(&t,0,sizeof(t));
5581	t.data=(char *)i;
5582	t.rtyp=IDEAL_CMD;
5583	int rank=1;
5584	if (u->Typ()==VECTOR_CMD)
5585	{
5586	i->rank=rank=pMaxComp(p);
5587	t.rtyp=MODUL_CMD;
5588	}
5589	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5590	t.CleanUp();
5591	if (r) return TRUE;
5592	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5593	return FALSE;
5594	}
5595	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5596	{
5597	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5598	(intvec *)w->Data());
5599	//setFlag(res,FLAG_STD);
5600	return FALSE;
5601	}
5602	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5603	{
5604	/*4
5605	* look for the substring what in the string where
5606	* starting at position n
5607	* return the position of the first char of what in where
5608	* or 0
5609	*/
5610	int n=(int)(long)w->Data();
5611	char where=(char )u->Data();
5612	char what=(char )v->Data();
5613	char *found;
5614	if ((1>n)\|\|(n>(int)strlen(where)))
5615	{
5616	Werror("start position %d out of range",n);
5617	return TRUE;
5618	}
5619	found = strchr(where+n-1,*what);
5620	if (*(what+1)!='\0')
5621	{
5622	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5623	{
5624	found=strchr(found+1,*what);
5625	}
5626	}
5627	if (found != NULL)
5628	{
5629	res->data=(char *)((found-where)+1);
5630	}
5631	return FALSE;
5632	}
5633	static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5634	{
5635	if ((int)(long)w->Data()==0)
5636	res->data=(char *)walkProc(u,v);
5637	else
5638	res->data=(char *)fractalWalkProc(u,v);
5639	setFlag( res, FLAG_STD );
5640	return FALSE;
5641	}
5642	static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5643	{
5644	assumeStdFlag(u);
5645	intvec module_w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
5646	intvec wdegree=(intvec)w->Data();
5647	if (wdegree->length()!=pVariables)
5648	{
5649	Werror("weight vector must have size %d, not %d",
5650	pVariables,wdegree->length());
5651	return TRUE;
5652	}
5653	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5654	switch((int)(long)v->Data())
5655	{
5656	case 1:
5657	res->data=(void *)iv;
5658	return FALSE;
5659	case 2:
5660	res->data=(void *)hSecondSeries(iv);
5661	delete iv;
5662	return FALSE;
5663	}
5664	WerrorS(feNotImplemented);
5665	delete iv;
5666	return TRUE;
5667	}
5668	static BOOLEAN jjHOMOG_ID_W(leftv res, leftv u, leftv v, leftv w)
5669	{
5670	PrintS("TODO\n");
5671	int i=pVar((poly)v->Data());
5672	if (i==0)
5673	{
5674	WerrorS("ringvar expected");
5675	return TRUE;
5676	}
5677	poly p=pOne(); pSetExp(p,i,1); pSetm(p);
5678	int d=pWTotaldegree(p);
5679	pLmDelete(p);
5680	if (d==1)
5681	res->data = (char *)idHomogen((ideal)u->Data(),i);
5682	else
5683	WerrorS("variable must have weight 1");
5684	return (d!=1);
5685	}
5686	static BOOLEAN jjHOMOG_P_W(leftv res, leftv u, leftv v,leftv w)
5687	{
5688	PrintS("TODO\n");
5689	int i=pVar((poly)v->Data());
5690	if (i==0)
5691	{
5692	WerrorS("ringvar expected");
5693	return TRUE;
5694	}
5695	poly p=pOne(); pSetExp(p,i,1); pSetm(p);
5696	int d=pWTotaldegree(p);
5697	pLmDelete(p);
5698	if (d==1)
5699	res->data = (char *)pHomogen((poly)u->Data(),i);
5700	else
5701	WerrorS("variable must have weight 1");
5702	return (d!=1);
5703	}
5704	static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5705	{
5706	intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5707	intvec* arg = (intvec*) u->Data();
5708	int i, n = si_min(im->cols()im->rows(), arg->cols()arg->rows());
5709
5710	for (i=0; i<n; i++)
5711	{
5712	(im)[i] = (arg)[i];
5713	}
5714
5715	res->data = (char *)im;
5716	return FALSE;
5717	}
5718	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5719	{
5720	short iw=iv2array((intvec )w->Data());
5721	res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5722	omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5723	return FALSE;
5724	}
5725	static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5726	{
5727	if (!pIsUnit((poly)v->Data()))
5728	{
5729	WerrorS("2nd argument must be a unit");
5730	return TRUE;
5731	}
5732	res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5733	return FALSE;
5734	}
5735	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5736	{
5737	res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5738	(intvec *)w->Data());
5739	return FALSE;
5740	}
5741	static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5742	{
5743	if (!mpIsDiagUnit((matrix)v->Data()))
5744	{
5745	WerrorS("2nd argument must be a diagonal matrix of units");
5746	return TRUE;
5747	}
5748	res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5749	(matrix)v->CopyD());
5750	return FALSE;
5751	}
5752	static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5753	{
5754	assumeStdFlag(w);
5755	res->data = (char *)idMinors(
5756	(matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5757	return FALSE;
5758	}
5759	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5760	{
5761	// handles preimage(r,phi,i) and kernel(r,phi)
5762	idhdl h;
5763	ring rr;
5764	map mapping;
5765	BOOLEAN kernel_cmd= (iiOp==KERNEL_CMD);
5766
5767	if ((v->name==NULL) \|\| (!kernel_cmd && (w->name==NULL)))
5768	{
5769	WerrorS("2nd/3rd arguments must have names");
5770	return TRUE;
5771	}
5772	rr=(ring)u->Data();
5773	const char *ring_name=u->Name();
5774	if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5775	{
5776	if (h->typ==MAP_CMD)
5777	{
5778	mapping=IDMAP(h);
5779	idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5780	if ((preim_ring==NULL)
5781	\|\| (IDRING(preim_ring)!=currRing))
5782	{
5783	Werror("preimage ring `%s` is not the basering",mapping->preimage);
5784	return TRUE;
5785	}
5786	}
5787	else if (h->typ==IDEAL_CMD)
5788	{
5789	mapping=IDMAP(h);
5790	}
5791	else
5792	{
5793	Werror("`%s` is no map nor ideal",IDID(h));
5794	return TRUE;
5795	}
5796	}
5797	else
5798	{
5799	Werror("`%s` is not defined in `%s`",v->name,ring_name);
5800	return TRUE;
5801	}
5802	ideal image;
5803	if (kernel_cmd) image=idInit(1,1);
5804	else
5805	{
5806	if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5807	{
5808	if (h->typ==IDEAL_CMD)
5809	{
5810	image=IDIDEAL(h);
5811	}
5812	else
5813	{
5814	Werror("`%s` is no ideal",IDID(h));
5815	return TRUE;
5816	}
5817	}
5818	else
5819	{
5820	Werror("`%s` is not defined in `%s`",w->name,ring_name);
5821	return TRUE;
5822	}
5823	}
5824	if (((currRing->qideal!=NULL) && (rHasLocalOrMixedOrdering_currRing()))
5825	\|\| ((rr->qideal!=NULL) && (rHasLocalOrMixedOrdering(rr))))
5826	{
5827	WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5828	}
5829	res->data=(char *)maGetPreimage(rr,mapping,image);
5830	if (kernel_cmd) idDelete(&image);
5831	return (res->data==NULL/* is of type ideal, should not be NULL*/);
5832	}
5833	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5834	{
5835	int di, k;
5836	int i=(int)(long)u->Data();
5837	int r=(int)(long)v->Data();
5838	int c=(int)(long)w->Data();
5839	if ((r<=0) \|\| (c<=0)) return TRUE;
5840	intvec *iv = new intvec(r, c, 0);
5841	if (iv->rows()==0)
5842	{
5843	delete iv;
5844	return TRUE;
5845	}
5846	if (i!=0)
5847	{
5848	if (i<0) i = -i;
5849	di = 2 * i + 1;
5850	for (k=0; k<iv->length(); k++)
5851	{
5852	#ifdef buildin_rand
5853	(*iv)[k] = ((siRand() % di) - i);
5854	#else
5855	(*iv)[k] = ((rand() % di) - i);
5856	#endif
5857	}
5858	}
5859	res->data = (char *)iv;
5860	return FALSE;
5861	}
5862	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5863	int &ringvar, poly &monomexpr)
5864	{
5865	monomexpr=(poly)w->Data();
5866	poly p=(poly)v->Data();
5867	#if 0
5868	if (pLength(monomexpr)>1)
5869	{
5870	Werror("`%s` substitutes a ringvar only by a term",
5871	Tok2Cmdname(SUBST_CMD));
5872	return TRUE;
5873	}
5874	#endif
5875	if (!(ringvar=pVar(p)))
5876	{
5877	if (rField_is_Extension(currRing))
5878	{
5879	assume(currRing->algring!=NULL);
5880	lnumber n=(lnumber)pGetCoeff(p);
5881	ringvar=-p_Var(n->z,currRing->algring);
5882	}
5883	if(ringvar==0)
5884	{
5885	WerrorS("ringvar/par expected");
5886	return TRUE;
5887	}
5888	}
5889	return FALSE;
5890	}
5891	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5892	{
5893	int ringvar;
5894	poly monomexpr;
5895	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5896	if (nok) return TRUE;
5897	if (ringvar>0)
5898	{
5899	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5900	res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5901	else
5902	res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5903	}
5904	else
5905	{
5906	res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5907	}
5908	return FALSE;
5909	}
5910	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5911	{
5912	int ringvar;
5913	poly monomexpr;
5914	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5915	if (nok) return TRUE;
5916	if (ringvar>0)
5917	{
5918	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5919	res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5920	else
5921	res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5922	}
5923	else
5924	{
5925	res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5926	}
5927	return FALSE;
5928	}
5929	// we do not want to have jjSUBST_Id_X inlined:
5930	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5931	int input_type);
5932	static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5933	{
5934	return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5935	}
5936	static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5937	{
5938	return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5939	}
5940	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5941	{
5942	sleftv tmp;
5943	memset(&tmp,0,sizeof(tmp));
5944	// do not check the result, conversion from int/number to poly works always
5945	iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5946	BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5947	tmp.CleanUp();
5948	return b;
5949	}
5950	static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5951	{
5952	matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5953	ideal I=(ideal)u->CopyD(IDEAL_CMD);
5954	int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5955	//for(i=i-1;i>=0;i--)
5956	//{
5957	// m->m[i]=I->m[i];
5958	// I->m[i]=NULL;
5959	//}
5960	memcpy4(m->m,I->m,i*sizeof(poly));
5961	memset(I->m,0,i*sizeof(poly));
5962	idDelete(&I);
5963	res->data = (char *)m;
5964	return FALSE;
5965	}
5966	static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5967	{
5968	res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5969	(int)(long)v->Data(),(int)(long)w->Data());
5970	return FALSE;
5971	}
5972	static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v,leftv w)
5973	{
5974	matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5975	matrix I=(matrix)u->CopyD(MATRIX_CMD);
5976	int r=si_min(MATROWS(I),(int)(long)v->Data());
5977	int c=si_min(MATCOLS(I),(int)(long)w->Data());
5978	int i,j;
5979	for(i=r;i>0;i--)
5980	{
5981	for(j=c;j>0;j--)
5982	{
5983	MATELEM(m,i,j)=MATELEM(I,i,j);
5984	MATELEM(I,i,j)=NULL;
5985	}
5986	}
5987	idDelete((ideal *)&I);
5988	res->data = (char *)m;
5989	return FALSE;
5990	}
5991	static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
5992	{
5993	if (w->rtyp!=IDHDL) return TRUE;
5994	BITSET save_test=test;
5995	int ul= IDELEMS((ideal)u->Data());
5996	int vl= IDELEMS((ideal)v->Data());
5997	ideal m
5998	= idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
5999	FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
6000	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
6001	test=save_test;
6002	return FALSE;
6003	}
6004	static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
6005	{
6006	assumeStdFlag(v);
6007	if (!idIsZeroDim((ideal)v->Data()))
6008	{
6009	Werror("`%s` must be 0-dimensional",v->Name());
6010	return TRUE;
6011	}
6012	res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
6013	(poly)w->CopyD());
6014	return FALSE;
6015	}
6016	static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
6017	{
6018	assumeStdFlag(v);
6019	if (!idIsZeroDim((ideal)v->Data()))
6020	{
6021	Werror("`%s` must be 0-dimensional",v->Name());
6022	return TRUE;
6023	}
6024	res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
6025	(matrix)w->CopyD());
6026	return FALSE;
6027	}
6028	static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
6029	{
6030	assumeStdFlag(v);
6031	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
6032	0,(int)(long)w->Data());
6033	return FALSE;
6034	}
6035	static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
6036	{
6037	assumeStdFlag(v);
6038	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
6039	0,(int)(long)w->Data());
6040	return FALSE;
6041	}
6042	#ifdef OLD_RES
6043	static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
6044	{
6045	int maxl=(int)v->Data();
6046	ideal u_id=(ideal)u->Data();
6047	int l=0;
6048	resolvente r;
6049	intvec **weights=NULL;
6050	int wmaxl=maxl;
6051	maxl--;
6052	if ((maxl==-1) && (iiOp!=MRES_CMD))
6053	maxl = pVariables-1;
6054	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
6055	{
6056	intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
6057	if (iv!=NULL)
6058	{
6059	l=1;
6060	if (!idTestHomModule(u_id,currQuotient,iv))
6061	{
6062	WarnS("wrong weights");
6063	iv=NULL;
6064	}
6065	else
6066	{
6067	weights = (intvec**)omAlloc0Bin(void_ptr_bin);
6068	weights[0] = ivCopy(iv);
6069	}
6070	}
6071	r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
6072	}
6073	else
6074	r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
6075	if (r==NULL) return TRUE;
6076	int t3=u->Typ();
6077	iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
6078	return FALSE;
6079	}
6080	#endif
6081	static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
6082	{
6083	res->data=(void *)rInit(u,v,w);
6084	return (res->data==NULL);
6085	}
6086	static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
6087	{
6088	int yes;
6089	jjSTATUS2(res, u, v);
6090	yes = (strcmp((char ) res->data, (char ) w->Data()) == 0);
6091	omFree((ADDRESS) res->data);
6092	res->data = (void *)(long)yes;
6093	return FALSE;
6094	}
6095	static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
6096	{
6097	intvec vw=(intvec )w->Data(); // weights of vars
6098	if (vw->length()!=currRing->N)
6099	{
6100	Werror("%d weights for %d variables",vw->length(),currRing->N);
6101	return TRUE;
6102	}
6103	ideal result;
6104	intvec ww=(intvec )atGet(u,"isHomog",INTVEC_CMD);
6105	tHomog hom=testHomog;
6106	ideal u_id=(ideal)(u->Data());
6107	if (ww!=NULL)
6108	{
6109	if (!idTestHomModule(u_id,currQuotient,ww))
6110	{
6111	WarnS("wrong weights");
6112	ww=NULL;
6113	}
6114	else
6115	{
6116	ww=ivCopy(ww);
6117	hom=isHomog;
6118	}
6119	}
6120	result=kStd(u_id,
6121	currQuotient,
6122	hom,
6123	&ww, // module weights
6124	(intvec *)v->Data(), // hilbert series
6125	0,0, // syzComp, newIdeal
6126	vw); // weights of vars
6127	idSkipZeroes(result);
6128	res->data = (char *)result;
6129	setFlag(res,FLAG_STD);
6130	if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
6131	return FALSE;
6132	}
6133
6134	/=================== operations with 3 args.: table =================/
6135	struct sValCmd3 dArith3[]=
6136	{
6137	// operations:
6138	// proc cmd res arg1 arg2 arg3 plural
6139	{jjBRACK_S, '[', STRING_CMD, STRING_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6140	,{jjBRACK_Im, '[', INT_CMD, INTMAT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6141	,{jjBRACK_Ma_I_IV, '[', INT_CMD, INTMAT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6142	,{jjBRACK_Ma_IV_I, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
6143	,{jjBRACK_Ma_IV_IV, '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
6144	,{jjBRACK_Ma, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6145	,{jjBRACK_Ma_I_IV, '[', POLY_CMD, MATRIX_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6146	,{jjBRACK_Ma_IV_I, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
6147	,{jjBRACK_Ma_IV_IV, '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
6148	,{jjPROC3, '(', ANY_TYPE, PROC_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6149	,{atATTRIB3, ATTRIB_CMD, NONE, IDHDL, STRING_CMD, DEF_CMD ALLOW_PLURAL}
6150	,{jjBAREISS3, BAREISS_CMD,LIST_CMD, MODUL_CMD, INT_CMD, INT_CMD NO_PLURAL}
6151	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
6152	,{jjCOEFFS3_P, COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
6153	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
6154	,{jjCOEFFS3_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
6155	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
6156	,{jjCOEFFS3_KB, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
6157	,{jjELIMIN_HILB, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
6158	,{jjELIMIN_HILB, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD, INTVEC_CMD NO_PLURAL}
6159	,{jjFIND3, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
6160	,{jjFWALK3, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD, INT_CMD NO_PLURAL}
6161	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD NO_PLURAL}
6162	,{jjHILBERT3, HILBERT_CMD,INTVEC_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD NO_PLURAL}
6163	,{jjHOMOG_P_W, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
6164	,{jjHOMOG_P_W, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
6165	,{jjHOMOG_ID_W, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
6166	,{jjHOMOG_ID_W, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
6167	,{jjCALL3MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6168	,{lInsert3, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
6169	//,{jjCALL3MANY, INTERSECT_CMD, NONE, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6170	,{jjINTMAT3, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6171	,{jjCALL3MANY, INTVEC_CMD, INTVEC_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6172	,{jjJET_P_IV, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6173	,{jjJET_ID_IV, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6174	,{jjJET_P_IV, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6175	,{jjJET_ID_IV, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
6176	,{jjJET_P_P, JET_CMD, POLY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
6177	,{jjJET_P_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
6178	,{jjJET_ID_M, JET_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
6179	,{jjJET_ID_M, JET_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
6180	,{jjWRONG3, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6181	,{mpKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
6182	,{jjCALL3MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6183	,{jjMATRIX_Id, MATRIX_CMD, MATRIX_CMD, IDEAL_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6184	,{jjMATRIX_Mo, MATRIX_CMD, MATRIX_CMD, MODUL_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6185	,{jjMATRIX_Ma, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6186	,{jjMINOR3, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
6187	,{jjCALL3MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6188	#ifdef OLD_RES
6189	,{jjRES3, MRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
6190	,{jjRES3, MRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
6191	#endif
6192	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
6193	,{jjLIFT3, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
6194	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ANY_TYPE ALLOW_PLURAL}
6195	,{jjPREIMAGE, PREIMAGE_CMD, IDEAL_CMD, QRING_CMD, ANY_TYPE, ANY_TYPE ALLOW_PLURAL}
6196	,{jjRANDOM_Im, RANDOM_CMD, INTMAT_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
6197	,{jjREDUCE3_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
6198	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
6199	,{jjREDUCE3_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
6200	,{jjREDUCE3_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
6201	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
6202	,{jjREDUCE3_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
6203	,{jjREDUCE3_CP, REDUCE_CMD, POLY_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
6204	,{jjREDUCE3_CP, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, MODUL_CMD ALLOW_PLURAL}
6205	,{jjREDUCE3_CID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
6206	,{jjREDUCE3_CID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
6207	#ifdef OLD_RES
6208	,{jjRES3, RES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
6209	,{jjRES3, RES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE ALLOW_PLURAL}
6210	#endif
6211	#ifdef HAVE_FACTORY
6212	,{jjRESULTANT, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
6213	#else
6214	,{jjWRONG3, RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
6215	#endif
6216	,{jjRING3, RING_CMD, RING_CMD, DEF_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6217	#ifdef OLD_RES
6218	,{jjRES3, SRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE NO_PLURAL}
6219	,{jjRES3, SRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE NO_PLURAL}
6220	#endif
6221	,{jjSTATUS3, STATUS_CMD, INT_CMD, LINK_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
6222	,{jjSTD_HILB_W, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
6223	,{jjSTD_HILB_W, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
6224	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6225	,{jjSUBST_P, SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6226	,{jjSUBST_P, SUBST_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6227	,{jjSUBST_Id, SUBST_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6228	,{jjSUBST_Id, SUBST_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6229	,{jjSUBST_Id, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
6230	,{jjSUBST_Id_I, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
6231	,{jjSUBST_Id_N, SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, NUMBER_CMD ALLOW_PLURAL}
6232	,{jjCALL3MANY, SYSTEM_CMD, NONE, STRING_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
6233	,{nuLagSolve, LAGSOLVE_CMD,LIST_CMD, POLY_CMD, INT_CMD, INT_CMD NO_PLURAL}
6234	,{nuVanderSys, VANDER_CMD, POLY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
6235	,{NULL, 0, 0, 0, 0, 0 NO_PLURAL}
6236	};
6237	/=================== operations with many arg.: static proc =================/
6238	static BOOLEAN jjBREAK0(leftv res, leftv v)
6239	{
6240	#ifdef HAVE_SDB
6241	sdb_show_bp();
6242	#endif
6243	return FALSE;
6244	}
6245	static BOOLEAN jjBREAK1(leftv res, leftv v)
6246	{
6247	#ifdef HAVE_SDB
6248	if(v->Typ()==PROC_CMD)
6249	{
6250	int lineno=0;
6251	if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
6252	{
6253	lineno=(int)(long)v->next->Data();
6254	}
6255	return sdb_set_breakpoint(v->Name(),lineno);
6256	}
6257	return TRUE;
6258	#else
6259	return FALSE;
6260	#endif
6261	}
6262	static BOOLEAN jjCALL1ARG(leftv res, leftv v)
6263	{
6264	return iiExprArith1(res,v,iiOp);
6265	}
6266	static BOOLEAN jjCALL2ARG(leftv res, leftv u)
6267	{
6268	leftv v=u->next;
6269	u->next=NULL;
6270	BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
6271	u->next=v;
6272	return b;
6273	}
6274	static BOOLEAN jjCALL3ARG(leftv res, leftv u)
6275	{
6276	leftv v = u->next;
6277	leftv w = v->next;
6278	u->next = NULL;
6279	v->next = NULL;
6280	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6281	u->next = v;
6282	v->next = w;
6283	return b;
6284	}
6285
6286	static BOOLEAN jjCOEF_M(leftv res, leftv v)
6287	{
6288	if((v->Typ() != VECTOR_CMD)
6289	\|\| (v->next->Typ() != POLY_CMD)
6290	\|\| (v->next->next->Typ() != MATRIX_CMD)
6291	\|\| (v->next->next->next->Typ() != MATRIX_CMD))
6292	return TRUE;
6293	if (v->next->next->rtyp!=IDHDL) return TRUE;
6294	idhdl c=(idhdl)v->next->next->data;
6295	if (v->next->next->next->rtyp!=IDHDL) return TRUE;
6296	idhdl m=(idhdl)v->next->next->next->data;
6297	idDelete((ideal *)&(c->data.uideal));
6298	idDelete((ideal *)&(m->data.uideal));
6299	mpCoef2((poly)v->Data(),(poly)v->next->Data(),
6300	(matrix )&(c->data.umatrix),(matrix )&(m->data.umatrix));
6301	return FALSE;
6302	}
6303
6304	static BOOLEAN jjDIVISION4(leftv res, leftv v)
6305	{ // may have 3 or 4 arguments
6306	leftv v1=v;
6307	leftv v2=v1->next;
6308	leftv v3=v2->next;
6309	leftv v4=v3->next;
6310	assumeStdFlag(v2);
6311
6312	int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
6313	int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
6314
6315	if((i1==0)\|\|(i2==0)
6316	\|\|(v3->Typ()!=INT_CMD)\|\|((v4!=NULL)&&(v4->Typ()!=INTVEC_CMD)))
6317	{
6318	WarnS("<module>,<module>,<int>[,<intvec>] expected!");
6319	return TRUE;
6320	}
6321
6322	sleftv w1,w2;
6323	iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
6324	iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
6325	ideal P=(ideal)w1.Data();
6326	ideal Q=(ideal)w2.Data();
6327
6328	int n=(int)(long)v3->Data();
6329	short *w=NULL;
6330	if(v4!=NULL)
6331	{
6332	w=iv2array((intvec *)v4->Data());
6333	short *w0=w+1;
6334	int i=pVariables;
6335	while(i>0&&*w0>0)
6336	{
6337	w0++;
6338	i--;
6339	}
6340	if(i>0)
6341	WarnS("not all weights are positive!");
6342	}
6343
6344	matrix T;
6345	ideal R;
6346	idLiftW(P,Q,n,T,R,w);
6347
6348	w1.CleanUp();
6349	w2.CleanUp();
6350	if(w!=NULL)
6351	omFree(w);
6352
6353	lists L=(lists) omAllocBin(slists_bin);
6354	L->Init(2);
6355	L->m[1].rtyp=v1->Typ();
6356	if(v1->Typ()==POLY_CMD\|\|v1->Typ()==VECTOR_CMD)
6357	{
6358	if(v1->Typ()==POLY_CMD)
6359	pShift(&R->m[0],-1);
6360	L->m[1].data=(void *)R->m[0];
6361	R->m[0]=NULL;
6362	idDelete(&R);
6363	}
6364	else if(v1->Typ()==IDEAL_CMD\|\|v1->Typ()==MATRIX_CMD)
6365	L->m[1].data=(void *)idModule2Matrix(R);
6366	else
6367	{
6368	L->m[1].rtyp=MODUL_CMD;
6369	L->m[1].data=(void *)R;
6370	}
6371	L->m[0].rtyp=MATRIX_CMD;
6372	L->m[0].data=(char *)T;
6373
6374	res->data=L;
6375	res->rtyp=LIST_CMD;
6376
6377	return FALSE;
6378	}
6379
6380	//static BOOLEAN jjEXPORTTO_M(leftv res, leftv u)
6381	//{
6382	// int l=u->listLength();
6383	// if (l<2) return TRUE;
6384	// BOOLEAN b;
6385	// leftv v=u->next;
6386	// leftv zz=v;
6387	// leftv z=zz;
6388	// u->next=NULL;
6389	// do
6390	// {
6391	// leftv z=z->next;
6392	// b=iiExprArith2(res,u,iiOp,z, (iiOp > 255));
6393	// if (b) break;
6394	// } while (z!=NULL);
6395	// u->next=zz;
6396	// return b;
6397	//}
6398	static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
6399	{
6400	int s=1;
6401	leftv h=v;
6402	if (h!=NULL) s=exprlist_length(h);
6403	ideal id=idInit(s,1);
6404	int rank=1;
6405	int i=0;
6406	poly p;
6407	while (h!=NULL)
6408	{
6409	switch(h->Typ())
6410	{
6411	case POLY_CMD:
6412	{
6413	p=(poly)h->CopyD(POLY_CMD);
6414	break;
6415	}
6416	case INT_CMD:
6417	{
6418	number n=nInit((int)(long)h->Data());
6419	if (!nIsZero(n))
6420	{
6421	p=pOne();
6422	pSetCoeff(p,n);
6423	}
6424	else
6425	{
6426	p=NULL;
6427	nDelete(&n);
6428	}
6429	break;
6430	}
6431	case BIGINT_CMD:
6432	{
6433	number b=(number)h->Data();
6434	number n=nInit_bigint(b);
6435	if (!nIsZero(n))
6436	{
6437	p=pOne();
6438	pSetCoeff(p,n);
6439	}
6440	else
6441	{
6442	p=NULL;
6443	nDelete(&n);
6444	}
6445	break;
6446	}
6447	case NUMBER_CMD:
6448	{
6449	number n=(number)h->CopyD(NUMBER_CMD);
6450	if (!nIsZero(n))
6451	{
6452	p=pOne();
6453	pSetCoeff(p,n);
6454	}
6455	else
6456	{
6457	p=NULL;
6458	nDelete(&n);
6459	}
6460	break;
6461	}
6462	case VECTOR_CMD:
6463	{
6464	p=(poly)h->CopyD(VECTOR_CMD);
6465	if (iiOp!=MODUL_CMD)
6466	{
6467	idDelete(&id);
6468	pDelete(&p);
6469	return TRUE;
6470	}
6471	rank=si_max(rank,(int)pMaxComp(p));
6472	break;
6473	}
6474	default:
6475	{
6476	idDelete(&id);
6477	return TRUE;
6478	}
6479	}
6480	if ((iiOp==MODUL_CMD)&&(p!=NULL)&&(pGetComp(p)==0))
6481	{
6482	pSetCompP(p,1);
6483	}
6484	id->m[i]=p;
6485	i++;
6486	h=h->next;
6487	}
6488	id->rank=rank;
6489	res->data=(char *)id;
6490	return FALSE;
6491	}
6492	static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
6493	{
6494	leftv h=v;
6495	int l=v->listLength();
6496	resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
6497	BOOLEAN copied=(BOOLEAN )omAlloc0(l*sizeof(BOOLEAN));
6498	int t=0;
6499	// try to convert to IDEAL_CMD
6500	while (h!=NULL)
6501	{
6502	if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
6503	{
6504	t=IDEAL_CMD;
6505	}
6506	else break;
6507	h=h->next;
6508	}
6509	// if failure, try MODUL_CMD
6510	if (t==0)
6511	{
6512	h=v;
6513	while (h!=NULL)
6514	{
6515	if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
6516	{
6517	t=MODUL_CMD;
6518	}
6519	else break;
6520	h=h->next;
6521	}
6522	}
6523	// check for success in converting
6524	if (t==0)
6525	{
6526	WerrorS("cannot convert to ideal or module");
6527	return TRUE;
6528	}
6529	// call idMultSect
6530	h=v;
6531	int i=0;
6532	sleftv tmp;
6533	while (h!=NULL)
6534	{
6535	if (h->Typ()==t)
6536	{
6537	r[i]=(ideal)h->Data(); /no copy/
6538	h=h->next;
6539	}
6540	else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
6541	{
6542	omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
6543	omFreeSize((ADDRESS)r,l*sizeof(ideal));
6544	Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
6545	return TRUE;
6546	}
6547	else
6548	{
6549	r[i]=(ideal)tmp.Data(); /now it's a copy/
6550	copied[i]=TRUE;
6551	h=tmp.next;
6552	}
6553	i++;
6554	}
6555	res->rtyp=t;
6556	res->data=(char *)idMultSect(r,i);
6557	while(i>0)
6558	{
6559	i--;
6560	if (copied[i]) idDelete(&(r[i]));
6561	}
6562	omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
6563	omFreeSize((ADDRESS)r,l*sizeof(ideal));
6564	return FALSE;
6565	}
6566	static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
6567	{
6568	int i=0;
6569	leftv h=v;
6570	if (h!=NULL) i=exprlist_length(h);
6571	intvec *iv=new intvec(i);
6572	i=0;
6573	while (h!=NULL)
6574	{
6575	if(h->Typ()==INT_CMD)
6576	{
6577	(*iv)[i]=(int)(long)h->Data();
6578	}
6579	else
6580	{
6581	delete iv;
6582	return TRUE;
6583	}
6584	i++;
6585	h=h->next;
6586	}
6587	res->data=(char *)iv;
6588	return FALSE;
6589	}
6590	static BOOLEAN jjJET4(leftv res, leftv u)
6591	{
6592	leftv u1=u;
6593	leftv u2=u1->next;
6594	leftv u3=u2->next;
6595	leftv u4=u3->next;
6596	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6597	(u4->Typ()==INTVEC_CMD)\|\|
6598	(u1->Typ()==VECTOR_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==INT_CMD)&&
6599	(u4->Typ()==INTVEC_CMD))
6600	{
6601	if(!pIsUnit((poly)u2->Data()))
6602	{
6603	WerrorS("2nd argument must be a unit");
6604	return TRUE;
6605	}
6606	res->rtyp=u1->Typ();
6607	res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
6608	pCopy((poly)u2->Data()),(intvec*)u4->Data());
6609	return FALSE;
6610	}
6611	else
6612	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6613	(u4->Typ()==INTVEC_CMD)\|\|
6614	(u1->Typ()==MODUL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==INT_CMD)&&
6615	(u4->Typ()==INTVEC_CMD))
6616	{
6617	if(!mpIsDiagUnit((matrix)u2->Data()))
6618	{
6619	WerrorS("2nd argument must be a diagonal matrix of units");
6620	return TRUE;
6621	}
6622	res->rtyp=u1->Typ();
6623	res->data=(char*)idSeries((int)(long)u3->Data(),idCopy((ideal)u1->Data()),
6624	mpCopy((matrix)u2->Data()),(intvec*)u4->Data());
6625	return FALSE;
6626	}
6627	else
6628	{
6629	Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
6630	Tok2Cmdname(iiOp));
6631	return TRUE;
6632	}
6633	}
6634	static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
6635	{
6636	if ((yyInRingConstruction)
6637	&& ((strcmp(u->Name(),"real")==0) \|\| (strcmp(u->Name(),"complex")==0)))
6638	{
6639	memcpy(res,u,sizeof(sleftv));
6640	memset(u,0,sizeof(sleftv));
6641	return FALSE;
6642	}
6643	leftv v=u->next;
6644	BOOLEAN b;
6645	if(v==NULL)
6646	b=iiExprArith1(res,u,iiOp);
6647	else
6648	{
6649	u->next=NULL;
6650	b=iiExprArith2(res,u,iiOp,v);
6651	u->next=v;
6652	}
6653	return b;
6654	}
6655	static BOOLEAN jjLIST_PL(leftv res, leftv v)
6656	{
6657	int sl=0;
6658	if (v!=NULL) sl = v->listLength();
6659	lists L;
6660	if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
6661	{
6662	int add_row_shift = 0;
6663	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
6664	if (weights!=NULL) add_row_shift=weights->min_in();
6665	L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
6666	}
6667	else
6668	{
6669	L=(lists)omAllocBin(slists_bin);
6670	leftv h=NULL;
6671	int i;
6672	int rt;
6673
6674	L->Init(sl);
6675	for (i=0;i<sl;i++)
6676	{
6677	if (h!=NULL)
6678	{ /* e.g. not in the first step:
6679	* h is the pointer to the old sleftv,
6680	* v is the pointer to the next sleftv
6681	* (in this moment) */
6682	h->next=v;
6683	}
6684	h=v;
6685	v=v->next;
6686	h->next=NULL;
6687	rt=h->Typ();
6688	if (rt==0)
6689	{
6690	L->Clean();
6691	Werror("`%s` is undefined",h->Fullname());
6692	return TRUE;
6693	}
6694	if ((rt==RING_CMD)\|\|(rt==QRING_CMD))
6695	{
6696	L->m[i].rtyp=rt; L->m[i].data=h->Data();
6697	((ring)L->m[i].data)->ref++;
6698	}
6699	else
6700	L->m[i].Copy(h);
6701	}
6702	}
6703	res->data=(char *)L;
6704	return FALSE;
6705	}
6706	static BOOLEAN jjNAMES0(leftv res, leftv v)
6707	{
6708	res->data=(void *)ipNameList(IDROOT);
6709	return FALSE;
6710	}
6711	static BOOLEAN jjOPTION_PL(leftv res, leftv v)
6712	{
6713	if(v==NULL)
6714	{
6715	res->data=(char *)showOption();
6716	return FALSE;
6717	}
6718	res->rtyp=NONE;
6719	return setOption(res,v);
6720	}
6721	static BOOLEAN jjREDUCE4(leftv res, leftv u)
6722	{
6723	leftv u1=u;
6724	leftv u2=u1->next;
6725	leftv u3=u2->next;
6726	leftv u4=u3->next;
6727	if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
6728	{
6729	int save_d=Kstd1_deg;
6730	Kstd1_deg=(int)(long)u3->Data();
6731	kModW=(intvec *)u4->Data();
6732	BITSET save=verbose;
6733	verbose\|=Sy_bit(V_DEG_STOP);
6734	u2->next=NULL;
6735	BOOLEAN r=jjCALL2ARG(res,u);
6736	kModW=NULL;
6737	Kstd1_deg=save_d;
6738	verbose=save;
6739	u->next->next=u3;
6740	return r;
6741	}
6742	else
6743	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6744	(u4->Typ()==INT_CMD))
6745	{
6746	assumeStdFlag(u3);
6747	if(!mpIsDiagUnit((matrix)u2->Data()))
6748	{
6749	WerrorS("2nd argument must be a diagonal matrix of units");
6750	return TRUE;
6751	}
6752	res->rtyp=IDEAL_CMD;
6753	res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6754	mpCopy((matrix)u2->Data()),(int)(long)u4->Data());
6755	return FALSE;
6756	}
6757	else
6758	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6759	(u4->Typ()==INT_CMD))
6760	{
6761	assumeStdFlag(u3);
6762	if(!pIsUnit((poly)u2->Data()))
6763	{
6764	WerrorS("2nd argument must be a unit");
6765	return TRUE;
6766	}
6767	res->rtyp=POLY_CMD;
6768	res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6769	pCopy((poly)u2->Data()),(int)(long)u4->Data());
6770	return FALSE;
6771	}
6772	else
6773	{
6774	Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
6775	return TRUE;
6776	}
6777	}
6778	static BOOLEAN jjREDUCE5(leftv res, leftv u)
6779	{
6780	leftv u1=u;
6781	leftv u2=u1->next;
6782	leftv u3=u2->next;
6783	leftv u4=u3->next;
6784	leftv u5=u4->next;
6785	if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6786	(u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6787	{
6788	assumeStdFlag(u3);
6789	if(!mpIsDiagUnit((matrix)u2->Data()))
6790	{
6791	WerrorS("2nd argument must be a diagonal matrix of units");
6792	return TRUE;
6793	}
6794	res->rtyp=IDEAL_CMD;
6795	res->data=(char*)redNF(idCopy((ideal)u3->Data()),idCopy((ideal)u1->Data()),
6796	mpCopy((matrix)u2->Data()),
6797	(int)(long)u4->Data(),(intvec*)u5->Data());
6798	return FALSE;
6799	}
6800	else
6801	if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
6802	(u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
6803	{
6804	assumeStdFlag(u3);
6805	if(!pIsUnit((poly)u2->Data()))
6806	{
6807	WerrorS("2nd argument must be a unit");
6808	return TRUE;
6809	}
6810	res->rtyp=POLY_CMD;
6811	res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
6812	pCopy((poly)u2->Data()),
6813	(int)(long)u4->Data(),(intvec*)u5->Data());
6814	return FALSE;
6815	}
6816	else
6817	{
6818	Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
6819	Tok2Cmdname(iiOp));
6820	return TRUE;
6821	}
6822	}
6823	static BOOLEAN jjRESERVED0(leftv res, leftv v)
6824	{
6825	int i=1;
6826	int nCount = (sArithBase.nCmdUsed-1)/3;
6827	if((3*nCount)<sArithBase.nCmdUsed) nCount++;
6828	//Print("CMDS: %d/%d\n", sArithBase.nCmdUsed,
6829	// sArithBase.nCmdAllocated);
6830	for(i=0; i<nCount; i++)
6831	{
6832	Print("%-20s",sArithBase.sCmds[i+1].name);
6833	if(i+1+nCount<sArithBase.nCmdUsed)
6834	Print("%-20s",sArithBase.sCmds[i+1+nCount].name);
6835	if(i+1+2*nCount<sArithBase.nCmdUsed)
6836	Print("%-20s",sArithBase.sCmds[i+1+2*nCount].name);
6837	//if ((i%3)==1) PrintLn();
6838	PrintLn();
6839	}
6840	PrintLn();
6841	return FALSE;
6842	}
6843	static BOOLEAN jjSTRING_PL(leftv res, leftv v)
6844	{
6845	if (v == NULL)
6846	{
6847	res->data = omStrDup("");
6848	return FALSE;
6849	}
6850	int n = v->listLength();
6851	if (n == 1)
6852	{
6853	res->data = v->String();
6854	return FALSE;
6855	}
6856
6857	char slist = (char) omAlloc(nsizeof(char));
6858	int i, j;
6859
6860	for (i=0, j=0; i<n; i++, v = v ->next)
6861	{
6862	slist[i] = v->String();
6863	assume(slist[i] != NULL);
6864	j+=strlen(slist[i]);
6865	}
6866	char* s = (char) omAlloc((j+1)sizeof(char));
6867	*s='\0';
6868	for (i=0;i<n;i++)
6869	{
6870	strcat(s, slist[i]);
6871	omFree(slist[i]);
6872	}
6873	omFreeSize(slist, nsizeof(char));
6874	res->data = s;
6875	return FALSE;
6876	}
6877	static BOOLEAN jjTEST(leftv res, leftv v)
6878	{
6879	do
6880	{
6881	if (v->Typ()!=INT_CMD)
6882	return TRUE;
6883	test_cmd((int)(long)v->Data());
6884	v=v->next;
6885	}
6886	while (v!=NULL);
6887	return FALSE;
6888	}
6889
6890	#if defined(__alpha) && !defined(linux)
6891	extern "C"
6892	{
6893	void usleep(unsigned long usec);
6894	};
6895	#endif
6896
6897	static BOOLEAN jjSTATUS_M(leftv res, leftv v)
6898	{
6899	if ((v->Typ() != LINK_CMD) \|\|
6900	(v->next->Typ() != STRING_CMD) \|\|
6901	(v->next->next->Typ() != STRING_CMD) \|\|
6902	(v->next->next->next->Typ() != INT_CMD))
6903	return TRUE;
6904	jjSTATUS3(res, v, v->next, v->next->next);
6905	#if defined(HAVE_USLEEP)
6906	if (((long) res->data) == 0L)
6907	{
6908	int i_s = (int)(long) v->next->next->next->Data();
6909	if (i_s > 0)
6910	{
6911	usleep((int)(long) v->next->next->next->Data());
6912	jjSTATUS3(res, v, v->next, v->next->next);
6913	}
6914	}
6915	#elif defined(HAVE_SLEEP)
6916	if (((int) res->data) == 0)
6917	{
6918	int i_s = (int) v->next->next->next->Data();
6919	if (i_s > 0)
6920	{
6921	sleep((is - 1)/1000000 + 1);
6922	jjSTATUS3(res, v, v->next, v->next->next);
6923	}
6924	}
6925	#endif
6926	return FALSE;
6927	}
6928	static BOOLEAN jjSUBST_M(leftv res, leftv u)
6929	{
6930	leftv v = u->next; // number of args > 0
6931	if (v==NULL) return TRUE;
6932	leftv w = v->next;
6933	if (w==NULL) return TRUE;
6934	leftv rest = w->next;;
6935
6936	u->next = NULL;
6937	v->next = NULL;
6938	w->next = NULL;
6939	BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
6940	if ((rest!=NULL) && (!b))
6941	{
6942	sleftv tmp_res;
6943	leftv tmp_next=res->next;
6944	res->next=rest;
6945	memset(&tmp_res,0,sizeof(tmp_res));
6946	b = iiExprArithM(&tmp_res,res,iiOp);
6947	memcpy(res,&tmp_res,sizeof(tmp_res));
6948	res->next=tmp_next;
6949	}
6950	u->next = v;
6951	v->next = w;
6952	// rest was w->next, but is already cleaned
6953	return b;
6954	}
6955	static BOOLEAN jjSTD_HILB_WP(leftv res, leftv INPUT)
6956	{ ideal result;
6957	leftv u = INPUT; /* an ideal, weighted homogeneous and standard */
6958	leftv v = u->next; /* one additional polynomial or ideal */
6959	leftv h = v->next; /* Hilbert vector */
6960	leftv w = h->next; /* weight vector */
6961	assumeStdFlag(u);
6962	ideal i1=(ideal)(u->Data());
6963	ideal i0;
6964	intvec vw=(intvec )w->Data(); // weights of vars
6965	/* merging std_hilb_w and std_1 */
6966	if (vw->length()!=currRing->N)
6967	{
6968	Werror("%d weights for %d variables",vw->length(),currRing->N);
6969	return TRUE;
6970	}
6971	int r=v->Typ();
6972	BOOLEAN cleanup_i0=FALSE;
6973	if ((r==POLY_CMD) \|\|(r==VECTOR_CMD))
6974	{
6975	i0=idInit(1,i1->rank);
6976	i0->m[0]=(poly)v->Data();
6977	BOOLEAN cleanup_i0=TRUE;;
6978	}
6979	else /* IDEAL */
6980	{
6981	i0=(ideal)v->Data();
6982	}
6983	int ii0=idElem(i0);
6984	i1 = idSimpleAdd(i1,i0);
6985	if (cleanup_i0)
6986	{
6987	memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
6988	idDelete(&i0);
6989	}
6990	intvec ww=(intvec )atGet(u,"isHomog",INTVEC_CMD);
6991	tHomog hom=testHomog;
6992	/* u_id from jjSTD_W is now i1 as in jjSTD_1 */
6993	if (ww!=NULL)
6994	{
6995	if (!idTestHomModule(i1,currQuotient,ww))
6996	{
6997	WarnS("wrong weights");
6998	ww=NULL;
6999	}
7000	else
7001	{
7002	ww=ivCopy(ww);
7003	hom=isHomog;
7004	}
7005	}
7006	BITSET save_test=test;
7007	test\|=Sy_bit(OPT_SB_1);
7008	result=kStd(i1,
7009	currQuotient,
7010	hom,
7011	&ww, // module weights
7012	(intvec *)h->Data(), // hilbert series
7013	0, // syzComp, whatever it is...
7014	IDELEMS(i1)-ii0, // new ideal
7015	vw); // weights of vars
7016	test=save_test;
7017	idDelete(&i1);
7018	idSkipZeroes(result);
7019	res->data = (char *)result;
7020	if (!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
7021	if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
7022	return FALSE;
7023	}
7024
7025
7026	/=================== operations with many arg.: table =================/
7027	/* number_of_args: -1: any, -2: any >0, .. */
7028	struct sValCmdM dArithM[]=
7029	{
7030	// operations:
7031	// proc cmd res number_of_args plural
7032	{jjKLAMMER_PL, '(', ANY_TYPE, -2 ALLOW_PLURAL}
7033	,{jjBREAK0, BREAKPOINT_CMD, NONE, 0 ALLOW_PLURAL}
7034	,{jjBREAK1, BREAKPOINT_CMD, NONE, -2 ALLOW_PLURAL}
7035	,{jjCALL2ARG, COEF_CMD, MATRIX_CMD, 2 ALLOW_PLURAL}
7036	,{jjCOEF_M, COEF_CMD, NONE, 4 ALLOW_PLURAL}
7037	,{jjCALL2ARG, DIVISION_CMD, ANY_TYPE/or set by p/,2 ALLOW_PLURAL}
7038	,{jjDIVISION4, DIVISION_CMD, ANY_TYPE/or set by p/,3 NO_PLURAL}
7039	,{jjDIVISION4, DIVISION_CMD, ANY_TYPE/or set by p/,4 NO_PLURAL}
7040	,{jjDBPRINT, DBPRINT_CMD, NONE, -2 ALLOW_PLURAL}
7041	//,{jjEXPORTTO_M, EXPORTTO_CMD, NONE, -2 ALLOW_PLURAL}
7042	,{jjCALL1ARG, IDEAL_CMD, IDEAL_CMD, 1 ALLOW_PLURAL}
7043	,{jjIDEAL_PL, IDEAL_CMD, IDEAL_CMD, -1 ALLOW_PLURAL}
7044	,{jjCALL2ARG, INTERSECT_CMD, IDEAL_CMD, 2 ALLOW_PLURAL}
7045	,{jjINTERSECT_PL,INTERSECT_CMD, IDEAL_CMD, -2 ALLOW_PLURAL}
7046	,{jjCALL1ARG, INTVEC_CMD, INTVEC_CMD, 1 ALLOW_PLURAL}
7047	,{jjINTVEC_PL, INTVEC_CMD, INTVEC_CMD, -2 ALLOW_PLURAL}
7048	,{jjCALL2ARG, JET_CMD, POLY_CMD,/or set by p/ 2 ALLOW_PLURAL}
7049	,{jjCALL3ARG, JET_CMD, POLY_CMD,/or set by p/ 3 ALLOW_PLURAL}
7050	,{jjJET4, JET_CMD, POLY_CMD,/or set by p/ 4 ALLOW_PLURAL}
7051	,{jjLIST_PL, LIST_CMD, LIST_CMD, -1 ALLOW_PLURAL}
7052	,{jjCALL1ARG, MODUL_CMD, MODUL_CMD, 1 ALLOW_PLURAL}
7053	,{jjIDEAL_PL, MODUL_CMD, MODUL_CMD, -1 ALLOW_PLURAL}
7054	,{jjCALL1ARG, NAMES_CMD, LIST_CMD, 1 ALLOW_PLURAL}
7055	,{jjNAMES0, NAMES_CMD, LIST_CMD, 0 ALLOW_PLURAL}
7056	,{jjOPTION_PL, OPTION_CMD, STRING_CMD/or set by p/,-1 ALLOW_PLURAL}
7057	,{jjCALL2ARG, REDUCE_CMD, IDEAL_CMD/or set by p/, 2 ALLOW_PLURAL}
7058	,{jjCALL3ARG, REDUCE_CMD, IDEAL_CMD/or set by p/, 3 ALLOW_PLURAL}
7059	,{jjREDUCE4, REDUCE_CMD, IDEAL_CMD/or set by p/, 4 ALLOW_PLURAL}
7060	,{jjREDUCE5, REDUCE_CMD, IDEAL_CMD/or set by p/, 5 ALLOW_PLURAL}
7061	,{jjCALL1ARG, RESERVEDNAME_CMD, INT_CMD, 1 ALLOW_PLURAL}
7062	,{jjRESERVED0, RESERVEDNAME_CMD, NONE, 0 ALLOW_PLURAL}
7063	,{jjSTRING_PL, STRING_CMD, STRING_CMD, -1 ALLOW_PLURAL}
7064	,{jjCALL3ARG, SUBST_CMD, NONE/set by p/, 3 ALLOW_PLURAL}
7065	,{jjSUBST_M, SUBST_CMD, NONE/set by p/, -2 ALLOW_PLURAL}
7066	,{jjSYSTEM, SYSTEM_CMD, NONE/or set by p/,-2 ALLOW_PLURAL}
7067	,{jjTEST, TEST_CMD, NONE, -2 ALLOW_PLURAL}
7068	,{iiWRITE, WRITE_CMD, NONE, -2 ALLOW_PLURAL}
7069	,{jjCALL2ARG, STATUS_CMD, STRING_CMD, 2 ALLOW_PLURAL}
7070	,{jjCALL3ARG, STATUS_CMD, INT_CMD, 3 ALLOW_PLURAL}
7071	,{jjSTATUS_M, STATUS_CMD, INT_CMD, 4 ALLOW_PLURAL}
7072	,{loSimplex, SIMPLEX_CMD, LIST_CMD, 6 NO_PLURAL}
7073	,{nuUResSolve, URSOLVE_CMD, LIST_CMD, 4 NO_PLURAL}
7074	,{jjCALL1ARG, STD_CMD, IDEAL_CMD, 1 ALLOW_PLURAL}
7075	,{jjCALL2ARG, STD_CMD, IDEAL_CMD, 2 ALLOW_PLURAL}
7076	,{jjCALL3ARG, STD_CMD, IDEAL_CMD, 3 NO_PLURAL}
7077	,{jjSTD_HILB_WP, STD_CMD, IDEAL_CMD, 4 NO_PLURAL}
7078	,{NULL, 0, 0, 0 NO_PLURAL}
7079	};
7080	#ifdef MDEBUG
7081	static Subexpr jjDBMakeSub(leftv e,const char *f,const int l)
7082	#else
7083	static Subexpr jjMakeSub(leftv e)
7084	#endif
7085	{
7086	assume( e->Typ()==INT_CMD );
7087	Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
7088	r->start =(int)(long)e->Data();
7089	return r;
7090	}
7091
7092	/================ generating tables ============================/
7093	#ifdef GENTABLE
7094	extern struct sValAssign dAssign[];
7095	struct sValCmdTab dArithTab1[]={ {0,0}};
7096	#define JJTAB1LEN 0
7097	struct sValCmdTab dArithTab2[]={ {0,0}};
7098	#define JJTAB2LEN 0
7099	void ttGen1()
7100	{
7101	FILE *outfile = myfopen("iparith.inc","w");
7102	int i,j,l1=0,l2=0;
7103	currRing=(ring)omAllocBin(sip_sring_bin);
7104	fprintf(outfile,
7105	"/****************************************\n"
7106	"* Computer Algebra System SINGULAR *\n"
7107	"****************************************/\n\n");
7108	/-------------------------------------------------------------------/
7109	fprintf(outfile,"// syntax table for Singular\n//\n");
7110	fprintf(outfile,"// - search for an exact match of the argument types\n");
7111	fprintf(outfile,"// - otherwise search for the first possibility\n");
7112	fprintf(outfile,"// with converted types of the arguments\n");
7113	fprintf(outfile,"// - otherwise report an error\n//\n");
7114
7115	int op;
7116	i=0;
7117	while ((op=dArith1[i].cmd)!=0)
7118	{
7119	if (dArith1[i].p==jjWRONG)
7120	fprintf(outfile,"// DUMMY ");
7121	const char *s = iiTwoOps(op);
7122	fprintf(outfile,"// operation: %s (%s) -> %s\n",
7123	s,
7124	Tok2Cmdname(dArith1[i].arg),
7125	Tok2Cmdname(ABS(dArith1[i].res)));
7126	i++;
7127	}
7128	fprintf(outfile,"/---------------------------------------------/\n");
7129	i=0;
7130	while ((op=dArith2[i].cmd)!=0)
7131	{
7132	if (dArith2[i].p==jjWRONG2)
7133	fprintf(outfile,"// DUMMY ");
7134	const char *s = iiTwoOps(op);
7135	fprintf(outfile,"// operation: %s (%s, %s) -> %s\n",
7136	s,
7137	Tok2Cmdname(dArith2[i].arg1),
7138	Tok2Cmdname(dArith2[i].arg2),
7139	Tok2Cmdname(dArith2[i].res));
7140	i++;
7141	}
7142	fprintf(outfile,"/---------------------------------------------/\n");
7143	i=0;
7144	while ((op=dArith3[i].cmd)!=0)
7145	{
7146	const char *s = iiTwoOps(op);
7147	if (dArith3[i].p==jjWRONG3)
7148	fprintf(outfile,"// DUMMY ");
7149	fprintf(outfile,"// operation: %s (%s, %s, %s) -> %s\n",
7150	s,
7151	Tok2Cmdname(dArith3[i].arg1),
7152	Tok2Cmdname(dArith3[i].arg2),
7153	Tok2Cmdname(dArith3[i].arg3),
7154	Tok2Cmdname(dArith3[i].res));
7155	i++;
7156	}
7157	fprintf(outfile,"/---------------------------------------------/\n");
7158	i=0;
7159	while ((op=dArithM[i].cmd)!=0)
7160	{
7161	const char *s = iiTwoOps(op);
7162	fprintf(outfile,"// operation: %s (...) -> %s",
7163	s,
7164	Tok2Cmdname(dArithM[i].res));
7165	switch(dArithM[i].number_of_args)
7166	{
7167	case -2:
7168	fprintf(outfile," ( number of arguments >0 )\n");
7169	break;
7170	case -1:
7171	fprintf(outfile," ( any number of arguments )\n");
7172	break;
7173	default:
7174	fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
7175	break;
7176	}
7177	i++;
7178	}
7179	fprintf(outfile,"/---------------------------------------------/\n");
7180	i=0;
7181	while ((op=dAssign[i].res)!=0)
7182	{
7183	fprintf(outfile,"// assign: %s = %s\n",
7184	Tok2Cmdname(op/dAssign[i].res/),
7185	Tok2Cmdname(dAssign[i].arg));
7186	i++;
7187	}
7188	/-------------------------------------------------------------------/
7189	fprintf(outfile,"/---------------------------------------------/\n");
7190	for (j=257;j<=MAX_TOK+1;j++)
7191	{
7192	for(i=257;i<=MAX_TOK+1;i++)
7193	{
7194	if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
7195	&& iiTestConvert(i,j))
7196	{
7197	fprintf(outfile,"// convert %s -> %s\n",
7198	Tok2Cmdname(i), Tok2Cmdname(j));
7199	if (j==ANY_TYPE) break;
7200	}
7201	}
7202	}
7203	fprintf(outfile,"/---------------------------------------------/\n");
7204	char ops[]="=><+*/[.^,%(;";
7205	for(i=0;ops[i]!='\0';i++)
7206	fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
7207	for (i=257;i<=MAX_TOK;i++)
7208	{
7209	const char *s=iiTwoOps(i);
7210	if (s[0]!='$')
7211	{
7212	fprintf(outfile,"// token %d : %s\n", i, s);
7213	}
7214	}
7215	/-------------------------------------------------------------------/
7216	fprintf(outfile,"/--max. token: %d, gr: %d --/\n",MAX_TOK,UMINUS);
7217	/-------------------------------------------------------------------/
7218	fprintf(outfile,"/---------------------------------------------/\n");
7219	fprintf(outfile,
7220	"struct sValCmdTab dArithTab1[]=\n"
7221	"{\n");
7222	for (j=1;j<=MAX_TOK+1;j++)
7223	{
7224	for(i=0;dArith1[i].cmd!=0;i++)
7225	{
7226	if (dArith1[i].cmd==j)
7227	{
7228	fprintf(outfile," { %d,%d },\n",j,i);
7229	l1++;
7230	break;
7231	}
7232	}
7233	}
7234	fprintf(outfile," { 10000,0 }\n};\n");
7235	fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
7236	/-------------------------------------------------------------------/
7237	fprintf(outfile,
7238	"struct sValCmdTab dArithTab2[]=\n"
7239	"{\n");
7240	for (j=1;j<=MAX_TOK+1;j++)
7241	{
7242	for(i=0;dArith2[i].cmd!=0;i++)
7243	{
7244	if (dArith2[i].cmd==j)
7245	{
7246	fprintf(outfile," { %d,%d },\n",j,i);
7247	l2++;
7248	break;
7249	}
7250	}
7251	}
7252	fprintf(outfile," { 10000,0 }\n};\n");
7253	fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
7254	fclose(outfile);
7255	}
7256	/-------------------------------------------------------------------/
7257	#if 0
7258	void ttGen2()
7259	{
7260	FILE *outfile = myfopen("iparith.inc","a");
7261	fprintf(outfile,
7262	"/****************************************\n"
7263	"* Computer Algebra System SINGULAR *\n"
7264	"****************************************/\n\n");
7265	/-------------------------------------------------------------------/
7266	fprintf(outfile,"// identifier table for Singular\n//\n");
7267
7268	fprintf(outfile,
7269	"cmdnames OLDcmds[] =\n"
7270	"{ // name-string alias tokval toktype\n"
7271	"{ \"$INVALID$\", 0, -1, 0},\n");
7272	int i=1;
7273	int m=-1;
7274	int id_nr=0;
7275	BOOLEAN f=FALSE;
7276	loop
7277	{
7278	while (cmds[i].tokval!=0)
7279	{
7280	if ((cmds[i].tokval!=-1)&&(cmds[i].name!=NULL))
7281	{
7282	if(m==-1)
7283	{
7284	m=i;
7285	f=TRUE;
7286	}
7287	else if(strcmp(cmds[m].name,cmds[i].name)>0)
7288	{
7289	m=i;
7290	f=TRUE;
7291	}
7292	}
7293	i++;
7294	}
7295	if(f)
7296	{
7297	id_nr++;
7298	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
7299	fprintf(outfile," {\"%s\", %*d, %3d, ",cmds[m].name,
7300	20-strlen(cmds[m].name),
7301	cmds[m].alias,
7302	cmds[m].tokval);
7303	switch(cmds[m].toktype)
7304	{
7305	case CMD_1: fprintf(outfile,"CMD_1 },\n"); break;
7306	case CMD_2: fprintf(outfile,"CMD_2 },\n"); break;
7307	case CMD_3: fprintf(outfile,"CMD_3 },\n"); break;
7308	case CMD_12: fprintf(outfile,"CMD_12 },\n"); break;
7309	case CMD_123 : fprintf(outfile,"CMD_123 },\n"); break;
7310	case CMD_23: fprintf(outfile,"CMD_23 },\n"); break;
7311	case CMD_M: fprintf(outfile,"CMD_M },\n"); break;
7312	case SYSVAR: fprintf(outfile,"SYSVAR },\n"); break;
7313	case ROOT_DECL: fprintf(outfile,"ROOT_DECL },\n"); break;
7314	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST },\n"); break;
7315	case RING_DECL: fprintf(outfile,"RING_DECL },\n"); break;
7316	case NONE: fprintf(outfile,"NONE },\n"); break;
7317	default: if((cmds[m].toktype>' ')
7318	&&(cmds[m].toktype<127))
7319	{
7320	fprintf(outfile,"'%c' },\n",cmds[m].toktype);
7321	}
7322	else
7323	{
7324	fprintf(outfile,"%d },\n",cmds[m].toktype);
7325	}
7326	break;
7327	}
7328	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
7329	cmds[m].name=NULL;
7330	m=-1;
7331	i=1;
7332	f=FALSE;
7333	}
7334	else break;
7335	}
7336	fprintf(outfile,
7337	"/* list of scanner identifiers/only for feread/reservedName */\n");
7338	f=FALSE;
7339	i=1;m=-1;
7340	loop
7341	{
7342	while (cmds[i].tokval!=0)
7343	{
7344	if (cmds[i].name!=NULL)
7345	{
7346	if(m==-1)
7347	{
7348	m=i;
7349	f=TRUE;
7350	}
7351	else if(strcmp(cmds[m].name,cmds[i].name)>0)
7352	{
7353	m=i;
7354	f=TRUE;
7355	}
7356	}
7357	i++;
7358	}
7359	if(f)
7360	{
7361	fprintf(outfile," {\"%s\", %*d, -1, 0 },\n",cmds[m].name,
7362	20-strlen(cmds[m].name),
7363	0/cmds[m].alias/
7364	/-1 cmds[m].tokval/
7365	/0 cmds[m].toktype/);
7366	cmds[m].name=NULL;
7367	m=-1;
7368	i=1;
7369	f=FALSE;
7370	}
7371	else break;
7372	}
7373	fprintf(outfile,
7374	"/* end of list marker */\n"
7375	" { NULL, 0, 0, 0}\n"
7376	"};\n"
7377	"#ifdef HAVE_RTIMER\n"
7378	"#define LAST_IDENTIFIER %d\n"
7379	"#else\n"
7380	"#define LAST_IDENTIFIER %d\n"
7381	"#endif\n",id_nr,id_nr-1);
7382	fclose(outfile);
7383	}
7384	#endif
7385	/---------------------------------------------------------------------/
7386	/**
7387	* @brief generate cmds initialisation
7388	**/
7389	/---------------------------------------------------------------------/
7390
7391	void ttGen2b()
7392	{
7393	int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
7394
7395	FILE *outfile = myfopen("iparith.inc","a");
7396	fprintf(outfile,
7397	"/****************************************\n"
7398	"* Computer Algebra System SINGULAR *\n"
7399	"****************************************/\n\n");
7400	/-------------------------------------------------------------------/
7401	fprintf(outfile,"// identifier table for Singular\n//\n");
7402
7403	fprintf(
7404	outfile,
7405	"#ifdef MODULE_GENERATOR\n"
7406	"#define omAlloc0(A) malloc(A)\n"
7407	"#endif\n"
7408	"void iiInitCmdName()\n{\n"
7409	" sArithBase.nCmdUsed = 0;\n"
7410	" sArithBase.nCmdAllocated = %d;\n"
7411	" sArithBase.sCmds = (cmdnames)omAlloc0(sArithBase.nCmdAllocatedsizeof(cmdnames));\n"
7412	"\n"
7413	" // name-string alias tokval toktype index\n",
7414	cmd_size);
7415	int m=0;
7416	int id_nr=0;
7417
7418	qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
7419
7420	for(m=0; m<cmd_size; m++)
7421	{
7422	if(cmds[m].tokval>0) id_nr++;
7423	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#ifdef HAVE_RTIMER\n");
7424	fprintf(outfile," iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
7425	20-strlen(cmds[m].name),
7426	cmds[m].alias,
7427	cmds[m].tokval);
7428	switch(cmds[m].toktype)
7429	{
7430	case CMD_1: fprintf(outfile,"CMD_1"); break;
7431	case CMD_2: fprintf(outfile,"CMD_2"); break;
7432	case CMD_3: fprintf(outfile,"CMD_3"); break;
7433	case CMD_12: fprintf(outfile,"CMD_12"); break;
7434	case CMD_123 : fprintf(outfile,"CMD_123"); break;
7435	case CMD_23: fprintf(outfile,"CMD_23"); break;
7436	case CMD_M: fprintf(outfile,"CMD_M"); break;
7437	case SYSVAR: fprintf(outfile,"SYSVAR"); break;
7438	case ROOT_DECL: fprintf(outfile,"ROOT_DECL"); break;
7439	case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST"); break;
7440	case RING_DECL: fprintf(outfile,"RING_DECL"); break;
7441	case NONE: fprintf(outfile,"NONE"); break;
7442	default:
7443	if((cmds[m].toktype>' ') &&(cmds[m].toktype<127))
7444	{
7445	fprintf(outfile,"'%c'",cmds[m].toktype);
7446	}
7447	else
7448	{
7449	fprintf(outfile,"%d",cmds[m].toktype);
7450	}
7451	break;
7452	#if 0
7453	fprintf(outfile," iiArithAddCmd(\"%s\", %*d, -1, 0 );\n",
7454	cmds[m].name, 20-strlen(cmds[m].name),
7455	0/cmds[m].alias/
7456	/-1 cmds[m].tokval/
7457	/0 cmds[m].toktype/);
7458	#endif
7459	}
7460	fprintf(outfile,", %d);\n", m);
7461	if(cmds[m].tokval==VRTIMER) fprintf(outfile,"#endif\n");
7462	}
7463	fprintf(outfile, "/* end of list marker */\n");
7464	fprintf(outfile,
7465	"#ifdef HAVE_RTIMER\n"
7466	" sArithBase.nLastIdentifier = %d;\n"
7467	"#else /* HAVE_RTIMER */\n"
7468	" sArithBase.nLastIdentifier = %d;\n"
7469	"#endif /* HAVE_RTIMER */\n",
7470	id_nr,id_nr-1);
7471
7472
7473	fprintf(outfile,
7474	"}\n"
7475	"#ifdef HAVE_RTIMER\n"
7476	"#define LAST_IDENTIFIER %d\n"
7477	"#else\n"
7478	"#define LAST_IDENTIFIER %d\n"
7479	"#endif\n",id_nr,id_nr-1);
7480	fclose(outfile);
7481	}
7482	/-------------------------------------------------------------------/
7483	#if 0
7484	void ttGen3()
7485	{
7486	FILE *outfile = myfopen("mpsr_tok.inc","w");
7487	fprintf(outfile,
7488	"/****************************************\n"
7489	"* Computer Algebra System SINGULAR *\n"
7490	"****************************************/\n\n");
7491	/-------------------------------------------------------------------/
7492	fprintf(outfile,"// token table for Singular\n//\n");
7493
7494	fprintf(outfile,
7495	"short vtok[] =\n"
7496	"{\n");
7497	// operations with 1 arg: ===========================================
7498	int i=0;
7499	while (dArith1[i].cmd!=0)
7500	{
7501	if ((dArith1[i].p!=jjWRONG)
7502	&&((i==0)\|\|(dArith1[i].cmd!=dArith1[i-1].cmd)))
7503	{
7504	fprintf(outfile," %d,\n",dArith1[i].cmd);
7505	}
7506	i++;
7507	}
7508	// operations with 2 args: ===========================================
7509	i=0;
7510	while (dArith2[i].cmd!=0)
7511	{
7512	if ((dArith2[i].p!=jjWRONG2)
7513	&&((i==0)\|\|(dArith2[i].cmd!=dArith2[i-1].cmd)))
7514	{
7515	fprintf(outfile," %d,\n",dArith2[i].cmd);
7516	}
7517	i++;
7518	}
7519	// operations with 3 args: ===========================================
7520	i=0;
7521	while (dArith3[i].cmd!=0)
7522	{
7523	if (
7524	((i==0)\|\|(dArith3[i].cmd!=dArith3[i-1].cmd)))
7525	{
7526	fprintf(outfile," %d,\n",dArith3[i].cmd);
7527	}
7528	i++;
7529	}
7530	// operations with many args: ===========================================
7531	i=0;
7532	while (dArithM[i].cmd!=0)
7533	{
7534	if (
7535	((i==0)\|\|(dArithM[i].cmd!=dArithM[i-1].cmd)))
7536	{
7537	fprintf(outfile," %d,\n",dArithM[i].cmd);
7538	}
7539	i++;
7540	}
7541	// ====================================================================
7542	fprintf(outfile,
7543	"/* end of list marker */\n"
7544	" %d };\n",MAX_TOK);
7545	fclose(outfile);
7546	}
7547	#endif
7548	void ttGen4()
7549	{
7550	FILE *outfile = myfopen("plural_cmd.inc","w");
7551	int i;
7552	const char *old_s="";
7553	fprintf(outfile,
7554	"@c *****************************************\n"
7555	"@c * Computer Algebra System SINGULAR *\n"
7556	"@c *****************************************\n\n");
7557	/-------------------------------------------------------------------/
7558	fprintf(outfile,"@multicolumn .45 .45\n");
7559	int op;
7560	i=0;
7561	while ((op=dArith1[i].cmd)!=0)
7562	{
7563	if (dArith1[i].p!=jjWRONG)
7564	{
7565	const char *s = iiTwoOps(op);
7566	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7567	{
7568	old_s=s;
7569	#ifdef HAVE_PLURAL
7570	switch (dArith1[i].valid_for_plural)
7571	{
7572	case NO_PLURAL_N:
7573	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7574	break;
7575	case ALLOW_PLURAL_N:
7576	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7577	break;
7578	case COMM_PLURAL_N:
7579	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7580	break;
7581	}
7582	#endif
7583	}
7584	}
7585	i++;
7586	}
7587	fprintf(outfile,"@c ---------------------------------------------\n");
7588	i=0;
7589	while ((op=dArith2[i].cmd)!=0)
7590	{
7591	if (dArith2[i].p!=jjWRONG2)
7592	{
7593	const char *s = iiTwoOps(op);
7594	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7595	{
7596	old_s=s;
7597	#ifdef HAVE_PLURAL
7598	switch (dArith2[i].valid_for_plural)
7599	{
7600	case NO_PLURAL_N:
7601	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7602	break;
7603	case ALLOW_PLURAL_N:
7604	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7605	break;
7606	case COMM_PLURAL_N:
7607	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7608	break;
7609	}
7610	#endif
7611	}
7612	}
7613	i++;
7614	}
7615	fprintf(outfile,"@c ---------------------------------------------\n");
7616	i=0;
7617	while ((op=dArith3[i].cmd)!=0)
7618	{
7619	const char *s = iiTwoOps(op);
7620	if (dArith3[i].p!=jjWRONG3)
7621	{
7622	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7623	{
7624	old_s=s;
7625	#ifdef HAVE_PLURAL
7626	switch (dArith3[i].valid_for_plural)
7627	{
7628	case NO_PLURAL_N:
7629	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7630	break;
7631	case ALLOW_PLURAL_N:
7632	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7633	break;
7634	case COMM_PLURAL_N:
7635	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7636	break;
7637	}
7638	#endif
7639	}
7640	}
7641	i++;
7642	}
7643	fprintf(outfile,"@c ---------------------------------------------\n");
7644	i=0;
7645	while ((op=dArithM[i].cmd)!=0)
7646	{
7647	const char *s = iiTwoOps(op);
7648	if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
7649	{
7650	old_s=s;
7651	#ifdef HAVE_PLURAL
7652	switch (dArithM[i].valid_for_plural)
7653	{
7654	case NO_PLURAL_N:
7655	fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
7656	break;
7657	case ALLOW_PLURAL_N:
7658	fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
7659	break;
7660	case COMM_PLURAL_N:
7661	fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
7662	break;
7663	}
7664	#endif
7665	}
7666	i++;
7667	}
7668	fprintf(outfile,"@c ---------------------------------------------\n");
7669	fprintf(outfile,"@end table\n");
7670	fclose(outfile);
7671	}
7672	/-------------------------------------------------------------------/
7673	#else
7674	#include "iparith.inc"
7675	#endif
7676
7677	/=================== operations with 2 args. ============================/
7678
7679	BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
7680	{
7681	#ifndef GENTABLE
7682	memset(res,0,sizeof(sleftv));
7683	BOOLEAN call_failed=FALSE;
7684
7685	if (!errorreported)
7686	{
7687	#ifdef SIQ
7688	if (siq>0)
7689	{
7690	//Print("siq:%d\n",siq);
7691	command d=(command)omAlloc0Bin(ip_command_bin);
7692	memcpy(&d->arg1,a,sizeof(sleftv));
7693	//a->Init();
7694	memcpy(&d->arg2,b,sizeof(sleftv));
7695	//b->Init();
7696	d->argc=2;
7697	d->op=op;
7698	res->data=(char *)d;
7699	res->rtyp=COMMAND;
7700	return FALSE;
7701	}
7702	#endif
7703	int at=a->Typ();
7704	int bt=b->Typ();
7705	int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
7706	int index=i;
7707
7708	iiOp=op;
7709	while (dArith2[i].cmd==op)
7710	{
7711	if ((at==dArith2[i].arg1)
7712	&& (bt==dArith2[i].arg2))
7713	{
7714	res->rtyp=dArith2[i].res;
7715	#ifdef HAVE_PLURAL
7716	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7717	{
7718	if (dArith2[i].valid_for_plural==0 /NO_PLURAL/)
7719	{
7720	WerrorS(ii_not_for_plural);
7721	break;
7722	}
7723	else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7724	{
7725	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7726	}
7727	/* else ALLOW_PLURAL */
7728	}
7729	#endif
7730	if ((call_failed=dArith2[i].p(res,a,b)))
7731	{
7732	break;// leave loop, goto error handling
7733	}
7734	a->CleanUp();
7735	b->CleanUp();
7736	//Print("op: %d,result typ:%d\n",op,res->rtyp);
7737	return FALSE;
7738	}
7739	i++;
7740	}
7741	// implicite type conversion ----------------------------------------------
7742	if (dArith2[i].cmd!=op)
7743	{
7744	int ai,bi;
7745	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7746	leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
7747	BOOLEAN failed=FALSE;
7748	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
7749	//Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
7750	while (dArith2[i].cmd==op)
7751	{
7752	//Print("test %s %s\n",Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7753	if ((ai=iiTestConvert(at,dArith2[i].arg1))!=0)
7754	{
7755	if ((bi=iiTestConvert(bt,dArith2[i].arg2))!=0)
7756	{
7757	res->rtyp=dArith2[i].res;
7758	#ifdef HAVE_PLURAL
7759	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7760	{
7761	if (dArith2[i].valid_for_plural==0 /NO_PLURAL/)
7762	{
7763	WerrorS(ii_not_for_plural);
7764	break;
7765	}
7766	else if (dArith2[i].valid_for_plural==2 /* COMM_PLURAL */)
7767	{
7768	Warn("assume commutative subalgebra for cmd `%s`",
7769	Tok2Cmdname(i));
7770	}
7771	/* else ALLOW_PLURAL */
7772	}
7773	#endif
7774	failed= ((iiConvert(at,dArith2[i].arg1,ai,a,an))
7775	\|\| (iiConvert(bt,dArith2[i].arg2,bi,b,bn))
7776	\|\| (call_failed=dArith2[i].p(res,an,bn)));
7777	// everything done, clean up temp. variables
7778	if (failed)
7779	{
7780	// leave loop, goto error handling
7781	break;
7782	}
7783	else
7784	{
7785	// everything ok, clean up and return
7786	an->CleanUp();
7787	bn->CleanUp();
7788	omFreeBin((ADDRESS)an, sleftv_bin);
7789	omFreeBin((ADDRESS)bn, sleftv_bin);
7790	a->CleanUp();
7791	b->CleanUp();
7792	return FALSE;
7793	}
7794	}
7795	}
7796	i++;
7797	}
7798	an->CleanUp();
7799	bn->CleanUp();
7800	omFreeBin((ADDRESS)an, sleftv_bin);
7801	omFreeBin((ADDRESS)bn, sleftv_bin);
7802	}
7803	// error handling ---------------------------------------------------
7804	const char *s=NULL;
7805	if (!errorreported)
7806	{
7807	if ((at==0) && (a->Fullname()!=sNoName))
7808	{
7809	s=a->Fullname();
7810	}
7811	else if ((bt==0) && (b->Fullname()!=sNoName))
7812	{
7813	s=b->Fullname();
7814	}
7815	if (s!=NULL)
7816	Werror("`%s` is not defined",s);
7817	else
7818	{
7819	i=index; /iiTabIndex(dArithTab2,JJTAB2LEN,op);/
7820	s = iiTwoOps(op);
7821	if (proccall)
7822	{
7823	Werror("%s(`%s`,`%s`) failed"
7824	,s,Tok2Cmdname(at),Tok2Cmdname(bt));
7825	}
7826	else
7827	{
7828	Werror("`%s` %s `%s` failed"
7829	,Tok2Cmdname(at),s,Tok2Cmdname(bt));
7830	}
7831	if ((!call_failed) && BVERBOSE(V_SHOW_USE))
7832	{
7833	while (dArith2[i].cmd==op)
7834	{
7835	if(((at==dArith2[i].arg1)\|\|(bt==dArith2[i].arg2))
7836	&& (dArith2[i].res!=0)
7837	&& (dArith2[i].p!=jjWRONG2))
7838	{
7839	if (proccall)
7840	Werror("expected %s(`%s`,`%s`)"
7841	,s,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
7842	else
7843	Werror("expected `%s` %s `%s`"
7844	,Tok2Cmdname(dArith2[i].arg1),s,Tok2Cmdname(dArith2[i].arg2));
7845	}
7846	i++;
7847	}
7848	}
7849	}
7850	}
7851	res->rtyp = UNKNOWN;
7852	}
7853	a->CleanUp();
7854	b->CleanUp();
7855	#endif
7856	return TRUE;
7857	}
7858
7859	/==================== operations with 1 arg. ===============================/
7860
7861	BOOLEAN iiExprArith1(leftv res, leftv a, int op)
7862	{
7863	#ifndef GENTABLE
7864	memset(res,0,sizeof(sleftv));
7865	BOOLEAN call_failed=FALSE;
7866
7867	if (!errorreported)
7868	{
7869	#ifdef SIQ
7870	if (siq>0)
7871	{
7872	//Print("siq:%d\n",siq);
7873	command d=(command)omAlloc0Bin(ip_command_bin);
7874	memcpy(&d->arg1,a,sizeof(sleftv));
7875	//a->Init();
7876	d->op=op;
7877	d->argc=1;
7878	res->data=(char *)d;
7879	res->rtyp=COMMAND;
7880	return FALSE;
7881	}
7882	#endif
7883	int at=a->Typ();
7884	BOOLEAN failed=FALSE;
7885
7886	iiOp=op;
7887	int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
7888	int ti = i;
7889	while (dArith1[i].cmd==op)
7890	{
7891	if (at==dArith1[i].arg)
7892	{
7893	int r=res->rtyp=dArith1[i].res;
7894	#ifdef HAVE_PLURAL
7895	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7896	{
7897	if (dArith1[i].valid_for_plural==0 /NO_PLURAL/)
7898	{
7899	WerrorS(ii_not_for_plural);
7900	break;
7901	}
7902	else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7903	{
7904	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7905	}
7906	/* else ALLOW_PLURAL */
7907	}
7908	#endif
7909	if (r<0)
7910	{
7911	res->rtyp=-r;
7912	#ifdef PROC_BUG
7913	dArith1[i].p(res,a);
7914	#else
7915	res->data=(char )((Proc1)dArith1[i].p)((char )a->Data());
7916	#endif
7917	}
7918	else if ((call_failed=dArith1[i].p(res,a)))
7919	{
7920	break;// leave loop, goto error handling
7921	}
7922	if (a->Next()!=NULL)
7923	{
7924	res->next=(leftv)omAllocBin(sleftv_bin);
7925	failed=iiExprArith1(res->next,a->next,op);
7926	}
7927	a->CleanUp();
7928	return failed;
7929	}
7930	i++;
7931	}
7932	// implicite type conversion --------------------------------------------
7933	if (dArith1[i].cmd!=op)
7934	{
7935	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
7936	i=ti;
7937	//Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
7938	while (dArith1[i].cmd==op)
7939	{
7940	int ai;
7941	//Print("test %s\n",Tok2Cmdname(dArith1[i].arg));
7942	if ((ai=iiTestConvert(at,dArith1[i].arg))!=0)
7943	{
7944	int r=res->rtyp=dArith1[i].res;
7945	#ifdef HAVE_PLURAL
7946	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
7947	{
7948	if (dArith1[i].valid_for_plural==0 /NO_PLURAL/)
7949	{
7950	WerrorS(ii_not_for_plural);
7951	break;
7952	}
7953	else if (dArith1[i].valid_for_plural==2 /* COMM_PLURAL */)
7954	{
7955	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
7956	}
7957	/* else ALLOW_PLURAL */
7958	}
7959	#endif
7960	if (r<0)
7961	{
7962	res->rtyp=-r;
7963	failed= iiConvert(at,dArith1[i].arg,ai,a,an);
7964	if (!failed)
7965	{
7966	#ifdef PROC_BUG
7967	dArith1[i].p(res,a);
7968	#else
7969	res->data=(char )((Proc1)dArith1[i].p)((char )an->Data());
7970	#endif
7971	}
7972	}
7973	else
7974	{
7975	failed= ((iiConvert(at,dArith1[i].arg,ai,a,an))
7976	\|\| (call_failed=dArith1[i].p(res,an)));
7977	}
7978	// everything done, clean up temp. variables
7979	if (failed)
7980	{
7981	// leave loop, goto error handling
7982	break;
7983	}
7984	else
7985	{
7986	if (an->Next() != NULL)
7987	{
7988	res->next = (leftv)omAllocBin(sleftv_bin);
7989	failed=iiExprArith1(res->next,an->next,op);
7990	}
7991	// everything ok, clean up and return
7992	an->CleanUp();
7993	omFreeBin((ADDRESS)an, sleftv_bin);
7994	a->CleanUp();
7995	return failed;
7996	}
7997	}
7998	i++;
7999	}
8000	an->CleanUp();
8001	omFreeBin((ADDRESS)an, sleftv_bin);
8002	}
8003	// error handling
8004	if (!errorreported)
8005	{
8006	if ((at==0) && (a->Fullname()!=sNoName))
8007	{
8008	Werror("`%s` is not defined",a->Fullname());
8009	}
8010	else
8011	{
8012	i=ti;
8013	const char *s = iiTwoOps(op);
8014	Werror("%s(`%s`) failed"
8015	,s,Tok2Cmdname(at));
8016	if ((!call_failed) && BVERBOSE(V_SHOW_USE))
8017	{
8018	while (dArith1[i].cmd==op)
8019	{
8020	if ((dArith1[i].res!=0)
8021	&& (dArith1[i].p!=jjWRONG))
8022	Werror("expected %s(`%s`)"
8023	,s,Tok2Cmdname(dArith1[i].arg));
8024	i++;
8025	}
8026	}
8027	}
8028	}
8029	res->rtyp = UNKNOWN;
8030	}
8031	a->CleanUp();
8032	#endif
8033	return TRUE;
8034	}
8035
8036	/=================== operations with 3 args. ============================/
8037
8038	BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
8039	{
8040	#ifndef GENTABLE
8041	memset(res,0,sizeof(sleftv));
8042	BOOLEAN call_failed=FALSE;
8043
8044	if (!errorreported)
8045	{
8046	#ifdef SIQ
8047	if (siq>0)
8048	{
8049	//Print("siq:%d\n",siq);
8050	command d=(command)omAlloc0Bin(ip_command_bin);
8051	memcpy(&d->arg1,a,sizeof(sleftv));
8052	//a->Init();
8053	memcpy(&d->arg2,b,sizeof(sleftv));
8054	//b->Init();
8055	memcpy(&d->arg3,c,sizeof(sleftv));
8056	//c->Init();
8057	d->op=op;
8058	d->argc=3;
8059	res->data=(char *)d;
8060	res->rtyp=COMMAND;
8061	return FALSE;
8062	}
8063	#endif
8064	int at=a->Typ();
8065	int bt=b->Typ();
8066	int ct=c->Typ();
8067
8068	iiOp=op;
8069	int i=0;
8070	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
8071	while (dArith3[i].cmd==op)
8072	{
8073	if ((at==dArith3[i].arg1)
8074	&& (bt==dArith3[i].arg2)
8075	&& (ct==dArith3[i].arg3))
8076	{
8077	res->rtyp=dArith3[i].res;
8078	#ifdef HAVE_PLURAL
8079	if ((currRing!=NULL) && (rIsPluralRing(currRing)))
8080	{
8081	if (dArith3[i].valid_for_plural==0 /NO_PLURAL/)
8082	{
8083	WerrorS(ii_not_for_plural);
8084	break;
8085	}
8086	else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
8087	{
8088	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
8089	}
8090	/* else ALLOW_PLURAL */
8091	}
8092	#endif
8093	if ((call_failed=dArith3[i].p(res,a,b,c)))
8094	{
8095	break;// leave loop, goto error handling
8096	}
8097	a->CleanUp();
8098	b->CleanUp();
8099	c->CleanUp();
8100	return FALSE;
8101	}
8102	i++;
8103	}
8104	// implicite type conversion ----------------------------------------------
8105	if (dArith3[i].cmd!=op)
8106	{
8107	int ai,bi,ci;
8108	leftv an = (leftv)omAlloc0Bin(sleftv_bin);
8109	leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
8110	leftv cn = (leftv)omAlloc0Bin(sleftv_bin);
8111	BOOLEAN failed=FALSE;
8112	i=0;
8113	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
8114	while (dArith3[i].cmd==op)
8115	{
8116	if ((ai=iiTestConvert(at,dArith3[i].arg1))!=0)
8117	{
8118	if ((bi=iiTestConvert(bt,dArith3[i].arg2))!=0)
8119	{
8120	if ((ci=iiTestConvert(ct,dArith3[i].arg3))!=0)
8121	{
8122	res->rtyp=dArith3[i].res;
8123	#ifdef HAVE_PLURAL
8124	if ((currRing!=NULL)
8125	&& (rIsPluralRing(currRing)))
8126	{
8127	if (dArith3[i].valid_for_plural==0 /NO_PLURAL/)
8128	{
8129	WerrorS(ii_not_for_plural);
8130	break;
8131	}
8132	else if (dArith3[i].valid_for_plural==2 /* COMM_PLURAL */)
8133	{
8134	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
8135	}
8136	/* else ALLOW_PLURAL */
8137	}
8138	#endif
8139	failed= ((iiConvert(at,dArith3[i].arg1,ai,a,an))
8140	\|\| (iiConvert(bt,dArith3[i].arg2,bi,b,bn))
8141	\|\| (iiConvert(ct,dArith3[i].arg3,ci,c,cn))
8142	\|\| (call_failed=dArith3[i].p(res,an,bn,cn)));
8143	// everything done, clean up temp. variables
8144	if (failed)
8145	{
8146	// leave loop, goto error handling
8147	break;
8148	}
8149	else
8150	{
8151	// everything ok, clean up and return
8152	an->CleanUp();
8153	bn->CleanUp();
8154	cn->CleanUp();
8155	omFreeBin((ADDRESS)an, sleftv_bin);
8156	omFreeBin((ADDRESS)bn, sleftv_bin);
8157	omFreeBin((ADDRESS)cn, sleftv_bin);
8158	a->CleanUp();
8159	b->CleanUp();
8160	c->CleanUp();
8161	//Print("op: %d,result typ:%d\n",op,res->rtyp);
8162	return FALSE;
8163	}
8164	}
8165	}
8166	}
8167	i++;
8168	}
8169	an->CleanUp();
8170	bn->CleanUp();
8171	cn->CleanUp();
8172	omFreeBin((ADDRESS)an, sleftv_bin);
8173	omFreeBin((ADDRESS)bn, sleftv_bin);
8174	omFreeBin((ADDRESS)cn, sleftv_bin);
8175	}
8176	// error handling ---------------------------------------------------
8177	if (!errorreported)
8178	{
8179	const char *s=NULL;
8180	if ((at==0) && (a->Fullname()!=sNoName))
8181	{
8182	s=a->Fullname();
8183	}
8184	else if ((bt==0) && (b->Fullname()!=sNoName))
8185	{
8186	s=b->Fullname();
8187	}
8188	else if ((ct==0) && (c->Fullname()!=sNoName))
8189	{
8190	s=c->Fullname();
8191	}
8192	if (s!=NULL)
8193	Werror("`%s` is not defined",s);
8194	else
8195	{
8196	i=0;
8197	while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
8198	const char *s = iiTwoOps(op);
8199	Werror("%s(`%s`,`%s`,`%s`) failed"
8200	,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
8201	if ((!call_failed) && BVERBOSE(V_SHOW_USE))
8202	{
8203	while (dArith3[i].cmd==op)
8204	{
8205	if(((at==dArith3[i].arg1)
8206	\|\|(bt==dArith3[i].arg2)
8207	\|\|(ct==dArith3[i].arg3))
8208	&& (dArith3[i].res!=0))
8209	{
8210	Werror("expected %s(`%s`,`%s`,`%s`)"
8211	,s,Tok2Cmdname(dArith3[i].arg1)
8212	,Tok2Cmdname(dArith3[i].arg2)
8213	,Tok2Cmdname(dArith3[i].arg3));
8214	}
8215	i++;
8216	}
8217	}
8218	}
8219	}
8220	res->rtyp = UNKNOWN;
8221	}
8222	a->CleanUp();
8223	b->CleanUp();
8224	c->CleanUp();
8225	//Print("op: %d,result typ:%d\n",op,res->rtyp);
8226	#endif
8227	return TRUE;
8228	}
8229	/==================== operations with many arg. ===============================/
8230
8231	BOOLEAN jjANY2LIST(leftv res, leftv v, int cnt)
8232	{
8233	// cnt = 0: all
8234	// cnt = 1: only first one
8235	leftv next;
8236	BOOLEAN failed = TRUE;
8237	if(v==NULL) return failed;
8238	res->rtyp = LIST_CMD;
8239	if(cnt) v->next = NULL;
8240	next = v->next; // saving next-pointer
8241	failed = jjLIST_PL(res, v);
8242	v->next = next; // writeback next-pointer
8243	return failed;
8244	}
8245
8246	BOOLEAN iiExprArithM(leftv res, leftv a, int op)
8247	{
8248	#ifndef GENTABLE
8249	memset(res,0,sizeof(sleftv));
8250
8251	if (!errorreported)
8252	{
8253	#ifdef SIQ
8254	if (siq>0)
8255	{
8256	//Print("siq:%d\n",siq);
8257	command d=(command)omAlloc0Bin(ip_command_bin);
8258	d->op=op;
8259	res->data=(char *)d;
8260	if (a!=NULL)
8261	{
8262	d->argc=a->listLength();
8263	// else : d->argc=0;
8264	memcpy(&d->arg1,a,sizeof(sleftv));
8265	switch(d->argc)
8266	{
8267	case 3:
8268	memcpy(&d->arg3,a->next->next,sizeof(sleftv));
8269	a->next->next->Init();
8270	/* no break */
8271	case 2:
8272	memcpy(&d->arg2,a->next,sizeof(sleftv));
8273	a->next->Init();
8274	a->next->next=d->arg2.next;
8275	d->arg2.next=NULL;
8276	/* no break */
8277	case 1:
8278	a->Init();
8279	a->next=d->arg1.next;
8280	d->arg1.next=NULL;
8281	}
8282	if (d->argc>3) a->next=NULL;
8283	a->name=NULL;
8284	a->rtyp=0;
8285	a->data=NULL;
8286	a->e=NULL;
8287	a->attribute=NULL;
8288	a->CleanUp();
8289	}
8290	res->rtyp=COMMAND;
8291	return FALSE;
8292	}
8293	#endif
8294	BOOLEAN failed=FALSE;
8295	int args=0;
8296	if (a!=NULL) args=a->listLength();
8297
8298	iiOp=op;
8299	int i=0;
8300	while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
8301	while (dArithM[i].cmd==op)
8302	{
8303	if ((args==dArithM[i].number_of_args)
8304	\|\| (dArithM[i].number_of_args==-1)
8305	\|\| ((dArithM[i].number_of_args==-2)&&(args>0)))
8306	{
8307	res->rtyp=dArithM[i].res;
8308	#ifdef HAVE_PLURAL
8309	if ((currRing!=NULL)
8310	&& (rIsPluralRing(currRing)))
8311	{
8312	if (dArithM[i].valid_for_plural==0 /NO_PLURAL/)
8313	{
8314	WerrorS(ii_not_for_plural);
8315	break;
8316	}
8317	else if (dArithM[i].valid_for_plural==2 /* COMM_PLURAL */)
8318	{
8319	Warn("assume commutative subalgebra for cmd `%s`",Tok2Cmdname(i));
8320	}
8321	/* else ALLOW_PLURAL */
8322	}
8323	#endif
8324	if (dArithM[i].p(res,a))
8325	{
8326	break;// leave loop, goto error handling
8327	}
8328	if (a!=NULL) a->CleanUp();
8329	//Print("op: %d,result typ:%d\n",op,res->rtyp);
8330	return failed;
8331	}
8332	i++;
8333	}
8334	// error handling
8335	if (!errorreported)
8336	{
8337	if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName))
8338	{
8339	Werror("`%s` is not defined",a->Fullname());
8340	}
8341	else
8342	{
8343	const char *s = iiTwoOps(op);
8344	Werror("%s(...) failed",s);
8345	}
8346	}
8347	res->rtyp = UNKNOWN;
8348	}
8349	if (a!=NULL) a->CleanUp();
8350	//Print("op: %d,result typ:%d\n",op,res->rtyp);
8351	#endif
8352	return TRUE;
8353	}
8354
8355	/=================== general utilities ============================/
8356	int IsCmd(const char *n, int & tok)
8357	{
8358	#ifndef GENTABLE
8359	int i;
8360	int an=1;
8361	int en=sArithBase.nLastIdentifier;
8362
8363	loop
8364	//for(an=0; an<sArithBase.nCmdUsed; )
8365	{
8366	if(an>=en-1)
8367	{
8368	if (strcmp(n, sArithBase.sCmds[an].name) == 0)
8369	{
8370	i=an;
8371	break;
8372	}
8373	else if ((an!=en) && (strcmp(n, sArithBase.sCmds[en].name) == 0))
8374	{
8375	i=en;
8376	break;
8377	}
8378	else
8379	{
8380	return 0;
8381	}
8382	}
8383	i=(an+en)/2;
8384	if (n < (sArithBase.sCmds[i].name))
8385	{
8386	en=i-1;
8387	}
8388	else if (n > (sArithBase.sCmds[i].name))
8389	{
8390	an=i+1;
8391	}
8392	else
8393	{
8394	int v=strcmp(n,sArithBase.sCmds[i].name);
8395	if(v<0)
8396	{
8397	en=i-1;
8398	}
8399	else if(v>0)
8400	{
8401	an=i+1;
8402	}
8403	else /v==0/
8404	{
8405	break;
8406	}
8407	}
8408	}
8409	lastreserved=sArithBase.sCmds[i].name;
8410	tok=sArithBase.sCmds[i].tokval;
8411	if(sArithBase.sCmds[i].alias==2)
8412	{
8413	Warn("outdated identifier `%s` used - please change your code",
8414	sArithBase.sCmds[i].name);
8415	sArithBase.sCmds[i].alias=1;
8416	}
8417	if (currRingHdl==NULL)
8418	{
8419	#ifdef SIQ
8420	if (siq<=0)
8421	{
8422	#endif
8423	if ((tok>=BEGIN_RING) && (tok<=END_RING))
8424	{
8425	WerrorS("no ring active");
8426	return 0;
8427	}
8428	#ifdef SIQ
8429	}
8430	#endif
8431	}
8432	if (!expected_parms)
8433	{
8434	switch (tok)
8435	{
8436	case IDEAL_CMD:
8437	case INT_CMD:
8438	case INTVEC_CMD:
8439	case MAP_CMD:
8440	case MATRIX_CMD:
8441	case MODUL_CMD:
8442	case POLY_CMD:
8443	case PROC_CMD:
8444	case RING_CMD:
8445	case STRING_CMD:
8446	cmdtok = tok;
8447	break;
8448	}
8449	}
8450	return sArithBase.sCmds[i].toktype;
8451	#else
8452	return 0;
8453	#endif
8454	}
8455	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
8456	{
8457	#ifndef GENTABLE
8458	int a=0;
8459	int e=len;
8460	int p=len/2;
8461	do
8462	{
8463	if (op==dArithTab[p].cmd) return dArithTab[p].start;
8464	if (op<dArithTab[p].cmd) e=p-1;
8465	else a = p+1;
8466	p=a+(e-a)/2;
8467	}
8468	while ( a <= e);
8469
8470	#endif
8471	assume(0);
8472	return 0;
8473	}
8474
8475	#ifdef GENTABLE
8476	const char * Tok2Cmdname(int tok)
8477	{
8478	int i = 0;
8479	if (tok < 0)
8480	{
8481	return cmds[0].name;
8482	}
8483	if (tok==ANY_TYPE) return "any_type";
8484	if (tok==NONE) return "nothing";
8485	//if (tok==IFBREAK) return "if_break";
8486	//if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
8487	//if (tok==ORDER_VECTOR) return "ordering";
8488	//if (tok==REF_VAR) return "ref";
8489	//if (tok==OBJECT) return "object";
8490	//if (tok==PRINT_EXPR) return "print_expr";
8491	if (tok==IDHDL) return "identifier";
8492	while (cmds[i].tokval!=0)
8493	{
8494	if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
8495	{
8496	return cmds[i].name;
8497	}
8498	i++;
8499	}
8500	return cmds[0].name;
8501	}
8502	#else /* GENTABLE */
8503	const char * Tok2Cmdname(int tok)
8504	{
8505	int i = 0;
8506	if (tok <= 0)
8507	{
8508	return sArithBase.sCmds[0].name;
8509	}
8510	if (tok==ANY_TYPE) return "any_type";
8511	if (tok==NONE) return "nothing";
8512	//if (tok==IFBREAK) return "if_break";
8513	//if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
8514	//if (tok==ORDER_VECTOR) return "ordering";
8515	//if (tok==REF_VAR) return "ref";
8516	//if (tok==OBJECT) return "object";
8517	//if (tok==PRINT_EXPR) return "print_expr";
8518	if (tok==IDHDL) return "identifier";
8519	for(i=0; i<sArithBase.nCmdUsed; i++)
8520	//while (sArithBase.sCmds[i].tokval!=0)
8521	{
8522	if ((sArithBase.sCmds[i].tokval == tok)&&
8523	(sArithBase.sCmds[i].alias==0))
8524	{
8525	return sArithBase.sCmds[i].name;
8526	}
8527	}
8528	return sArithBase.sCmds[0].name;
8529	}
8530	#endif /* GENTABLE */
8531
8532
8533	/---------------------------------------------------------------------/
8534	/**
8535	* @brief compares to entry of cmdsname-list
8536
8537	@param[in] a
8538	@param[in] b
8539
8540	@return <ReturnValue>
8541	**/
8542	/---------------------------------------------------------------------/
8543	static int _gentable_sort_cmds( const void a, const void b )
8544	{
8545	cmdnames pCmdL = (cmdnames)a;
8546	cmdnames pCmdR = (cmdnames)b;
8547
8548	if(a==NULL \|\| b==NULL) return 0;
8549
8550	/* empty entries goes to the end of the list for later reuse */
8551	if(pCmdL->name==NULL) return 1;
8552	if(pCmdR->name==NULL) return -1;
8553
8554	/* $INVALID$ must come first */
8555	if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
8556	if(strcmp(pCmdR->name, "$INVALID$")==0) return 1;
8557
8558	/* tokval=-1 are reserved names at the end */
8559	if (pCmdL->tokval==-1)
8560	{
8561	if (pCmdR->tokval==-1)
8562	return strcmp(pCmdL->name, pCmdR->name);
8563	/* pCmdL->tokval==-1, pCmdL goes at the end */
8564	return 1;
8565	}
8566	/* pCmdR->tokval==-1, pCmdR goes at the end */
8567	if(pCmdR->tokval==-1) return -1;
8568
8569	return strcmp(pCmdL->name, pCmdR->name);
8570	}
8571
8572	/---------------------------------------------------------------------/
8573	/**
8574	* @brief initialisation of arithmetic structured data
8575
8576	@retval 0 on success
8577
8578	**/
8579	/---------------------------------------------------------------------/
8580	int iiInitArithmetic()
8581	{
8582	int i;
8583	//printf("iiInitArithmetic()\n");
8584	#ifndef GENTABLE
8585	memset(&sArithBase, 0, sizeof(sArithBase));
8586	iiInitCmdName();
8587	/* fix last-identifier */
8588	#if 0
8589	/* we expect that gentable allready did every thing */
8590	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8591	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--) {
8592	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8593	}
8594	#endif
8595	//Print("L=%d\n", sArithBase.nLastIdentifier);
8596
8597	//iiArithAddCmd(szName, nAlias, nTokval, nToktype);
8598	//iiArithAddCmd("mygcd", 1, GCD_CMD, CMD_2);
8599
8600	//iiArithAddCmd("Top", 0,-1,0);
8601
8602
8603	//for(i=0; i<sArithBase.nCmdUsed; i++) {
8604	// printf("CMD[%03d] %s, %d, %d, %d\n", i,
8605	// sArithBase.sCmds[i].name,
8606	// sArithBase.sCmds[i].alias,
8607	// sArithBase.sCmds[i].tokval,
8608	// sArithBase.sCmds[i].toktype);
8609	//}
8610	//iiArithRemoveCmd("Top");
8611	//iiArithAddCmd("mygcd", 2, GCD_CMD, CMD_2);
8612	//iiArithRemoveCmd("mygcd");
8613	//iiArithAddCmd("kkk", 1, 1234, CMD_1);
8614	#endif /* !GENTABLE */
8615	return 0;
8616	}
8617
8618	/---------------------------------------------------------------------/
8619	/**
8620	* @brief append newitem of size sizeofitem to the list named list.
8621
8622	@param[in,out] list
8623	@param[in,out] item_count
8624	@param[in] sizeofitem
8625	@param[in] newitem
8626
8627	@retval 0 success
8628	@retval -1 failure
8629	**/
8630	/---------------------------------------------------------------------/
8631	int iiArithAddItem2list(
8632	void **list,
8633	long *item_count,
8634	long sizeofitem,
8635	void *newitem
8636	)
8637	{
8638	int count = *item_count;
8639
8640	//TRACE(0, "add_item_to_list(%p, %p, %ld, %p)\n", list, item_count,
8641	// sizeofitem, newitem);
8642
8643	if(count==0)
8644	{
8645	list = (void )omAlloc(sizeofitem);
8646	}
8647	else
8648	{
8649	list = (void )omRealloc(list, (count+1) sizeofitem);
8650	}
8651	if((*list)==NULL) return -1;
8652
8653	//memset((list)+countsizeofitem, 0, sizeofitem);
8654	//memcpy((list)+countsizeofitem, newitem, sizeofitem);
8655
8656	/* erhoehe counter um 1 */
8657	(count)++;
8658	*item_count = count;
8659	return 0;
8660	}
8661
8662	int iiArithFindCmd(const char *szName)
8663	{
8664	#ifndef GENTABLE
8665	int an=0;
8666	int i = 0,v = 0;
8667	int en=sArithBase.nLastIdentifier;
8668
8669	loop
8670	//for(an=0; an<sArithBase.nCmdUsed; )
8671	{
8672	if(an>=en-1)
8673	{
8674	if (strcmp(szName, sArithBase.sCmds[an].name) == 0)
8675	{
8676	//Print("RET-an=%d %s\n", an, sArithBase.sCmds[an].name);
8677	return an;
8678	}
8679	else if (strcmp(szName, sArithBase.sCmds[en].name) == 0)
8680	{
8681	//Print("RET-en=%d %s\n", en, sArithBase.sCmds[en].name);
8682	return en;
8683	}
8684	else
8685	{
8686	//Print("RET- 1\n");
8687	return -1;
8688	}
8689	}
8690	i=(an+en)/2;
8691	if (szName < (sArithBase.sCmds[i].name))
8692	{
8693	en=i-1;
8694	}
8695	else if (szName > (sArithBase.sCmds[i].name))
8696	{
8697	an=i+1;
8698	}
8699	else
8700	{
8701	v=strcmp(szName,sArithBase.sCmds[i].name);
8702	if(v<0)
8703	{
8704	en=i-1;
8705	}
8706	else if(v>0)
8707	{
8708	an=i+1;
8709	}
8710	else /v==0/
8711	{
8712	//Print("RET-i=%d %s\n", i, sArithBase.sCmds[i].name);
8713	return i;
8714	}
8715	}
8716	}
8717	//if(i>=0 && i<sArithBase.nCmdUsed)
8718	// return i;
8719	//Print("RET-2\n");
8720	return -2;
8721	#else
8722	return 0;
8723	#endif
8724	}
8725
8726	char *iiArithGetCmd( int nPos )
8727	{
8728	if(nPos<0) return NULL;
8729	if(nPos<sArithBase.nCmdUsed)
8730	return sArithBase.sCmds[nPos].name;
8731	return NULL;
8732	}
8733
8734	int iiArithRemoveCmd(const char *szName)
8735	{
8736	int nIndex;
8737	if(szName==NULL) return -1;
8738
8739	nIndex = iiArithFindCmd(szName);
8740	if(nIndex<0 \|\| nIndex>=sArithBase.nCmdUsed)
8741	{
8742	Print("'%s' not found (%d)\n", szName, nIndex);
8743	return -1;
8744	}
8745	omFree(sArithBase.sCmds[nIndex].name);
8746	sArithBase.sCmds[nIndex].name=NULL;
8747	qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8748	(&_gentable_sort_cmds));
8749	sArithBase.nCmdUsed--;
8750
8751	/* fix last-identifier */
8752	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8753	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8754	{
8755	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8756	}
8757	//Print("L=%d\n", sArithBase.nLastIdentifier);
8758	return 0;
8759	}
8760
8761	int iiArithAddCmd(
8762	const char *szName,
8763	short nAlias,
8764	short nTokval,
8765	short nToktype,
8766	short nPos
8767	)
8768	{
8769	//printf("AddCmd(%s, %d, %d, %d, %d)\n", szName, nAlias,
8770	// nTokval, nToktype, nPos);
8771	if(nPos>=0)
8772	{
8773	// no checks: we rely on a correct generated code in iparith.inc
8774	assume(nPos < sArithBase.nCmdAllocated);
8775	assume(szName!=NULL);
8776	sArithBase.sCmds[nPos].name = omStrDup(szName);
8777	sArithBase.sCmds[nPos].alias = nAlias;
8778	sArithBase.sCmds[nPos].tokval = nTokval;
8779	sArithBase.sCmds[nPos].toktype = nToktype;
8780	sArithBase.nCmdUsed++;
8781	//if(nTokval>0) sArithBase.nLastIdentifier++;
8782	}
8783	else
8784	{
8785	if(szName==NULL) return -1;
8786	int nIndex = iiArithFindCmd(szName);
8787	if(nIndex>=0)
8788	{
8789	Print("'%s' already exists at %d\n", szName, nIndex);
8790	return -1;
8791	}
8792
8793	if(sArithBase.nCmdUsed>=sArithBase.nCmdAllocated)
8794	{
8795	/* needs to create new slots */
8796	unsigned long nSize = (sArithBase.nCmdAllocated+1)*sizeof(cmdnames);
8797	sArithBase.sCmds = (cmdnames *)omRealloc(sArithBase.sCmds, nSize);
8798	if(sArithBase.sCmds==NULL) return -1;
8799	sArithBase.nCmdAllocated++;
8800	}
8801	/* still free slots available */
8802	sArithBase.sCmds[sArithBase.nCmdUsed].name = omStrDup(szName);
8803	sArithBase.sCmds[sArithBase.nCmdUsed].alias = nAlias;
8804	sArithBase.sCmds[sArithBase.nCmdUsed].tokval = nTokval;
8805	sArithBase.sCmds[sArithBase.nCmdUsed].toktype = nToktype;
8806	sArithBase.nCmdUsed++;
8807
8808	qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
8809	(&_gentable_sort_cmds));
8810	for(sArithBase.nLastIdentifier=sArithBase.nCmdUsed-1;
8811	sArithBase.nLastIdentifier>0; sArithBase.nLastIdentifier--)
8812	{
8813	if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
8814	}
8815	//Print("L=%d\n", sArithBase.nLastIdentifier);
8816	}
8817	return 0;
8818	}
8819
8820	#ifdef GENTABLE
8821	// some special cmds which do not fit in with the others, and
8822	// nevertheless need to be transmitted
8823	short ExtraCmds[] =
8824	{
8825	OPTION_CMD,
8826	NAMES_CMD,
8827	// RESERVEDNAME_CMD,
8828	PROC_CMD,
8829	MAP_CMD,
8830	PACKAGE_CMD,
8831	'=',
8832	0
8833	};
8834
8835	// This returns 1 if tok is a token which can appear in a Singular
8836	// (quoted) command, and 0 otherwise
8837	short IsCmdToken(short tok)
8838	{
8839	int i = 0;
8840	// cmds with one arg
8841	while (dArith1[i].cmd != 0)
8842	if (dArith1[i].cmd == tok) return 1;
8843	else i++;
8844
8845	// cmds with two args
8846	i=0;
8847	while (dArith2[i].cmd != 0)
8848	if (dArith2[i].cmd == tok) return 1;
8849	else i++;
8850
8851	// cmds with three args
8852	i=0;
8853	while (dArith3[i].cmd != 0)
8854	if (dArith3[i].cmd == tok) return 1;
8855	else i++;
8856
8857	// cmds with many args
8858	i=0;
8859	while (dArithM[i].cmd != 0)
8860	if (dArithM[i].cmd == tok) return 1;
8861	else i++;
8862
8863	// cmds which are somewhat special (like those having 0 args)
8864	i=0;
8865	while (ExtraCmds[i] != 0)
8866	if (ExtraCmds[i] == tok) return 1;
8867	else i++;
8868
8869	return 0;
8870	}
8871	#endif

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

Download in other formats: