src/common/readoct.c

/* Copyright (c) 1991 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"

extern double  atof();
static double  getflt();
static long  getint();
static char  *getstr();
static int  getobj(), octerror();
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[];
{
        extern int  fputs();
        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);
                }
        }
                                        /* get header */
        if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
                octerror(USER, "not an octree");
                                        /* check format */
        if ((objsize = getint(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(getstr(sbuf));
                scene->cusize = atof(getstr(sbuf));
        } else {
                for (i = 0; i < 4; i++)
                        getstr(sbuf);
        }
        objorig = nobjects;             /* set object offset */
        nf = 0;                         /* get object files */
        while (*getstr(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 = getint(objsize);
        if (fnobjects != m)
                octerror(USER, "too many objects");

        if (load & IO_TREE) {
                                                /* get the octree */
                scene->cutree = gettree();
                                                /* get the scene */
                if (nf == 0 && load & IO_SCENE) {
                        for (i = 0; *getstr(sbuf); i++)
                                if ((otypmap[i] = otype(sbuf)) < 0) {
                                        sprintf(errmsg, "unknown type \"%s\"",
                                                        sbuf);
                                        octerror(WARNING, errmsg);
                                }
                        while (getobj() != OVOID)
                                ;
                } else if (load & IO_SCENE) {           /* 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, "non-surface in set; octree stale?");
                }
        }
        fclose(infp);
        return(nf);
}


static char *
getstr(s)                       /* get null-terminated string */
char  *s;
{
        register char  *cp;
        register int  c;

        cp = s;
        while ((c = getc(infp)) != EOF)
                if ((*cp++ = c) == '\0')
                        return(s);
                
        octerror(USER, "truncated octree");
}


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

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


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

        if ((c = getc(infp)) == EOF)
                goto end_file;
        r = 0x80&c ? -1<<8|c : c;               /* sign extend */
        while (--siz > 0) {
                if ((c = getc(infp)) == EOF)
                        goto end_file;
                r <<= 8;
                r |= c;
        }
        return(r);
end_file:
        octerror(USER, "truncated octree");
}


static double
getflt()                        /* get a floating point number */
{
        extern double  ldexp();
        double  d;

        d = (double)getint(4)/0x7fffffff;
        return(ldexp(d, (int)getint(1)));
}
        

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
getobj()                                /* get next object */
{
        char  sbuf[MAXSTR];
        int  obj;
        register int  i;
        register long  m;
        register OBJREC  *objp;

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