ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/calexpr.c
(Generate patch)

Comparing ray/src/common/calexpr.c (file contents):
Revision 2.1 by greg, Tue Nov 12 16:55:21 1991 UTC vs.
Revision 2.24 by schorsch, Thu Jul 17 09:21:29 2003 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   *  Compute data values using expression parser
6   *
# Line 16 | Line 13 | static char SCCSid[] = "$SunId$ LBL";
13   *  1/29/87  Made variables conditional (VARIABLE)
14   *
15   *  5/19/88  Added constant subexpression elimination (RCONST)
16 + *
17 + *  2/19/03     Eliminated conditional compiles in favor of esupport extern.
18   */
19  
20 < #include  <stdio.h>
20 > #include "copyright.h"
21  
22 + #include  <stdio.h>
23 + #include  <string.h>
24   #include  <ctype.h>
24 –
25   #include  <errno.h>
26 + #include  <math.h>
27 + #include  <stdlib.h>
28  
29 + #include  "rterror.h"
30   #include  "calcomp.h"
31  
32 < #define  MAXLINE        256             /* maximum line length */
32 > #define  MAXLINE        256             /* maximum line length */
33  
34 < #define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
34 > #define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
35  
36 < #define  isdecimal(c)   (isdigit(c) || (c) == '.')
36 > #define  isdecimal(c)   (isdigit(c) || (c) == '.')
37  
38 < extern double  atof(), pow();
39 < extern char  *fgets(), *savestr();
40 < extern char  *emalloc(), *ecalloc();
41 < extern EPNODE  *curfunc;
42 < extern double  efunc(), evariable();
43 < static double  euminus(), echannel(), eargument(), enumber();
41 < static double  eadd(), esubtr(), emult(), edivi(), epow();
42 < static double  ebotch();
43 < extern int  errno;
38 > static double  euminus(EPNODE *), eargument(EPNODE *), enumber(EPNODE *);
39 > static double  echannel(EPNODE *);
40 > static double  eadd(EPNODE *), esubtr(EPNODE *),
41 >               emult(EPNODE *), edivi(EPNODE *),
42 >               epow(EPNODE *);
43 > static double  ebotch(EPNODE *);
44  
45 + unsigned int  esupport =                /* what to support */
46 +                E_VARIABLE | E_FUNCTION ;
47 +
48   int  nextc;                             /* lookahead character */
49  
50 < double  (*eoper[])() = {                /* expression operations */
50 > double  (*eoper[])() = {                /* expression operations */
51          ebotch,
49 – #ifdef  VARIABLE
52          evariable,
51 – #else
52 –        ebotch,
53 – #endif
53          enumber,
54          euminus,
56 – #ifdef  INCHAN
55          echannel,
58 – #else
59 –        ebotch,
60 – #endif
61 – #ifdef  FUNCTION
56          efunc,
57          eargument,
64 – #else
58          ebotch,
59          ebotch,
67 – #endif
68 –        ebotch,
69 –        ebotch,
60          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
61          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
62          emult,
# Line 98 | Line 88 | char  *expr;
88      EPNODE  *ep;
89  
90      initstr(expr, NULL, 0);
101 – #if  defined(VARIABLE) && defined(FUNCTION)
91      curfunc = NULL;
103 – #endif
92      ep = getE1();
93      if (nextc != EOF)
94          syntax("unexpected character");
# Line 122 | Line 110 | char  *expr;
110   }
111  
112  
113 + int
114 + epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
115 + register EPNODE  *ep1, *ep2;
116 + {
117 +        double  d;
118 +
119 +        if (ep1->type != ep2->type)
120 +                return(1);
121 +
122 +        switch (ep1->type) {
123 +
124 +        case VAR:
125 +                return(ep1->v.ln != ep2->v.ln);
126 +
127 +        case NUM:
128 +                if (ep2->v.num == 0)
129 +                        return(ep1->v.num != 0);
130 +                d = ep1->v.num / ep2->v.num;
131 +                return(d > 1.000000000001 | d < 0.999999999999);
132 +
133 +        case CHAN:
134 +        case ARG:
135 +                return(ep1->v.chan != ep2->v.chan);
136 +
137 +        case '=':
138 +        case ':':
139 +                return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
140 +
141 +        case TICK:
142 +        case SYM:                       /* should never get this one */
143 +                return(0);
144 +
145 +        default:
146 +                ep1 = ep1->v.kid;
147 +                ep2 = ep2->v.kid;
148 +                while (ep1 != NULL) {
149 +                        if (ep2 == NULL)
150 +                                return(1);
151 +                        if (epcmp(ep1, ep2))
152 +                                return(1);
153 +                        ep1 = ep1->sibling;
154 +                        ep2 = ep2->sibling;
155 +                }
156 +                return(ep2 != NULL);
157 +        }
158 + }
159 +
160 +
161 + void
162   epfree(epar)                    /* free a parse tree */
163 < register EPNODE  *epar;
163 > register EPNODE  *epar;
164   {
165      register EPNODE  *ep;
166  
167      switch (epar->type) {
168  
132 – #if  defined(VARIABLE) || defined(FUNCTION)
169          case VAR:
170              varfree(epar->v.ln);
171              break;
136 – #endif
172              
173          case SYM:
174              freestr(epar->v.name);
# Line 146 | Line 181 | register EPNODE  *epar;
181              break;
182  
183          default:
184 <            for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
184 >            while ((ep = epar->v.kid) != NULL) {
185 >                epar->v.kid = ep->sibling;
186                  epfree(ep);
187 +            }
188              break;
189  
190      }
# Line 156 | Line 193 | register EPNODE  *epar;
193   }
194  
195                                  /* the following used to be a switch */
159 – #ifdef  FUNCTION
196   static double
197   eargument(ep)
198 < EPNODE  *ep;
198 > EPNODE  *ep;
199   {
200      return(argument(ep->v.chan));
201   }
166 – #endif
202  
203   static double
204   enumber(ep)
205 < EPNODE  *ep;
205 > EPNODE  *ep;
206   {
207      return(ep->v.num);
208   }
209  
210   static double
211   euminus(ep)
212 < EPNODE  *ep;
212 > EPNODE  *ep;
213   {
214      register EPNODE  *ep1 = ep->v.kid;
215  
216      return(-evalue(ep1));
217   }
218  
184 – #ifdef  INCHAN
219   static double
220   echannel(ep)
221 < EPNODE  *ep;
221 > EPNODE  *ep;
222   {
223      return(chanvalue(ep->v.chan));
224   }
191 – #endif
225  
226   static double
227   eadd(ep)
228 < EPNODE  *ep;
228 > EPNODE  *ep;
229   {
230      register EPNODE  *ep1 = ep->v.kid;
231  
# Line 201 | Line 234 | EPNODE  *ep;
234  
235   static double
236   esubtr(ep)
237 < EPNODE  *ep;
237 > EPNODE  *ep;
238   {
239      register EPNODE  *ep1 = ep->v.kid;
240  
# Line 210 | Line 243 | EPNODE  *ep;
243  
244   static double
245   emult(ep)
246 < EPNODE  *ep;
246 > EPNODE  *ep;
247   {
248      register EPNODE  *ep1 = ep->v.kid;
249  
# Line 219 | Line 252 | EPNODE  *ep;
252  
253   static double
254   edivi(ep)
255 < EPNODE  *ep;
255 > EPNODE  *ep;
256   {
257      register EPNODE  *ep1 = ep->v.kid;
258      double  d;
# Line 235 | Line 268 | EPNODE  *ep;
268  
269   static double
270   epow(ep)
271 < EPNODE  *ep;
271 > EPNODE  *ep;
272   {
273      register EPNODE  *ep1 = ep->v.kid;
274      double  d;
275 <    int  lasterrno;
275 >    int  lasterrno;
276  
277      lasterrno = errno;
278      errno = 0;
279      d = pow(evalue(ep1), evalue(ep1->sibling));
280 < #ifdef  IEEE
280 > #ifdef  IEEE
281      if (!finite(d))
282          errno = EDOM;
283   #endif
284 <    if (errno) {
284 >    if (errno == EDOM || errno == ERANGE) {
285          wputs("Illegal power\n");
286          return(0.0);
287      }
# Line 258 | Line 291 | EPNODE  *ep;
291  
292   static double
293   ebotch(ep)
294 < EPNODE  *ep;
294 > EPNODE  *ep;
295   {
296      eputs("Bad expression!\n");
297      quit(1);
298 +        return 0.0; /* pro forma return */
299   }
300  
301  
302   EPNODE *
303   ekid(ep, n)                     /* return pointer to a node's nth kid */
304 < register EPNODE  *ep;
304 > register EPNODE  *ep;
305   register int  n;
306   {
307  
# Line 281 | Line 315 | register int  n;
315  
316   int
317   nekids(ep)                      /* return # of kids for node ep */
318 < register EPNODE  *ep;
318 > register EPNODE  *ep;
319   {
320      register int  n = 0;
321  
# Line 292 | Line 326 | register EPNODE  *ep;
326   }
327  
328  
329 + void
330   initfile(fp, fn, ln)            /* prepare input file */
331   FILE  *fp;
332   char  *fn;
333   int  ln;
334   {
335 <    static char  inpbuf[MAXLINE];
335 >    static char  inpbuf[MAXLINE];
336  
337      infp = fp;
338      linbuf = inpbuf;
# Line 309 | Line 344 | int  ln;
344   }
345  
346  
347 + void
348   initstr(s, fn, ln)              /* prepare input string */
349   char  *s;
350   char  *fn;
# Line 323 | Line 359 | int  ln;
359   }
360  
361  
362 + void
363   getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
364   char  **fnp;
365   int  *lnp;
# Line 369 | Line 406 | scan()                         /* scan next character, return literal next
406  
407  
408   char *
409 < ltoa(l)                         /* convert long to ascii */
409 > long2ascii(l)                         /* convert long to ascii */
410   long  l;
411   {
412 <    static char  buf[16];
412 >    static char  buf[16];
413      register char  *cp;
414 <    int  neg = 0;
414 >    int  neg = 0;
415  
416      if (l == 0)
417          return("0");
# Line 394 | Line 431 | long  l;
431   }
432  
433  
434 + void
435   syntax(err)                     /* report syntax error and quit */
436   char  *err;
437   {
# Line 403 | Line 441 | char  *err;
441          if (infile != NULL) eputs(infile);
442          if (lineno != 0) {
443              eputs(infile != NULL ? ", line " : "line ");
444 <            eputs(ltoa((long)lineno));
444 >            eputs(long2ascii((long)lineno));
445          }
446 <        eputs(": syntax error:\n");
446 >        eputs(":\n");
447      }
448      eputs(linbuf);
449      if (linbuf[strlen(linbuf)-1] != '\n')
# Line 419 | Line 457 | char  *err;
457   }
458  
459  
460 + void
461   addekid(ep, ekid)                       /* add a child to ep */
462 < register EPNODE  *ep;
463 < EPNODE  *ekid;
462 > register EPNODE  *ep;
463 > EPNODE  *ekid;
464   {
465      if (ep->v.kid == NULL)
466          ep->v.kid = ekid;
# Line 437 | Line 476 | EPNODE  *ekid;
476   char *
477   getname()                       /* scan an identifier */
478   {
479 <    static char  str[MAXWORD+1];
479 >    static char  str[RMAXWORD+1];
480      register int  i, lnext;
481  
482      lnext = nextc;
483 <    for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
483 >    for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
484          str[i] = lnext;
485      str[i] = '\0';
486      while (isid(lnext))         /* skip rest of name */
# Line 470 | Line 509 | double
509   getnum()                        /* scan a positive float */
510   {
511      register int  i, lnext;
512 <    char  str[MAXWORD+1];
512 >    char  str[RMAXWORD+1];
513  
514      i = 0;
515      lnext = nextc;
516 <    while (isdigit(lnext) && i < MAXWORD) {
516 >    while (isdigit(lnext) && i < RMAXWORD) {
517          str[i++] = lnext;
518          lnext = scan();
519      }
520 <    if (lnext == '.' && i < MAXWORD) {
521 <        str[i++] = lnext;
522 <        lnext = scan();
523 <        while (isdigit(lnext) && i < MAXWORD) {
520 >    if (lnext == '.' && i < RMAXWORD) {
521 >        str[i++] = lnext;
522 >        lnext = scan();
523 >        if (i == 1 && !isdigit(lnext))
524 >            syntax("badly formed number");
525 >        while (isdigit(lnext) && i < RMAXWORD) {
526              str[i++] = lnext;
527              lnext = scan();
528          }
529      }
530 <    if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
531 <        str[i++] = lnext;
532 <        lnext = scan();
533 <        if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
530 >    if ((lnext == 'e' | lnext == 'E') && i < RMAXWORD) {
531 >        str[i++] = lnext;
532 >        lnext = scan();
533 >        if ((lnext == '-' | lnext == '+') && i < RMAXWORD) {
534              str[i++] = lnext;
535              lnext = scan();
536          }
537 <        while (isdigit(lnext) && i < MAXWORD) {
537 >        if (!isdigit(lnext))
538 >            syntax("missing exponent");
539 >        while (isdigit(lnext) && i < RMAXWORD) {
540              str[i++] = lnext;
541              lnext = scan();
542          }
# Line 506 | Line 549 | getnum()                       /* scan a positive float */
549  
550   EPNODE *
551   getE1()                         /* E1 -> E1 ADDOP E2 */
552 <                                /*       E2 */
552 >                                /*       E2 */
553   {
554      register EPNODE  *ep1, *ep2;
555  
# Line 517 | Line 560 | getE1()                                /* E1 -> E1 ADDOP E2 */
560          scan();
561          addekid(ep2, ep1);
562          addekid(ep2, getE2());
563 < #ifdef  RCONST
564 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
563 >        if (esupport&E_RCONST &&
564 >                        ep1->type == NUM && ep1->sibling->type == NUM)
565                  ep2 = rconst(ep2);
523 – #endif
566          ep1 = ep2;
567      }
568      return(ep1);
# Line 529 | Line 571 | getE1()                                /* E1 -> E1 ADDOP E2 */
571  
572   EPNODE *
573   getE2()                         /* E2 -> E2 MULOP E3 */
574 <                                /*       E3 */
574 >                                /*       E3 */
575   {
576      register EPNODE  *ep1, *ep2;
577  
# Line 540 | Line 582 | getE2()                                /* E2 -> E2 MULOP E3 */
582          scan();
583          addekid(ep2, ep1);
584          addekid(ep2, getE3());
585 < #ifdef  RCONST
586 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
585 >        if (esupport&E_RCONST &&
586 >                        ep1->type == NUM && ep1->sibling->type == NUM)
587                  ep2 = rconst(ep2);
546 – #endif
588          ep1 = ep2;
589      }
590      return(ep1);
# Line 552 | Line 593 | getE2()                                /* E2 -> E2 MULOP E3 */
593  
594   EPNODE *
595   getE3()                         /* E3 -> E4 ^ E3 */
596 <                                /*       E4 */
596 >                                /*       E4 */
597   {
598      register EPNODE  *ep1, *ep2;
599  
# Line 563 | Line 604 | getE3()                                /* E3 -> E4 ^ E3 */
604          scan();
605          addekid(ep2, ep1);
606          addekid(ep2, getE3());
607 < #ifdef  RCONST
608 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
607 >        if (esupport&E_RCONST &&
608 >                        ep1->type == NUM && ep1->sibling->type == NUM)
609                  ep2 = rconst(ep2);
569 – #endif
610          return(ep2);
611      }
612      return(ep1);
# Line 575 | Line 615 | getE3()                                /* E3 -> E4 ^ E3 */
615  
616   EPNODE *
617   getE4()                         /* E4 -> ADDOP E5 */
618 <                                /*       E5 */
618 >                                /*       E5 */
619   {
620      register EPNODE  *ep1, *ep2;
621  
# Line 603 | Line 643 | getE4()                                /* E4 -> ADDOP E5 */
643  
644   EPNODE *
645   getE5()                         /* E5 -> (E1) */
646 <                                /*       VAR */
647 <                                /*       NUM */
648 <                                /*       $N */
649 <                                /*       FUNC(E1,..) */
650 <                                /*       ARG */
646 >                                /*       VAR */
647 >                                /*       NUM */
648 >                                /*       $N */
649 >                                /*       FUNC(E1,..) */
650 >                                /*       ARG */
651   {
652 <    int  i;
653 <    char  *nam;
654 <    register EPNODE  *ep1, *ep2;
652 >        int      i;
653 >        char  *nam;
654 >        register EPNODE  *ep1, *ep2;
655  
656 <    if (nextc == '(') {
657 <        scan();
658 <        ep1 = getE1();
659 <        if (nextc != ')')
660 <            syntax("')' expected");
661 <        scan();
662 <        return(ep1);
663 <    }
656 >        if (nextc == '(') {
657 >                scan();
658 >                ep1 = getE1();
659 >                if (nextc != ')')
660 >                        syntax("')' expected");
661 >                scan();
662 >                return(ep1);
663 >        }
664  
665 < #ifdef  INCHAN
666 <    if (nextc == '$') {
667 <        scan();
668 <        ep1 = newnode();
669 <        ep1->type = CHAN;
670 <        ep1->v.chan = getinum();
671 <        return(ep1);
632 <    }
633 < #endif
665 >        if (esupport&E_INCHAN && nextc == '$') {
666 >                scan();
667 >                ep1 = newnode();
668 >                ep1->type = CHAN;
669 >                ep1->v.chan = getinum();
670 >                return(ep1);
671 >        }
672  
673 < #if  defined(VARIABLE) || defined(FUNCTION)
674 <    if (isalpha(nextc) || nextc == CNTXMARK) {
675 <        nam = getname();
676 < #if  defined(VARIABLE) && defined(FUNCTION)
677 <        ep1 = NULL;
678 <        if (curfunc != NULL)
679 <            for (i = 1, ep2 = curfunc->v.kid->sibling;
680 <                                ep2 != NULL; i++, ep2 = ep2->sibling)
681 <                if (!strcmp(ep2->v.name, nam)) {
682 <                    ep1 = newnode();
683 <                    ep1->type = ARG;
684 <                    ep1->v.chan = i;
685 <                    break;
673 >        if (esupport&(E_VARIABLE|E_FUNCTION) &&
674 >                        (isalpha(nextc) || nextc == CNTXMARK)) {
675 >                nam = getname();
676 >                ep1 = NULL;
677 >                if ((esupport&(E_VARIABLE|E_FUNCTION)) == (E_VARIABLE|E_FUNCTION)
678 >                                && curfunc != NULL)
679 >                        for (i = 1, ep2 = curfunc->v.kid->sibling;
680 >                                        ep2 != NULL; i++, ep2 = ep2->sibling)
681 >                                if (!strcmp(ep2->v.name, nam)) {
682 >                                        ep1 = newnode();
683 >                                        ep1->type = ARG;
684 >                                        ep1->v.chan = i;
685 >                                        break;
686 >                                }
687 >                if (ep1 == NULL) {
688 >                        ep1 = newnode();
689 >                        ep1->type = VAR;
690 >                        ep1->v.ln = varinsert(nam);
691                  }
692 <        if (ep1 == NULL)
693 < #endif
694 <        {
695 <            ep1 = newnode();
696 <            ep1->type = VAR;
697 <            ep1->v.ln = varinsert(nam);
692 >                if (esupport&E_FUNCTION && nextc == '(') {
693 >                        ep2 = newnode();
694 >                        ep2->type = FUNC;
695 >                        addekid(ep2, ep1);
696 >                        ep1 = ep2;
697 >                        do {
698 >                                scan();
699 >                                addekid(ep1, getE1());
700 >                        } while (nextc == ',');
701 >                        if (nextc != ')')
702 >                                syntax("')' expected");
703 >                        scan();
704 >                } else if (!(esupport&E_VARIABLE))
705 >                        syntax("'(' expected");
706 >                if (esupport&E_RCONST && isconstvar(ep1))
707 >                        ep1 = rconst(ep1);
708 >                return(ep1);
709          }
656 – #ifdef  FUNCTION
657 –        if (nextc == '(') {
658 –            ep2 = newnode();
659 –            ep2->type = FUNC;
660 –            addekid(ep2, ep1);
661 –            ep1 = ep2;
662 –            do {
663 –                scan();
664 –                addekid(ep1, getE1());
665 –            } while (nextc == ',');
666 –            if (nextc != ')')
667 –                syntax("')' expected");
668 –            scan();
669 –        }
670 – #ifndef  VARIABLE
671 –        else
672 –            syntax("'(' expected");
673 – #endif
674 – #endif
675 – #ifdef  RCONST
676 –        if (isconstvar(ep1))
677 –            ep1 = rconst(ep1);
678 – #endif
679 –        return(ep1);
680 –    }
681 – #endif
710  
711 <    if (isdecimal(nextc)) {
712 <        ep1 = newnode();
713 <        ep1->type = NUM;
714 <        ep1->v.num = getnum();
715 <        return(ep1);
716 <    }
717 <    syntax("unexpected character");
711 >        if (isdecimal(nextc)) {
712 >                ep1 = newnode();
713 >                ep1->type = NUM;
714 >                ep1->v.num = getnum();
715 >                return(ep1);
716 >        }
717 >        syntax("unexpected character");
718 >        return NULL; /* pro forma return */
719   }
720  
721  
693 – #ifdef  RCONST
722   EPNODE *
723   rconst(epar)                    /* reduce a constant expression */
724 < register EPNODE  *epar;
724 > register EPNODE  *epar;
725   {
726      register EPNODE  *ep;
727  
# Line 701 | Line 729 | register EPNODE  *epar;
729      ep->type = NUM;
730      errno = 0;
731      ep->v.num = evalue(epar);
732 <    if (errno)
733 <        syntax("bad constant expression");
732 >    if (errno == EDOM || errno == ERANGE)
733 >        syntax("bad constant expression");
734      epfree(epar);
735  
736      return(ep);
737   }
738  
739  
740 + int
741   isconstvar(ep)                  /* is ep linked to a constant expression? */
742 < register EPNODE  *ep;
742 > register EPNODE  *ep;
743   {
715 – #ifdef  VARIABLE
744      register EPNODE  *ep1;
717 – #ifdef  FUNCTION
745  
746 <    if (ep->type == FUNC) {
746 >    if (esupport&E_FUNCTION && ep->type == FUNC) {
747          if (!isconstfun(ep->v.kid))
748                  return(0);
749          for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
# Line 724 | Line 751 | register EPNODE  *ep;
751                  return(0);
752          return(1);
753      }
727 – #endif
754      if (ep->type != VAR)
755          return(0);
756      ep1 = ep->v.ln->def;
757      if (ep1 == NULL || ep1->type != ':')
758          return(0);
759 < #ifdef  FUNCTION
734 <    if (ep1->v.kid->type != SYM)
759 >    if (esupport&E_FUNCTION && ep1->v.kid->type != SYM)
760          return(0);
736 – #endif
761      return(1);
738 – #else
739 –    return(ep->type == FUNC);
740 – #endif
762   }
763  
764  
765 < #if  defined(FUNCTION) && defined(VARIABLE)
765 > int
766   isconstfun(ep)                  /* is ep linked to a constant function? */
767 < register EPNODE  *ep;
767 > register EPNODE  *ep;
768   {
769      register EPNODE  *dp;
770      register LIBR  *lp;
771  
772      if (ep->type != VAR)
773          return(0);
774 <    dp = ep->v.ln->def;
775 <    if (dp != NULL && dp->type != ':')
776 <        return(0);
777 <    if ((dp == NULL || dp->v.kid->type != FUNC)
778 <            && ((lp = liblookup(ep->v.ln->name)) == NULL
779 <                    || lp->atyp != ':'))
780 <        return(0);
781 <    return(1);
774 >    if ((dp = ep->v.ln->def) != NULL)
775 >        if (dp->v.kid->type == FUNC)
776 >            return(dp->type == ':');
777 >        else
778 >            return(0);          /* don't identify masked library functions */
779 >    if ((lp = ep->v.ln->lib) != NULL)
780 >        return(lp->atyp == ':');
781 >    return(0);
782   }
762 – #endif
763 – #endif

Diff Legend

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