src/ot/wfconv.c

#ifndef lint
static const char RCSid[] = "$Id: wfconv.c,v 2.7 2004/01/29 22:21:34 greg Exp $";
#endif
/*
 *  Load Wavefront .OBJ file and convert to triangles with mesh info.
 *  Code borrowed largely from obj2rad.c
 */

#include "copyright.h"
#include "standard.h"
#include "cvmesh.h"
#include <ctype.h>

typedef int     VNDX[3];        /* vertex index (point,map,normal) */

#define CHUNKSIZ        1024    /* vertex allocation chunk size */

#define MAXARG          64      /* maximum # arguments in a statement */

static FVECT    *vlist;         /* our vertex list */
static int      nvs;            /* number of vertices in our list */
static FVECT    *vnlist;        /* vertex normal list */
static int      nvns;
static RREAL    (*vtlist)[2];   /* map vertex list */
static int      nvts;

static char     *inpfile;       /* input file name */
static int      havemats;       /* materials available? */
static char     material[64];   /* current material name */
static char     group[64];      /* current group name */
static int      lineno;         /* current line number */
static int      faceno;         /* current face number */

static int getstmt(char *av[MAXARG], FILE       *fp);
static int cvtndx(VNDX  vi, char        *vs);
static int putface(int  ac, char        **av);
static OBJECT getmod(void);
static int puttri(char  *v1, char       *v2, char       *v3);
static void freeverts(void);
static int newv(double  x, double       y, double       z);
static int newvn(double x, double       y, double       z);
static int newvt(double x, double       y);
static void syntax(char *er);


void
wfreadobj(              /* read in .OBJ file and convert */
        char    *objfn
)
{
        FILE    *fp;
        char    *argv[MAXARG];
        int     argc;
        int     nstats, nunknown;

        if (objfn == NULL) {
                inpfile = "<stdin>";
                fp = stdin;
        } else if ((fp = fopen(inpfile=objfn, "r")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\"", inpfile);
                error(USER, errmsg);
        }
        havemats = (nobjects > 0);
        nstats = nunknown = 0;
        material[0] = '\0';
        group[0] = '\0';
        lineno = 0; faceno = 0;
                                        /* scan until EOF */
        while ( (argc = getstmt(argv, fp)) ) {
                switch (argv[0][0]) {
                case 'v':               /* vertex */
                        switch (argv[0][1]) {
                        case '\0':                      /* point */
                                if (badarg(argc-1,argv+1,"fff"))
                                        syntax("bad vertex");
                                newv(atof(argv[1]), atof(argv[2]),
                                                atof(argv[3]));
                                break;
                        case 'n':                       /* normal */
                                if (argv[0][2])
                                        goto unknown;
                                if (badarg(argc-1,argv+1,"fff"))
                                        syntax("bad normal");
                                if (!newvn(atof(argv[1]), atof(argv[2]),
                                                atof(argv[3])))
                                        syntax("zero normal");
                                break;
                        case 't':                       /* coordinate */
                                if (argv[0][2])
                                        goto unknown;
                                if (badarg(argc-1,argv+1,"ff"))
                                        goto unknown;
                                newvt(atof(argv[1]), atof(argv[2]));
                                break;
                        default:
                                goto unknown;
                        }
                        break;
                case 'f':                               /* face */
                        if (argv[0][1])
                                goto unknown;
                        faceno++;
                        switch (argc-1) {
                        case 0: case 1: case 2:
                                syntax("too few vertices");
                                break;
                        case 3:
                                if (!puttri(argv[1], argv[2], argv[3]))
                                        syntax("bad triangle");
                                break;
                        default:
                                if (!putface(argc-1, argv+1))
                                        syntax("bad face");
                                break;
                        }
                        break;
                case 'u':                               /* usemtl/usemap */
                        if (!strcmp(argv[0], "usemap"))
                                break;
                        if (strcmp(argv[0], "usemtl"))
                                goto unknown;
                        if (argc > 1)
                                strcpy(material, argv[1]);
                        else
                                material[0] = '\0';
                        break;
                case 'o':               /* object name */
                        if (argv[0][1])
                                goto unknown;
                        break;
                case 'g':               /* group name */
                        if (argv[0][1])
                                goto unknown;
                        if (argc > 1)
                                strcpy(group, argv[1]);
                        else
                                group[0] = '\0';
                        break;
                case '#':               /* comment */
                        break;
                default:;               /* something we don't deal with */
                unknown:
                        nunknown++;
                        break;
                }
                nstats++;
        }
                                /* clean up */
        freeverts();
        fclose(fp);
        if (nunknown > 0) {
                sprintf(errmsg, "%d of %d statements unrecognized",
                                nunknown, nstats);
                error(WARNING, errmsg);
        }
}


static int
getstmt(                                /* read the next statement from fp */
        register char   *av[MAXARG],
        FILE    *fp
)
{
        static char     sbuf[MAXARG*16];
        register char   *cp;
        register int    i;

        do {
                if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
                        return(0);
                i = 0;
                for ( ; ; ) {
                        while (isspace(*cp) || *cp == '\\') {
                                if (*cp == '\n')
                                        lineno++;
                                *cp++ = '\0';
                        }
                        if (!*cp || i >= MAXARG-1)
                                break;
                        av[i++] = cp;
                        while (*++cp && !isspace(*cp))
                                ;
                }
                av[i] = NULL;
                lineno++;
        } while (!i);

        return(i);
}


static int
cvtndx(                         /* convert vertex string to index */
        register VNDX   vi,
        register char   *vs
)
{
                                        /* get point */
        vi[0] = atoi(vs);
        if (vi[0] > 0) {
                if (vi[0]-- > nvs)
                        return(0);
        } else if (vi[0] < 0) {
                vi[0] += nvs;
                if (vi[0] < 0)
                        return(0);
        } else
                return(0);
                                        /* get map coord. */
        while (*vs)
                if (*vs++ == '/')
                        break;
        vi[1] = atoi(vs);
        if (vi[1] > 0) {
                if (vi[1]-- > nvts)
                        return(0);
        } else if (vi[1] < 0) {
                vi[1] += nvts;
                if (vi[1] < 0)
                        return(0);
        } else
                vi[1] = -1;
                                        /* get normal */
        while (*vs)
                if (*vs++ == '/')
                        break;
        vi[2] = atoi(vs);
        if (vi[2] > 0) {
                if (vi[2]-- > nvns)
                        return(0);
        } else if (vi[2] < 0) {
                vi[2] += nvns;
                if (vi[2] < 0)
                        return(0);
        } else
                vi[2] = -1;
        return(1);
}


static int
putface(                                /* put out an N-sided polygon */
        int     ac,
        register char   **av
)
{
        char            *cp;
        register int    i;

        while (ac > 3) {                /* break into triangles */
                if (!puttri(av[0], av[1], av[2]))
                        return(0);
                ac--;                   /* remove vertex & rotate */
                cp = av[0];
                for (i = 0; i < ac-1; i++)
                        av[i] = av[i+2];
                av[i] = cp;
        }
        return(puttri(av[0], av[1], av[2]));
}


static OBJECT
getmod(void)                            /* get current modifier ID */
{
        char    *mnam;
        OBJECT  mod;

        if (!havemats)
                return(OVOID);
        if (!strcmp(material, VOIDID))
                return(OVOID);
        if (material[0])                /* prefer usemtl statements */
                mnam = material;
        else if (group[0])              /* else use group name */
                mnam = group;
        else
                return(OVOID);
        mod = modifier(mnam);
        if (mod == OVOID) {
                sprintf(errmsg, "%s: undefined modifier \"%s\"",
                                inpfile, mnam);
                error(USER, errmsg);
        }
        return(mod);
}


static int
puttri(                 /* convert a triangle */
        char    *v1,
        char    *v2,
        char    *v3
)
{
        VNDX    v1i, v2i, v3i;
        RREAL   *v1c, *v2c, *v3c;
        RREAL   *v1n, *v2n, *v3n;
        
        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3)) {
                error(WARNING, "bad vertex reference");
                return(0);
        }
        if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
                v1c = vtlist[v1i[1]];
                v2c = vtlist[v2i[1]];
                v3c = vtlist[v3i[1]];
        } else
                v1c = v2c = v3c = NULL;

        if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
                v1n = vnlist[v1i[2]];
                v2n = vnlist[v2i[2]];
                v3n = vnlist[v3i[2]];
        } else
                v1n = v2n = v3n = NULL;
        
        return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
                        v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
}


static void
freeverts(void)                 /* free all vertices */
{
        if (nvs) {
                free((void *)vlist);
                nvs = 0;
        }
        if (nvts) {
                free((void *)vtlist);
                nvts = 0;
        }
        if (nvns) {
                free((void *)vnlist);
                nvns = 0;
        }
}


static int
newv(                   /* create a new vertex */
        double  x,
        double  y,
        double  z
)
{
        if (!(nvs%CHUNKSIZ)) {          /* allocate next block */
                if (nvs == 0)
                        vlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
                else
                        vlist = (FVECT *)realloc((void *)vlist,
                                        (nvs+CHUNKSIZ)*sizeof(FVECT));
                if (vlist == NULL)
                        error(SYSTEM, "out of memory in newv");
        }
                                        /* assign new vertex */
        vlist[nvs][0] = x;
        vlist[nvs][1] = y;
        vlist[nvs][2] = z;
        return(++nvs);
}


static int
newvn(                  /* create a new vertex normal */
        double  x,
        double  y,
        double  z
)
{
        if (!(nvns%CHUNKSIZ)) {         /* allocate next block */
                if (nvns == 0)
                        vnlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
                else
                        vnlist = (FVECT *)realloc((void *)vnlist,
                                        (nvns+CHUNKSIZ)*sizeof(FVECT));
                if (vnlist == NULL)
                        error(SYSTEM, "out of memory in newvn");
        }
                                        /* assign new normal */
        vnlist[nvns][0] = x;
        vnlist[nvns][1] = y;
        vnlist[nvns][2] = z;
        if (normalize(vnlist[nvns]) == 0.0)
                return(0);
        return(++nvns);
}


static int
newvt(                  /* create a new texture map vertex */
        double  x,
        double  y
)
{
        if (!(nvts%CHUNKSIZ)) {         /* allocate next block */
                if (nvts == 0)
                        vtlist = (RREAL (*)[2])malloc(CHUNKSIZ*2*sizeof(RREAL));
                else
                        vtlist = (RREAL (*)[2])realloc((void *)vtlist,
                                        (nvts+CHUNKSIZ)*2*sizeof(RREAL));
                if (vtlist == NULL)
                        error(SYSTEM, "out of memory in newvt");
        }
                                        /* assign new vertex */
        vtlist[nvts][0] = x;
        vtlist[nvts][1] = y;
        return(++nvts);
}


static void
syntax(                 /* report syntax error and exit */
        char    *er
)
{
        sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
                        inpfile, lineno, er);
        error(USER, errmsg);
}
Revision:	2.8
Committed:	Sat Mar 27 12:41:45 2004 UTC (20 years ago) by schorsch
Content type:	text/plain
Branch:	MAIN
Changes since 2.7:	+50 -35 lines
Log Message:	Continued ANSIfication. Renamed local initotypes() to ot_initotypes().
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	schorsch	2.8	static const char RCSid[] = "$Id: wfconv.c,v 2.7 2004/01/29 22:21:34 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Load Wavefront .OBJ file and convert to triangles with mesh info.
6			* Code borrowed largely from obj2rad.c
7			*/
8
9			#include "copyright.h"
10			#include "standard.h"
11			#include "cvmesh.h"
12			#include <ctype.h>
13
14			typedef int VNDX[3]; /* vertex index (point,map,normal) */
15
16			#define CHUNKSIZ 1024 /* vertex allocation chunk size */
17
18			#define MAXARG 64 /* maximum # arguments in a statement */
19
20	greg	2.3	static FVECT vlist; / our vertex list */
21			static int nvs; /* number of vertices in our list */
22			static FVECT vnlist; / vertex normal list */
23			static int nvns;
24	schorsch	2.5	static RREAL (vtlist)[2]; / map vertex list */
25	greg	2.3	static int nvts;
26
27			static char inpfile; / input file name */
28			static int havemats; /* materials available? */
29			static char material[64]; /* current material name */
30			static char group[64]; /* current group name */
31			static int lineno; /* current line number */
32			static int faceno; /* current face number */
33
34	schorsch	2.8	static int getstmt(char av[MAXARG], FILE fp);
35			static int cvtndx(VNDX vi, char *vs);
36			static int putface(int ac, char **av);
37			static OBJECT getmod(void);
38			static int puttri(char v1, char v2, char *v3);
39			static void freeverts(void);
40			static int newv(double x, double y, double z);
41			static int newvn(double x, double y, double z);
42			static int newvt(double x, double y);
43			static void syntax(char *er);
44	greg	2.1
45
46	greg	2.3	void
47	schorsch	2.8	wfreadobj( /* read in .OBJ file and convert */
48			char *objfn
49			)
50	greg	2.1	{
51			FILE *fp;
52			char *argv[MAXARG];
53			int argc;
54			int nstats, nunknown;
55
56			if (objfn == NULL) {
57			inpfile = "<stdin>";
58			fp = stdin;
59			} else if ((fp = fopen(inpfile=objfn, "r")) == NULL) {
60			sprintf(errmsg, "cannot open \"%s\"", inpfile);
61			error(USER, errmsg);
62			}
63	greg	2.3	havemats = (nobjects > 0);
64	greg	2.1	nstats = nunknown = 0;
65	greg	2.3	material[0] = '\0';
66			group[0] = '\0';
67	greg	2.1	lineno = 0; faceno = 0;
68			/* scan until EOF */
69	schorsch	2.6	while ( (argc = getstmt(argv, fp)) ) {
70	greg	2.1	switch (argv[0][0]) {
71			case 'v': /* vertex */
72			switch (argv[0][1]) {
73			case '\0': /* point */
74			if (badarg(argc-1,argv+1,"fff"))
75	greg	2.2	syntax("bad vertex");
76	greg	2.1	newv(atof(argv[1]), atof(argv[2]),
77			atof(argv[3]));
78			break;
79			case 'n': /* normal */
80			if (argv[0][2])
81			goto unknown;
82			if (badarg(argc-1,argv+1,"fff"))
83	greg	2.2	syntax("bad normal");
84	greg	2.1	if (!newvn(atof(argv[1]), atof(argv[2]),
85			atof(argv[3])))
86	greg	2.2	syntax("zero normal");
87	greg	2.1	break;
88	greg	2.2	case 't': /* coordinate */
89	greg	2.1	if (argv[0][2])
90			goto unknown;
91			if (badarg(argc-1,argv+1,"ff"))
92			goto unknown;
93			newvt(atof(argv[1]), atof(argv[2]));
94			break;
95			default:
96			goto unknown;
97			}
98			break;
99			case 'f': /* face */
100			if (argv[0][1])
101			goto unknown;
102			faceno++;
103			switch (argc-1) {
104			case 0: case 1: case 2:
105	greg	2.2	syntax("too few vertices");
106	greg	2.1	break;
107			case 3:
108			if (!puttri(argv[1], argv[2], argv[3]))
109	greg	2.2	syntax("bad triangle");
110	greg	2.1	break;
111			default:
112			if (!putface(argc-1, argv+1))
113	greg	2.2	syntax("bad face");
114	greg	2.1	break;
115			}
116			break;
117	greg	2.3	case 'u': /* usemtl/usemap */
118			if (!strcmp(argv[0], "usemap"))
119			break;
120			if (strcmp(argv[0], "usemtl"))
121	greg	2.1	goto unknown;
122	greg	2.3	if (argc > 1)
123			strcpy(material, argv[1]);
124			else
125			material[0] = '\0';
126	greg	2.1	break;
127			case 'o': /* object name */
128			if (argv[0][1])
129			goto unknown;
130			break;
131	greg	2.3	case 'g': /* group name */
132	greg	2.1	if (argv[0][1])
133			goto unknown;
134	greg	2.3	if (argc > 1)
135			strcpy(group, argv[1]);
136			else
137			group[0] = '\0';
138	greg	2.1	break;
139			case '#': /* comment */
140			break;
141			default:; /* something we don't deal with */
142			unknown:
143			nunknown++;
144			break;
145			}
146			nstats++;
147			}
148			/* clean up */
149			freeverts();
150			fclose(fp);
151			if (nunknown > 0) {
152			sprintf(errmsg, "%d of %d statements unrecognized",
153			nunknown, nstats);
154			error(WARNING, errmsg);
155			}
156			}
157
158
159	greg	2.3	static int
160	schorsch	2.8	getstmt( /* read the next statement from fp */
161			register char *av[MAXARG],
162			FILE *fp
163			)
164	greg	2.1	{
165	greg	2.3	static char sbuf[MAXARG*16];
166	greg	2.1	register char *cp;
167			register int i;
168
169			do {
170			if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
171			return(0);
172			i = 0;
173			for ( ; ; ) {
174			while (isspace(cp) \|\| cp == '\\') {
175			if (*cp == '\n')
176			lineno++;
177			*cp++ = '\0';
178			}
179			if (!*cp \|\| i >= MAXARG-1)
180			break;
181			av[i++] = cp;
182			while (++cp && !isspace(cp))
183			;
184			}
185			av[i] = NULL;
186			lineno++;
187			} while (!i);
188
189			return(i);
190			}
191
192
193	greg	2.3	static int
194	schorsch	2.8	cvtndx( /* convert vertex string to index */
195			register VNDX vi,
196			register char *vs
197			)
198	greg	2.1	{
199			/* get point */
200			vi[0] = atoi(vs);
201			if (vi[0] > 0) {
202			if (vi[0]-- > nvs)
203			return(0);
204			} else if (vi[0] < 0) {
205			vi[0] += nvs;
206			if (vi[0] < 0)
207			return(0);
208			} else
209			return(0);
210			/* get map coord. */
211			while (*vs)
212			if (*vs++ == '/')
213			break;
214			vi[1] = atoi(vs);
215			if (vi[1] > 0) {
216			if (vi[1]-- > nvts)
217			return(0);
218			} else if (vi[1] < 0) {
219			vi[1] += nvts;
220			if (vi[1] < 0)
221			return(0);
222			} else
223			vi[1] = -1;
224			/* get normal */
225			while (*vs)
226			if (*vs++ == '/')
227			break;
228			vi[2] = atoi(vs);
229			if (vi[2] > 0) {
230			if (vi[2]-- > nvns)
231			return(0);
232			} else if (vi[2] < 0) {
233			vi[2] += nvns;
234			if (vi[2] < 0)
235			return(0);
236			} else
237			vi[2] = -1;
238			return(1);
239			}
240
241
242	greg	2.3	static int
243	schorsch	2.8	putface( /* put out an N-sided polygon */
244			int ac,
245			register char **av
246			)
247	greg	2.1	{
248			char *cp;
249			register int i;
250
251			while (ac > 3) { /* break into triangles */
252			if (!puttri(av[0], av[1], av[2]))
253			return(0);
254			ac--; /* remove vertex & rotate */
255			cp = av[0];
256			for (i = 0; i < ac-1; i++)
257			av[i] = av[i+2];
258			av[i] = cp;
259			}
260			return(puttri(av[0], av[1], av[2]));
261			}
262
263
264	greg	2.3	static OBJECT
265	schorsch	2.8	getmod(void) /* get current modifier ID */
266	greg	2.3	{
267			char *mnam;
268			OBJECT mod;
269
270			if (!havemats)
271			return(OVOID);
272			if (!strcmp(material, VOIDID))
273			return(OVOID);
274			if (material[0]) /* prefer usemtl statements */
275			mnam = material;
276			else if (group[0]) /* else use group name */
277			mnam = group;
278			else
279			return(OVOID);
280			mod = modifier(mnam);
281			if (mod == OVOID) {
282			sprintf(errmsg, "%s: undefined modifier \"%s\"",
283			inpfile, mnam);
284			error(USER, errmsg);
285			}
286			return(mod);
287			}
288
289
290			static int
291	schorsch	2.8	puttri( /* convert a triangle */
292			char *v1,
293			char *v2,
294			char *v3
295			)
296	greg	2.1	{
297			VNDX v1i, v2i, v3i;
298	schorsch	2.5	RREAL v1c, v2c, *v3c;
299			RREAL v1n, v2n, *v3n;
300	greg	2.2
301	greg	2.7	if (!cvtndx(v1i, v1) \|\| !cvtndx(v2i, v2) \|\| !cvtndx(v3i, v3)) {
302			error(WARNING, "bad vertex reference");
303	greg	2.1	return(0);
304	greg	2.7	}
305	greg	2.1	if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
306			v1c = vtlist[v1i[1]];
307			v2c = vtlist[v2i[1]];
308			v3c = vtlist[v3i[1]];
309			} else
310			v1c = v2c = v3c = NULL;
311
312			if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
313			v1n = vnlist[v1i[2]];
314			v2n = vnlist[v2i[2]];
315			v3n = vnlist[v3i[2]];
316			} else
317			v1n = v2n = v3n = NULL;
318
319	greg	2.3	return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
320	greg	2.1	v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
321			}
322
323
324	greg	2.3	static void
325	schorsch	2.8	freeverts(void) /* free all vertices */
326	greg	2.1	{
327			if (nvs) {
328			free((void *)vlist);
329			nvs = 0;
330			}
331			if (nvts) {
332			free((void *)vtlist);
333			nvts = 0;
334			}
335			if (nvns) {
336			free((void *)vnlist);
337			nvns = 0;
338			}
339			}
340
341
342	greg	2.3	static int
343	schorsch	2.8	newv( /* create a new vertex */
344			double x,
345			double y,
346			double z
347			)
348	greg	2.1	{
349			if (!(nvs%CHUNKSIZ)) { /* allocate next block */
350			if (nvs == 0)
351			vlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
352			else
353	greg	2.4	vlist = (FVECT )realloc((void )vlist,
354	greg	2.1	(nvs+CHUNKSIZ)*sizeof(FVECT));
355	greg	2.2	if (vlist == NULL)
356			error(SYSTEM, "out of memory in newv");
357	greg	2.1	}
358			/* assign new vertex */
359			vlist[nvs][0] = x;
360			vlist[nvs][1] = y;
361			vlist[nvs][2] = z;
362			return(++nvs);
363			}
364
365
366	greg	2.3	static int
367	schorsch	2.8	newvn( /* create a new vertex normal */
368			double x,
369			double y,
370			double z
371			)
372	greg	2.1	{
373			if (!(nvns%CHUNKSIZ)) { /* allocate next block */
374			if (nvns == 0)
375			vnlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
376			else
377	greg	2.4	vnlist = (FVECT )realloc((void )vnlist,
378	greg	2.1	(nvns+CHUNKSIZ)*sizeof(FVECT));
379	greg	2.2	if (vnlist == NULL)
380			error(SYSTEM, "out of memory in newvn");
381	greg	2.1	}
382			/* assign new normal */
383			vnlist[nvns][0] = x;
384			vnlist[nvns][1] = y;
385			vnlist[nvns][2] = z;
386			if (normalize(vnlist[nvns]) == 0.0)
387			return(0);
388			return(++nvns);
389			}
390
391
392	greg	2.3	static int
393	schorsch	2.8	newvt( /* create a new texture map vertex */
394			double x,
395			double y
396			)
397	greg	2.1	{
398			if (!(nvts%CHUNKSIZ)) { /* allocate next block */
399			if (nvts == 0)
400	schorsch	2.5	vtlist = (RREAL ()[2])malloc(CHUNKSIZ2*sizeof(RREAL));
401	greg	2.1	else
402	schorsch	2.5	vtlist = (RREAL ()[2])realloc((void )vtlist,
403			(nvts+CHUNKSIZ)2sizeof(RREAL));
404	greg	2.2	if (vtlist == NULL)
405			error(SYSTEM, "out of memory in newvt");
406	greg	2.1	}
407			/* assign new vertex */
408			vtlist[nvts][0] = x;
409			vtlist[nvts][1] = y;
410			return(++nvts);
411			}
412
413
414	greg	2.3	static void
415	schorsch	2.8	syntax( /* report syntax error and exit */
416			char *er
417			)
418	greg	2.1	{
419	greg	2.2	sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
420	greg	2.1	inpfile, lineno, er);
421	greg	2.2	error(USER, errmsg);
422	greg	2.1	}