src/common/readoct.c

#ifndef lint
static const char       RCSid[] = "$Id: readoct.c,v 2.35 2025/04/22 14:51:29 greg Exp $";
#endif
/*
 *  readoct.c - routines to read octree information.
 */

#include "copyright.h"

#include  <stdio.h>
#include  <time.h>

#include  "platform.h"
#include  "paths.h"
#include  "standard.h"
#include  "octree.h"
#include  "object.h"
#include  "otypes.h"
#include  "resolu.h"

static double  ogetflt(void);
static long  ogetint(int);
static char  *ogetstr(char *);
static int  nonsurfintree(OCTREE ot);
static void  octerror(int  etyp, char  *msg);
static void  skiptree(void);
static OCTREE  getfullnode(void), gettree(void);

static char  *infn;                     /* input file specification */
static FILE  *infp;                     /* input file stream */
static int  objsize;                    /* size of stored OBJECT's */
static OBJECT  objorig;                 /* zeroeth object */
static OBJECT  fnobjects;               /* number of objects in this file */


int
readoct(                                /* read in octree file or stream */
        char  *inpspec,
        int  load,
        CUBE  *scene,
        char  *ofn[]
)
{
        time_t  oct_t = 0;
        time_t  last_it = 0;
        char  sbuf[512];
        int  nf;
        int  i;
        long  m;
        
        if (inpspec == NULL) {
                infn = "standard input";
                infp = stdin;
        } else if (inpspec[0] == '!') {
                infn = inpspec;
                if ((infp = popen(inpspec+1, "r")) == NULL) {
                        sprintf(errmsg, "cannot execute \"%s\"", inpspec);
                        error(SYSTEM, errmsg);
                }
        } else {
                infn = inpspec;
                if ((infp = fopen(inpspec, "r")) == NULL) {
                        sprintf(errmsg, "cannot open octree file \"%s\"",
                                        inpspec);
                        error(SYSTEM, errmsg);
                }
                oct_t = fddate(fileno(infp));
        }
#ifdef getc_unlocked                    /* avoid stupid semaphores */
        flockfile(infp);
#endif
        SET_FILE_BINARY(infp);
                                        /* get header */
        if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)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);
                if (oct_t > last_it) {
                        time_t  t = fdate(sbuf);
                        if (t > last_it)
                                last_it = t;
                }
                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) {
                                        /* load binary scene data */
                readscene(infp, objsize);

            } else {                    /* consistency checks */
                                /* check object count */
                if (nobjects != objorig+fnobjects)
                        octerror(USER, "bad object count; octree stale?");
                                /* check for non-surfaces */
                if (oct_t <= last_it && nonsurfintree(scene->cutree))
                        octerror(USER, "modifier in tree; octree stale?");
            }
        }
                                /* close the input */
        if (inpspec[0] == '!') {
                if (pclose(infp) != 0) {
                        sprintf(errmsg, "bad status from \"%s\"", inpspec);
                        error(WARNING, errmsg);
                }
        } else if (infp != stdin)
                fclose(infp);
#ifdef getc_unlocked
        else
                funlockfile(infp);
#endif
        return(nf);
}


static char *
ogetstr(char *s)                /* get null-terminated string */
{
        if (getstr(s, infp) == NULL)
                octerror(USER, "truncated octree");
        return(s);
}


static OCTREE
getfullnode()                   /* get a set, return fullnode */
{
        OBJECT  set[MAXSET+1];
        int  i;
        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(int siz)                /* get a siz-byte integer */
{
        long  r;

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


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

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

static OCTREE
gettree()                       /* get a pre-ordered octree */
{
        OCTREE   ot;
        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");
        }
        return EMPTY; /* pro forma return */
}


static int
nonsurfintree(OCTREE ot)                /* check tree for modifiers */
{
        OBJECT  set[MAXSET+1];
        int  i;

        if (isempty(ot))
                return(0);
        if (istree(ot)) {
                for (i = 0; i < 8; i++)
                        if (nonsurfintree(octkid(ot, i)))
                                return(1);
                return(0);
        }
        objset(set, ot);
        for (i = set[0]; i > 0; i-- )
                if (ismodifier(objptr(set[i])->otype))
                        return(1);
        return(0);
}


static void
skiptree(void)                          /* skip octree on input */
{
        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 void
octerror(int etyp, char *msg)           /* octree error */
{
        char  msgbuf[128];

        sprintf(msgbuf, "(%s): %s", infn, msg);
        error(etyp, msgbuf);
}
Revision:	2.36
Committed:	Wed Apr 23 01:57:04 2025 UTC (2 weeks, 2 days ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.35:	+8 -12 lines
Log Message:	fix: Functio prototypes and other fixes to reduce compiler warnings
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.36	static const char RCSid[] = "$Id: readoct.c,v 2.35 2025/04/22 14:51:29 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* readoct.c - routines to read octree information.
6	greg	2.13	*/
7
8	greg	2.14	#include "copyright.h"
9	greg	1.1
10	schorsch	2.17	#include <stdio.h>
11	greg	2.19	#include <time.h>
12	schorsch	2.17
13	greg	2.23	#include "platform.h"
14	greg	2.29	#include "paths.h"
15	greg	1.1	#include "standard.h"
16			#include "octree.h"
17			#include "object.h"
18			#include "otypes.h"
19	schorsch	2.17	#include "resolu.h"
20	greg	1.1
21	schorsch	2.20	static double ogetflt(void);
22			static long ogetint(int);
23			static char ogetstr(char );
24	greg	2.27	static int nonsurfintree(OCTREE ot);
25	schorsch	2.17	static void octerror(int etyp, char *msg);
26			static void skiptree(void);
27	schorsch	2.20	static OCTREE getfullnode(void), gettree(void);
28	greg	1.1
29	greg	2.13	static char infn; / input file specification */
30	greg	1.1	static FILE infp; / input file stream */
31	greg	1.14	static int objsize; /* size of stored OBJECT's */
32	greg	1.1	static OBJECT objorig; /* zeroeth object */
33	greg	2.12	static OBJECT fnobjects; /* number of objects in this file */
34	greg	1.1
35
36			int
37	greg	2.27	readoct( /* read in octree file or stream */
38			char *inpspec,
39			int load,
40			CUBE *scene,
41			char *ofn[]
42			)
43	greg	1.1	{
44	greg	2.33	time_t oct_t = 0;
45			time_t last_it = 0;
46	greg	1.11	char sbuf[512];
47	greg	1.1	int nf;
48	greg	2.15	int i;
49	greg	1.15	long m;
50	greg	1.1
51	greg	2.13	if (inpspec == NULL) {
52	greg	1.1	infn = "standard input";
53			infp = stdin;
54	greg	2.13	} else if (inpspec[0] == '!') {
55			infn = inpspec;
56			if ((infp = popen(inpspec+1, "r")) == NULL) {
57			sprintf(errmsg, "cannot execute \"%s\"", inpspec);
58			error(SYSTEM, errmsg);
59			}
60	greg	1.1	} else {
61	greg	2.13	infn = inpspec;
62			if ((infp = fopen(inpspec, "r")) == NULL) {
63	greg	1.1	sprintf(errmsg, "cannot open octree file \"%s\"",
64	greg	2.13	inpspec);
65	greg	1.1	error(SYSTEM, errmsg);
66			}
67	greg	2.33	oct_t = fddate(fileno(infp));
68	greg	1.1	}
69	greg	2.32	#ifdef getc_unlocked /* avoid stupid semaphores */
70			flockfile(infp);
71			#endif
72	schorsch	2.16	SET_FILE_BINARY(infp);
73	greg	1.1	/* get header */
74	greg	2.11	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
75	greg	1.12	octerror(USER, "not an octree");
76	greg	1.1	/* check format */
77	greg	2.4	if ((objsize = ogetint(2)-OCTMAGIC) <= 0 \|\|
78	greg	1.14	objsize > MAXOBJSIZ \|\| objsize > sizeof(long))
79	greg	1.12	octerror(USER, "incompatible octree format");
80	greg	1.1	/* get boundaries */
81			if (load & IO_BOUNDS) {
82			for (i = 0; i < 3; i++)
83	greg	2.4	scene->cuorg[i] = atof(ogetstr(sbuf));
84			scene->cusize = atof(ogetstr(sbuf));
85	greg	1.1	} else {
86			for (i = 0; i < 4; i++)
87	greg	2.4	ogetstr(sbuf);
88	greg	1.1	}
89			objorig = nobjects; /* set object offset */
90			nf = 0; /* get object files */
91	greg	2.4	while (*ogetstr(sbuf)) {
92	greg	1.1	if (load & IO_SCENE)
93			readobj(sbuf);
94			if (load & IO_FILES)
95			ofn[nf] = savqstr(sbuf);
96	greg	2.33	if (oct_t > last_it) {
97			time_t t = fdate(sbuf);
98			if (t > last_it)
99			last_it = t;
100			}
101	greg	1.1	nf++;
102			}
103			if (load & IO_FILES)
104			ofn[nf] = NULL;
105	greg	1.8	/* get number of objects */
106	greg	2.4	fnobjects = m = ogetint(objsize);
107	greg	1.15	if (fnobjects != m)
108			octerror(USER, "too many objects");
109	greg	1.1
110	greg	2.13	if (load & IO_TREE) /* get the octree */
111	greg	1.1	scene->cutree = gettree();
112	greg	2.5	else if (load & IO_SCENE && nf == 0)
113			skiptree();
114
115	schorsch	2.21	if (load & IO_SCENE) { /* get the scene */
116	greg	2.5	if (nf == 0) {
117	greg	2.15	/* load binary scene data */
118			readscene(infp, objsize);
119
120	greg	2.5	} else { /* consistency checks */
121			/* check object count */
122			if (nobjects != objorig+fnobjects)
123			octerror(USER, "bad object count; octree stale?");
124			/* check for non-surfaces */
125	greg	2.33	if (oct_t <= last_it && nonsurfintree(scene->cutree))
126	greg	2.5	octerror(USER, "modifier in tree; octree stale?");
127			}
128	schorsch	2.21	}
129	greg	2.13	/* close the input */
130	greg	2.34	if (inpspec[0] == '!') {
131			if (pclose(infp) != 0) {
132			sprintf(errmsg, "bad status from \"%s\"", inpspec);
133	greg	2.35	error(WARNING, errmsg);
134	greg	2.34	}
135			} else if (infp != stdin)
136	greg	2.13	fclose(infp);
137	greg	2.32	#ifdef getc_unlocked
138			else
139			funlockfile(infp);
140			#endif
141	greg	1.1	return(nf);
142			}
143
144
145			static char *
146	greg	2.27	ogetstr(char s) / get null-terminated string */
147	greg	1.1	{
148	greg	2.4	if (getstr(s, infp) == NULL)
149			octerror(USER, "truncated octree");
150			return(s);
151	greg	1.1	}
152
153
154			static OCTREE
155			getfullnode() /* get a set, return fullnode */
156			{
157	greg	2.7	OBJECT set[MAXSET+1];
158	greg	2.36	int i;
159			long m;
160	greg	1.1
161	greg	2.4	if ((set[0] = ogetint(objsize)) > MAXSET)
162	greg	1.1	octerror(USER, "bad set in getfullnode");
163	greg	1.14	for (i = 1; i <= set[0]; i++) {
164	greg	2.4	m = ogetint(objsize) + objorig;
165	greg	1.15	if ((set[i] = m) != m)
166	greg	1.14	octerror(USER, "too many objects");
167			}
168	greg	1.1	return(fullnode(set));
169			}
170
171
172			static long
173	greg	2.27	ogetint(int siz) /* get a siz-byte integer */
174	greg	1.1	{
175	greg	2.36	long r;
176	greg	1.1
177	greg	2.4	r = getint(siz, infp);
178			if (feof(infp))
179			octerror(USER, "truncated octree");
180	greg	1.1	return(r);
181			}
182
183
184			static double
185	greg	2.4	ogetflt() /* get a floating point number */
186	greg	1.1	{
187	greg	2.7	double r;
188	greg	1.1
189	greg	2.4	r = getflt(infp);
190			if (feof(infp))
191			octerror(USER, "truncated octree");
192			return(r);
193	greg	1.1	}
194
195
196			static OCTREE
197			gettree() /* get a pre-ordered octree */
198			{
199	greg	2.36	OCTREE ot;
200			int i;
201	greg	1.1
202			switch (getc(infp)) {
203			case OT_EMPTY:
204			return(EMPTY);
205			case OT_FULL:
206			return(getfullnode());
207			case OT_TREE:
208			if ((ot = octalloc()) == EMPTY)
209			octerror(SYSTEM, "out of tree space in gettree");
210			for (i = 0; i < 8; i++)
211			octkid(ot, i) = gettree();
212			return(ot);
213	greg	2.5	case EOF:
214			octerror(USER, "truncated octree");
215			default:
216			octerror(USER, "damaged octree");
217			}
218	greg	2.22	return EMPTY; /* pro forma return */
219	greg	2.12	}
220
221
222			static int
223	greg	2.27	nonsurfintree(OCTREE ot) /* check tree for modifiers */
224	greg	2.12	{
225	greg	2.27	OBJECT set[MAXSET+1];
226	greg	2.36	int i;
227	greg	2.12
228	greg	2.27	if (isempty(ot))
229			return(0);
230			if (istree(ot)) {
231			for (i = 0; i < 8; i++)
232			if (nonsurfintree(octkid(ot, i)))
233			return(1);
234			return(0);
235			}
236			objset(set, ot);
237	greg	2.28	for (i = set[0]; i > 0; i-- )
238	greg	2.27	if (ismodifier(objptr(set[i])->otype))
239	greg	2.12	return(1);
240			return(0);
241	greg	2.5	}
242
243
244	schorsch	2.17	static void
245			skiptree(void) /* skip octree on input */
246	greg	2.5	{
247	greg	2.36	int i;
248	greg	2.5
249			switch (getc(infp)) {
250			case OT_EMPTY:
251			return;
252			case OT_FULL:
253	greg	2.6	for (i = ogetint(objsize)*objsize; i-- > 0; )
254			if (getc(infp) == EOF)
255			octerror(USER, "truncated octree");
256	greg	2.5	return;
257			case OT_TREE:
258			for (i = 0; i < 8; i++)
259			skiptree();
260			return;
261	greg	1.1	case EOF:
262			octerror(USER, "truncated octree");
263			default:
264			octerror(USER, "damaged octree");
265			}
266			}
267
268
269	schorsch	2.17	static void
270	greg	2.27	octerror(int etyp, char msg) / octree error */
271	greg	1.1	{
272			char msgbuf[128];
273
274			sprintf(msgbuf, "(%s): %s", infn, msg);
275			error(etyp, msgbuf);
276			}