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 */

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.5
Committed:	Thu Dec 13 10:37:17 1990 UTC (33 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+0 -2 lines
Log Message:	changed FUN structure and sorted list
#	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	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
28			int
29			otype(ofname) /* get object function number from its name */
30			register char *ofname;
31			{
32			register int i;
33
34			for (i = 0; i < NUMOTYPE; i++)
35			if (!strcmp(ofun[i].funame, ofname))
36			return(i);
37
38			return(-1); /* not found */
39			}
40
41
42			#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	greg	1.4	register int i;
70	greg	1.1
71			#ifdef GETOBJ
72	greg	1.4	i = otndx(objptr(obj)->oname, &objtab);
73			objtab.htab[i] = obj;
74	greg	1.1	#endif
75			if (ismodifier(objptr(obj)->otype)) {
76	greg	1.4	i = otndx(objptr(obj)->oname, &modtab);
77			modtab.htab[i] = obj;
78	greg	1.1	}
79	greg	1.4	for (i = 0; addobjnotify[i] != NULL; i++)
80			(*addobjnotify[i])(obj);
81	greg	1.1	}
82
83
84			objerror(o, etyp, msg) /* report error related to object */
85			OBJREC *o;
86			int etyp;
87			char *msg;
88			{
89			char msgbuf[128];
90
91			sprintf(msgbuf, "%s for %s \"%s\"",
92			msg, ofun[o->otype].funame, o->oname);
93			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(oldsiz2 + 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->hsizsizeof(OBJECT));
137			if (tab->htab == NULL)
138	greg	1.2	error(SYSTEM, "out of memory in otndx");
139	greg	1.1	ndx = tab->hsiz;
140			while (ndx--) /* empty it */
141			tab->htab[ndx] = OVOID;
142			}
143			/* look up object */
144			hval = shash(name);
145	greg	1.3	tryagain:
146	greg	1.1	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	greg	1.3	goto tryagain; /* should happen only once! */
163	greg	1.1	}