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

Comparing ray/src/common/otypes.c (file contents):
Revision 1.2 by greg, Mon Apr 10 21:30:17 1989 UTC vs.
Revision 2.6 by greg, Sat Mar 9 19:20:31 2013 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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 < *  otypes.c - object lookup functions.
5 > * Object type lookup and error reporting
6   *
7 < *     7/29/85
7 > *  External symbols declared in object.h
8   */
9  
10 + #include "copyright.h"
11 +
12   #include  "standard.h"
13  
14   #include  "object.h"
# Line 17 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16   #include  "otypes.h"
17  
18  
20 – FUN  ofun[NUMOTYPE] = INIT_OTYPE;       /* our object function table */
21 –
22 – static struct ohtab {
23 –        int  hsiz;                      /* current table size */
24 –        OBJECT  *htab;                  /* table, if allocated */
25 – }  modtab = {100, NULL}, objtab = {1000, NULL}; /* modifiers and objects */
26 –
27 –
19   int
20 < otype(ofname)                   /* get object function number from its name */
21 < register char  *ofname;
20 > otype(                          /* get object function number from its name */
21 >        char  *ofname
22 > )
23   {
24 <        register int  i;
24 >        int  i;
25  
26          for (i = 0; i < NUMOTYPE; i++)
27 <                if (!strcmp(ofun[i].funame, ofname))
27 >                if (ofun[i].funame[0] == ofname[0] &&
28 >                                !strcmp(ofun[i].funame, ofname))
29                          return(i);
30  
31          return(-1);             /* not found */
32   }
33  
34  
35 < #ifdef  GETOBJ
36 < int
37 < object(oname)                   /* get an object number from its name */
38 < char  *oname;
35 > void
36 > objerror(                       /* report error related to object */
37 >        OBJREC  *o,
38 >        int  etyp,
39 >        char  *msg
40 > )
41   {
42 <        register int  ndx;
42 >        char  msgbuf[512];
43  
49 –        ndx = otndx(oname, &objtab);
50 –        return(objtab.htab[ndx]);
51 – }
52 – #endif
53 –
54 –
55 – int
56 – modifier(mname)                 /* get a modifier number from its name */
57 – char  *mname;
58 – {
59 –        register int  ndx;
60 –
61 –        ndx = otndx(mname, &modtab);
62 –        return(modtab.htab[ndx]);
63 – }
64 –
65 –
66 – insertobject(obj)               /* insert new object into our list */
67 – register OBJECT  obj;
68 – {
69 –        register int  ndx;
70 –
71 – #ifdef  GETOBJ
72 –        ndx = otndx(objptr(obj)->oname, &objtab);
73 –        objtab.htab[ndx] = obj;
74 – #endif
75 –        if (ismodifier(objptr(obj)->otype)) {
76 –                ndx = otndx(objptr(obj)->oname, &modtab);
77 –                modtab.htab[ndx] = obj;
78 –        }
79 – }
80 –
81 –
82 – objerror(o, etyp, msg)          /* report error related to object */
83 – OBJREC  *o;
84 – int  etyp;
85 – char  *msg;
86 – {
87 –        char  msgbuf[128];
88 –
44          sprintf(msgbuf, "%s for %s \"%s\"",
45 <                        msg, ofun[o->otype].funame, o->oname);
45 >                        msg, ofun[o->otype].funame,
46 >                        o->oname!=NULL ? o->oname : "(NULL)");
47          error(etyp, msgbuf);
92 – }
93 –
94 –
95 – static int
96 – nexthsiz(oldsiz)                /* return next hash table size */
97 – int  oldsiz;
98 – {
99 –        static int  hsiztab[] = {
100 –                251, 509, 1021, 2039, 4093, 8191, 16381, 0
101 –        };
102 –        register int  *hsp;
103 –
104 –        for (hsp = hsiztab; *hsp; hsp++)
105 –                if (*hsp > oldsiz)
106 –                        return(*hsp);
107 –        return(oldsiz*2 + 1);           /* not always prime */
108 – }
109 –
110 –
111 – static int
112 – shash(s)                        /* hash a string */
113 – register char  *s;
114 – {
115 –        register int  h = 0;
116 –
117 –        while (*s)
118 –                h = (h<<1 & 0x7fff) ^ *s++;
119 –        return(h);
120 – }
121 –
122 –
123 – static int
124 – otndx(name, tab)                /* get object table index for name */
125 – char  *name;
126 – register struct ohtab  *tab;
127 – {
128 –        OBJECT  *oldhtab;
129 –        int  hval, i;
130 –        register int  ndx;
131 –
132 –        if (tab->htab == NULL) {                /* new table */
133 –                tab->hsiz = nexthsiz(tab->hsiz);
134 –                tab->htab = (OBJECT *)malloc(tab->hsiz*sizeof(OBJECT));
135 –                if (tab->htab == NULL)
136 –                        error(SYSTEM, "out of memory in otndx");
137 –                ndx = tab->hsiz;
138 –                while (ndx--)                   /* empty it */
139 –                        tab->htab[ndx] = OVOID;
140 –        }
141 –                                        /* look up object */
142 –        hval = shash(name);
143 –        for (i = 0; i < tab->hsiz; i++) {
144 –                ndx = (hval + i*i) % tab->hsiz;
145 –                if (tab->htab[ndx] == OVOID ||
146 –                                !strcmp(objptr(tab->htab[ndx])->oname, name))
147 –                        return(ndx);
148 –        }
149 –                                        /* table is full, reallocate */
150 –        oldhtab = tab->htab;
151 –        ndx = tab->hsiz;
152 –        tab->htab = NULL;
153 –        while (ndx--)
154 –                if (oldhtab[ndx] != OVOID) {
155 –                        i = otndx(objptr(oldhtab[ndx])->oname, tab);
156 –                        tab->htab[i] = oldhtab[ndx];
157 –                }
158 –        free((char *)oldhtab);
159 –        return(otndx(name, tab));
48   }

Diff Legend

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