src/common/modobject.c

#ifndef lint
static const char RCSid[] = "$Id: modobject.c,v 2.16 2013/12/09 17:57:44 greg Exp $";
#endif
/*
 *  Routines for tracking object modifiers
 *
 *  External symbols declared in object.h
 */

#include "copyright.h"

#include  "standard.h"

#include  "object.h"

#include  "otypes.h"


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(char *, struct ohtab *);


OBJECT
objndx(                         /* get object number from pointer */
        OBJREC  *op
)
{
        int  i, j;

        for (i = nobjects>>OBJBLKSHFT; i >= 0; i--) {
                j = op - objblock[i];
                if ((j >= 0) & (j < OBJBLKSIZ))
                        return((i<<OBJBLKSHFT) + j);
        }
        return(OVOID);
}


OBJECT
lastmod(                        /* find modifier definition before obj */
        OBJECT  obj,
        char  *mname
)
{
        OBJREC  *op;
        int  i;

        i = modifier(mname);            /* try hash table first */
        if ((obj == OVOID) | (i < obj))
                return(i);
        for (i = obj; i-- > 0; ) {      /* need to search */
                op = objptr(i);
                if (ismodifier(op->otype) && op->oname[0] == mname[0] &&
                                        !strcmp(op->oname, mname))
                        return(i);
        }
        return(OVOID);
}


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

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


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

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


int
eqreal(                         /* are two real values close enough to equal? */
        double  d1,
        double  d2
)
{
        if (d2 != 0.0)
                d1 = d1/d2 - 1.0;
        return((-FTINY <= d1) & (d1 <= FTINY));
}


int
eqobjects(                      /* check if two objects are equal */
        OBJECT  obj1,
        OBJECT  obj2
)
{
        OBJREC  *op1, *op2;
        int     i, n;

        while (obj1 != obj2) {
                if (obj1 == OVOID)
                        return(0);
                if (obj2 == OVOID)
                        return(0);
                op1 = objptr(obj1);
                op2 = objptr(obj2);
                if (op1->otype != op2->otype)
                        return(0);
                if (op1->oargs.nsargs != op2->oargs.nsargs)
                        return(0);
                if (op1->oargs.nfargs != op2->oargs.nfargs)
                        return(0);
#ifdef IARGS
                if (op1->oargs.niargs != op2->oargs.niargs)
                        return(0);
                for (i = op1->oargs.niargs; i-- > 0; )
                        if (op1->oargs.iarg[i] != op2->oargs.iarg[i])
                                return(0);
#endif
                for (i = op1->oargs.nfargs; i-- > 0; )
                        if (!eqreal(op1->oargs.farg[i], op2->oargs.farg[i]))
                                return(0);
                n = 0;
                switch (op1->otype) {   /* special cases (KEEP CONSISTENT!) */
                case MOD_ALIAS:
                case MAT_ILLUM:
                case MAT_MIRROR:
                        n = (op1->oargs.nsargs > 0);
                        break;
                case MIX_FUNC:
                case MIX_DATA:
                case MIX_TEXT:
                case MIX_PICT:
                        n = 2*(op1->oargs.nsargs >= 2);
                        break;
                case MAT_CLIP:
                        n = op1->oargs.nsargs;
                        break;
                }
                                        /* check other string arguments */
                for (i = op1->oargs.nsargs; i-- > n; )
                        if (strcmp(op1->oargs.sarg[i], op2->oargs.sarg[i]))
                                return(0);
                while (n-- > 0)         /* check modifier references */
                        if (!eqobjects( lastmod(obj1, op1->oargs.sarg[n]),
                                        lastmod(obj2, op2->oargs.sarg[n]) ))
                                return(0);
                obj1 = op1->omod;
                obj2 = op2->omod;
        }
        return(1);
}


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

        if (ismodifier(objptr(obj)->otype)) {
                i = otndx(objptr(obj)->oname, &modtab);
                if (eqobjects(obj, modtab.htab[i]))
                        return; /* don't index if same as earlier def. */
                modtab.htab[i] = obj;
        }
#ifdef  GETOBJ
        else {
                i = otndx(objptr(obj)->oname, &objtab);
                objtab.htab[i] = obj;
        }
#endif
        for (i = 0; addobjnotify[i] != NULL; i++)
                (*addobjnotify[i])(obj);
}


void
clearobjndx(void)               /* clear object hash tables */
{
        if (modtab.htab != NULL) {
                free((void *)modtab.htab);
                modtab.htab = NULL;
                modtab.hsiz = 100;
        }
        if (objtab.htab != NULL) {
                free((void *)objtab.htab);
                objtab.htab = NULL;
                objtab.hsiz = 100;
        }
}


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

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


static int
otndx(                          /* get object table index for name */
        char  *name,
        struct ohtab  *tab
)
{
        OBJECT  *oldhtab;
        int  hval, i;
        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 + (unsigned long)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((void *)oldhtab);
        goto tryagain;                  /* should happen only once! */
}
Revision:	2.17
Committed:	Mon Dec 9 18:17:13 2013 UTC (10 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R2, rad4R2P2, rad5R0, rad5R1, rad4R2, rad4R2P1, rad5R3
Changes since 2.16:	+13 -12 lines
Log Message:	Minor optimization to reference check in eqobjects()
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.17	static const char RCSid[] = "$Id: modobject.c,v 2.16 2013/12/09 17:57:44 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* Routines for tracking object modifiers
6	greg	2.7	*
7			* External symbols declared in object.h
8			*/
9
10	greg	2.8	#include "copyright.h"
11	greg	1.1
12			#include "standard.h"
13
14			#include "object.h"
15
16	greg	1.2	#include "otypes.h"
17
18	greg	1.1
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	schorsch	2.10	static int otndx(char , struct ohtab );
25	greg	1.3
26	greg	1.1
27	greg	2.9	OBJECT
28	greg	2.13	objndx( /* get object number from pointer */
29			OBJREC *op
30			)
31	greg	1.1	{
32	greg	2.13	int i, j;
33	greg	1.1
34	gwlarson	2.6	for (i = nobjects>>OBJBLKSHFT; i >= 0; i--) {
35	greg	2.3	j = op - objblock[i];
36	greg	2.12	if ((j >= 0) & (j < OBJBLKSIZ))
37	gwlarson	2.6	return((i<<OBJBLKSHFT) + j);
38	greg	2.3	}
39			return(OVOID);
40	greg	1.1	}
41
42
43	greg	2.9	OBJECT
44	greg	2.13	lastmod( /* find modifier definition before obj */
45			OBJECT obj,
46			char *mname
47			)
48	greg	2.3	{
49	greg	2.13	OBJREC *op;
50			int i;
51	greg	2.3
52	greg	2.4	i = modifier(mname); /* try hash table first */
53	greg	2.12	if ((obj == OVOID) \| (i < obj))
54	greg	2.4	return(i);
55			for (i = obj; i-- > 0; ) { /* need to search */
56	greg	2.3	op = objptr(i);
57	greg	2.13	if (ismodifier(op->otype) && op->oname[0] == mname[0] &&
58			!strcmp(op->oname, mname))
59	greg	2.3	return(i);
60			}
61			return(OVOID);
62			}
63
64
65	greg	2.9	OBJECT
66	greg	2.13	modifier( /* get a modifier number from its name */
67			char *mname
68			)
69	greg	1.1	{
70	greg	2.13	int ndx;
71	greg	1.1
72			ndx = otndx(mname, &modtab);
73			return(modtab.htab[ndx]);
74			}
75
76
77	greg	2.3	#ifdef GETOBJ
78	greg	2.9	OBJECT
79	greg	2.13	object( /* get an object number from its name */
80			char *oname
81			)
82	greg	2.3	{
83	greg	2.13	int ndx;
84	greg	2.3
85			ndx = otndx(oname, &objtab);
86			return(objtab.htab[ndx]);
87			}
88			#endif
89
90
91	greg	2.15	int
92	greg	2.14	eqreal( /* are two real values close enough to equal? */
93			double d1,
94			double d2
95			)
96			{
97			if (d2 != 0.0)
98			d1 = d1/d2 - 1.0;
99			return((-FTINY <= d1) & (d1 <= FTINY));
100			}
101
102
103			int
104			eqobjects( /* check if two objects are equal */
105			OBJECT obj1,
106			OBJECT obj2
107			)
108			{
109			OBJREC op1, op2;
110	greg	2.17	int i, n;
111	greg	2.14
112	greg	2.15	while (obj1 != obj2) {
113			if (obj1 == OVOID)
114			return(0);
115			if (obj2 == OVOID)
116			return(0);
117			op1 = objptr(obj1);
118			op2 = objptr(obj2);
119			if (op1->otype != op2->otype)
120			return(0);
121			if (op1->oargs.nsargs != op2->oargs.nsargs)
122			return(0);
123			if (op1->oargs.nfargs != op2->oargs.nfargs)
124			return(0);
125	greg	2.14	#ifdef IARGS
126	greg	2.15	if (op1->oargs.niargs != op2->oargs.niargs)
127	greg	2.14	return(0);
128	greg	2.15	for (i = op1->oargs.niargs; i-- > 0; )
129			if (op1->oargs.iarg[i] != op2->oargs.iarg[i])
130			return(0);
131	greg	2.14	#endif
132	greg	2.15	for (i = op1->oargs.nfargs; i-- > 0; )
133			if (!eqreal(op1->oargs.farg[i], op2->oargs.farg[i]))
134			return(0);
135	greg	2.17	n = 0;
136	greg	2.16	switch (op1->otype) { /* special cases (KEEP CONSISTENT!) */
137			case MOD_ALIAS:
138			case MAT_ILLUM:
139			case MAT_MIRROR:
140	greg	2.17	n = (op1->oargs.nsargs > 0);
141	greg	2.16	break;
142			case MIX_FUNC:
143			case MIX_DATA:
144			case MIX_TEXT:
145			case MIX_PICT:
146	greg	2.17	n = 2*(op1->oargs.nsargs >= 2);
147	greg	2.16	break;
148			case MAT_CLIP:
149	greg	2.17	n = op1->oargs.nsargs;
150	greg	2.16	break;
151			}
152	greg	2.17	/* check other string arguments */
153			for (i = op1->oargs.nsargs; i-- > n; )
154			if (strcmp(op1->oargs.sarg[i], op2->oargs.sarg[i]))
155			return(0);
156			while (n-- > 0) /* check modifier references */
157			if (!eqobjects( lastmod(obj1, op1->oargs.sarg[n]),
158			lastmod(obj2, op2->oargs.sarg[n]) ))
159	greg	2.16	return(0);
160	greg	2.15	obj1 = op1->omod;
161			obj2 = op2->omod;
162			}
163	greg	2.14	return(1);
164			}
165
166
167	greg	2.7	void
168	greg	2.13	insertobject( /* insert new object into our list */
169			OBJECT obj
170			)
171	greg	1.1	{
172	greg	2.13	int i;
173	greg	1.1
174			if (ismodifier(objptr(obj)->otype)) {
175			i = otndx(objptr(obj)->oname, &modtab);
176	greg	2.14	if (eqobjects(obj, modtab.htab[i]))
177	greg	2.16	return; /* don't index if same as earlier def. */
178	greg	1.1	modtab.htab[i] = obj;
179			}
180	greg	2.3	#ifdef GETOBJ
181			else {
182			i = otndx(objptr(obj)->oname, &objtab);
183			objtab.htab[i] = obj;
184			}
185			#endif
186	greg	1.1	for (i = 0; addobjnotify[i] != NULL; i++)
187			(*addobjnotify[i])(obj);
188			}
189
190
191	greg	2.7	void
192	greg	2.13	clearobjndx(void) /* clear object hash tables */
193	greg	2.7	{
194			if (modtab.htab != NULL) {
195			free((void *)modtab.htab);
196			modtab.htab = NULL;
197			modtab.hsiz = 100;
198			}
199			if (objtab.htab != NULL) {
200			free((void *)objtab.htab);
201			objtab.htab = NULL;
202			objtab.hsiz = 100;
203			}
204			}
205
206
207	greg	1.1	static int
208	greg	2.13	nexthsiz( /* return next hash table size */
209			int oldsiz
210			)
211	greg	1.1	{
212			static int hsiztab[] = {
213			251, 509, 1021, 2039, 4093, 8191, 16381, 0
214			};
215	greg	2.13	int *hsp;
216	greg	1.1
217			for (hsp = hsiztab; *hsp; hsp++)
218			if (*hsp > oldsiz)
219			return(*hsp);
220			return(oldsiz2 + 1); / not always prime */
221			}
222
223
224			static int
225	greg	2.13	otndx( /* get object table index for name */
226			char *name,
227			struct ohtab *tab
228			)
229	greg	1.1	{
230			OBJECT *oldhtab;
231			int hval, i;
232	greg	2.13	int ndx;
233	greg	1.1
234			if (tab->htab == NULL) { /* new table */
235			tab->hsiz = nexthsiz(tab->hsiz);
236			tab->htab = (OBJECT )malloc(tab->hsizsizeof(OBJECT));
237			if (tab->htab == NULL)
238			error(SYSTEM, "out of memory in otndx");
239			ndx = tab->hsiz;
240			while (ndx--) /* empty it */
241			tab->htab[ndx] = OVOID;
242			}
243			/* look up object */
244			hval = shash(name);
245			tryagain:
246			for (i = 0; i < tab->hsiz; i++) {
247	greg	2.11	ndx = (hval + (unsigned long)i*i) % tab->hsiz;
248	greg	1.1	if (tab->htab[ndx] == OVOID \|\|
249			!strcmp(objptr(tab->htab[ndx])->oname, name))
250			return(ndx);
251			}
252			/* table is full, reallocate */
253			oldhtab = tab->htab;
254			ndx = tab->hsiz;
255			tab->htab = NULL;
256			while (ndx--)
257			if (oldhtab[ndx] != OVOID) {
258			i = otndx(objptr(oldhtab[ndx])->oname, tab);
259			tab->htab[i] = oldhtab[ndx];
260			}
261	greg	2.7	free((void *)oldhtab);
262	greg	1.1	goto tryagain; /* should happen only once! */
263			}