[ViewVC] Diff of: radiance/ray/src/common/caldefn.c

Comparing ray/src/common/caldefn.c (file contents):
Revision 1.14 by greg, Thu Aug 8 12:12:16 1991 UTC vs.
Revision 2.28 by greg, Thu Apr 2 18:00:34 2020 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1991 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Store variable definitions.
6		*
#	Line 22 \| Line 19 \| static char SCCSid[] = "$SunId$ LBL";
19		* 4/23/91 Added ':' assignment for constant expressions
20		*
21		* 8/7/91 Added optional context path to append to variable names
22	+	*
23	+	* 5/17/2001 Fixed clock counter wrapping behavior
24	+	*
25	+	* 2/19/03 Eliminated conditional compiles in favor of esupport extern.
26		*/
27
28	<	#include <stdio.h>
28	>	#include "copyright.h"
29
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
38	<	#define NHASH 521 /* hash size (a prime!) */
37	>	#ifndef NHASH
38	>	#define NHASH 521 /* hash size (a prime!) */
39		#endif
40
41	<	#define newnode() (EPNODE *)ecalloc(1, sizeof(EPNODE))
41	>	#define hash(s) (shash(s)%NHASH)
42
43	<	extern char ecalloc(), savestr(), *strcpy();
43	>	#define newnode() (EPNODE *)ecalloc(1, sizeof(EPNODE))
44
45	<	static double dvalue();
45	>	static double dvalue(char name, EPNODE d);
46
47	<	long eclock = -1; /* value storage timer */
47	>	#define MAXCLOCK (1L<<31) /* clock wrap value */
48
49	<	static char context[MAXWORD]; /* current context path */
49	>	unsigned long eclock = 0; /* value storage timer */
50
51	+	#define MAXCNTX 1023 /* maximum context length */
52	+
53	+	static char context[MAXCNTX+1]; /* current context path */
54	+
55		static VARDEF hashtbl[NHASH]; / definition list */
56		static int htndx; /* index for */
57		static VARDEF htpos; / ...dfirst() and */
50	–	#ifdef OUTCHAN
58		static EPNODE ochpos; / ...dnext */
59		static EPNODE *outchan;
53	–	#endif
60
61	<	#ifdef FUNCTION
62	<	EPNODE *curfunc;
57	<	#define dname(ep) ((ep)->v.kid->type == SYM ? \
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)
60	–	#else
61	–	#define dname(ep) ((ep)->v.kid->v.name)
62	–	#endif
65
66
67	<	fcompile(fname) /* get definitions from a file */
68	<	char *fname;
67	>	void
68	>	fcompile( /* get definitions from a file */
69	>	char *fname
70	>	)
71		{
72		FILE *fp;
73
#	Line 82 \| Line 86 \| *char fname;**
86		}
87
88
89	<	scompile(str, fn, ln) /* get definitions from a string */
90	<	char *str;
91	<	char *fn;
92	<	int ln;
89	>	void
90	>	scompile( /* get definitions from a string */
91	>	char *str,
92	>	char *fn,
93	>	int ln
94	>	)
95		{
96		initstr(str, fn, ln);
97		while (nextc != EOF)
#	Line 94 \| Line 100 \| int ln;
100
101
102		double
103	<	varvalue(vname) /* return a variable's value */
104	<	char *vname;
103	>	varvalue( /* return a variable's value */
104	>	char *vname
105	>	)
106		{
107		return(dvalue(vname, dlookup(vname)));
108		}
109
110
111		double
112	<	evariable(ep) /* evaluate a variable */
113	<	EPNODE *ep;
112	>	evariable( /* evaluate a variable */
113	>	EPNODE *ep
114	>	)
115		{
116	<	register VARDEF *dp = ep->v.ln;
116	>	VARDEF *dp = ep->v.ln;
117
118		return(dvalue(dp->name, dp->def));
119		}
120
121
122	<	varset(vname, assign, val) /* set a variable's value */
123	<	char *vname;
124	<	int assign;
125	<	double val;
122	>	void
123	>	varset( /* set a variable's value */
124	>	char *vname,
125	>	int assign,
126	>	double val
127	>	)
128		{
129		char *qname;
130	<	register EPNODE ep1, ep2;
130	>	EPNODE ep1, ep2;
131		/* get qualified name */
132		qname = qualname(vname, 0);
133		/* check for quick set */
134	<	if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM) {
134	>	if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM &&
135	>	(ep1->type == ':') <= (assign == ':')) {
136		ep2 = ep1->v.kid->sibling;
137		if (ep2->type == NUM) {
138		ep2->v.num = val;
#	Line 129 \| Line 140 \| double val;
140		return;
141		}
142		}
143	+	if (ep1 != NULL && esupport&E_REDEFW) {
144	+	wputs(qname);
145	+	if (ep1->type == ':')
146	+	wputs(": reset constant expression\n");
147	+	else
148	+	wputs(": reset expression\n");
149	+	}
150		/* hand build definition */
151		ep1 = newnode();
152		ep1->type = assign;
#	Line 140 \| Line 158 \| double val;
158		ep2->type = NUM;
159		ep2->v.num = val;
160		addekid(ep1, ep2);
161	<	dremove(qname);
161	>	if (assign == ':')
162	>	dremove(qname);
163	>	else
164	>	dclear(qname);
165		dpush(qname, ep1);
166		}
167
168
169	<	dclear(name) /* delete variable definitions of name */
170	<	char *name;
169	>	void
170	>	dclear( /* delete variable definitions of name */
171	>	char *name
172	>	)
173		{
174	<	register EPNODE *ep;
174	>	EPNODE *ep;
175
176		while ((ep = dpop(name)) != NULL) {
177		if (ep->type == ':') {
#	Line 160 \| Line 183 \| *char name;**
183		}
184
185
186	<	dremove(name) /* delete all definitions of name */
187	<	char *name;
186	>	void
187	>	dremove( /* delete all definitions of name */
188	>	char *name
189	>	)
190		{
191	<	register EPNODE *ep;
191	>	EPNODE *ep;
192
193		while ((ep = dpop(name)) != NULL)
194		epfree(ep);
195		}
196
197
198	<	vardefined(name) /* return non-zero if variable defined */
199	<	char *name;
198	>	int
199	>	vardefined( /* return non-zero if variable defined */
200	>	char *name
201	>	)
202		{
203	<	register EPNODE *dp;
203	>	EPNODE *dp;
204
205		return((dp = dlookup(name)) != NULL && dp->v.kid->type == SYM);
206		}
207
208
209		char *
210	<	setcontext(ctx) /* set a new context path */
211	<	register char *ctx;
210	>	setcontext( /* set a new context path */
211	>	char *ctx
212	>	)
213		{
214	<	register char *cpp;
214	>	char *cpp;
215
216		if (ctx == NULL)
217		return(context); /* just asking */
218	+	while (*ctx == CNTXMARK)
219	+	ctx++; /* skip past marks */
220		if (!*ctx) {
221	<	context[0] = '\0'; /* clear context */
221	>	context[0] = '\0'; /* empty means clear context */
222		return(context);
223		}
224	<	cpp = context; /* else copy it (carefully!) */
225	<	if (*ctx != CNTXMARK)
226	<	cpp++ = CNTXMARK; / make sure there's a mark */
227	<	do {
228	<	if (cpp >= context+MAXWORD-1) {
199	<	*cpp = '\0';
200	<	wputs(context);
201	<	wputs(": context path too long\n");
202	<	return(NULL);
203	<	}
224	>	cpp = context; /* start context with mark */
225	>	*cpp++ = CNTXMARK;
226	>	do { /* carefully copy new context */
227	>	if (cpp >= context+MAXCNTX)
228	>	break; /* just copy what we can */
229		if (isid(*ctx))
230		cpp++ = ctx++;
231		else {
232		*cpp++ = '_'; ctx++;
233		}
234		} while (*ctx);
235	+	while (cpp[-1] == CNTXMARK) /* cannot end in context mark */
236	+	cpp--;
237		*cpp = '\0';
238		return(context);
239		}
240
241
242		char *
243	<	qualname(nam, lvl) /* get qualified name */
244	<	register char *nam;
245	<	int lvl;
243	>	pushcontext( /* push on another context */
244	>	char *ctx
245	>	)
246		{
247	<	static char nambuf[MAXWORD];
248	<	register char cp = nambuf, cpp = context;
249	<	/* check for repeat call */
250	<	if (nam == nambuf)
251	<	return(lvl > 0 ? NULL : nambuf);
247	>	char oldcontext[MAXCNTX+1];
248	>	int n;
249	>
250	>	strcpy(oldcontext, context); /* save old context */
251	>	setcontext(ctx); /* set new context */
252	>	n = strlen(context); /* tack on old */
253	>	if (n+strlen(oldcontext) > MAXCNTX) {
254	>	strncpy(context+n, oldcontext, MAXCNTX-n);
255	>	context[MAXCNTX] = '\0';
256	>	} else
257	>	strcpy(context+n, oldcontext);
258	>	return(context);
259	>	}
260	>
261	>
262	>	char *
263	>	popcontext(void) /* pop off top context */
264	>	{
265	>	char cp1, cp2;
266	>
267	>	if (!context[0]) /* nothing left to pop */
268	>	return(context);
269	>	cp2 = context; /* find mark */
270	>	while (++cp2 && cp2 != CNTXMARK)
271	>	;
272	>	cp1 = context; /* copy tail to front */
273	>	while ( (cp1++ = cp2++) )
274	>	;
275	>	return(context);
276	>	}
277	>
278	>
279	>	char *
280	>	qualname( /* get qualified name */
281	>	char *nam,
282	>	int lvl
283	>	)
284	>	{
285	>	static char nambuf[RMAXWORD+1];
286	>	char cp = nambuf, cpp;
287	>	/* check for explicit local */
288	>	if (*nam == CNTXMARK)
289	>	if (lvl > 0) /* only action is to refuse search */
290	>	return(NULL);
291	>	else
292	>	nam++;
293	>	else if (nam == nambuf) /* check for repeat call */
294	>	return(lvl > 0 ? NULL : nam);
295		/* copy name to static buffer */
296		while (*nam) {
297	<	if (cp >= nambuf+MAXWORD-1)
297	>	if (cp >= nambuf+RMAXWORD)
298		goto toolong;
299	<	if ((cp++ = nam++) == CNTXMARK)
230	<	cpp = NULL; /* flag a qualified name */
299	>	cp++ = nam++;
300		}
301	<	if (cpp == NULL) {
301	>	/* check for explicit global */
302	>	if (cp > nambuf && cp[-1] == CNTXMARK) {
303		if (lvl > 0)
304	<	return(NULL); /* no higher level */
305	<	if (cp[-1] == CNTXMARK) {
306	<	cp--; cpp = context; /* current context explicitly */
307	<	} else
308	<	cpp = ""; /* else fully qualified */
309	<	} else /* else skip the requested levels */
310	<	while (lvl-- > 0) {
311	<	if (!*cpp)
312	<	return(NULL); /* return NULL if past global level */
313	<	while (++cpp && cpp != CNTXMARK)
314	<	;
245	<	}
304	>	return(NULL);
305	>	*--cp = '\0';
306	>	return(nambuf); /* already qualified */
307	>	}
308	>	cpp = context; /* else skip the requested levels */
309	>	while (lvl-- > 0) {
310	>	if (!*cpp)
311	>	return(NULL); /* return NULL if past global level */
312	>	while (++cpp && cpp != CNTXMARK)
313	>	;
314	>	}
315		while (cpp) { / copy context to static buffer */
316	<	if (cp >= nambuf+MAXWORD-1)
316	>	if (cp >= nambuf+RMAXWORD)
317		goto toolong;
318		cp++ = cpp++;
319		}
251	–	*cp = '\0';
252	–	return(nambuf); /* return qualified name */
320		toolong:
321		*cp = '\0';
322	<	eputs(nambuf);
256	<	eputs(": name too long\n");
257	<	quit(1);
322	>	return(nambuf); /* return qualified name */
323		}
324
325
326	<	incontext(qn) /* is qualified name in current context? */
327	<	register char *qn;
326	>	int
327	>	incontext( /* is qualified name in current context? */
328	>	char *qn
329	>	)
330		{
331	+	if (!context[0]) /* global context accepts all */
332	+	return(1);
333		while (qn && qn != CNTXMARK) /* find context mark */
334	<	;
334	>	qn++;
335		return(!strcmp(qn, context));
336		}
337
338
339	<	#ifdef OUTCHAN
340	<	chanout(cs) /* set output channels */
341	<	int (*cs)();
339	>	void
340	>	chanout( /* set output channels */
341	>	void (*cs)(int n, double v)
342	>	)
343		{
344	<	register EPNODE *ep;
344	>	EPNODE *ep;
345
346		for (ep = outchan; ep != NULL; ep = ep->sibling)
347		(*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
348
349		}
280	–	#endif
350
351
352	<	dcleanup(lvl) /* clear definitions (0->vars,1->output,2->consts) */
353	<	int lvl;
352	>	void
353	>	dcleanup( /* clear definitions (0->vars,1->output,2->consts) */
354	>	int lvl
355	>	)
356		{
357	<	register int i;
358	<	register VARDEF *vp;
359	<	register EPNODE *ep;
357	>	int i;
358	>	VARDEF *vp;
359	>	EPNODE *ep;
360		/* if context is global, clear all */
361		for (i = 0; i < NHASH; i++)
362		for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
363	<	if (!context[0] \|\| incontext(vp->name))
363	>	if (incontext(vp->name)) {
364		if (lvl >= 2)
365		dremove(vp->name);
366		else
367		dclear(vp->name);
368	<	#ifdef OUTCHAN
368	>	}
369		if (lvl >= 1) {
370		for (ep = outchan; ep != NULL; ep = ep->sibling)
371		epfree(ep);
372		outchan = NULL;
373		}
303	–	#endif
374		}
375
376
377		EPNODE *
378	<	dlookup(name) /* look up a definition */
379	<	char *name;
378	>	dlookup( /* look up a definition */
379	>	char *name
380	>	)
381		{
382	<	register VARDEF *vp;
382	>	VARDEF *vp;
383
384		if ((vp = varlookup(name)) == NULL)
385	<	return(NULL);
385	>	return(NULL);
386		return(vp->def);
387		}
388
389
390		VARDEF *
391	<	varlookup(name) /* look up a variable */
392	<	char *name;
391	>	varlookup( /* look up a variable */
392	>	char *name
393	>	)
394		{
395	<	int lvl = 0;
396	<	register char *qname;
397	<	register VARDEF *vp;
398	<	/* find most qualified match */
395	>	int lvl = 0;
396	>	char *qname;
397	>	VARDEF *vp;
398	>	/* find most qualified match */
399		while ((qname = qualname(name, lvl++)) != NULL)
400		for (vp = hashtbl[hash(qname)]; vp != NULL; vp = vp->next)
401		if (!strcmp(vp->name, qname))
#	Line 333 \| Line 405 \| *char name;**
405
406
407		VARDEF *
408	<	varinsert(name) /* get a link to a variable */
409	<	char *name;
408	>	varinsert( /* get a link to a variable */
409	>	char *name
410	>	)
411		{
412	<	register VARDEF *vp;
413	<	int hv;
412	>	VARDEF *vp;
413	>	int hv;
414
415		if ((vp = varlookup(name)) != NULL) {
416		vp->nlinks++;
417		return(vp);
418		}
346	–	name = qualname(name, 0); /* use fully qualified name */
347	–	hv = hash(name);
419		vp = (VARDEF *)emalloc(sizeof(VARDEF));
420	+	vp->lib = liblookup(name);
421	+	if (vp->lib == NULL) /* if name not in library */
422	+	name = qualname(name, 0); /* use fully qualified version */
423	+	hv = hash(name);
424		vp->name = savestr(name);
425		vp->nlinks = 1;
426		vp->def = NULL;
352	–	vp->lib = NULL;
427		vp->next = hashtbl[hv];
428		hashtbl[hv] = vp;
429		return(vp);
430		}
431
432
433	<	varfree(ln) /* release link to variable */
434	<	register VARDEF *ln;
433	>	void
434	>	libupdate( /* update library links */
435	>	char *fn
436	>	)
437		{
438	<	register VARDEF *vp;
439	<	int hv;
438	>	int i;
439	>	VARDEF *vp;
440	>	/* if fn is NULL then relink all */
441	>	for (i = 0; i < NHASH; i++)
442	>	for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
443	>	if (vp->lib != NULL \|\| fn == NULL \|\| !strcmp(fn, vp->name))
444	>	vp->lib = liblookup(vp->name);
445	>	}
446
447	+
448	+	void
449	+	varfree( /* release link to variable */
450	+	VARDEF *ln
451	+	)
452	+	{
453	+	VARDEF *vp;
454	+	int hv;
455	+
456		if (--ln->nlinks > 0)
457	<	return; /* still active */
457	>	return; /* still active */
458
459		hv = hash(ln->name);
460		vp = hashtbl[hv];
461		if (vp == ln)
462	<	hashtbl[hv] = vp->next;
462	>	hashtbl[hv] = vp->next;
463		else {
464	<	while (vp->next != ln) /* must be in list */
465	<	vp = vp->next;
466	<	vp->next = ln->next;
464	>	while (vp->next != ln) /* must be in list */
465	>	vp = vp->next;
466	>	vp->next = ln->next;
467		}
468		freestr(ln->name);
469		efree((char *)ln);
#	Line 380 \| Line 471 \| *register VARDEF ln;**
471
472
473		EPNODE *
474	<	dfirst() /* return pointer to first definition */
474	>	dfirst(void) /* return pointer to first definition */
475		{
476		htndx = 0;
477		htpos = NULL;
387	–	#ifdef OUTCHAN
478		ochpos = outchan;
389	–	#endif
479		return(dnext());
480		}
481
482
483		EPNODE *
484	<	dnext() /* return pointer to next definition */
484	>	dnext(void) /* return pointer to next definition */
485		{
486	<	register EPNODE *ep;
486	>	EPNODE *ep;
487	>	char *nm;
488
489		while (htndx < NHASH) {
490	<	if (htpos == NULL)
491	<	htpos = hashtbl[htndx++];
492	<	while (htpos != NULL) {
493	<	ep = htpos->def;
494	<	htpos = htpos->next;
495	<	if (ep != NULL)
496	<	return(ep);
497	<	}
490	>	if (htpos == NULL)
491	>	htpos = hashtbl[htndx++];
492	>	while (htpos != NULL) {
493	>	ep = htpos->def;
494	>	nm = htpos->name;
495	>	htpos = htpos->next;
496	>	if (ep != NULL && incontext(nm))
497	>	return(ep);
498	>	}
499		}
409	–	#ifdef OUTCHAN
500		if ((ep = ochpos) != NULL)
501	<	ochpos = ep->sibling;
501	>	ochpos = ep->sibling;
502		return(ep);
413	–	#else
414	–	return(NULL);
415	–	#endif
503		}
504
505
506		EPNODE *
507	<	dpop(name) /* pop a definition */
508	<	char *name;
507	>	dpop( /* pop a definition */
508	>	char *name
509	>	)
510		{
511	<	register VARDEF *vp;
512	<	register EPNODE *dp;
511	>	VARDEF *vp;
512	>	EPNODE *dp;
513
514		if ((vp = varlookup(name)) == NULL \|\| vp->def == NULL)
515	<	return(NULL);
515	>	return(NULL);
516		dp = vp->def;
517		vp->def = dp->sibling;
518		varfree(vp);
#	Line 432 \| Line 520 \| *char name;**
520		}
521
522
523	<	dpush(nm, ep) /* push on a definition */
524	<	char *nm;
525	<	register EPNODE *ep;
523	>	void
524	>	dpush( /* push on a definition */
525	>	char *nm,
526	>	EPNODE *ep
527	>	)
528		{
529	<	register VARDEF *vp;
529	>	VARDEF *vp;
530
531		vp = varinsert(nm);
532		ep->sibling = vp->def;
#	Line 444 \| Line 534 \| *register EPNODE ep;**
534		}
535
536
537	<	#ifdef OUTCHAN
538	<	addchan(sp) /* add an output channel assignment */
539	<	EPNODE *sp;
537	>	void
538	>	addchan( /* add an output channel assignment */
539	>	EPNODE *sp
540	>	)
541		{
542	<	int ch = sp->v.kid->v.chan;
543	<	register EPNODE ep, epl;
542	>	int ch = sp->v.kid->v.chan;
543	>	EPNODE ep, epl;
544
545		for (epl = NULL, ep = outchan; ep != NULL; epl = ep, ep = ep->sibling)
546		if (ep->v.kid->v.chan >= ch) {
#	Line 472 \| Line 563 \| *EPNODE sp;**
563		sp->sibling = NULL;
564
565		}
475	–	#endif
566
567
568	<	getstatement() /* get next statement */
568	>	void
569	>	getstatement(void) /* get next statement */
570		{
571	<	register EPNODE *ep;
571	>	EPNODE *ep;
572		char *qname;
573	<	EPNODE *lastdef;
573	>	VARDEF *vdef;
574
575		if (nextc == ';') { /* empty statement */
576		scan();
577		return;
578		}
579	<	#ifdef OUTCHAN
580	<	if (nextc == '$') { /* channel assignment */
579	>	if (esupport&E_OUTCHAN &&
580	>	nextc == '$') { /* channel assignment */
581		ep = getchan();
582		addchan(ep);
583	<	} else
493	<	#endif
494	<	{ /* ordinary definition */
583	>	} else { /* ordinary definition */
584		ep = getdefn();
585		qname = qualname(dname(ep), 0);
586	<	#ifdef REDEFW
587	<	if ((lastdef = dlookup(qname)) != NULL) {
588	<	wputs(qname);
589	<	if (lastdef->type == ':')
590	<	wputs(": redefined constant expression\n");
591	<	else
592	<	wputs(": redefined\n");
586	>	if (esupport&E_REDEFW && (vdef = varlookup(qname)) != NULL) {
587	>	if (vdef->def != NULL && epcmp(ep, vdef->def)) {
588	>	wputs(qname);
589	>	if (vdef->def->type == ':')
590	>	wputs(": redefined constant expression\n");
591	>	else
592	>	wputs(": redefined\n");
593	>	} else if (ep->v.kid->type == FUNC && vdef->lib != NULL) {
594	>	wputs(qname);
595	>	wputs(": definition hides library function\n");
596	>	}
597		}
505	–	#ifdef FUNCTION
506	–	else if (ep->v.kid->type == FUNC && liblookup(qname) != NULL) {
507	–	wputs(qname);
508	–	wputs(": definition hides library function\n");
509	–	}
510	–	#endif
511	–	#endif
598		if (ep->type == ':')
599		dremove(qname);
600		else
#	Line 524 \| Line 610 \| *getstatement() / get next statement /*
610
611
612		EPNODE *
613	<	getdefn() /* A -> SYM = E1 */
614	<	/* SYM : E1 */
615	<	/* FUNC(SYM,..) = E1 */
616	<	/* FUNC(SYM,..) : E1 */
613	>	getdefn(void)
614	>	/* A -> SYM = E1 */
615	>	/* SYM : E1 */
616	>	/* FUNC(SYM,..) = E1 */
617	>	/* FUNC(SYM,..) : E1 */
618		{
619	<	register EPNODE ep1, ep2;
619	>	EPNODE ep1, ep2;
620
621	<	if (!isalpha(nextc))
621	>	if (!isalpha(nextc) && nextc != CNTXMARK)
622		syntax("illegal variable name");
623
624		ep1 = newnode();
625		ep1->type = SYM;
626		ep1->v.name = savestr(getname());
627
628	<	#ifdef FUNCTION
542	<	if (nextc == '(') {
628	>	if (esupport&E_FUNCTION && nextc == '(') {
629		ep2 = newnode();
630		ep2->type = FUNC;
631		addekid(ep2, ep1);
#	Line 547 \| Line 633 \| *getdefn() / A -> SYM = E1 /*
633		do {
634		scan();
635		if (!isalpha(nextc))
636	<	syntax("illegal variable name");
636	>	syntax("illegal parameter name");
637		ep2 = newnode();
638		ep2->type = SYM;
639		ep2->v.name = savestr(getname());
#	Line 557 \| Line 643 \| *getdefn() / A -> SYM = E1 /*
643		syntax("')' expected");
644		scan();
645		curfunc = ep1;
646	<	} else
561	<	curfunc = NULL;
562	<	#endif
646	>	}
647
648		if (nextc != '=' && nextc != ':')
649		syntax("'=' or ':' expected");
#	Line 570 \| Line 654 \| *getdefn() / A -> SYM = E1 /*
654		addekid(ep2, ep1);
655		addekid(ep2, getE1());
656
657	<	if (
574	<	#ifdef FUNCTION
575	<	ep1->type == SYM &&
576	<	#endif
577	<	ep1->sibling->type != NUM) {
657	>	if (ep1->type == SYM && ep1->sibling->type != NUM) {
658		ep1 = newnode();
659	<	ep1->type = TICK;
660	<	ep1->v.tick = -1;
659	>	ep1->type = CLKT;
660	>	ep1->v.tick = 0;
661		addekid(ep2, ep1);
662		ep1 = newnode();
663		ep1->type = NUM;
664		addekid(ep2, ep1);
665		}
666	+	curfunc = NULL;
667
668		return(ep2);
669		}
670
671
591	–	#ifdef OUTCHAN
672		EPNODE *
673	<	getchan() /* A -> $N = E1 */
673	>	getchan(void) /* A -> $N = E1 */
674		{
675	<	register EPNODE ep1, ep2;
675	>	EPNODE ep1, ep2;
676
677		if (nextc != '$')
678		syntax("missing '$'");
#	Line 613 \| Line 693 \| *getchan() / A -> $N = E1 /*
693
694		return(ep2);
695		}
616	–	#endif
696
697
698
#	Line 622 \| Line 701 \| *getchan() / A -> $N = E1 /*
701		*/
702
703
704	<	static double
705	<	dvalue(name, d) /* evaluate a variable */
627	<	char *name;
628	<	EPNODE *d;
704	>	static double /* evaluate a variable */
705	>	dvalue(char name, EPNODE d)
706		{
707	<	register EPNODE ep1, ep2;
707	>	EPNODE ep1, ep2;
708
709		if (d == NULL \|\| d->v.kid->type != SYM) {
710		eputs(name);
#	Line 637 \| Line 714 \| *EPNODE d;**
714		ep1 = d->v.kid->sibling; /* get expression */
715		if (ep1->type == NUM)
716		return(ep1->v.num); /* return if number */
717	+	if (esupport&E_RCONST && d->type == ':') {
718	+	wputs(name);
719	+	wputs(": assigned non-constant value\n");
720	+	}
721		ep2 = ep1->sibling; /* check time */
722	<	if (ep2->v.tick < 0 \|\| ep2->v.tick < eclock) {
723	<	ep2->v.tick = d->type == ':' ? 1L<<30 : eclock;
722	>	if (eclock >= MAXCLOCK)
723	>	eclock = 1; /* wrap clock counter */
724	>	if (ep2->v.tick < MAXCLOCK &&
725	>	(ep2->v.tick == 0) \| (ep2->v.tick != eclock)) {
726	>	ep2->v.tick = d->type == ':' ? MAXCLOCK : eclock;
727		ep2 = ep2->sibling;
728		ep2->v.num = evalue(ep1); /* needs new value */
729		} else
730		ep2 = ep2->sibling; /* else reuse old value */
731
732		return(ep2->v.num);
649	–	}
650	–
651	–
652	–	static int
653	–	hash(s) /* hash a string */
654	–	register char *s;
655	–	{
656	–	register int rval = 0;
657	–
658	–	while (*s)
659	–	rval += *s++;
660	–
661	–	return(rval % NHASH);
733		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/common/caldefn.c (file contents): Revision 1.14 by greg, Thu Aug 8 12:12:16 1991 UTC vs. Revision 2.28 by greg, Thu Apr 2 18:00:34 2020 UTC

Diff Legend

Comparing ray/src/common/caldefn.c (file contents):
Revision 1.14 by greg, Thu Aug 8 12:12:16 1991 UTC vs.
Revision 2.28 by greg, Thu Apr 2 18:00:34 2020 UTC