ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/caldefn.c

Comparing ray/src/common/caldefn.c (file contents):
Revision 2.18 by schorsch, Thu Jul 17 09:21:29 2003 UTC vs.
Revision 2.41 by greg, Wed Jan 1 19:02:08 2025 UTC

#	Line 27 | Line 27 | static const char      RCSid[] = "$Id$";
27
28		#include "copyright.h"
29
30	–	#include  <stdio.h>
31	–	#include  <string.h>
30		#include  <ctype.h>
31
32		#include  "rterror.h"
33	+	#include  "rtio.h"
34	+	#include  "rtmisc.h"
35		#include  "calcomp.h"
36
37		#ifndef  NHASH
#	Line 58 | Line 58 | static VARDEF  *htpos;                 /* ...dfirst() and */
58		static EPNODE  *ochpos;                 /* ...dnext */
59		static EPNODE  *outchan;
60
61	<	EPNODE  *curfunc = NULL;
62	<	#define  dname(ep)      ((ep)->v.kid->type == SYM ? \
63	<	(ep)->v.kid->v.name : \
64	<	(ep)->v.kid->v.kid->v.name)
61	>	static int  optimized = 0;              /* are we optimized? */
62
63	+	EPNODE  *ecurfunc = NULL;
64
65	+
66		void
67		fcompile(                       /* get definitions from a file */
68		char  *fname
#	Line 78 | Line 77 | fcompile(                      /* get definitions from a file */
77		eputs(": cannot open\n");
78		quit(1);
79		}
80	<	initfile(fp, fname, 0);
80	>	#ifdef getc_unlocked                    /* avoid stupid semaphores */
81	>	flockfile(fp);
82	>	#endif
83	>	initfile(fp, fname, 0);
84		while (nextc != EOF)
85	<	getstatement();
85	>	egetstatement();
86		if (fname != NULL)
87		fclose(fp);
88	+	#ifdef getc_unlocked
89	+	else
90	+	funlockfile(fp);
91	+	#endif
92		}
93
94
#	Line 95 | Line 101 | scompile(              /* get definitions from a string */
101		{
102		initstr(str, fn, ln);
103		while (nextc != EOF)
104	<	getstatement();
104	>	egetstatement();
105		}
106
107
#	Line 113 | Line 119 | evariable(                     /* evaluate a variable */
119		EPNODE  *ep
120		)
121		{
122	<	register VARDEF  *dp = ep->v.ln;
122	>	VARDEF  *dp = ep->v.ln;
123
124		return(dvalue(dp->name, dp->def));
125		}
#	Line 127 | Line 133 | varset(                /* set a variable's value */
133		)
134		{
135		char  *qname;
136	<	register EPNODE  *ep1, *ep2;
136	>	EPNODE  *ep1, *ep2;
137		/* get qualified name */
138		qname = qualname(vname, 0);
139		/* check for quick set */
140	<	if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM) {
140	>	if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM &&
141	>	(ep1->type == ':') <= (assign == ':')) {
142		ep2 = ep1->v.kid->sibling;
143		if (ep2->type == NUM) {
144		ep2->v.num = val;
#	Line 139 | Line 146 | varset(                /* set a variable's value */
146		return;
147		}
148		}
149	+	if (ep1 != NULL && esupport&E_REDEFW) {
150	+	wputs(qname);
151	+	if (ep1->type == ':')
152	+	wputs(": reset constant expression\n");
153	+	else
154	+	wputs(": reset expression\n");
155	+	}
156		/* hand build definition */
157		ep1 = newnode();
158		ep1->type = assign;
#	Line 150 | Line 164 | varset(                /* set a variable's value */
164		ep2->type = NUM;
165		ep2->v.num = val;
166		addekid(ep1, ep2);
167	<	dremove(qname);
167	>	if (assign == ':')
168	>	dremove(qname);
169	>	else
170	>	dclear(qname);
171		dpush(qname, ep1);
172		}
173
#	Line 160 | Line 177 | dclear(                        /* delete variable definitions of name */
177		char  *name
178		)
179		{
180	<	register EPNODE  *ep;
180	>	VARDEF  *vp;
181	>	EPNODE  *dp;
182
183	<	while ((ep = dpop(name)) != NULL) {
184	<	if (ep->type == ':') {
185	<	dpush(name, ep);            /* don't clear constants */
186	<	return;
187	<	}
170	<	epfree(ep);
183	>	while ((vp = varlookup(name)) != NULL &&
184	>	(dp = vp->def) != NULL && dp->type == '=') {
185	>	vp->def = dp->sibling;
186	>	epfree(dp,1);
187	>	varfree(vp);
188		}
189		}
190
#	Line 177 | Line 194 | dremove(                       /* delete all definitions of name */
194		char  *name
195		)
196		{
197	<	register EPNODE  *ep;
197	>	EPNODE  *ep;
198
199		while ((ep = dpop(name)) != NULL)
200	<	epfree(ep);
200	>	epfree(ep,1);
201		}
202
203
204		int
205	<	vardefined(     /* return non-zero if variable defined */
205	>	vardefined(     /* return '=' or ':' if variable/constant defined */
206		char  *name
207		)
208		{
209	<	register EPNODE  *dp;
209	>	EPNODE  *dp = dlookup(name);
210
211	<	return((dp = dlookup(name)) != NULL && dp->v.kid->type == SYM);
211	>	if (dp == NULL || dp->v.kid->type != SYM)
212	>	return(0);
213	>
214	>	return(dp->type);
215		}
216
217
218		char *
219	<	setcontext(                     /* set a new context path */
220	<	register char  *ctx
219	>	calcontext(                     /* set a new context path */
220	>	char  *ctx
221		)
222		{
223	<	register char  *cpp;
223	>	char  *cpp;
224
225		if (ctx == NULL)
226		return(context);                /* just asking */
#	Line 234 | Line 254 | pushcontext(           /* push on another context */
254		)
255		{
256		char  oldcontext[MAXCNTX+1];
257	<	register int  n;
257	>	int  n;
258
259		strcpy(oldcontext, context);        /* save old context */
260	<	setcontext(ctx);                    /* set new context */
260	>	calcontext(ctx);                    /* set new context */
261		n = strlen(context);                /* tack on old */
262		if (n+strlen(oldcontext) > MAXCNTX) {
263		strncpy(context+n, oldcontext, MAXCNTX-n);
#	Line 251 | Line 271 | pushcontext(           /* push on another context */
271		char *
272		popcontext(void)                        /* pop off top context */
273		{
274	<	register char  *cp1, *cp2;
274	>	char  *cp1, *cp2;
275
276		if (!context[0])                    /* nothing left to pop */
277		return(context);
#	Line 259 | Line 279 | popcontext(void)                       /* pop off top context */
279		while (*++cp2 && *cp2 != CNTXMARK)
280		;
281		cp1 = context;                      /* copy tail to front */
282	<	while (*cp1++ = *cp2++)
282	>	while ( (*cp1++ = *cp2++) )
283		;
284		return(context);
285		}
#	Line 267 | Line 287 | popcontext(void)                       /* pop off top context */
287
288		char *
289		qualname(               /* get qualified name */
290	<	register char  *nam,
290	>	char  *nam,
291		int  lvl
292		)
293		{
294	<	static char  nambuf[RMAXWORD+1];
295	<	register char  *cp = nambuf, *cpp;
294	>	static char  nambuf[MAXCNTX+RMAXWORD+1];
295	>	char  *cp = nambuf, *cpp;
296		/* check for explicit local */
297	<	if (*nam == CNTXMARK)
297	>	if (*nam == CNTXMARK) {
298		if (lvl > 0)            /* only action is to refuse search */
299		return(NULL);
300	<	else
301	<	nam++;
282	<	else if (nam == nambuf)     /* check for repeat call */
300	>	nam++;
301	>	} else if (nam == nambuf)   /* check for repeat call */
302		return(lvl > 0 ? NULL : nam);
303		/* copy name to static buffer */
304		while (*nam) {
305	<	if (cp >= nambuf+RMAXWORD)
305	>	if (cp >= nambuf+(MAXCNTX+RMAXWORD))
306		goto toolong;
307		*cp++ = *nam++;
308		}
#	Line 301 | Line 320 | qualname(              /* get qualified name */
320		while (*++cpp && *cpp != CNTXMARK)
321		;
322		}
323	<	while (*cpp) {              /* copy context to static buffer */
324	<	if (cp >= nambuf+RMAXWORD)
323	>	while (*cpp) {              /* add remaining context to name */
324	>	if (cp >= nambuf+(MAXCNTX+RMAXWORD))
325		goto toolong;
326		*cp++ = *cpp++;
327		}
#	Line 314 | Line 333 | toolong:
333
334		int
335		incontext(                      /* is qualified name in current context? */
336	<	register char  *qn
336	>	char  *qn
337		)
338		{
339		if (!context[0])                    /* global context accepts all */
#	Line 330 | Line 349 | chanout(                       /* set output channels */
349		void  (*cs)(int n, double v)
350		)
351		{
352	<	register EPNODE  *ep;
352	>	EPNODE  *ep;
353
354		for (ep = outchan; ep != NULL; ep = ep->sibling)
355		(*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
#	Line 339 | Line 358 | chanout(                       /* set output channels */
358
359
360		void
361	+	doptimize(int activate)         /* optimize current and future definitions? */
362	+	{
363	+	EPNODE      *ep;
364	+
365	+	if (activate && optimized)
366	+	return;                 /* already going */
367	+
368	+	if (!(optimized = activate))
369	+	return;                 /* switching off */
370	+
371	+	for (ep = dfirst(); ep != NULL; ep = dnext())
372	+	epoptimize(ep);
373	+	}
374	+
375	+
376	+	void
377		dcleanup(               /* clear definitions (0->vars,1->output,2->consts) */
378		int  lvl
379		)
380		{
381	<	register int  i;
382	<	register VARDEF  *vp;
383	<	register EPNODE  *ep;
381	>	int  i;
382	>	VARDEF  *vp;
383	>	EPNODE  *ep;
384		/* if context is global, clear all */
385		for (i = 0; i < NHASH; i++)
386		for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
387	<	if (incontext(vp->name))
387	>	if (incontext(vp->name)) {
388		if (lvl >= 2)
389		dremove(vp->name);
390		else
391		dclear(vp->name);
392	<	if (lvl >= 1) {
393	<	for (ep = outchan; ep != NULL; ep = ep->sibling)
394	<	epfree(ep);
395	<	outchan = NULL;
396	<	}
392	>	}
393	>	if (lvl >= 1)
394	>	while (outchan != NULL) {
395	>	ep = outchan;
396	>	outchan = ep->sibling;
397	>	epfree(ep,1);
398	>	}
399		}
400
401
#	Line 367 | Line 404 | dlookup(                       /* look up a definition */
404		char  *name
405		)
406		{
407	<	register VARDEF  *vp;
407	>	VARDEF  *vp;
408
409		if ((vp = varlookup(name)) == NULL)
410		return(NULL);
#	Line 381 | Line 418 | varlookup(                     /* look up a variable */
418		)
419		{
420		int  lvl = 0;
421	<	register char  *qname;
422	<	register VARDEF  *vp;
421	>	char  *qname;
422	>	VARDEF  *vp;
423		/* find most qualified match */
424		while ((qname = qualname(name, lvl++)) != NULL)
425		for (vp = hashtbl[hash(qname)]; vp != NULL; vp = vp->next)
#	Line 397 | Line 434 | varinsert(                     /* get a link to a variable */
434		char  *name
435		)
436		{
437	<	register VARDEF  *vp;
437	>	VARDEF  *vp;
438		int  hv;
439
440		if ((vp = varlookup(name)) != NULL) {
#	Line 405 | Line 442 | varinsert(                     /* get a link to a variable */
442		return(vp);
443		}
444		vp = (VARDEF *)emalloc(sizeof(VARDEF));
445	<	vp->lib = liblookup(name);
445	>	vp->lib = eliblookup(name);
446		if (vp->lib == NULL)                /* if name not in library */
447		name = qualname(name, 0);       /* use fully qualified version */
448		hv = hash(name);
#	Line 419 | Line 456 | varinsert(                     /* get a link to a variable */
456
457
458		void
459	<	libupdate(                      /* update library links */
459	>	elibupdate(                     /* update library links */
460		char  *fn
461		)
462		{
463	<	register int  i;
464	<	register VARDEF  *vp;
463	>	int  i;
464	>	VARDEF  *vp;
465		/* if fn is NULL then relink all */
466		for (i = 0; i < NHASH; i++)
467		for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
468	<	if (vp->lib != NULL || fn == NULL || !strcmp(fn, vp->name))
469	<	vp->lib = liblookup(vp->name);
468	>	if ((vp->lib != NULL) | (fn == NULL) || !strcmp(fn, vp->name))
469	>	vp->lib = eliblookup(vp->name);
470		}
471
472
473		void
474		varfree(                                /* release link to variable */
475	<	register VARDEF  *ln
475	>	VARDEF   *ln
476		)
477		{
478	<	register VARDEF  *vp;
478	>	VARDEF  *vp;
479		int  hv;
480
481		if (--ln->nlinks > 0)
#	Line 454 | Line 491 | varfree(                               /* release link to variable */
491		vp->next = ln->next;
492		}
493		freestr(ln->name);
494	<	efree((char *)ln);
494	>	efree(ln);
495		}
496
497
#	Line 471 | Line 508 | dfirst(void)                   /* return pointer to first definition *
508		EPNODE *
509		dnext(void)                             /* return pointer to next definition */
510		{
511	<	register EPNODE  *ep;
512	<	register char  *nm;
511	>	EPNODE  *ep;
512	>	char  *nm;
513
514		while (htndx < NHASH) {
515		if (htpos == NULL)
#	Line 496 | Line 533 | dpop(                  /* pop a definition */
533		char  *name
534		)
535		{
536	<	register VARDEF  *vp;
537	<	register EPNODE  *dp;
536	>	VARDEF  *vp;
537	>	EPNODE  *dp;
538
539		if ((vp = varlookup(name)) == NULL || vp->def == NULL)
540		return(NULL);
#	Line 511 | Line 548 | dpop(                  /* pop a definition */
548		void
549		dpush(                  /* push on a definition */
550		char  *nm,
551	<	register EPNODE  *ep
551	>	EPNODE   *ep
552		)
553		{
554	<	register VARDEF  *vp;
554	>	VARDEF  *vp;
555
556		vp = varinsert(nm);
557		ep->sibling = vp->def;
#	Line 523 | Line 560 | dpush(                 /* push on a definition */
560
561
562		void
563	<	addchan(                        /* add an output channel assignment */
563	>	eaddchan(                       /* add an output channel assignment */
564		EPNODE  *sp
565		)
566		{
567		int  ch = sp->v.kid->v.chan;
568	<	register EPNODE  *ep, *epl;
568	>	EPNODE  *ep, *epl;
569
570		for (epl = NULL, ep = outchan; ep != NULL; epl = ep, ep = ep->sibling)
571		if (ep->v.kid->v.chan >= ch) {
#	Line 540 | Line 577 | addchan(                       /* add an output channel assignment */
577		sp->sibling = ep;
578		else {
579		sp->sibling = ep->sibling;
580	<	epfree(ep);
580	>	epfree(ep,1);
581		}
582		return;
583		}
#	Line 554 | Line 591 | addchan(                       /* add an output channel assignment */
591
592
593		void
594	<	getstatement(void)                      /* get next statement */
594	>	egetstatement(void)                     /* get next statement */
595		{
596	<	register EPNODE  *ep;
596	>	EPNODE  *ep;
597		char  *qname;
598	<	register VARDEF  *vdef;
598	>	VARDEF  *vdef;
599
600		if (nextc == ';') {         /* empty statement */
601	<	scan();
601	>	escan();
602		return;
603		}
604		if (esupport&E_OUTCHAN &&
605		nextc == '$') {         /* channel assignment */
606	<	ep = getchan();
607	<	addchan(ep);
606	>	ep = egetchan();
607	>	if (optimized)
608	>	epoptimize(ep);             /* optimize new chan expr */
609	>	eaddchan(ep);
610		} else {                            /* ordinary definition */
611	<	ep = getdefn();
612	<	qname = qualname(dname(ep), 0);
613	<	if (esupport&E_REDEFW && (vdef = varlookup(qname)) != NULL)
611	>	ep = egetdefn();
612	>	if (optimized)
613	>	epoptimize(ep);             /* optimize new statement */
614	>	qname = qualname(dfn_name(ep), 0);
615	>	if (esupport&E_REDEFW && (vdef = varlookup(qname)) != NULL) {
616		if (vdef->def != NULL && epcmp(ep, vdef->def)) {
617		wputs(qname);
618		if (vdef->def->type == ':')
#	Line 582 | Line 623 | getstatement(void)                     /* get next statement */
623		wputs(qname);
624		wputs(": definition hides library function\n");
625		}
626	+	}
627		if (ep->type == ':')
628		dremove(qname);
629		else
#	Line 590 | Line 632 | getstatement(void)                     /* get next statement */
632		}
633		if (nextc != EOF) {
634		if (nextc != ';')
635	<	syntax("';' expected");
636	<	scan();
635	>	esyntax("';' expected");
636	>	escan();
637		}
638		}
639
640
641		EPNODE *
642	<	getdefn(void)
642	>	egetdefn(void)
643		/* A -> SYM = E1 */
644		/*      SYM : E1 */
645		/*      FUNC(SYM,..) = E1 */
646		/*      FUNC(SYM,..) : E1 */
647		{
648	<	register EPNODE  *ep1, *ep2;
648	>	EPNODE  *ep1, *ep2;
649
650	<	if (!isalpha(nextc) && nextc != CNTXMARK)
651	<	syntax("illegal variable name");
650	>	if (!isalpha(nextc) & (nextc != CNTXMARK))
651	>	esyntax("illegal variable name");
652
653		ep1 = newnode();
654		ep1->type = SYM;
#	Line 618 | Line 660 | getdefn(void)
660		addekid(ep2, ep1);
661		ep1 = ep2;
662		do {
663	<	scan();
663	>	escan();
664		if (!isalpha(nextc))
665	<	syntax("illegal variable name");
665	>	esyntax("illegal parameter name");
666		ep2 = newnode();
667		ep2->type = SYM;
668		ep2->v.name = savestr(getname());
669	+	if (strchr(ep2->v.name, CNTXMARK) != NULL)
670	+	esyntax("illegal parameter name");
671		addekid(ep1, ep2);
672		} while (nextc == ',');
673		if (nextc != ')')
674	<	syntax("')' expected");
675	<	scan();
676	<	curfunc = ep1;
674	>	esyntax("')' expected");
675	>	escan();
676	>	ecurfunc = ep1;
677		}
678
679	<	if (nextc != '=' && nextc != ':')
680	<	syntax("'=' or ':' expected");
679	>	if ((nextc != '=') & (nextc != ':'))
680	>	esyntax("'=' or ':' expected");
681
682		ep2 = newnode();
683		ep2->type = nextc;
684	<	scan();
684	>	escan();
685		addekid(ep2, ep1);
686		addekid(ep2, getE1());
687
688		if (ep1->type == SYM && ep1->sibling->type != NUM) {
689		ep1 = newnode();
690	<	ep1->type = TICK;
690	>	ep1->type = CLKT;
691		ep1->v.tick = 0;
692		addekid(ep2, ep1);
693		ep1 = newnode();
694		ep1->type = NUM;
695		addekid(ep2, ep1);
696		}
697	<	curfunc = NULL;
697	>	ecurfunc = NULL;
698
699		return(ep2);
700		}
701
702
703		EPNODE *
704	<	getchan(void)                   /* A -> $N = E1 */
704	>	egetchan(void)                  /* A -> $N = E1 */
705		{
706	<	register EPNODE  *ep1, *ep2;
706	>	EPNODE  *ep1, *ep2;
707
708		if (nextc != '$')
709	<	syntax("missing '$'");
710	<	scan();
709	>	esyntax("missing '$'");
710	>	escan();
711
712		ep1 = newnode();
713		ep1->type = CHAN;
714		ep1->v.chan = getinum();
715
716		if (nextc != '=')
717	<	syntax("'=' expected");
718	<	scan();
717	>	esyntax("'=' expected");
718	>	escan();
719
720		ep2 = newnode();
721		ep2->type = '=';
#	Line 689 | Line 733 | getchan(void)                  /* A -> $N = E1 */
733
734
735		static double                   /* evaluate a variable */
736	<	dvalue(char  *name, EPNODE      *d)
736	>	dvalue(char *name, EPNODE *d)
737		{
738	<	register EPNODE  *ep1, *ep2;
738	>	EPNODE  *ep1, *ep2;
739
740		if (d == NULL || d->v.kid->type != SYM) {
741		eputs(name);
#	Line 701 | Line 745 | dvalue(char  *name, EPNODE     *d)
745		ep1 = d->v.kid->sibling;                    /* get expression */
746		if (ep1->type == NUM)
747		return(ep1->v.num);                     /* return if number */
748	+	if (esupport&E_RCONST && d->type == ':') {
749	+	wputs(name);
750	+	wputs(": assigned non-constant value\n");
751	+	}
752		ep2 = ep1->sibling;                         /* check time */
753		if (eclock >= MAXCLOCK)
754		eclock = 1;                             /* wrap clock counter */
755		if (ep2->v.tick < MAXCLOCK &&
756	<	ep2->v.tick == 0 | ep2->v.tick != eclock) {
756	>	(ep2->v.tick == 0) | (ep2->v.tick != eclock)) {
757		ep2->v.tick = d->type == ':' ? MAXCLOCK : eclock;
758		ep2 = ep2->sibling;
759		ep2->v.num = evalue(ep1);               /* needs new value */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)