Context Navigation

source: git/Singular/iparith.cc @ a5f15a

spielwiese

Last change on this file since a5f15a was a5f15a, checked in by Moritz Wenk <wenk@…>, 25 years ago
* wenk: added numerical algorithms: vandermonde, laguerre, uressolve, mpresmat (mpr_base.cc mpr_base.h mpr_inout.cc mpr_inout.h mpr_numeric.cc mpr_numeric.h) git-svn-id: file:///usr/local/Singular/svn/trunk@3177 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 165.2 KB

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

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

Download in other formats: