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.8 by greg, Wed Apr 17 10:54:58 1991 UTC vs.
Revision 2.2 by greg, Thu Dec 19 14:45:47 1991 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1986 Regents of the University of California */
1	>	/* Copyright (c) 1991 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	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();
35	>	#ifndef atof
36	>	extern double  atof();
37	>	#endif
38	>	extern double  pow();
39		extern char  *fgets(), *savestr();
40		extern char  *emalloc(), *ecalloc();
41		extern EPNODE  *curfunc;
#	Line 78 | Line 78 | double  (*eoper[])() = {               /* expression operations */
78		esubtr,
79		0,
80		edivi,
81	<	0,0,0,0,0,0,0,0,0,0,0,0,0,
81	>	0,0,0,0,0,0,0,0,0,0,
82		ebotch,
83	+	0,0,
84	+	ebotch,
85		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
86		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
87		epow,
#	Line 324 | Line 326 | int  ln;
326		}
327
328
329	<	scan()                          /* scan next character */
329	>	getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
330	>	char  **fnp;
331	>	int  *lnp;
332	>	char  **spp;
333	>	FILE  **fpp;
334		{
335	+	if (fnp != NULL) *fnp = infile;
336	+	if (lnp != NULL) *lnp = lineno;
337	+	if (spp != NULL) *spp = linbuf+linepos;
338	+	if (fpp != NULL) *fpp = infp;
339	+	}
340	+
341	+
342	+	int
343	+	scan()                          /* scan next character, return literal next */
344	+	{
345	+	register int  lnext = 0;
346	+
347		do {
348		if (linbuf[linepos] == '\0')
349		if (infp == NULL || fgets(linbuf, MAXLINE, infp) == NULL)
#	Line 337 | Line 355 | scan()                         /* scan next character */
355		}
356		else
357		nextc = linbuf[linepos++];
358	+	if (!lnext)
359	+	lnext = nextc;
360		if (nextc == '{') {
361		scan();
362		while (nextc != '}')
#	Line 347 | Line 367 | scan()                         /* scan next character */
367		scan();
368		}
369		} while (isspace(nextc));
370	+	return(lnext);
371		}
372
373
#	Line 420 | Line 441 | char *
441		getname()                       /* scan an identifier */
442		{
443		static char  str[MAXWORD+1];
444	<	register int  i;
444	>	register int  i, lnext;
445
446	<	for (i = 0; i < MAXWORD && isid(nextc); i++, scan())
447	<	str[i] = nextc;
446	>	lnext = nextc;
447	>	for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
448	>	str[i] = lnext;
449		str[i] = '\0';
450	+	while (isid(lnext))         /* skip rest of name */
451	+	lnext = scan();
452
453		return(str);
454		}
#	Line 433 | Line 457 | getname()                      /* scan an identifier */
457		int
458		getinum()                       /* scan a positive integer */
459		{
460	<	register int  n;
460	>	register int  n, lnext;
461
462		n = 0;
463	<	while (isdigit(nextc)) {
464	<	n = n * 10 + nextc - '0';
465	<	scan();
463	>	lnext = nextc;
464	>	while (isdigit(lnext)) {
465	>	n = n * 10 + lnext - '0';
466	>	lnext = scan();
467		}
468		return(n);
469		}
#	Line 447 | Line 472 | getinum()                      /* scan a positive integer */
472		double
473		getnum()                        /* scan a positive float */
474		{
475	<	register int  i;
475	>	register int  i, lnext;
476		char  str[MAXWORD+1];
477
478		i = 0;
479	<	while (isdigit(nextc) && i < MAXWORD) {
480	<	str[i++] = nextc;
481	<	scan();
479	>	lnext = nextc;
480	>	while (isdigit(lnext) && i < MAXWORD) {
481	>	str[i++] = lnext;
482	>	lnext = scan();
483		}
484	<	if (nextc == '.' && i < MAXWORD) {
485	<	str[i++] = nextc;
486	<	scan();
487	<	while (isdigit(nextc) && i < MAXWORD) {
488	<	str[i++] = nextc;
489	<	scan();
484	>	if (lnext == '.' && i < MAXWORD) {
485	>	str[i++] = lnext;
486	>	lnext = scan();
487	>	while (isdigit(lnext) && i < MAXWORD) {
488	>	str[i++] = lnext;
489	>	lnext = scan();
490		}
491		}
492	<	if ((nextc == 'e' || nextc == 'E') && i < MAXWORD) {
493	<	str[i++] = nextc;
494	<	scan();
495	<	if ((nextc == '-' || nextc == '+') && i < MAXWORD) {
496	<	str[i++] = nextc;
497	<	scan();
492	>	if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
493	>	str[i++] = lnext;
494	>	lnext = scan();
495	>	if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
496	>	str[i++] = lnext;
497	>	lnext = scan();
498		}
499	<	while (isdigit(nextc) && i < MAXWORD) {
500	<	str[i++] = nextc;
501	<	scan();
499	>	while (isdigit(lnext) && i < MAXWORD) {
500	>	str[i++] = lnext;
501	>	lnext = scan();
502		}
503		}
504		str[i] = '\0';
#	Line 563 | Line 589 | getE4()                                /* E4 -> ADDOP E5 */
589		ep2->v.num = -ep2->v.num;
590		return(ep2);
591		}
592	+	if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
593	+	efree((char *)ep2);
594	+	return(ep2->v.kid);
595	+	}
596		ep1 = newnode();
597		ep1->type = UMINUS;
598		addekid(ep1, ep2);
#	Line 583 | Line 613 | getE5()                                /* E5 -> (E1) */
613		/*       ARG */
614		{
615		int  i;
616	+	char  *nam;
617		register EPNODE  *ep1, *ep2;
618
619		if (nextc == '(') {
#	Line 605 | Line 636 | getE5()                                /* E5 -> (E1) */
636		#endif
637
638		#if  defined(VARIABLE) || defined(FUNCTION)
639	<	if (isalpha(nextc)) {
640	<	ep1 = newnode();
610	<	ep1->type = VAR;
611	<	ep1->v.ln = varinsert(getname());
612	<
639	>	if (isalpha(nextc) || nextc == CNTXMARK) {
640	>	nam = getname();
641		#if  defined(VARIABLE) && defined(FUNCTION)
642	+	ep1 = NULL;
643		if (curfunc != NULL)
644		for (i = 1, ep2 = curfunc->v.kid->sibling;
645		ep2 != NULL; i++, ep2 = ep2->sibling)
646	<	if (!strcmp(ep2->v.name, ep1->v.ln->name)) {
618	<	epfree(ep1);
646	>	if (!strcmp(ep2->v.name, nam)) {
647		ep1 = newnode();
648		ep1->type = ARG;
649		ep1->v.chan = i;
650		break;
651		}
652	+	if (ep1 == NULL)
653		#endif
654	+	{
655	+	ep1 = newnode();
656	+	ep1->type = VAR;
657	+	ep1->v.ln = varinsert(nam);
658	+	}
659		#ifdef  FUNCTION
660		if (nextc == '(') {
661		ep2 = newnode();
#	Line 641 | Line 675 | getE5()                                /* E5 -> (E1) */
675		syntax("'(' expected");
676		#endif
677		#endif
678	+	#ifdef  RCONST
679	+	if (isconstvar(ep1))
680	+	ep1 = rconst(ep1);
681	+	#endif
682		return(ep1);
683		}
684		#endif
#	Line 672 | Line 710 | register EPNODE  *epar;
710
711		return(ep);
712		}
713	+
714	+
715	+	isconstvar(ep)                  /* is ep linked to a constant expression? */
716	+	register EPNODE  *ep;
717	+	{
718	+	#ifdef  VARIABLE
719	+	register EPNODE  *ep1;
720	+	#ifdef  FUNCTION
721	+
722	+	if (ep->type == FUNC) {
723	+	if (!isconstfun(ep->v.kid))
724	+	return(0);
725	+	for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
726	+	if (ep1->type != NUM && !isconstfun(ep1))
727	+	return(0);
728	+	return(1);
729	+	}
730	+	#endif
731	+	if (ep->type != VAR)
732	+	return(0);
733	+	ep1 = ep->v.ln->def;
734	+	if (ep1 == NULL || ep1->type != ':')
735	+	return(0);
736	+	#ifdef  FUNCTION
737	+	if (ep1->v.kid->type != SYM)
738	+	return(0);
739	+	#endif
740	+	return(1);
741	+	#else
742	+	return(ep->type == FUNC);
743	+	#endif
744	+	}
745	+
746	+
747	+	#if  defined(FUNCTION) && defined(VARIABLE)
748	+	isconstfun(ep)                  /* is ep linked to a constant function? */
749	+	register EPNODE  *ep;
750	+	{
751	+	register EPNODE  *dp;
752	+	register LIBR  *lp;
753	+
754	+	if (ep->type != VAR)
755	+	return(0);
756	+	dp = ep->v.ln->def;
757	+	if (dp != NULL && dp->type != ':')
758	+	return(0);
759	+	if ((dp == NULL || dp->v.kid->type != FUNC)
760	+	&& ((lp = liblookup(ep->v.ln->name)) == NULL
761	+	|| lp->atyp != ':'))
762	+	return(0);
763	+	return(1);
764	+	}
765	+	#endif
766		#endif

Diff Legend

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