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.7 by greg, Thu Feb 16 09:49:27 1995 UTC vs.
Revision 2.17 by schorsch, Thu Jul 3 22:41:44 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1992 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 "copyright.h"
29	+
30		#include  <stdio.h>
31
32	+	#include  <string.h>
33	+
34		#include  <ctype.h>
35
36		#include  "calcomp.h"
#	Line 38 | Line 43 | static char SCCSid[] = "$SunId$ LBL";
43
44		#define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
45
41	–	extern char  *ecalloc(), *emalloc(), *savestr(), *strcpy();
42	–
46		static double  dvalue();
47
48	<	long  eclock = -1;                      /* value storage timer */
48	>	#define  MAXCLOCK       (1L<<31)        /* clock wrap value */
49
50	<	static char  context[MAXWORD+1];        /* current context path */
50	>	unsigned long  eclock = 0;              /* value storage timer */
51
52	+	#define  MAXCNTX        1023            /* maximum context length */
53	+
54	+	static char  context[MAXCNTX+1];        /* current context path */
55	+
56		static VARDEF  *hashtbl[NHASH];         /* definition list */
57		static int  htndx;                      /* index for */
58		static VARDEF  *htpos;                  /* ...dfirst() and */
52	–	#ifdef  OUTCHAN
59		static EPNODE  *ochpos;                 /* ...dnext */
60		static EPNODE  *outchan;
55	–	#endif
61
62	<	#ifdef  FUNCTION
58	<	EPNODE  *curfunc;
62	>	EPNODE  *curfunc = NULL;
63		#define  dname(ep)      ((ep)->v.kid->type == SYM ? \
64		(ep)->v.kid->v.name : \
65		(ep)->v.kid->v.kid->v.name)
62	–	#else
63	–	#define  dname(ep)      ((ep)->v.kid->v.name)
64	–	#endif
66
67
68	<	fcompile(fname)                 /* get definitions from a file */
69	<	char  *fname;
68	>	void
69	>	fcompile(                       /* get definitions from a file */
70	>	char  *fname
71	>	)
72		{
73		FILE  *fp;
74
#	Line 84 | Line 87 | char  *fname;
87		}
88
89
90	<	scompile(str, fn, ln)           /* get definitions from a string */
91	<	char  *str;
92	<	char  *fn;
93	<	int  ln;
90	>	void
91	>	scompile(               /* get definitions from a string */
92	>	char  *str,
93	>	char  *fn,
94	>	int  ln
95	>	)
96		{
97		initstr(str, fn, ln);
98		while (nextc != EOF)
#	Line 96 | Line 101 | int  ln;
101
102
103		double
104	<	varvalue(vname)                 /* return a variable's value */
105	<	char  *vname;
104	>	varvalue(                       /* return a variable's value */
105	>	char  *vname
106	>	)
107		{
108		return(dvalue(vname, dlookup(vname)));
109		}
110
111
112		double
113	<	evariable(ep)                   /* evaluate a variable */
114	<	EPNODE  *ep;
113	>	evariable(                      /* evaluate a variable */
114	>	EPNODE  *ep
115	>	)
116		{
117		register VARDEF  *dp = ep->v.ln;
118
#	Line 113 | Line 120 | EPNODE *ep;
120		}
121
122
123	<	varset(vname, assign, val)      /* set a variable's value */
124	<	char  *vname;
125	<	int  assign;
126	<	double  val;
123	>	void
124	>	varset(         /* set a variable's value */
125	>	char  *vname,
126	>	int  assign,
127	>	double  val
128	>	)
129		{
130		char  *qname;
131		register EPNODE  *ep1, *ep2;
#	Line 147 | Line 156 | double val;
156		}
157
158
159	<	dclear(name)                    /* delete variable definitions of name */
160	<	char  *name;
159	>	void
160	>	dclear(                 /* delete variable definitions of name */
161	>	char  *name
162	>	)
163		{
164		register EPNODE  *ep;
165
#	Line 162 | Line 173 | char  *name;
173		}
174
175
176	<	dremove(name)                   /* delete all definitions of name */
177	<	char  *name;
176	>	void
177	>	dremove(                        /* delete all definitions of name */
178	>	char  *name
179	>	)
180		{
181		register EPNODE  *ep;
182
#	Line 172 | Line 185 | char  *name;
185		}
186
187
188	<	vardefined(name)        /* return non-zero if variable defined */
189	<	char  *name;
188	>	int
189	>	vardefined(     /* return non-zero if variable defined */
190	>	char  *name
191	>	)
192		{
193		register EPNODE  *dp;
194
#	Line 182 | Line 197 | char  *name;
197
198
199		char *
200	<	setcontext(ctx)                 /* set a new context path */
201	<	register char  *ctx;
200	>	setcontext(                     /* set a new context path */
201	>	register char  *ctx
202	>	)
203		{
204		register char  *cpp;
205
#	Line 198 | Line 214 | register char  *ctx;
214		cpp = context;                      /* start context with mark */
215		*cpp++ = CNTXMARK;
216		do {                                /* carefully copy new context */
217	<	if (cpp >= context+MAXWORD)
217	>	if (cpp >= context+MAXCNTX)
218		break;                      /* just copy what we can */
219		if (isid(*ctx))
220		*cpp++ = *ctx++;
#	Line 214 | Line 230 | register char  *ctx;
230
231
232		char *
233	<	pushcontext(ctx)                /* push on another context */
234	<	char  *ctx;
233	>	pushcontext(            /* push on another context */
234	>	char  *ctx
235	>	)
236		{
237	<	extern char  *strncpy(), *strcpy();
221	<	char  oldcontext[MAXWORD+1];
237	>	char  oldcontext[MAXCNTX+1];
238		register int  n;
239
240		strcpy(oldcontext, context);        /* save old context */
241		setcontext(ctx);                    /* set new context */
242		n = strlen(context);                /* tack on old */
243	<	if (n+strlen(oldcontext) > MAXWORD) {
244	<	strncpy(context+n, oldcontext, MAXWORD-n);
245	<	context[MAXWORD] = '\0';
243	>	if (n+strlen(oldcontext) > MAXCNTX) {
244	>	strncpy(context+n, oldcontext, MAXCNTX-n);
245	>	context[MAXCNTX] = '\0';
246		} else
247		strcpy(context+n, oldcontext);
248		return(context);
#	Line 234 | Line 250 | char  *ctx;
250
251
252		char *
253	<	popcontext()                    /* pop off top context */
253	>	popcontext(void)                        /* pop off top context */
254		{
255		register char  *cp1, *cp2;
256
#	Line 251 | Line 267 | popcontext()                   /* pop off top context */
267
268
269		char *
270	<	qualname(nam, lvl)              /* get qualified name */
271	<	register char  *nam;
272	<	int  lvl;
270	>	qualname(               /* get qualified name */
271	>	register char  *nam,
272	>	int  lvl
273	>	)
274		{
275	<	static char  nambuf[MAXWORD+1];
275	>	static char  nambuf[RMAXWORD+1];
276		register char  *cp = nambuf, *cpp;
277		/* check for explicit local */
278		if (*nam == CNTXMARK)
#	Line 267 | Line 284 | int  lvl;
284		return(lvl > 0 ? NULL : nam);
285		/* copy name to static buffer */
286		while (*nam) {
287	<	if (cp >= nambuf+MAXWORD)
287	>	if (cp >= nambuf+RMAXWORD)
288		goto toolong;
289		*cp++ = *nam++;
290		}
#	Line 286 | Line 303 | int  lvl;
303		;
304		}
305		while (*cpp) {              /* copy context to static buffer */
306	<	if (cp >= nambuf+MAXWORD)
306	>	if (cp >= nambuf+RMAXWORD)
307		goto toolong;
308		*cp++ = *cpp++;
309		}
#	Line 296 | Line 313 | toolong:
313		}
314
315
316	<	incontext(qn)                   /* is qualified name in current context? */
317	<	register char  *qn;
316	>	int
317	>	incontext(                      /* is qualified name in current context? */
318	>	register char  *qn
319	>	)
320		{
321	+	if (!context[0])                    /* global context accepts all */
322	+	return(1);
323		while (*qn && *qn != CNTXMARK)      /* find context mark */
324		qn++;
325		return(!strcmp(qn, context));
326		}
327
328
329	<	#ifdef  OUTCHAN
330	<	chanout(cs)                     /* set output channels */
331	<	int  (*cs)();
329	>	void
330	>	chanout(                        /* set output channels */
331	>	void  (*cs)(int n, double v)
332	>	)
333		{
334		register EPNODE  *ep;
335
#	Line 315 | Line 337 | int  (*cs)();
337		(*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
338
339		}
318	–	#endif
340
341
342	<	dcleanup(lvl)           /* clear definitions (0->vars,1->output,2->consts) */
343	<	int  lvl;
342	>	void
343	>	dcleanup(               /* clear definitions (0->vars,1->output,2->consts) */
344	>	int  lvl
345	>	)
346		{
347		register int  i;
348		register VARDEF  *vp;
#	Line 327 | Line 350 | int  lvl;
350		/* if context is global, clear all */
351		for (i = 0; i < NHASH; i++)
352		for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
353	<	if (!context[0] || incontext(vp->name))
353	>	if (incontext(vp->name))
354		if (lvl >= 2)
355		dremove(vp->name);
356		else
357		dclear(vp->name);
335	–	#ifdef  OUTCHAN
358		if (lvl >= 1) {
359		for (ep = outchan; ep != NULL; ep = ep->sibling)
360		epfree(ep);
361		outchan = NULL;
362		}
341	–	#endif
363		}
364
365
366		EPNODE *
367	<	dlookup(name)                   /* look up a definition */
368	<	char  *name;
367	>	dlookup(                        /* look up a definition */
368	>	char  *name
369	>	)
370		{
371		register VARDEF  *vp;
372
#	Line 355 | Line 377 | char  *name;
377
378
379		VARDEF *
380	<	varlookup(name)                 /* look up a variable */
381	<	char  *name;
380	>	varlookup(                      /* look up a variable */
381	>	char  *name
382	>	)
383		{
384		int  lvl = 0;
385		register char  *qname;
#	Line 371 | Line 394 | char  *name;
394
395
396		VARDEF *
397	<	varinsert(name)                 /* get a link to a variable */
398	<	char  *name;
397	>	varinsert(                      /* get a link to a variable */
398	>	char  *name
399	>	)
400		{
401		register VARDEF  *vp;
402		int  hv;
#	Line 382 | Line 406 | char  *name;
406		return(vp);
407		}
408		vp = (VARDEF *)emalloc(sizeof(VARDEF));
385	–	#ifdef  FUNCTION
409		vp->lib = liblookup(name);
387	–	#else
388	–	vp->lib = NULL;
389	–	#endif
410		if (vp->lib == NULL)                /* if name not in library */
411		name = qualname(name, 0);       /* use fully qualified version */
412		hv = hash(name);
#	Line 399 | Line 419 | char  *name;
419		}
420
421
422	<	#ifdef  FUNCTION
423	<	libupdate(fn)                   /* update library links */
424	<	char  *fn;
422	>	void
423	>	libupdate(                      /* update library links */
424	>	char  *fn
425	>	)
426		{
427		register int  i;
428		register VARDEF  *vp;
#	Line 411 | Line 432 | char  *fn;
432		if (vp->lib != NULL || fn == NULL || !strcmp(fn, vp->name))
433		vp->lib = liblookup(vp->name);
434		}
414	–	#endif
435
436
437	<	varfree(ln)                             /* release link to variable */
438	<	register VARDEF  *ln;
437	>	void
438	>	varfree(                                /* release link to variable */
439	>	register VARDEF  *ln
440	>	)
441		{
442		register VARDEF  *vp;
443		int  hv;
#	Line 438 | Line 460 | register VARDEF         *ln;
460
461
462		EPNODE *
463	<	dfirst()                        /* return pointer to first definition */
463	>	dfirst(void)                    /* return pointer to first definition */
464		{
465		htndx = 0;
466		htpos = NULL;
445	–	#ifdef  OUTCHAN
467		ochpos = outchan;
447	–	#endif
468		return(dnext());
469		}
470
471
472		EPNODE *
473	<	dnext()                         /* return pointer to next definition */
473	>	dnext(void)                             /* return pointer to next definition */
474		{
475		register EPNODE  *ep;
476		register char  *nm;
#	Line 466 | Line 486 | dnext()                                /* return pointer to next definition */
486		return(ep);
487		}
488		}
469	–	#ifdef  OUTCHAN
489		if ((ep = ochpos) != NULL)
490		ochpos = ep->sibling;
491		return(ep);
473	–	#else
474	–	return(NULL);
475	–	#endif
492		}
493
494
495		EPNODE *
496	<	dpop(name)                      /* pop a definition */
497	<	char  *name;
496	>	dpop(                   /* pop a definition */
497	>	char  *name
498	>	)
499		{
500		register VARDEF  *vp;
501		register EPNODE  *dp;
#	Line 492 | Line 509 | char  *name;
509		}
510
511
512	<	dpush(nm, ep)                   /* push on a definition */
513	<	char  *nm;
514	<	register EPNODE  *ep;
512	>	void
513	>	dpush(                  /* push on a definition */
514	>	char  *nm,
515	>	register EPNODE  *ep
516	>	)
517		{
518		register VARDEF  *vp;
519
#	Line 504 | Line 523 | register EPNODE         *ep;
523		}
524
525
526	<	#ifdef  OUTCHAN
527	<	addchan(sp)                     /* add an output channel assignment */
528	<	EPNODE  *sp;
526	>	void
527	>	addchan(                        /* add an output channel assignment */
528	>	EPNODE  *sp
529	>	)
530		{
531		int  ch = sp->v.kid->v.chan;
532		register EPNODE  *ep, *epl;
#	Line 532 | Line 552 | EPNODE *sp;
552		sp->sibling = NULL;
553
554		}
535	–	#endif
555
556
557	<	getstatement()                  /* get next statement */
557	>	void
558	>	getstatement(void)                      /* get next statement */
559		{
560		register EPNODE  *ep;
561		char  *qname;
#	Line 545 | Line 565 | getstatement()                 /* get next statement */
565		scan();
566		return;
567		}
568	<	#ifdef  OUTCHAN
569	<	if (nextc == '$') {         /* channel assignment */
568	>	if (esupport&E_OUTCHAN &&
569	>	nextc == '$') {         /* channel assignment */
570		ep = getchan();
571		addchan(ep);
572	<	} else
553	<	#endif
554	<	{                           /* ordinary definition */
572	>	} else {                            /* ordinary definition */
573		ep = getdefn();
574		qname = qualname(dname(ep), 0);
575	<	#ifdef  REDEFW
558	<	if ((vdef = varlookup(qname)) != NULL)
575	>	if (esupport&E_REDEFW && (vdef = varlookup(qname)) != NULL)
576		if (vdef->def != NULL && epcmp(ep, vdef->def)) {
577		wputs(qname);
578		if (vdef->def->type == ':')
579		wputs(": redefined constant expression\n");
580		else
581		wputs(": redefined\n");
582	<	}
566	<	#ifdef  FUNCTION
567	<	else if (ep->v.kid->type == FUNC && vdef->lib != NULL) {
582	>	} else if (ep->v.kid->type == FUNC && vdef->lib != NULL) {
583		wputs(qname);
584		wputs(": definition hides library function\n");
585		}
571	–	#endif
572	–	#endif
586		if (ep->type == ':')
587		dremove(qname);
588		else
#	Line 585 | Line 598 | getstatement()                 /* get next statement */
598
599
600		EPNODE *
601	<	getdefn()                       /* A -> SYM = E1 */
602	<	/*      SYM : E1 */
603	<	/*      FUNC(SYM,..) = E1 */
604	<	/*      FUNC(SYM,..) : E1 */
601	>	getdefn(void)
602	>	/* A -> SYM = E1 */
603	>	/*      SYM : E1 */
604	>	/*      FUNC(SYM,..) = E1 */
605	>	/*      FUNC(SYM,..) : E1 */
606		{
607		register EPNODE  *ep1, *ep2;
608
#	Line 599 | Line 613 | getdefn()                      /* A -> SYM = E1 */
613		ep1->type = SYM;
614		ep1->v.name = savestr(getname());
615
616	<	#ifdef  FUNCTION
603	<	if (nextc == '(') {
616	>	if (esupport&E_FUNCTION && nextc == '(') {
617		ep2 = newnode();
618		ep2->type = FUNC;
619		addekid(ep2, ep1);
#	Line 618 | Line 631 | getdefn()                      /* A -> SYM = E1 */
631		syntax("')' expected");
632		scan();
633		curfunc = ep1;
634	<	} else
622	<	curfunc = NULL;
623	<	#endif
634	>	}
635
636		if (nextc != '=' && nextc != ':')
637		syntax("'=' or ':' expected");
#	Line 631 | Line 642 | getdefn()                      /* A -> SYM = E1 */
642		addekid(ep2, ep1);
643		addekid(ep2, getE1());
644
645	<	if (
635	<	#ifdef  FUNCTION
636	<	ep1->type == SYM &&
637	<	#endif
638	<	ep1->sibling->type != NUM) {
645	>	if (ep1->type == SYM && ep1->sibling->type != NUM) {
646		ep1 = newnode();
647		ep1->type = TICK;
648	<	ep1->v.tick = -1;
648	>	ep1->v.tick = 0;
649		addekid(ep2, ep1);
650		ep1 = newnode();
651		ep1->type = NUM;
652		addekid(ep2, ep1);
653		}
654	+	curfunc = NULL;
655
656		return(ep2);
657		}
658
659
652	–	#ifdef  OUTCHAN
660		EPNODE *
661	<	getchan()                       /* A -> $N = E1 */
661	>	getchan(void)                   /* A -> $N = E1 */
662		{
663		register EPNODE  *ep1, *ep2;
664
#	Line 674 | Line 681 | getchan()                      /* A -> $N = E1 */
681
682		return(ep2);
683		}
677	–	#endif
684
685
686
#	Line 684 | Line 690 | getchan()                      /* A -> $N = E1 */
690
691
692		static double
693	<	dvalue(name, d)                 /* evaluate a variable */
694	<	char  *name;
695	<	EPNODE  *d;
693	>	dvalue(                 /* evaluate a variable */
694	>	char  *name,
695	>	EPNODE  *d
696	>	)
697		{
698		register EPNODE  *ep1, *ep2;
699
#	Line 699 | Line 706 | EPNODE *d;
706		if (ep1->type == NUM)
707		return(ep1->v.num);                     /* return if number */
708		ep2 = ep1->sibling;                         /* check time */
709	<	if (ep2->v.tick < 0 || ep2->v.tick < eclock) {
710	<	ep2->v.tick = d->type == ':' ? 1L<<30 : eclock;
709	>	if (eclock >= MAXCLOCK)
710	>	eclock = 1;                             /* wrap clock counter */
711	>	if (ep2->v.tick < MAXCLOCK &&
712	>	ep2->v.tick == 0 | ep2->v.tick != eclock) {
713	>	ep2->v.tick = d->type == ':' ? MAXCLOCK : eclock;
714		ep2 = ep2->sibling;
715		ep2->v.num = evalue(ep1);               /* needs new value */
716		} else

Diff Legend

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