src/common/otypes.c

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

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

/*
 *  otypes.c - object lookup functions.
 *
 *     7/29/85
 */

#include  "standard.h"

#include  "object.h"

#include  "otypes.h"


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

FUN  ofun[NUMOTYPE] = INIT_OTYPE;       /* our object function table */

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


int
otype(ofname)                   /* get object function number from its name */
register char  *ofname;
{
        register int  i;

        for (i = 0; i < NUMOTYPE; i++)
                if (!strcmp(ofun[i].funame, ofname))
                        return(i);

        return(-1);             /* not found */
}


#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);
}


objerror(o, etyp, msg)          /* report error related to object */
OBJREC  *o;
int  etyp;
char  *msg;
{
        char  msgbuf[128];

        sprintf(msgbuf, "%s for %s \"%s\"",
                        msg, ofun[o->otype].funame, o->oname);
        error(etyp, msgbuf);
}


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