ViewVC Help

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

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

Comparing ray/src/common/calexpr.c (file contents):
Revision 1.9 by greg, Tue Apr 23 15:26:26 1991 UTC vs.
Revision 1.12 by greg, Thu Aug 8 11:22:04 1991 UTC

#	Line 27 | Line 27 | static char SCCSid[] = "$SunId$ LBL";
27		#include  "calcomp.h"
28
29		#define  MAXLINE        256             /* maximum line length */
30	–	#define  MAXWORD        64              /* maximum word length */
30
31		#define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
32
34	–	#define  isid(c)        (isalnum(c) || (c) == '_' || (c) == '.')
35	–
33		#define  isdecimal(c)   (isdigit(c) || (c) == '.')
34
35		extern double  atof(), pow();
#	Line 326 | Line 323 | int  ln;
323		}
324
325
326	<	scan()                          /* scan next character */
326	>	int
327	>	scan()                          /* scan next character, return literal next */
328		{
329	+	register int  lnext = 0;
330	+
331		do {
332		if (linbuf[linepos] == '\0')
333		if (infp == NULL || fgets(linbuf, MAXLINE, infp) == NULL)
#	Line 339 | Line 339 | scan()                         /* scan next character */
339		}
340		else
341		nextc = linbuf[linepos++];
342	+	if (!lnext)
343	+	lnext = nextc;
344		if (nextc == '{') {
345		scan();
346		while (nextc != '}')
#	Line 349 | Line 351 | scan()                         /* scan next character */
351		scan();
352		}
353		} while (isspace(nextc));
354	+	return(lnext);
355		}
356
357
#	Line 422 | Line 425 | char *
425		getname()                       /* scan an identifier */
426		{
427		static char  str[MAXWORD+1];
428	<	register int  i;
428	>	register int  i, lnext;
429
430	<	for (i = 0; i < MAXWORD && isid(nextc); i++, scan())
431	<	str[i] = nextc;
430	>	lnext = nextc;
431	>	for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
432	>	str[i] = lnext;
433		str[i] = '\0';
434
435		return(str);
#	Line 435 | Line 439 | getname()                      /* scan an identifier */
439		int
440		getinum()                       /* scan a positive integer */
441		{
442	<	register int  n;
442	>	register int  n, lnext;
443
444		n = 0;
445	<	while (isdigit(nextc)) {
446	<	n = n * 10 + nextc - '0';
447	<	scan();
445	>	lnext = nextc;
446	>	while (isdigit(lnext)) {
447	>	n = n * 10 + lnext - '0';
448	>	lnext = scan();
449		}
450		return(n);
451		}
#	Line 449 | Line 454 | getinum()                      /* scan a positive integer */
454		double
455		getnum()                        /* scan a positive float */
456		{
457	<	register int  i;
457	>	register int  i, lnext;
458		char  str[MAXWORD+1];
459
460		i = 0;
461	<	while (isdigit(nextc) && i < MAXWORD) {
462	<	str[i++] = nextc;
463	<	scan();
461	>	lnext = nextc;
462	>	while (isdigit(lnext) && i < MAXWORD) {
463	>	str[i++] = lnext;
464	>	lnext = scan();
465		}
466	<	if (nextc == '.' && i < MAXWORD) {
467	<	str[i++] = nextc;
468	<	scan();
469	<	while (isdigit(nextc) && i < MAXWORD) {
470	<	str[i++] = nextc;
471	<	scan();
466	>	if (lnext == '.' && i < MAXWORD) {
467	>	str[i++] = lnext;
468	>	lnext = scan();
469	>	while (isdigit(lnext) && i < MAXWORD) {
470	>	str[i++] = lnext;
471	>	lnext = scan();
472		}
473		}
474	<	if ((nextc == 'e' || nextc == 'E') && i < MAXWORD) {
475	<	str[i++] = nextc;
476	<	scan();
477	<	if ((nextc == '-' || nextc == '+') && i < MAXWORD) {
478	<	str[i++] = nextc;
479	<	scan();
474	>	if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
475	>	str[i++] = lnext;
476	>	lnext = scan();
477	>	if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
478	>	str[i++] = lnext;
479	>	lnext = scan();
480		}
481	<	while (isdigit(nextc) && i < MAXWORD) {
482	<	str[i++] = nextc;
483	<	scan();
481	>	while (isdigit(lnext) && i < MAXWORD) {
482	>	str[i++] = lnext;
483	>	lnext = scan();
484		}
485		}
486		str[i] = '\0';
#	Line 680 | Line 686 | register EPNODE  *epar;
686		}
687
688
689	<	isconstvar(ep)                  /* is ep linked to a constant? */
689	>	isconstvar(ep)                  /* is ep linked to a constant expression? */
690		register EPNODE  *ep;
691		{
692		#ifdef  VARIABLE
693		register EPNODE  *ep1;
688	–
694		#ifdef  FUNCTION
695	+
696		if (ep->type == FUNC) {
697	<	if (ep->v.kid->type != VAR)
698	<	return(0);
693	<	ep1 = ep->v.kid->v.ln->def;
694	<	if (ep1 != NULL && ep1->type != ':')
695	<	return(0);
696	<	if ((ep1 == NULL || ep1->v.kid->type != FUNC)
697	<	&& liblookup(ep->v.kid->v.ln->name) == NULL)
698	<	return(0);
697	>	if (!isconstfun(ep->v.kid))
698	>	return(0);
699		for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
700	<	if (ep1->type != NUM)
700	>	if (ep1->type != NUM && !isconstfun(ep1))
701		return(0);
702		return(1);
703		}
#	Line 716 | Line 716 | register EPNODE  *ep;
716		return(ep->type == FUNC);
717		#endif
718		}
719	+
720	+
721	+	#if  defined(FUNCTION) && defined(VARIABLE)
722	+	isconstfun(ep)                  /* is ep linked to a constant function? */
723	+	register EPNODE  *ep;
724	+	{
725	+	register EPNODE  *dp;
726	+	register LIBR  *lp;
727	+
728	+	if (ep->type != VAR)
729	+	return(0);
730	+	dp = ep->v.ln->def;
731	+	if (dp != NULL && dp->type != ':')
732	+	return(0);
733	+	if ((dp == NULL || dp->v.kid->type != FUNC)
734	+	&& ((lp = liblookup(ep->v.ln->name)) == NULL
735	+	|| lp->atyp != ':'))
736	+	return(0);
737	+	return(1);
738	+	}
739	+	#endif
740		#endif

Diff Legend

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