src/common/modobject.c

/* Copyright (c) 1986 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  Routines for tracking object modifiers
 */

#include  "standard.h"

#include  "object.h"

#include  "otypes.h"


extern int  (*addobjnotify[])();        /* people to notify of new objects */

static struct ohtab {
        int  hsiz;                      /* current table size */
        OBJECT  *htab;                  /* table, if allocated */
}  modtab = {100, NULL}, objtab = {1000, NULL}; /* modifiers and objects */

static int  otndx();


#ifdef  GETOBJ
int
object(oname)                   /* get an object number from its name */
char  *oname;
{
        register int  ndx;

        ndx = otndx(oname, &objtab);
        return(objtab.htab[ndx]);
}
#endif


int
modifier(mname)                 /* get a modifier number from its name */
char  *mname;
{
        register int  ndx;

        ndx = otndx(mname, &modtab);
        return(modtab.htab[ndx]);
}


insertobject(obj)               /* insert new object into our list */
register OBJECT  obj;
{
        register int  i;

#ifdef  GETOBJ
        i = otndx(objptr(obj)->oname, &objtab);
        objtab.htab[i] = obj;
#endif
        if (ismodifier(objptr(obj)->otype)) {
                i = otndx(objptr(obj)->oname, &modtab);
                modtab.htab[i] = obj;
        }
        for (i = 0; addobjnotify[i] != NULL; i++)
                (*addobjnotify[i])(obj);
}


static int
nexthsiz(oldsiz)                /* return next hash table size */
int  oldsiz;
{
        static int  hsiztab[] = {
                251, 509, 1021, 2039, 4093, 8191, 16381, 0
        };
        register int  *hsp;

        for (hsp = hsiztab; *hsp; hsp++)
                if (*hsp > oldsiz)
                        return(*hsp);
        return(oldsiz*2 + 1);           /* not always prime */
}


static int
shash(s)                        /* hash a string */
register char  *s;
{
        register int  h = 0;

        while (*s)
                h = (h<<1 & 0x7fff) ^ *s++;
        return(h);
}


static int
otndx(name, tab)                /* get object table index for name */
char  *name;
register struct ohtab  *tab;
{
        OBJECT  *oldhtab;
        int  hval, i;
        register int  ndx;

        if (tab->htab == NULL) {                /* new table */
                tab->hsiz = nexthsiz(tab->hsiz);
                tab->htab = (OBJECT *)malloc(tab->hsiz*sizeof(OBJECT));
                if (tab->htab == NULL)
                        error(SYSTEM, "out of memory in otndx");
                ndx = tab->hsiz;
                while (ndx--)                   /* empty it */
                        tab->htab[ndx] = OVOID;
        }
                                        /* look up object */
        hval = shash(name);
tryagain:
        for (i = 0; i < tab->hsiz; i++) {
                ndx = (hval + i*i) % tab->hsiz;
                if (tab->htab[ndx] == OVOID ||
                                !strcmp(objptr(tab->htab[ndx])->oname, name))
                        return(ndx);
        }
                                        /* table is full, reallocate */
        oldhtab = tab->htab;
        ndx = tab->hsiz;
        tab->htab = NULL;
        while (ndx--)
                if (oldhtab[ndx] != OVOID) {
                        i = otndx(objptr(oldhtab[ndx])->oname, tab);
                        tab->htab[i] = oldhtab[ndx];
                }
        free((char *)oldhtab);
        goto tryagain;                  /* should happen only once! */
}
Revision:	2.1
Committed:	Tue Nov 12 16:56:08 1991 UTC (32 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+0 -0 lines
Log Message:	updated revision number for release 2.0
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1986 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Routines for tracking object modifiers
9			*/
10
11			#include "standard.h"
12
13			#include "object.h"
14
15	greg	1.2	#include "otypes.h"
16
17	greg	1.1
18			extern int (addobjnotify[])(); / people to notify of new objects */
19
20			static struct ohtab {
21			int hsiz; /* current table size */
22			OBJECT htab; / table, if allocated */
23			} modtab = {100, NULL}, objtab = {1000, NULL}; /* modifiers and objects */
24
25	greg	1.3	static int otndx();
26
27	greg	1.1
28			#ifdef GETOBJ
29			int
30			object(oname) /* get an object number from its name */
31			char *oname;
32			{
33			register int ndx;
34
35			ndx = otndx(oname, &objtab);
36			return(objtab.htab[ndx]);
37			}
38			#endif
39
40
41			int
42			modifier(mname) /* get a modifier number from its name */
43			char *mname;
44			{
45			register int ndx;
46
47			ndx = otndx(mname, &modtab);
48			return(modtab.htab[ndx]);
49			}
50
51
52			insertobject(obj) /* insert new object into our list */
53			register OBJECT obj;
54			{
55			register int i;
56
57			#ifdef GETOBJ
58			i = otndx(objptr(obj)->oname, &objtab);
59			objtab.htab[i] = obj;
60			#endif
61			if (ismodifier(objptr(obj)->otype)) {
62			i = otndx(objptr(obj)->oname, &modtab);
63			modtab.htab[i] = obj;
64			}
65			for (i = 0; addobjnotify[i] != NULL; i++)
66			(*addobjnotify[i])(obj);
67			}
68
69
70			static int
71			nexthsiz(oldsiz) /* return next hash table size */
72			int oldsiz;
73			{
74			static int hsiztab[] = {
75			251, 509, 1021, 2039, 4093, 8191, 16381, 0
76			};
77			register int *hsp;
78
79			for (hsp = hsiztab; *hsp; hsp++)
80			if (*hsp > oldsiz)
81			return(*hsp);
82			return(oldsiz2 + 1); / not always prime */
83			}
84
85
86			static int
87			shash(s) /* hash a string */
88			register char *s;
89			{
90			register int h = 0;
91
92			while (*s)
93			h = (h<<1 & 0x7fff) ^ *s++;
94			return(h);
95			}
96
97
98			static int
99			otndx(name, tab) /* get object table index for name */
100			char *name;
101			register struct ohtab *tab;
102			{
103			OBJECT *oldhtab;
104			int hval, i;
105			register int ndx;
106
107			if (tab->htab == NULL) { /* new table */
108			tab->hsiz = nexthsiz(tab->hsiz);
109			tab->htab = (OBJECT )malloc(tab->hsizsizeof(OBJECT));
110			if (tab->htab == NULL)
111			error(SYSTEM, "out of memory in otndx");
112			ndx = tab->hsiz;
113			while (ndx--) /* empty it */
114			tab->htab[ndx] = OVOID;
115			}
116			/* look up object */
117			hval = shash(name);
118			tryagain:
119			for (i = 0; i < tab->hsiz; i++) {
120			ndx = (hval + i*i) % tab->hsiz;
121			if (tab->htab[ndx] == OVOID \|\|
122			!strcmp(objptr(tab->htab[ndx])->oname, name))
123			return(ndx);
124			}
125			/* table is full, reallocate */
126			oldhtab = tab->htab;
127			ndx = tab->hsiz;
128			tab->htab = NULL;
129			while (ndx--)
130			if (oldhtab[ndx] != OVOID) {
131			i = otndx(objptr(oldhtab[ndx])->oname, tab);
132			tab->htab[i] = oldhtab[ndx];
133			}
134			free((char *)oldhtab);
135			goto tryagain; /* should happen only once! */
136			}