src/common/readoct.c

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

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

/*
 *  readoct.c - routines to read octree information.
 *
 *     7/30/85
 */

#include  "standard.h"

#include  "octree.h"

#include  "object.h"

#include  "otypes.h"

static double  ogetflt();
static long  ogetint();
static char  *ogetstr();
static int  getobj(), octerror(), skiptree();
static OCTREE  getfullnode(), gettree();

static char  *infn;                     /* input file name */
static FILE  *infp;                     /* input file stream */
static int  objsize;                    /* size of stored OBJECT's */
static OBJECT  objorig;                 /* zeroeth object */
static short  otypmap[NUMOTYPE+8];      /* object type map */


int
readoct(fname, load, scene, ofn)        /* read in octree from file */
char  *fname;
int  load;
CUBE  *scene;
char  *ofn[];
{
        char  sbuf[512];
        int  nf;
        OBJECT  fnobjects;
        register int  i;
        long  m;
        
        if (fname == NULL) {
                infn = "standard input";
                infp = stdin;
        } else {
                infn = fname;
                if ((infp = fopen(fname, "r")) == NULL) {
                        sprintf(errmsg, "cannot open octree file \"%s\"",
                                        fname);
                        error(SYSTEM, errmsg);
                }
        }
#ifdef MSDOS
        setmode(fileno(infp), O_BINARY);
#endif
                                        /* get header */
        if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
                octerror(USER, "not an octree");
                                        /* check format */
        if ((objsize = ogetint(2)-OCTMAGIC) <= 0 ||
                        objsize > MAXOBJSIZ || objsize > sizeof(long))
                octerror(USER, "incompatible octree format");
                                        /* get boundaries */
        if (load & IO_BOUNDS) {
                for (i = 0; i < 3; i++)
                        scene->cuorg[i] = atof(ogetstr(sbuf));
                scene->cusize = atof(ogetstr(sbuf));
        } else {
                for (i = 0; i < 4; i++)
                        ogetstr(sbuf);
        }
        objorig = nobjects;             /* set object offset */
        nf = 0;                         /* get object files */
        while (*ogetstr(sbuf)) {
                if (load & IO_SCENE)
                        readobj(sbuf);
                if (load & IO_FILES)
                        ofn[nf] = savqstr(sbuf);
                nf++;
        }
        if (load & IO_FILES)
                ofn[nf] = NULL;
                                        /* get number of objects */
        fnobjects = m = ogetint(objsize);
        if (fnobjects != m)
                octerror(USER, "too many objects");

        if (load & IO_TREE)                     /* get the octree */
                scene->cutree = gettree();
        else if (load & IO_SCENE && nf == 0)
                skiptree();
                
        if (load & IO_SCENE)            /* get the scene */
            if (nf == 0) {
                for (i = 0; *ogetstr(sbuf); i++)
                        if ((otypmap[i] = otype(sbuf)) < 0) {
                                sprintf(errmsg, "unknown type \"%s\"", sbuf);
                                octerror(WARNING, errmsg);
                        }
                while (getobj() != OVOID)
                        ;
            } else {                    /* consistency checks */
                                /* check object count */
                if (nobjects != objorig+fnobjects)
                        octerror(USER, "bad object count; octree stale?");
                                /* check for non-surfaces */
                if (nonsurfinset(objorig, fnobjects))
                        octerror(USER, "modifier in tree; octree stale?");
            }
        fclose(infp);
        return(nf);
}


static char *
ogetstr(s)                      /* get null-terminated string */
char  *s;
{
        extern char  *getstr();

        if (getstr(s, infp) == NULL)
                octerror(USER, "truncated octree");
        return(s);
}


static OCTREE
getfullnode()                   /* get a set, return fullnode */
{
        OBJECT  set[MAXSET+1];
        register int  i;
        register long  m;

        if ((set[0] = ogetint(objsize)) > MAXSET)
                octerror(USER, "bad set in getfullnode");
        for (i = 1; i <= set[0]; i++) {
                m = ogetint(objsize) + objorig;
                if ((set[i] = m) != m)
                        octerror(USER, "too many objects");
        }
        return(fullnode(set));
}       


static long
ogetint(siz)                    /* get a siz-byte integer */
int  siz;
{
        extern long  getint();
        register long  r;

        r = getint(siz, infp);
        if (feof(infp))
                octerror(USER, "truncated octree");
        return(r);
}


static double
ogetflt()                       /* get a floating point number */
{
        extern double  getflt();
        double  r;

        r = getflt(infp);
        if (feof(infp))
                octerror(USER, "truncated octree");
        return(r);
}
        

static OCTREE
gettree()                       /* get a pre-ordered octree */
{
        register OCTREE  ot;
        register int  i;
        
        switch (getc(infp)) {
        case OT_EMPTY:
                return(EMPTY);
        case OT_FULL:
                return(getfullnode());
        case OT_TREE:
                if ((ot = octalloc()) == EMPTY)
                        octerror(SYSTEM, "out of tree space in gettree");
                for (i = 0; i < 8; i++)
                        octkid(ot, i) = gettree();
                return(ot);
        case EOF:
                octerror(USER, "truncated octree");
        default:
                octerror(USER, "damaged octree");
        }
}


static
skiptree()                              /* skip octree on input */
{
        register int  i;
        
        switch (getc(infp)) {
        case OT_EMPTY:
                return;
        case OT_FULL:
                for (i = ogetint(objsize)*objsize; i-- > 0; )
                        if (getc(infp) == EOF)
                                octerror(USER, "truncated octree");
                return;
        case OT_TREE:
                for (i = 0; i < 8; i++)
                        skiptree();
                return;
        case EOF:
                octerror(USER, "truncated octree");
        default:
                octerror(USER, "damaged octree");
        }
}


static
getobj()                                /* get next object */
{
        char  sbuf[MAXSTR];
        int  obj;
        register int  i;
        register long  m;
        register OBJREC  *objp;

        i = ogetint(1);
        if (i == -1)
                return(OVOID);          /* terminator */
        if ((obj = newobject()) == OVOID)
                error(SYSTEM, "out of object space");
        objp = objptr(obj);
        if ((objp->otype = otypmap[i]) < 0)
                octerror(USER, "reference to unknown type");
        if ((m = ogetint(objsize)) != OVOID) {
                m += objorig;
                if ((OBJECT)m != m)
                        octerror(USER, "too many objects");
        }
        objp->omod = m;
        objp->oname = savqstr(ogetstr(sbuf));
        if (objp->oargs.nsargs = ogetint(2)) {
                objp->oargs.sarg = (char **)bmalloc
                                (objp->oargs.nsargs*sizeof(char *));
                if (objp->oargs.sarg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.nsargs; i++)
                        objp->oargs.sarg[i] = savestr(ogetstr(sbuf));
        } else
                objp->oargs.sarg = NULL;
#ifdef  IARGS
        if (objp->oargs.niargs = ogetint(2)) {
                objp->oargs.iarg = (long *)bmalloc
                                (objp->oargs.niargs*sizeof(long));
                if (objp->oargs.iarg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.niargs; i++)
                        objp->oargs.iarg[i] = ogetint(4);
        } else
                objp->oargs.iarg = NULL;
#endif
        if (objp->oargs.nfargs = ogetint(2)) {
                objp->oargs.farg = (FLOAT *)bmalloc
                                (objp->oargs.nfargs*sizeof(FLOAT));
                if (objp->oargs.farg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.nfargs; i++)
                        objp->oargs.farg[i] = ogetflt();
        } else
                objp->oargs.farg = NULL;
                                                /* initialize */
        objp->os = NULL;
                                                /* insert */
        insertobject(obj);
        return(obj);
memerr:
        error(SYSTEM, "out of memory in getobj");
}


static
octerror(etyp, msg)                     /* octree error */
int  etyp;
char  *msg;
{
        char  msgbuf[128];

        sprintf(msgbuf, "(%s): %s", infn, msg);
        error(etyp, msgbuf);
}
Revision:	2.10
Committed:	Thu Nov 18 09:27:01 1993 UTC (31 years ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.9:	+1 -1 lines
Log Message:	minor compiler warning fixes
#	User	Rev	Content
1	greg	2.5	/* Copyright (c) 1992 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* readoct.c - routines to read octree information.
9			*
10			* 7/30/85
11			*/
12
13			#include "standard.h"
14
15			#include "octree.h"
16
17			#include "object.h"
18
19			#include "otypes.h"
20
21	greg	2.4	static double ogetflt();
22			static long ogetint();
23			static char *ogetstr();
24	greg	2.10	static int getobj(), octerror(), skiptree();
25	greg	1.7	static OCTREE getfullnode(), gettree();
26	greg	1.1
27			static char infn; / input file name */
28			static FILE infp; / input file stream */
29	greg	1.14	static int objsize; /* size of stored OBJECT's */
30	greg	1.1	static OBJECT objorig; /* zeroeth object */
31			static short otypmap[NUMOTYPE+8]; /* object type map */
32
33
34			int
35			readoct(fname, load, scene, ofn) /* read in octree from file */
36			char *fname;
37			int load;
38			CUBE *scene;
39			char *ofn[];
40			{
41	greg	1.11	char sbuf[512];
42	greg	1.1	int nf;
43	greg	2.7	OBJECT fnobjects;
44	greg	1.1	register int i;
45	greg	1.15	long m;
46	greg	1.1
47			if (fname == NULL) {
48			infn = "standard input";
49			infp = stdin;
50			} else {
51			infn = fname;
52			if ((infp = fopen(fname, "r")) == NULL) {
53			sprintf(errmsg, "cannot open octree file \"%s\"",
54			fname);
55			error(SYSTEM, errmsg);
56			}
57			}
58	greg	2.7	#ifdef MSDOS
59			setmode(fileno(infp), O_BINARY);
60			#endif
61	greg	1.1	/* get header */
62	greg	1.12	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
63			octerror(USER, "not an octree");
64	greg	1.1	/* check format */
65	greg	2.4	if ((objsize = ogetint(2)-OCTMAGIC) <= 0 \|\|
66	greg	1.14	objsize > MAXOBJSIZ \|\| objsize > sizeof(long))
67	greg	1.12	octerror(USER, "incompatible octree format");
68	greg	1.1	/* get boundaries */
69			if (load & IO_BOUNDS) {
70			for (i = 0; i < 3; i++)
71	greg	2.4	scene->cuorg[i] = atof(ogetstr(sbuf));
72			scene->cusize = atof(ogetstr(sbuf));
73	greg	1.1	} else {
74			for (i = 0; i < 4; i++)
75	greg	2.4	ogetstr(sbuf);
76	greg	1.1	}
77			objorig = nobjects; /* set object offset */
78			nf = 0; /* get object files */
79	greg	2.4	while (*ogetstr(sbuf)) {
80	greg	1.1	if (load & IO_SCENE)
81			readobj(sbuf);
82			if (load & IO_FILES)
83			ofn[nf] = savqstr(sbuf);
84			nf++;
85			}
86			if (load & IO_FILES)
87			ofn[nf] = NULL;
88	greg	1.8	/* get number of objects */
89	greg	2.4	fnobjects = m = ogetint(objsize);
90	greg	1.15	if (fnobjects != m)
91			octerror(USER, "too many objects");
92	greg	1.1
93	greg	2.5	if (load & IO_TREE) /* get the octree */
94	greg	1.1	scene->cutree = gettree();
95	greg	2.5	else if (load & IO_SCENE && nf == 0)
96			skiptree();
97
98			if (load & IO_SCENE) /* get the scene */
99			if (nf == 0) {
100			for (i = 0; *ogetstr(sbuf); i++)
101			if ((otypmap[i] = otype(sbuf)) < 0) {
102			sprintf(errmsg, "unknown type \"%s\"", sbuf);
103			octerror(WARNING, errmsg);
104			}
105			while (getobj() != OVOID)
106			;
107			} else { /* consistency checks */
108			/* check object count */
109			if (nobjects != objorig+fnobjects)
110			octerror(USER, "bad object count; octree stale?");
111			/* check for non-surfaces */
112			if (nonsurfinset(objorig, fnobjects))
113			octerror(USER, "modifier in tree; octree stale?");
114			}
115	greg	1.1	fclose(infp);
116			return(nf);
117			}
118
119
120			static char *
121	greg	2.4	ogetstr(s) /* get null-terminated string */
122	greg	1.1	char *s;
123			{
124	greg	2.4	extern char *getstr();
125	greg	1.1
126	greg	2.4	if (getstr(s, infp) == NULL)
127			octerror(USER, "truncated octree");
128			return(s);
129	greg	1.1	}
130
131
132			static OCTREE
133			getfullnode() /* get a set, return fullnode */
134			{
135	greg	2.7	OBJECT set[MAXSET+1];
136	greg	1.1	register int i;
137	greg	1.14	register long m;
138	greg	1.1
139	greg	2.4	if ((set[0] = ogetint(objsize)) > MAXSET)
140	greg	1.1	octerror(USER, "bad set in getfullnode");
141	greg	1.14	for (i = 1; i <= set[0]; i++) {
142	greg	2.4	m = ogetint(objsize) + objorig;
143	greg	1.15	if ((set[i] = m) != m)
144	greg	1.14	octerror(USER, "too many objects");
145			}
146	greg	1.1	return(fullnode(set));
147			}
148
149
150			static long
151	greg	2.4	ogetint(siz) /* get a siz-byte integer */
152			int siz;
153	greg	1.1	{
154	greg	2.4	extern long getint();
155	greg	1.3	register long r;
156	greg	1.1
157	greg	2.4	r = getint(siz, infp);
158			if (feof(infp))
159			octerror(USER, "truncated octree");
160	greg	1.1	return(r);
161			}
162
163
164			static double
165	greg	2.4	ogetflt() /* get a floating point number */
166	greg	1.1	{
167	greg	2.4	extern double getflt();
168	greg	2.7	double r;
169	greg	1.1
170	greg	2.4	r = getflt(infp);
171			if (feof(infp))
172			octerror(USER, "truncated octree");
173			return(r);
174	greg	1.1	}
175
176
177			static OCTREE
178			gettree() /* get a pre-ordered octree */
179			{
180	greg	2.7	register OCTREE ot;
181	greg	1.1	register int i;
182
183			switch (getc(infp)) {
184			case OT_EMPTY:
185			return(EMPTY);
186			case OT_FULL:
187			return(getfullnode());
188			case OT_TREE:
189			if ((ot = octalloc()) == EMPTY)
190			octerror(SYSTEM, "out of tree space in gettree");
191			for (i = 0; i < 8; i++)
192			octkid(ot, i) = gettree();
193			return(ot);
194	greg	2.5	case EOF:
195			octerror(USER, "truncated octree");
196			default:
197			octerror(USER, "damaged octree");
198			}
199			}
200
201
202			static
203			skiptree() /* skip octree on input */
204			{
205			register int i;
206
207			switch (getc(infp)) {
208			case OT_EMPTY:
209			return;
210			case OT_FULL:
211	greg	2.6	for (i = ogetint(objsize)*objsize; i-- > 0; )
212			if (getc(infp) == EOF)
213			octerror(USER, "truncated octree");
214	greg	2.5	return;
215			case OT_TREE:
216			for (i = 0; i < 8; i++)
217			skiptree();
218			return;
219	greg	1.1	case EOF:
220			octerror(USER, "truncated octree");
221			default:
222			octerror(USER, "damaged octree");
223			}
224			}
225
226
227			static
228			getobj() /* get next object */
229			{
230			char sbuf[MAXSTR];
231			int obj;
232			register int i;
233	greg	1.14	register long m;
234	greg	2.7	register OBJREC *objp;
235	greg	1.1
236	greg	2.4	i = ogetint(1);
237	greg	1.3	if (i == -1)
238	greg	1.1	return(OVOID); /* terminator */
239			if ((obj = newobject()) == OVOID)
240			error(SYSTEM, "out of object space");
241			objp = objptr(obj);
242			if ((objp->otype = otypmap[i]) < 0)
243			octerror(USER, "reference to unknown type");
244	greg	2.4	if ((m = ogetint(objsize)) != OVOID) {
245	greg	1.14	m += objorig;
246			if ((OBJECT)m != m)
247			octerror(USER, "too many objects");
248			}
249			objp->omod = m;
250	greg	2.4	objp->oname = savqstr(ogetstr(sbuf));
251			if (objp->oargs.nsargs = ogetint(2)) {
252	greg	1.1	objp->oargs.sarg = (char **)bmalloc
253			(objp->oargs.nsargssizeof(char ));
254			if (objp->oargs.sarg == NULL)
255			goto memerr;
256			for (i = 0; i < objp->oargs.nsargs; i++)
257	greg	2.4	objp->oargs.sarg[i] = savestr(ogetstr(sbuf));
258	greg	1.1	} else
259			objp->oargs.sarg = NULL;
260	greg	2.7	#ifdef IARGS
261	greg	2.4	if (objp->oargs.niargs = ogetint(2)) {
262	greg	1.1	objp->oargs.iarg = (long *)bmalloc
263			(objp->oargs.niargs*sizeof(long));
264			if (objp->oargs.iarg == NULL)
265			goto memerr;
266			for (i = 0; i < objp->oargs.niargs; i++)
267	greg	2.4	objp->oargs.iarg[i] = ogetint(4);
268	greg	1.1	} else
269			objp->oargs.iarg = NULL;
270			#endif
271	greg	2.4	if (objp->oargs.nfargs = ogetint(2)) {
272	greg	1.15	objp->oargs.farg = (FLOAT *)bmalloc
273			(objp->oargs.nfargs*sizeof(FLOAT));
274	greg	1.1	if (objp->oargs.farg == NULL)
275			goto memerr;
276			for (i = 0; i < objp->oargs.nfargs; i++)
277	greg	2.4	objp->oargs.farg[i] = ogetflt();
278	greg	1.1	} else
279			objp->oargs.farg = NULL;
280			/* initialize */
281			objp->os = NULL;
282			/* insert */
283			insertobject(obj);
284			return(obj);
285			memerr:
286			error(SYSTEM, "out of memory in getobj");
287			}
288
289
290			static
291			octerror(etyp, msg) /* octree error */
292			int etyp;
293			char *msg;
294			{
295			char msgbuf[128];
296
297			sprintf(msgbuf, "(%s): %s", infn, msg);
298			error(etyp, msgbuf);
299			}