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.5 by greg, Thu Dec 13 10:37:17 1990 UTC vs.
Revision 2.4 by greg, Mon Mar 10 17:13:29 2003 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 – extern int  (*addobjnotify[])();        /* people to notify of new objects */
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;
# Line 39 | Line 30 | register char  *ofname;
30   }
31  
32  
33 < #ifdef  GETOBJ
43 < int
44 < object(oname)                   /* get an object number from its name */
45 < char  *oname;
46 < {
47 <        register int  ndx;
48 <
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  i;
70 <
71 < #ifdef  GETOBJ
72 <        i = otndx(objptr(obj)->oname, &objtab);
73 <        objtab.htab[i] = obj;
74 < #endif
75 <        if (ismodifier(objptr(obj)->otype)) {
76 <                i = otndx(objptr(obj)->oname, &modtab);
77 <                modtab.htab[i] = obj;
78 <        }
79 <        for (i = 0; addobjnotify[i] != NULL; i++)
80 <                (*addobjnotify[i])(obj);
81 < }
82 <
83 <
33 > void
34   objerror(o, etyp, msg)          /* report error related to object */
35   OBJREC  *o;
36   int  etyp;
# Line 89 | Line 39 | char  *msg;
39          char  msgbuf[128];
40  
41          sprintf(msgbuf, "%s for %s \"%s\"",
42 <                        msg, ofun[o->otype].funame, o->oname);
42 >                        msg, ofun[o->otype].funame,
43 >                        o->oname!=NULL ? o->oname : "(NULL)");
44          error(etyp, msgbuf);
94 – }
95 –
96 –
97 – static int
98 – nexthsiz(oldsiz)                /* return next hash table size */
99 – int  oldsiz;
100 – {
101 –        static int  hsiztab[] = {
102 –                251, 509, 1021, 2039, 4093, 8191, 16381, 0
103 –        };
104 –        register int  *hsp;
105 –
106 –        for (hsp = hsiztab; *hsp; hsp++)
107 –                if (*hsp > oldsiz)
108 –                        return(*hsp);
109 –        return(oldsiz*2 + 1);           /* not always prime */
110 – }
111 –
112 –
113 – static int
114 – shash(s)                        /* hash a string */
115 – register char  *s;
116 – {
117 –        register int  h = 0;
118 –
119 –        while (*s)
120 –                h = (h<<1 & 0x7fff) ^ *s++;
121 –        return(h);
122 – }
123 –
124 –
125 – static int
126 – otndx(name, tab)                /* get object table index for name */
127 – char  *name;
128 – register struct ohtab  *tab;
129 – {
130 –        OBJECT  *oldhtab;
131 –        int  hval, i;
132 –        register int  ndx;
133 –
134 –        if (tab->htab == NULL) {                /* new table */
135 –                tab->hsiz = nexthsiz(tab->hsiz);
136 –                tab->htab = (OBJECT *)malloc(tab->hsiz*sizeof(OBJECT));
137 –                if (tab->htab == NULL)
138 –                        error(SYSTEM, "out of memory in otndx");
139 –                ndx = tab->hsiz;
140 –                while (ndx--)                   /* empty it */
141 –                        tab->htab[ndx] = OVOID;
142 –        }
143 –                                        /* look up object */
144 –        hval = shash(name);
145 – tryagain:
146 –        for (i = 0; i < tab->hsiz; i++) {
147 –                ndx = (hval + i*i) % tab->hsiz;
148 –                if (tab->htab[ndx] == OVOID ||
149 –                                !strcmp(objptr(tab->htab[ndx])->oname, name))
150 –                        return(ndx);
151 –        }
152 –                                        /* table is full, reallocate */
153 –        oldhtab = tab->htab;
154 –        ndx = tab->hsiz;
155 –        tab->htab = NULL;
156 –        while (ndx--)
157 –                if (oldhtab[ndx] != OVOID) {
158 –                        i = otndx(objptr(oldhtab[ndx])->oname, tab);
159 –                        tab->htab[i] = oldhtab[ndx];
160 –                }
161 –        free((char *)oldhtab);
162 –        goto tryagain;                  /* should happen only once! */
45   }

Diff Legend

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