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

Comparing src/common/modobject.c (file contents):
Revision 1.2 by greg, Mon Jul 29 15:47:46 1991 UTC vs.
Revision 2.9 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   *  Routines for tracking object modifiers
6 + *
7 + *  External symbols declared in object.h
8   */
9  
10 + #include "copyright.h"
11 +
12   #include  "standard.h"
13  
14   #include  "object.h"
# Line 15 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16   #include  "otypes.h"
17  
18  
18 – extern int  (*addobjnotify[])();        /* people to notify of new objects */
19 –
19   static struct ohtab {
20          int  hsiz;                      /* current table size */
21          OBJECT  *htab;                  /* table, if allocated */
22   }  modtab = {100, NULL}, objtab = {1000, NULL}; /* modifiers and objects */
23  
24 + static int  otndx();
25  
26 < #ifdef  GETOBJ
27 < int
28 < object(oname)                   /* get an object number from its name */
29 < char  *oname;
26 >
27 > OBJECT
28 > objndx(op)                      /* get object number from pointer */
29 > register OBJREC  *op;
30   {
31 <        register int  ndx;
31 >        register int  i, j;
32  
33 <        ndx = otndx(oname, &objtab);
34 <        return(objtab.htab[ndx]);
33 >        for (i = nobjects>>OBJBLKSHFT; i >= 0; i--) {
34 >                j = op - objblock[i];
35 >                if (j >= 0 && j < OBJBLKSIZ)
36 >                        return((i<<OBJBLKSHFT) + j);
37 >        }
38 >        return(OVOID);
39   }
36 – #endif
40  
41  
42 < int
42 > OBJECT
43 > lastmod(obj, mname)             /* find modifier definition before obj */
44 > OBJECT  obj;
45 > char  *mname;
46 > {
47 >        register OBJREC  *op;
48 >        register int  i;
49 >
50 >        i = modifier(mname);            /* try hash table first */
51 >        if (i < obj)
52 >                return(i);
53 >        for (i = obj; i-- > 0; ) {      /* need to search */
54 >                op = objptr(i);
55 >                if (ismodifier(op->otype) && !strcmp(op->oname, mname))
56 >                        return(i);
57 >        }
58 >        return(OVOID);
59 > }
60 >
61 >
62 > OBJECT
63   modifier(mname)                 /* get a modifier number from its name */
64   char  *mname;
65   {
# Line 47 | Line 70 | char  *mname;
70   }
71  
72  
73 + #ifdef  GETOBJ
74 + OBJECT
75 + object(oname)                   /* get an object number from its name */
76 + char  *oname;
77 + {
78 +        register int  ndx;
79 +
80 +        ndx = otndx(oname, &objtab);
81 +        return(objtab.htab[ndx]);
82 + }
83 + #endif
84 +
85 +
86 + void
87   insertobject(obj)               /* insert new object into our list */
88   register OBJECT  obj;
89   {
90          register int  i;
91  
55 – #ifdef  GETOBJ
56 –        i = otndx(objptr(obj)->oname, &objtab);
57 –        objtab.htab[i] = obj;
58 – #endif
92          if (ismodifier(objptr(obj)->otype)) {
93                  i = otndx(objptr(obj)->oname, &modtab);
94                  modtab.htab[i] = obj;
95          }
96 + #ifdef  GETOBJ
97 +        else {
98 +                i = otndx(objptr(obj)->oname, &objtab);
99 +                objtab.htab[i] = obj;
100 +        }
101 + #endif
102          for (i = 0; addobjnotify[i] != NULL; i++)
103                  (*addobjnotify[i])(obj);
104   }
105  
106  
107 + void
108 + clearobjndx()                   /* clear object hash tables */
109 + {
110 +        if (modtab.htab != NULL) {
111 +                free((void *)modtab.htab);
112 +                modtab.htab = NULL;
113 +                modtab.hsiz = 100;
114 +        }
115 +        if (objtab.htab != NULL) {
116 +                free((void *)objtab.htab);
117 +                objtab.htab = NULL;
118 +                objtab.hsiz = 100;
119 +        }
120 + }
121 +
122 +
123   static int
124   nexthsiz(oldsiz)                /* return next hash table size */
125   int  oldsiz;
# Line 82 | Line 137 | int  oldsiz;
137  
138  
139   static int
85 – shash(s)                        /* hash a string */
86 – register char  *s;
87 – {
88 –        register int  h = 0;
89 –
90 –        while (*s)
91 –                h = (h<<1 & 0x7fff) ^ *s++;
92 –        return(h);
93 – }
94 –
95 –
96 – static int
140   otndx(name, tab)                /* get object table index for name */
141   char  *name;
142   register struct ohtab  *tab;
# Line 129 | Line 172 | tryagain:
172                          i = otndx(objptr(oldhtab[ndx])->oname, tab);
173                          tab->htab[i] = oldhtab[ndx];
174                  }
175 <        free((char *)oldhtab);
175 >        free((void *)oldhtab);
176          goto tryagain;                  /* should happen only once! */
177   }

Diff Legend

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