Context Navigation

source: git/Singular/subexpr.cc @ 17ccde

fieker-DuValspielwiese

Last change on this file since 17ccde was 17ccde, checked in by Hans Schönemann <hannes@…>, 22 years ago
*hannes: n_Copy is now r->cf->cfCopy git-svn-id: file:///usr/local/Singular/svn/trunk@6135 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 36.5 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/*
5	* ABSTRACT: handling of leftv
6	*/
7	/* $Id: subexpr.cc,v 1.82 2002-06-10 15:25:35 Singular Exp $ */
8
9	#include <stdlib.h>
10	#include <stdio.h>
11	#include <string.h>
12	#include <ctype.h>
13	#include <unistd.h>
14
15	#include "mod2.h"
16	#include "tok.h"
17	#include "ipid.h"
18	#include "intvec.h"
19	#include <omalloc.h>
20	#include "febase.h"
21	#include "polys.h"
22	#include "ideals.h"
23	#include "maps.h"
24	#include "matpol.h"
25	#include "kstd1.h"
26	#include "timer.h"
27	#include "ring.h"
28	#include "ffields.h"
29	#include "numbers.h"
30	#include "ipshell.h"
31	#include "lists.h"
32	#include "attrib.h"
33	#include "silink.h"
34	#include "syz.h"
35	#include "subexpr.h"
36
37
38	omBin sSubexpr_bin = omGetSpecBin(sizeof(sSubexpr));
39	omBin sleftv_bin = omGetSpecBin(sizeof(sleftv));
40	omBin procinfo_bin = omGetSpecBin(sizeof(procinfo));
41	omBin libstack_bin = omGetSpecBin(sizeof(libstack));
42	static omBin size_two_bin = omGetSpecBin(2);
43
44	sleftv sLastPrinted;
45	const char sNoName[]="_";
46	#ifdef SIQ
47	BOOLEAN siq=FALSE;
48	#endif
49
50	void sleftv::Set(int val)
51	{
52	Init();
53	rtyp = INT_CMD;
54	data = (void *)val;
55	}
56
57	int sleftv::listLength()
58	{
59	int n = 1;
60	leftv sl = next;
61	while (sl!=NULL)
62	{
63	n++;
64	sl=sl->next;
65	}
66	return n;
67	}
68
69	void sleftv::Print(leftv store, int spaces)
70	{
71	int t=Typ();
72	if (errorreported) return;
73	#ifdef SIQ
74	if (rtyp==COMMAND)
75	{
76	command c=(command)data;
77	char ch[2];
78	ch[0]=c->op;ch[1]='\0';
79	char *s=ch;
80	if (c->op>127) s=iiTwoOps(c->op);
81	::Print("##command %d(%s), %d args\n",
82	c->op, s, c->argc);
83	if (c->argc>0)
84	c->arg1.Print(NULL,spaces+2);
85	if(c->argc<4)
86	{
87	if (c->argc>1)
88	c->arg2.Print(NULL,spaces+2);
89	if (c->argc>2)
90	c->arg3.Print(NULL,spaces+2);
91	}
92	PrintS("##end");
93	}
94	else
95	#endif
96	{
97	const char *n=Name();
98	char *s;
99	void *d=Data();
100	if (errorreported)
101	return;
102	if ((store!=NULL)&&(store!=this))
103	store->CleanUp();
104
105	switch (t /=Typ()/)
106	{
107	case UNKNOWN:
108	case DEF_CMD:
109	::Print("%-.s`%s`",spaces,spaces," ",n);
110	break;
111	case PACKAGE_CMD:
112	::Print("%-.s`%s`",spaces,spaces," ",n);
113	break;
114	case NONE:
115	return;
116	case INTVEC_CMD:
117	case INTMAT_CMD:
118	((intvec *)d)->show(t,spaces);
119	break;
120	case RING_CMD:
121	case QRING_CMD:
122	::Print("%-.s",spaces,spaces," ");
123	rWrite((ring)d);
124	break;
125	case MATRIX_CMD:
126	iiWriteMatrix((matrix)d,n,2,spaces);
127	break;
128	case MAP_CMD:
129	case MODUL_CMD:
130	case IDEAL_CMD:
131	iiWriteMatrix((matrix)d,n,1,spaces);
132	break;
133	case POLY_CMD:
134	case VECTOR_CMD:
135	::Print("%-.s",spaces,spaces," ");
136	pWrite0((poly)d);
137	break;
138	case RESOLUTION_CMD:
139	syPrint((syStrategy)d);
140	break;
141	case STRING_CMD:
142	::Print("%-.s%s",spaces,spaces," ",(char *)d);
143	break;
144	case INT_CMD:
145	::Print("%-.s%d",spaces,spaces," ",(int)d);
146	break;
147	case PROC_CMD:
148	{
149	procinfov pi=(procinfov)d;
150	::Print("%-.s// libname : %s\n",spaces,spaces," ",
151	piProcinfo(pi, "libname"));
152	::Print("%-.s// procname : %s\n",spaces,spaces," ",
153	piProcinfo(pi, "procname"));
154	::Print("%-.s// type : %s",spaces,spaces," ",
155	piProcinfo(pi, "type"));
156	// ::Print("%-.s// ref : %s",spaces,spaces," ",
157	// piProcinfo(pi, "ref"));
158	break;
159	}
160	case POINTER_CMD:
161	{ package pack = (package)d;
162	::Print("%-.s// %s\n",spaces,spaces," ","PointerTest");
163	::Print("%-.s// %s",spaces,spaces," ",IDID(pack->idroot));
164	//::Print(((char *)(pack->idroot)->data), spaces);
165	break;
166	}
167	case LINK_CMD:
168	{
169	si_link l=(si_link)d;
170	::Print("%-.s// type : %s\n",spaces,spaces," ",
171	slStatus(l, "type"));
172	::Print("%-.s// mode : %s\n",spaces,spaces," ",
173	slStatus(l, "mode"));
174	::Print("%-.s// name : %s\n",spaces,spaces," ",
175	slStatus(l, "name"));
176	::Print("%-.s// open : %s\n",spaces,spaces," ",
177	slStatus(l, "open"));
178	::Print("%-.s// read : %s\n",spaces,spaces," ",
179	slStatus(l, "read"));
180	::Print("%-.s// write: %s",spaces,spaces," ",
181	slStatus(l, "write"));
182	break;
183	}
184	case NUMBER_CMD:
185	s=String(d);
186	if (s==NULL) return;
187	::Print("%-.s",spaces,spaces," ");
188	PrintS(s);
189	omFree((ADDRESS)s);
190	break;
191	case LIST_CMD:
192	{
193	lists l=(lists)d;
194	if (l->nr<0)
195	::Print("%-.sempty list\n",spaces,spaces," ");
196	else
197	{
198	int i=0;
199	for (;i<=l->nr;i++)
200	{
201	if (l->m[i].rtyp!=DEF_CMD)
202	{
203	::Print("%-.s[%d]:\n",spaces,spaces," ",i+1);
204	l->m[i].Print(NULL,spaces+3);
205	}
206	}
207	}
208	break;
209	}
210	#ifdef TEST
211	default:
212	::Print("Print:unknown type %s(%d)", Tok2Cmdname(t),t);
213	#endif
214	} /* end switch: (Typ()) */
215	}
216	if (next!=NULL)
217	{
218	if (t==COMMAND) PrintLn();
219	else if (t!=LIST_CMD) PrintS(" ");
220	next->Print(NULL,spaces);
221	}
222	else if (t!=LIST_CMD)
223	{
224	PrintLn();
225	}
226	#ifdef SIQ
227	if (rtyp!=COMMAND)
228	#endif
229	{
230	if ((store!=NULL)
231	&& (store!=this)
232	&& (t/Typ()/!=LINK_CMD)
233	&& (t/Typ()/!=RING_CMD)
234	&& (t/Typ()/!=QRING_CMD)
235	&& (t/Typ()/!=POINTER_CMD)
236	&& (t/Typ()/!=PACKAGE_CMD)
237	&& (t/Typ()/!=PROC_CMD)
238	&& (t/Typ()/!=DEF_CMD)
239	)
240	{
241	store->rtyp=t/Typ()/;
242	store->data=CopyD();
243	if((e!=NULL)\|\|(attribute!=NULL))
244	{
245	store->attribute=CopyA();
246	}
247	if (e==NULL)
248	{
249	store->flag=flag;
250	}
251	//else
252	//{
253	//}
254	}
255	}
256	}
257
258	void sleftv::CleanUp(ring r)
259	{
260	if ((name!=NULL) && (name!=sNoName) && (rtyp!=IDHDL))
261	{
262	//::Print("free %x (%s)\n",name,name);
263	omFree((ADDRESS)name);
264	}
265	//name=NULL;
266	//flag=0;
267	if (data!=NULL)
268	{
269	switch (rtyp)
270	{
271	case INTVEC_CMD:
272	case INTMAT_CMD:
273	delete (intvec *)data;
274	break;
275	case MAP_CMD:
276	omFree((ADDRESS)((map)data)->preimage);
277	((map)data)->preimage=NULL;
278	// no break: kill the image as an ideal
279	case MATRIX_CMD:
280	case MODUL_CMD:
281	case IDEAL_CMD:
282	id_Delete((ideal *)(&data),r);
283	break;
284	case STRING_CMD:
285	omFree((ADDRESS)data);
286	break;
287	case POLY_CMD:
288	case VECTOR_CMD:
289	p_Delete((poly *)(&data),r);
290	break;
291	case NUMBER_CMD:
292	n_Delete((number *)(&data),r);
293	break;
294	case LIST_CMD:
295	((lists)data)->Clean(r); // may contain ring-dep data
296	break;
297	case QRING_CMD:
298	case RING_CMD:
299	rKill((ring)data);
300	break;
301	case PROC_CMD:
302	piKill((procinfov)data);
303	break;
304	case LINK_CMD:
305	slKill((si_link)data);
306	break;
307	case COMMAND:
308	{
309	command cmd=(command)data;
310	if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp();
311	if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp();
312	if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp();
313	omFreeBin((ADDRESS)data, ip_command_bin);
314	break;
315	}
316	case RESOLUTION_CMD:
317	{
318	syKillComputation((syStrategy)data,r);
319	break;
320	}
321	#ifdef TEST
322	// the following types do not take memory
323	// or are not copied
324	case IDHDL:
325	case PACKAGE_CMD:
326	case ANY_TYPE:
327	#ifdef SRING
328	case VALTVARS:
329	#endif
330	case VECHO:
331	case VPAGELENGTH:
332	case VPRINTLEVEL:
333	case VCOLMAX:
334	case VTIMER:
335	#ifdef HAVE_RTIMER
336	case VRTIMER:
337	#endif
338	case VOICE:
339	case VMAXDEG:
340	case VMAXMULT:
341	case TRACE:
342	case VSHORTOUT:
343	case VNOETHER:
344	case VMINPOLY:
345	case LIB_CMD:
346	case 0:
347	case INT_CMD:
348	break;
349	default:
350	::Print("CleanUp: unknown type %d\n",rtyp); /* DEBUG */
351	#endif
352	} /* end switch: (rtyp) */
353	//data=NULL;
354	}
355	if (attribute!=NULL)
356	{
357	switch (rtyp)
358	{
359	case POINTER_CMD:
360	case PACKAGE_CMD:
361	case IDHDL:
362	case ANY_TYPE:
363	#ifdef SRING
364	case VALTVARS:
365	#endif
366	case VECHO:
367	case VPAGELENGTH:
368	case VPRINTLEVEL:
369	case VCOLMAX:
370	case VTIMER:
371	#ifdef HAVE_RTIMER
372	case VRTIMER:
373	#endif
374	case VOICE:
375	case VMAXDEG:
376	case VMAXMULT:
377	case TRACE:
378	case VSHORTOUT:
379	case VNOETHER:
380	case VMINPOLY:
381	case LIB_CMD:
382	case 0:
383	//attribute=NULL;
384	break;
385	default:
386	{
387	attr t;
388	while (attribute!=NULL)
389	{
390	t=attribute->next;
391	attribute->kill();
392	attribute=t;
393	}
394	}
395	}
396	}
397	Subexpr h;
398	while (e!=NULL)
399	{
400	h=e->next;
401	omFreeBin((ADDRESS)e, sSubexpr_bin);
402	e=h;
403	}
404	//rtyp=NONE;
405	if (next!=NULL)
406	{
407	leftv tmp_n;
408	do
409	{
410	tmp_n=next->next;
411	//next->name=NULL;
412	next->next=NULL;
413	next->CleanUp(r);
414	omFreeBin((ADDRESS)next, sleftv_bin);
415	next=tmp_n;
416	} while (next!=NULL);
417	}
418	Init();
419	}
420
421	BOOLEAN sleftv::RingDependend()
422	{
423	int rt=Typ();
424	if(::RingDependend(rt) && (rt!=QRING_CMD))
425	return TRUE;
426	if (rt==LIST_CMD)
427	return lRingDependend((lists)Data());
428	return FALSE;
429	}
430
431	void * slInternalCopy(leftv source, int t, void *d, Subexpr e)
432	{
433	switch (t)
434	{
435	case INTVEC_CMD:
436	case INTMAT_CMD:
437	return (void )ivCopy((intvec )d);
438	case MATRIX_CMD:
439	return (void *)mpCopy((matrix)d);
440	case IDEAL_CMD:
441	case MODUL_CMD:
442	return (void *)idCopy((ideal)d);
443	case STRING_CMD:
444	if ((e==NULL)
445	\|\| (source->rtyp==LIST_CMD)
446	\|\| ((source->rtyp==IDHDL)&&(IDTYP((idhdl)source->data)==LIST_CMD)))
447	return (void )omStrDup((char )d);
448	else if (e->next==NULL)
449	{
450	char s=(char)omAllocBin(size_two_bin);
451	s[0]=(char )d;
452	s[1]='\0';
453	return s;
454	}
455	#ifdef TEST
456	else
457	{
458	Werror("not impl. string-op in `%s`",my_yylinebuf);
459	return NULL;
460	}
461	#endif
462	case POINTER_CMD:
463	return d;
464	case PACKAGE_CMD:
465	return (void *)paCopy((package) d);
466	case PROC_CMD:
467	return (void *)piCopy((procinfov) d);
468	case POLY_CMD:
469	case VECTOR_CMD:
470	return (void *)pCopy((poly)d);
471	case INT_CMD:
472	return d;
473	case NUMBER_CMD:
474	return (void *)nCopy((number)d);
475	case MAP_CMD:
476	return (void *)maCopy((map)d);
477	case LIST_CMD:
478	return (void *)lCopy((lists)d);
479	case LINK_CMD:
480	return (void *)slCopy((si_link) d);
481	case RING_CMD:
482	case QRING_CMD:
483	{
484	ring r=(ring)d;
485	r->ref++;
486	return d;
487	}
488	case RESOLUTION_CMD:
489	return (void*)syCopy((syStrategy)d);
490	#ifdef TEST
491	case DEF_CMD:
492	case NONE:
493	break; /* error recovery: do nothing */
494	//case COMMAND:
495	default:
496	Warn("InternalCopy: cannot copy type %s(%d)",
497	Tok2Cmdname(source->rtyp),source->rtyp);
498	#endif
499	}
500	return NULL;
501	}
502
503	void sleftv::Copy(leftv source)
504	{
505	Init();
506	rtyp=source->Typ();
507	void *d=source->Data();
508	if(!errorreported)
509	{
510	switch (rtyp)
511	{
512	case INTVEC_CMD:
513	case INTMAT_CMD:
514	data=(void )ivCopy((intvec )d);
515	break;
516	case MATRIX_CMD:
517	data=(void *)mpCopy((matrix)d);
518	break;
519	case IDEAL_CMD:
520	case MODUL_CMD:
521	data= (void *)idCopy((ideal)d);
522	break;
523	case STRING_CMD:
524	data= (void )omStrDup((char )d);
525	break;
526	case POINTER_CMD:
527	data=d;
528	break;
529	case PROC_CMD:
530	data= (void *)piCopy((procinfov) d);
531	break;
532	case POLY_CMD:
533	case VECTOR_CMD:
534	data= (void *)pCopy((poly)d);
535	break;
536	case INT_CMD:
537	data= d;
538	break;
539	case NUMBER_CMD:
540	data= (void *)nCopy((number)d);
541	break;
542	case MAP_CMD:
543	data= (void *)maCopy((map)d);
544	break;
545	case LIST_CMD:
546	data= (void *)lCopy((lists)d);
547	break;
548	case LINK_CMD:
549	data = (void *)slCopy((si_link)d);
550	break;
551	case RING_CMD:
552	case QRING_CMD:
553	{
554	if (d!=NULL)
555	{
556	ring r=(ring)d;
557	r->ref++;
558	data=d;
559	}
560	else
561	{
562	WerrorS("invalid ring description");
563	}
564	break;
565	}
566	case RESOLUTION_CMD:
567	data=(void*)syCopy((syStrategy)d);
568	break;
569	#ifdef TEST
570	case DEF_CMD:
571	case NONE:
572	break; /* error recovery: do nothing */
573	//case COMMAND:
574	default:
575	Warn("Copy: cannot copy type %s(%d)",Tok2Cmdname(rtyp),rtyp);
576	#endif
577	}
578	if ((source->attribute!=NULL)\|\|(source->e!=NULL))
579	attribute=source->CopyA();
580	if(source->e==NULL)
581	{
582	flag=source->flag;
583	}
584	//else
585	//{
586	//}
587	if (source->next!=NULL)
588	{
589	next=(leftv)omAllocBin(sleftv_bin);
590	next->Copy(source->next);
591	}
592	}
593	}
594
595	void * sleftv::CopyD(int t)
596	{
597	if ((rtyp!=IDHDL)&&(e==NULL))
598	{
599	if (iiCheckRing(t)) return NULL;
600	void *x=data;
601	if (rtyp==VNOETHER) x=(void *)pCopy(ppNoether);
602	else if (rtyp==LIB_CMD)
603	x=(void )omStrDup((char )Data());
604	else if ((rtyp==VMINPOLY)&& (currRing->minpoly!=NULL)&&(!rField_is_GF()))
605	x=(void *)nCopy(currRing->minpoly);
606	data=NULL;
607	return x;
608	}
609	void *d=Data(); // will also do a iiCheckRing
610	if ((!errorreported) && (d!=NULL)) return slInternalCopy(this,t,d,e);
611	return NULL;
612	}
613
614	//void * sleftv::CopyD()
615	//{
616	//if ((rtyp!=IDHDL)&&(e==NULL)
617	//&&(rtyp!=VNOETHER)&&(rtyp!=LIB_CMD)&&(rtyp!=VMINPOLY))
618	//{
619	// void *x=data;
620	// data=NULL;
621	// return x;
622	//}
623	// return CopyD(Typ());
624	//}
625
626	attr sleftv::CopyA()
627	{
628	attr *a=Attribute();
629	if ((a!=NULL) && (*a!=NULL))
630	return (*a)->Copy();
631	return NULL;
632	}
633
634	char * sleftv::String(void *d, BOOLEAN typed, int dim)
635	{
636	#ifdef SIQ
637	if (rtyp==COMMAND)
638	{
639	::Print("##command %d\n",((command)data)->op);
640	if (((command)data)->arg1.rtyp!=0)
641	((command)data)->arg1.Print(NULL,2);
642	if (((command)data)->arg2.rtyp!=0)
643	((command)data)->arg2.Print(NULL,2);
644	if (((command)data)->arg3.rtyp==0)
645	((command)data)->arg3.Print(NULL,2);
646	PrintS("##end\n");
647	return omStrDup("");
648	}
649	#endif
650	if (d==NULL) d=Data();
651	if (!errorreported)
652	{
653	char *s;
654	const char *n;
655	if (name!=NULL) n=name;
656	else n=sNoName;
657	switch (Typ())
658	{
659	case INT_CMD:
660	if (typed)
661	{
662	s=(char *)omAlloc(MAX_INT_LEN+7);
663	sprintf(s,"int(%d)",(int)d);
664	}
665	else
666	{
667	s=(char *)omAlloc(MAX_INT_LEN+2);
668	sprintf(s,"%d",(int)d);
669	}
670	return s;
671
672	case STRING_CMD:
673	if (d == NULL)
674	{
675	if (typed) return omStrDup("\"\"");
676	return omStrDup("");
677	}
678	if (typed)
679	{
680	s = (char) omAlloc(strlen((char) d) + 3);
681	sprintf(s,"\"%s\"", (char*) d);
682	return s;
683	}
684	else
685	{
686	return omStrDup((char*)d);
687	}
688
689	case POLY_CMD:
690	case VECTOR_CMD:
691	if (typed)
692	{
693	char* ps = pString((poly) d);
694	s = (char*) omAlloc(strlen(ps) + 10);
695	sprintf(s,"%s(%s)", (Typ() == POLY_CMD ? "poly" : "vector"), ps);
696	return s;
697	}
698	else
699	return omStrDup(pString((poly)d));
700
701	case NUMBER_CMD:
702	StringSetS((char*) (typed ? "number(" : ""));
703	if ((rtyp==IDHDL)&&(IDTYP((idhdl)data)==NUMBER_CMD))
704	{
705	nWrite(IDNUMBER((idhdl)data));
706	}
707	else if (rtyp==NUMBER_CMD)
708	{
709	number n=(number)data;
710	nWrite(n);
711	data=(char *)n;
712	}
713	else if((rtyp==VMINPOLY)&&(rField_is_GF()))
714	{
715	nfShowMipo();
716	}
717	else
718	{
719	number n=nCopy((number)d);
720	nWrite(n);
721	nDelete(&n);
722	}
723	s = StringAppendS((char*) (typed ? ")" : ""));
724	return omStrDup(s);
725
726	case MATRIX_CMD:
727	s= iiStringMatrix((matrix)d,dim);
728	if (typed)
729	{
730	char* ns = (char*) omAlloc(strlen(s) + 40);
731	sprintf(ns, "matrix(ideal(%s),%d,%d)", s,
732	((ideal) d)->nrows, ((ideal) d)->ncols);
733	omCheckAddr(ns);
734	return ns;
735	}
736	else
737	{
738	return omStrDup(s);
739	}
740
741	case MODUL_CMD:
742	case IDEAL_CMD:
743	case MAP_CMD:
744	s= iiStringMatrix((matrix)d,dim);
745	if (typed)
746	{
747	char* ns = (char*) omAlloc(strlen(s) + 10);
748	sprintf(ns, "%s(%s)", (Typ()==MODUL_CMD ? "module" : "ideal"), s);
749	omCheckAddr(ns);
750	return ns;
751	}
752	return omStrDup(s);
753
754	case INTVEC_CMD:
755	case INTMAT_CMD:
756	{
757	intvec v=(intvec )d;
758	s = v->String(dim);
759	if (typed)
760	{
761	char* ns;
762	if (Typ() == INTMAT_CMD)
763	{
764	ns = (char*) omAlloc(strlen(s) + 40);
765	sprintf(ns, "intmat(intvec(%s),%d,%d)", s, v->rows(), v->cols());
766	}
767	else
768	{
769	ns = (char*) omAlloc(strlen(s) + 10);
770	sprintf(ns, "intvec(%s)", s);
771	}
772	omCheckAddr(ns);
773	omFree(s);
774	return ns;
775	}
776	else
777	return s;
778	}
779
780	case RING_CMD:
781	case QRING_CMD:
782	s = rString((ring)d);
783
784	if (typed)
785	{
786	char* ns;
787	if (Typ() == QRING_CMD)
788	{
789	char* id = iiStringMatrix((matrix) ((ring) d)->qideal, dim);
790	ns = (char*) omAlloc(strlen(s) + strlen(id) + 20);
791	sprintf(ns, "\"%s\";%sideal(%s)", s,(dim == 2 ? "\n" : " "), id);
792	}
793	else
794	{
795	ns = (char*) omAlloc(strlen(s) + 4);
796	sprintf(ns, "\"%s\"", s);
797	}
798	omFree(s);
799	omCheckAddr(ns);
800	return ns;
801	}
802	return s;
803
804	case RESOLUTION_CMD:
805	{
806	lists l = syConvRes((syStrategy)d);
807	s = lString(l, typed, dim);
808	l->Clean();
809	return s;
810	}
811
812	case PROC_CMD:
813	{
814	procinfo* pi = (procinfo*) d;
815	if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
816	s = (pi->data.s.body);
817	else
818	s = "";
819	if (typed)
820	{
821	char* ns = (char*) omAlloc(strlen(s) + 4);
822	sprintf(ns, "\"%s\"", s);
823	omCheckAddr(ns);
824	return ns;
825	}
826	return omStrDup(s);
827	}
828
829	case LINK_CMD:
830	s = slString((si_link) d);
831	if (typed)
832	{
833	char* ns = (char*) omAlloc(strlen(s) + 10);
834	sprintf(ns, "link(\"%s\")", s);
835	omFree(s);
836	omCheckAddr(ns);
837	return ns;
838	}
839	return s;
840
841	case LIST_CMD:
842	return lString((lists) d, typed, dim);
843	} /* end switch: (Typ()) */
844	}
845	return omStrDup("");
846	}
847
848
849	int sleftv::Typ()
850	{
851	if (e==NULL)
852	{
853	switch (rtyp)
854	{
855	case IDHDL:
856	return IDTYP((idhdl)data);
857	#ifdef SRING
858	case VALTVARS:
859	#endif
860	case VECHO:
861	case VPAGELENGTH:
862	case VPRINTLEVEL:
863	case VCOLMAX:
864	case VTIMER:
865	#ifdef HAVE_RTIMER
866	case VRTIMER:
867	#endif
868	case VOICE:
869	case VMAXDEG:
870	case VMAXMULT:
871	case TRACE:
872	case VSHORTOUT:
873	return INT_CMD;
874	case LIB_CMD:
875	return STRING_CMD;
876	case VMINPOLY:
877	return NUMBER_CMD;
878	case VNOETHER:
879	return POLY_CMD;
880	//case COMMAND:
881	// return COMMAND;
882	default:
883	return rtyp;
884	}
885	}
886	int r=0;
887	int t=rtyp;
888	if (t==IDHDL) t=IDTYP((idhdl)data);
889	switch (t)
890	{
891	case INTVEC_CMD:
892	case INTMAT_CMD:
893	r=INT_CMD;
894	break;
895	case IDEAL_CMD:
896	case MATRIX_CMD:
897	case MAP_CMD:
898	r=POLY_CMD;
899	break;
900	case MODUL_CMD:
901	r=VECTOR_CMD;
902	break;
903	case STRING_CMD:
904	r=STRING_CMD;
905	break;
906	case LIST_CMD:
907	{
908	lists l;
909	if (rtyp==IDHDL) l=IDLIST((idhdl)data);
910	else l=(lists)data;
911	if ((0<e->start)&&(e->start<=l->nr+1))
912	{
913	l->m[e->start-1].e=e->next;
914	r=l->m[e->start-1].Typ();
915	l->m[e->start-1].e=NULL;
916	}
917	else
918	{
919	//Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
920	r=NONE;
921	}
922	break;
923	}
924	default:
925	Werror("cannot index type %d",t);
926	}
927	return r;
928	}
929
930	int sleftv::LTyp()
931	{
932	lists l=NULL;
933	int r;
934	if (rtyp==LIST_CMD)
935	l=(lists)data;
936	else if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
937	l=IDLIST((idhdl)data);
938	else
939	return Typ();
940	//if (l!=NULL)
941	{
942	if ((e!=NULL) && (e->next!=NULL))
943	{
944	if ((0<e->start)&&(e->start<=l->nr+1))
945	{
946	l->m[e->start-1].e=e->next;
947	r=l->m[e->start-1].LTyp();
948	l->m[e->start-1].e=NULL;
949	}
950	else
951	{
952	//Warn("out of range: %d not in 1..%d",e->start,l->nr+1);
953	r=NONE;
954	}
955	return r;
956	}
957	return LIST_CMD;
958	}
959	return Typ();
960	}
961
962	void sleftv::SetData(void* what)
963	{
964	if (rtyp == IDHDL)
965	{
966	IDDATA((idhdl)data) = (char *)what;
967	}
968	else
969	{
970	data = what;
971	}
972	}
973
974	void * sleftv::Data()
975	{
976	if (rtyp!=IDHDL && iiCheckRing(rtyp))
977	return NULL;
978	if (e==NULL)
979	{
980	switch (rtyp)
981	{
982	case VECHO: return (void *)si_echo;
983	case VPAGELENGTH:return (void *)pagelength;
984	case VPRINTLEVEL:return (void *)printlevel;
985	case VCOLMAX: return (void *)colmax;
986	case VTIMER: return (void *)getTimer();
987	#ifdef HAVE_RTIMER
988	case VRTIMER: return (void *)getRTimer();
989	#endif
990	case VOICE: return (void *)(myynest+1);
991	case VMAXDEG: return (void *)Kstd1_deg;
992	case VMAXMULT: return (void *)Kstd1_mu;
993	case TRACE: return (void *)traceit;
994	case VSHORTOUT: return (void *)(currRing != NULL ? currRing->ShortOut : 0);
995	case VMINPOLY: if (currRing != NULL &&
996	(currRing->minpoly!=NULL)&&(!rField_is_GF()))
997	/* Q(a), Fp(a), but not GF(q) */
998	return (void *)currRing->minpoly;
999	else
1000	return (void *)nNULL;
1001	case VNOETHER: return (void *) ppNoether;
1002	#ifndef HAVE_NAMESSPACES
1003	#ifndef HAVE_NS
1004	case LIB_CMD: {
1005	idhdl h = ggetid( "LIB" );
1006	if(h==NULL) return (void *)sNoName;
1007	return IDSTRING(h);
1008	}
1009	#endif
1010	#endif
1011	case IDHDL:
1012	return IDDATA((idhdl)data);
1013	case POINTER_CMD:
1014	return IDDATA((idhdl)data);
1015	case COMMAND:
1016	//return NULL;
1017	default:
1018	return data;
1019	}
1020	}
1021	/* e != NULL : */
1022	int t=rtyp;
1023	void *d=data;
1024	if (t==IDHDL)
1025	{
1026	t=((idhdl)data)->typ;
1027	d=IDDATA((idhdl)data);
1028	}
1029	if (iiCheckRing(t))
1030	return NULL;
1031	char *r=NULL;
1032	int index=e->start;
1033	switch (t)
1034	{
1035	case INTVEC_CMD:
1036	{
1037	intvec iv=(intvec )d;
1038	if ((index<1)\|\|(index>iv->length()))
1039	{
1040	if (!errorreported)
1041	Werror("wrong range[%d] in intvec(%d)",index,iv->length());
1042	}
1043	else
1044	r=(char )((iv)[index-1]);
1045	break;
1046	}
1047	case INTMAT_CMD:
1048	{
1049	intvec iv=(intvec )d;
1050	if ((index<1)
1051	\|\|(index>iv->rows())
1052	\|\|(e->next->start<1)
1053	\|\|(e->next->start>iv->cols()))
1054	{
1055	if (!errorreported)
1056	Werror("wrong range[%d,%d] in intmat(%dx%d)",index,e->next->start,
1057	iv->rows(),iv->cols());
1058	}
1059	else
1060	r=(char )(IMATELEM((iv),index,e->next->start));
1061	break;
1062	}
1063	case IDEAL_CMD:
1064	case MODUL_CMD:
1065	case MAP_CMD:
1066	{
1067	ideal I=(ideal)d;
1068	if ((index<1)\|\|(index>IDELEMS(I)))
1069	{
1070	if (!errorreported)
1071	Werror("wrong range[%d] in ideal/module(%d)",index,IDELEMS(I));
1072	}
1073	else
1074	r=(char *)I->m[index-1];
1075	break;
1076	}
1077	case STRING_CMD:
1078	{
1079	// this was a memory leak
1080	// we evalute it, cleanup and replace this leftv by it's evalutated form
1081	// the evalutated form will be build in tmp
1082	sleftv tmp;
1083	tmp.Init();
1084	tmp.rtyp=STRING_CMD;
1085	r=(char *)omAllocBin(size_two_bin);
1086	if ((index>0)&& (index<=(int)strlen((char *)d)))
1087	{
1088	r[0]=(((char )d)+index-1);
1089	r[1]='\0';
1090	}
1091	else
1092	{
1093	r[0]='\0';
1094	}
1095	tmp.data=r;
1096	if ((rtyp==IDHDL)\|\|(rtyp==STRING_CMD))
1097	{
1098	tmp.next=next; next=NULL;
1099	data=NULL; d=NULL;
1100	CleanUp();
1101	memcpy(this,&tmp,sizeof(tmp));
1102	}
1103	// and, remember, r is also the result...
1104	else
1105	{
1106	// ???
1107	// here we still have a memory leak...
1108	// example: list L="123","456";
1109	// L[1][2];
1110	// therefore, it should never happen:
1111	assume(0);
1112	// but if it happens: here is the temporary fix:
1113	// omMarkAsStaticAddr(r);
1114	}
1115	break;
1116	}
1117	case MATRIX_CMD:
1118	{
1119	if ((index<1)
1120	\|\|(index>MATROWS((matrix)d))
1121	\|\|(e->next->start<1)
1122	\|\|(e->next->start>MATCOLS((matrix)d)))
1123	{
1124	if (!errorreported)
1125	Werror("wrong range[%d,%d] in intmat(%dx%d)",
1126	index,e->next->start,
1127	MATROWS((matrix)d),MATCOLS((matrix)d));
1128	}
1129	else
1130	r=(char *)MATELEM((matrix)d,index,e->next->start);
1131	break;
1132	}
1133	case LIST_CMD:
1134	{
1135	lists l=(lists)d;
1136	if ((0<index)&&(index<=l->nr+1))
1137	{
1138	if ((e->next!=NULL)
1139	&& (l->m[index-1].rtyp==STRING_CMD))
1140	// string[..].Data() modifies sleftv, so let's do it ourself
1141	{
1142	char dd=(char )l->m[index-1].data;
1143	int j=e->next->start-1;
1144	r=(char *)omAllocBin(size_two_bin);
1145	if ((j>=0) && (j<(int)strlen(dd)))
1146	{
1147	r[0]=*(dd+j);
1148	r[1]='\0';
1149	}
1150	else
1151	{
1152	r[0]='\0';
1153	}
1154	}
1155	else
1156	{
1157	l->m[index-1].e=e->next;
1158	r=(char *)l->m[index-1].Data();
1159	l->m[index-1].e=NULL;
1160	}
1161	}
1162	else //if (!errorreported)
1163	Werror("wrong range[%d] in list(%d)",index,l->nr+1);
1164	break;
1165	}
1166	#ifdef TEST
1167	default:
1168	Werror("cannot index type %s(%d)",Tok2Cmdname(t),t);
1169	#endif
1170	}
1171	return r;
1172	}
1173
1174	attr * sleftv::Attribute()
1175	{
1176	if (e==NULL) return &attribute;
1177	if ((rtyp==LIST_CMD)
1178	\|\|((rtyp==IDHDL)&&(IDTYP((idhdl)data)==LIST_CMD)))
1179	{
1180	leftv v=LData();
1181	return &(v->attribute);
1182	}
1183	return NULL;
1184	}
1185
1186	leftv sleftv::LData()
1187	{
1188	if (e!=NULL)
1189	{
1190	lists l=NULL;
1191
1192	if (rtyp==LIST_CMD)
1193	l=(lists)data;
1194	if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1195	l=IDLIST((idhdl)data);
1196	if (l!=NULL)
1197	{
1198	if ((0>=e->start)\|\|(e->start>l->nr+1))
1199	return NULL;
1200	if (e->next!=NULL)
1201	{
1202	l->m[e->start-1].e=e->next;
1203	leftv r=l->m[e->start-1].LData();
1204	l->m[e->start-1].e=NULL;
1205	return r;
1206	}
1207	return &(l->m[e->start-1]);
1208	}
1209	}
1210	return this;
1211	}
1212
1213	leftv sleftv::LHdl()
1214	{
1215	if (e!=NULL)
1216	{
1217	lists l=NULL;
1218
1219	if (rtyp==LIST_CMD)
1220	l=(lists)data;
1221	if ((rtyp==IDHDL)&& (IDTYP((idhdl)data)==LIST_CMD))
1222	l=IDLIST((idhdl)data);
1223	if (l!=NULL)
1224	{
1225	if ((0>=e->start)\|\|(e->start>l->nr+1))
1226	return NULL;
1227	if (e->next!=NULL)
1228	{
1229	l->m[e->start-1].e=e->next;
1230	leftv r=l->m[e->start-1].LHdl();
1231	l->m[e->start-1].e=NULL;
1232	return r;
1233	}
1234	return &(l->m[e->start-1]);
1235	}
1236	}
1237	return this;
1238	}
1239
1240	BOOLEAN assumeStdFlag(leftv h)
1241	{
1242	if ((h->e!=NULL)&&(h->LTyp()==LIST_CMD))
1243	{
1244	return assumeStdFlag(h->LData());
1245	}
1246	if (!hasFlag(h,FLAG_STD))
1247	{
1248	if (!TEST_VERB_NSB)
1249	Warn("%s is no standardbasis",h->Name());
1250	return FALSE;
1251	}
1252	return TRUE;
1253	}
1254
1255	/*2
1256	* transforms a name (as an string created by omAlloc or omStrDup)
1257	* into an expression (sleftv), deletes the string
1258	* utility for grammar and iparith
1259	*/
1260	void syMake(leftv v,char * id, idhdl packhdl)
1261	{
1262	/* resolv an identifier: (to DEF_CMD, if siq>0)
1263	* 1) reserved id: done by scanner
1264	* 2) `basering`
1265	* 3) existing identifier, local
1266	* 4) ringvar, local ring
1267	* 5) existing identifier, global
1268	* 6) monom (resp. number), local ring: consisting of:
1269	* 6') ringvar, global ring
1270	* 6'') monom (resp. number), local ring
1271	* 7) monom (resp. number), non-local ring
1272	* 8) basering
1273	* 9) `_`
1274	* 10) everything else is of type 0
1275	*/
1276	#ifdef TEST
1277	if ((id<' ')\|\|(id>(char)126))
1278	{
1279	Print("wrong id :%s:\n",id);
1280	}
1281	#endif
1282	v->Init();
1283	#ifdef HAVE_NS
1284	v->packhdl = NULL;
1285	if(packhdl != NULL)
1286	{
1287	// Print("setting req_packhdl to %s\n",IDID(packhdl));
1288	v->req_packhdl = IDPACKAGE(packhdl);
1289	}
1290	else v->req_packhdl = currPack;
1291	// if (v->req_packhdl!=basePack)
1292	// Print("search %s in %s\n",id,v->req_packhdl->libname);
1293	#endif /* HAVE_NS */
1294	#ifdef SIQ
1295	if (siq<=0)
1296	#endif
1297	{
1298	idhdl h=NULL;
1299	if (!isdigit(id[0]))
1300	{
1301	if (strcmp(id,"basering")==0)
1302	{
1303	if (currRingHdl!=NULL)
1304	{
1305	if (id!=IDID(currRingHdl)) omFree((ADDRESS)id);
1306	v->rtyp = IDHDL;
1307	v->data = (char *)currRingHdl;
1308	v->name = IDID(currRingHdl);
1309	v->flag = IDFLAG(currRingHdl);
1310	return;
1311	}
1312	else
1313	{
1314	v->name = id;
1315	return; /* undefined */
1316	}
1317	}
1318	#ifdef HAVE_NS
1319	if(v->req_packhdl!=currPack)
1320	{
1321	h=v->req_packhdl->idroot->get(id,myynest);
1322	}
1323	else
1324	#endif
1325	h=ggetid(id);
1326	/* 3) existing identifier, local */
1327	if ((h!=NULL) && (IDLEV(h)==myynest))
1328	{
1329	if (id!=IDID(h)) omFree((ADDRESS)id);
1330	v->rtyp = IDHDL;
1331	v->data = (char *)h;
1332	v->flag = IDFLAG(h);
1333	v->name = IDID(h);
1334	v->attribute=IDATTR(h);
1335	return;
1336	}
1337	}
1338	/* 4. local ring: ringvar */
1339	if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1340	{
1341	int vnr;
1342	if ((vnr=rIsRingVar(id))>=0)
1343	{
1344	poly p=pOne();
1345	pSetExp(p,vnr+1,1);
1346	pSetm(p);
1347	v->data = (void *)p;
1348	v->name = id;
1349	v->rtyp = POLY_CMD;
1350	return;
1351	}
1352	}
1353	/* 5. existing identifier, global */
1354	if (h!=NULL)
1355	{
1356	if (id!=IDID(h)) omFree((ADDRESS)id);
1357	v->rtyp = IDHDL;
1358	v->data = (char *)h;
1359	v->flag = IDFLAG(h);
1360	v->name = IDID(h);
1361	v->attribute=IDATTR(h);
1362	return;
1363	}
1364	/* 6. local ring: number/poly */
1365	if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1366	{
1367	BOOLEAN ok=FALSE;
1368	poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;
1369	if (ok)
1370	{
1371	if (p==NULL)
1372	{
1373	v->data = (void *)nInit(0);
1374	v->rtyp = NUMBER_CMD;
1375	omFree((ADDRESS)id);
1376	}
1377	else
1378	if (pIsConstant(p))
1379	{
1380	v->data = pGetCoeff(p);
1381	pGetCoeff(p)=NULL;
1382	pLmFree(p);
1383	v->rtyp = NUMBER_CMD;
1384	v->name = id;
1385	}
1386	else
1387	{
1388	v->data = p;
1389	v->rtyp = POLY_CMD;
1390	v->name = id;
1391	}
1392	return;
1393	}
1394	}
1395	/* 7. non-local ring: number/poly */
1396	{
1397	BOOLEAN ok=FALSE;
1398	poly p = ((currRingHdl!=NULL) /* ring required */
1399	&&(!yyInRingConstruction) /* not in decl */
1400	&&(IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1401	? pmInit(id,ok) : (poly)NULL;
1402	if (ok)
1403	{
1404	if (p==NULL)
1405	{
1406	v->data = (void *)nInit(0);
1407	v->rtyp = NUMBER_CMD;
1408	omFree((ADDRESS)id);
1409	}
1410	else
1411	if (pIsConstant(p))
1412	{
1413	v->data = pGetCoeff(p);
1414	pGetCoeff(p)=NULL;
1415	pLmFree(p);
1416	v->rtyp = NUMBER_CMD;
1417	v->name = id;
1418	}
1419	else
1420	{
1421	v->data = p;
1422	v->rtyp = POLY_CMD;
1423	v->name = id;
1424	}
1425	return;
1426	}
1427	}
1428	/* 8. basering ? */
1429	if ((myynest>1)&&(currRingHdl!=NULL))
1430	{
1431	if (strcmp(id,IDID(currRingHdl))==0)
1432	{
1433	if (IDID(currRingHdl)!=id) omFree((ADDRESS)id);
1434	v->rtyp=IDHDL;
1435	v->data=currRingHdl;
1436	v->name=IDID(currRingHdl);
1437	v->attribute=IDATTR(currRingHdl);
1438	return;
1439	}
1440	}
1441	#ifdef HAVE_NS
1442	if(v->req_packhdl!=basePack)
1443	{
1444	v->req_packhdl=basePack;
1445	return syMake(v,id,basePackHdl);
1446	}
1447	#endif
1448	}
1449	#ifdef SIQ
1450	else
1451	v->rtyp=DEF_CMD;
1452	#endif
1453	/* 9: _ */
1454	if (strcmp(id,"_")==0)
1455	{
1456	omFree((ADDRESS)id);
1457	v->Copy(&sLastPrinted);
1458	}
1459	else
1460	{
1461	/* 10: everything else */
1462	/* v->rtyp = UNKNOWN;*/
1463	v->name = id;
1464	}
1465	}
1466
1467	int sleftv::Eval()
1468	{
1469	BOOLEAN nok=FALSE;
1470	leftv nn=next;
1471	next=NULL;
1472	if(rtyp==IDHDL)
1473	{
1474	int t=Typ();
1475	if (t!=PROC_CMD)
1476	{
1477	void *d=CopyD(t);
1478	data=d;
1479	rtyp=t;
1480	name=NULL;
1481	e=NULL;
1482	}
1483	}
1484	else if (rtyp==COMMAND)
1485	{
1486	command d=(command)data;
1487	if(d->op==PROC_CMD) //assume d->argc==2
1488	{
1489	char what=(char )(d->arg1.Data());
1490	idhdl h=ggetid(what);
1491	if((h!=NULL)&&(IDTYP(h)==PROC_CMD))
1492	{
1493	nok=d->arg2.Eval();
1494	if(!nok)
1495	{
1496	#ifdef HAVE_NS
1497	leftv r=iiMake_proc(h,req_packhdl,&d->arg2);
1498	#else /* HAVE_NS */
1499	leftv r=iiMake_proc(h,&d->arg2);
1500	#endif /* HAVE_NS */
1501	if (r!=NULL)
1502	memcpy(this,r,sizeof(sleftv));
1503	else
1504	nok=TRUE;
1505	}
1506	}
1507	else nok=TRUE;
1508	}
1509	else if (d->op=='=') //assume d->argc==2
1510	{
1511	if ((d->arg1.rtyp!=IDHDL)&&(d->arg1.rtyp!=DEF_CMD))
1512	{
1513	nok=d->arg1.Eval();
1514	}
1515	if (!nok)
1516	{
1517	char *n=d->arg1.name;
1518	nok=(n == NULL) \|\| d->arg2.Eval();
1519	if (!nok)
1520	{
1521	int save_typ=d->arg1.rtyp;
1522	omCheckAddr(n);
1523	if (d->arg1.rtyp!=IDHDL)
1524	syMake(&d->arg1,n);
1525	omCheckAddr(d->arg1.name);
1526	if (d->arg1.rtyp==IDHDL)
1527	{
1528	n=omStrDup(IDID((idhdl)d->arg1.data));
1529	killhdl((idhdl)d->arg1.data);
1530	d->arg1.Init();
1531	//d->arg1.data=NULL;
1532	d->arg1.name=n;
1533	}
1534	d->arg1.rtyp=DEF_CMD;
1535	sleftv t;
1536	if(save_typ!=PROC_CMD) save_typ=d->arg2.rtyp;
1537	if (::RingDependend(d->arg2.rtyp))
1538	nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&currRing->idroot);
1539	else
1540	nok=iiDeclCommand(&t,&d->arg1,0,save_typ,&IDROOT);
1541	memcpy(&d->arg1,&t,sizeof(sleftv));
1542	omCheckAddr(d->arg1.name);
1543	nok=nok\|\|iiAssign(&d->arg1,&d->arg2);
1544	omCheckIf(d->arg1.name != NULL, // OB: ????
1545	omCheckAddr(d->arg1.name));
1546	if (!nok)
1547	{
1548	memset(&d->arg1,0,sizeof(sleftv));
1549	this->CleanUp();
1550	rtyp=NONE;
1551	}
1552	}
1553	}
1554	else nok=TRUE;
1555	}
1556	else if (d->argc==1)
1557	{
1558	nok=d->arg1.Eval();
1559	nok=nok\|\|iiExprArith1(this,&d->arg1,d->op);
1560	}
1561	else if(d->argc==2)
1562	{
1563	nok=d->arg1.Eval();
1564	nok=nok\|\|d->arg2.Eval();
1565	nok=nok\|\|iiExprArith2(this,&d->arg1,d->op,&d->arg2);
1566	}
1567	else if(d->argc==3)
1568	{
1569	nok=d->arg1.Eval();
1570	nok=nok\|\|d->arg2.Eval();
1571	nok=nok\|\|d->arg3.Eval();
1572	nok=nok\|\|iiExprArith3(this,d->op,&d->arg1,&d->arg2,&d->arg3);
1573	}
1574	else if(d->argc!=0)
1575	{
1576	nok=d->arg1.Eval();
1577	nok=nok\|\|iiExprArithM(this,&d->arg1,d->op);
1578	}
1579	else // d->argc == 0
1580	{
1581	nok = iiExprArithM(this, NULL, d->op);
1582	}
1583	}
1584	else if (((rtyp==0)\|\|(rtyp==DEF_CMD))
1585	&&(name!=NULL))
1586	{
1587	syMake(this,name);
1588	}
1589	#ifdef MDEBUG
1590	switch(Typ())
1591	{
1592	case NUMBER_CMD:
1593	#ifdef LDEBUG
1594	nTest((number)Data());
1595	#endif
1596	break;
1597	case POLY_CMD:
1598	pTest((poly)Data());
1599	break;
1600	case IDEAL_CMD:
1601	case MODUL_CMD:
1602	case MATRIX_CMD:
1603	{
1604	ideal id=(ideal)Data();
1605	omCheckAddrSize(id,sizeof(*id));
1606	int i=id->ncols*id->nrows-1;
1607	for(;i>=0;i--) pTest(id->m[i]);
1608	}
1609	break;
1610	}
1611	#endif
1612	if (nn!=NULL) nok=nok\|\|nn->Eval();
1613	next=nn;
1614	return nok;
1615	}
1616
1617	char *iiSleftv2name(leftv v)
1618	{
1619	return(v->name);
1620	}

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

Download in other formats: