ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cv/mgflib/parser.c

Comparing ray/src/cv/mgflib/parser.c (file contents):
Revision 1.17 by greg, Tue May 9 14:38:22 1995 UTC vs.
Revision 1.28 by schorsch, Sat Nov 15 17:54:06 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1995 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Parse an MGF file, converting or discarding unsupported entities
6		*/
7
8		#include <stdio.h>
9	+	#include <stdlib.h>
10		#include <math.h>
11		#include <ctype.h>
12		#include <string.h>
#	Line 27 | Line 25 | char   mg_ename[MG_NENTITIES][MG_MAXELEN] = MG_NAMELIST;
25
26		int     (*mg_ehand[MG_NENTITIES])();
27
28	+	/* Handler routine for unknown entities */
29	+
30	+	int     (*mg_uhand)() = mg_defuhand;
31	+
32	+	unsigned        mg_nunknown;    /* count of unknown entities */
33	+
34		/* error messages */
35
36		char    *mg_err[MG_NERRS] = MG_ERRLIST;
#	Line 55 | Line 59 | int    mg_nqcdivs = MG_NQCD;   /* number of divisions per q
59		#define e_ies e_any_toss
60		/* alternate handler routines */
61
62	<	static int      e_any_toss(),           /* discard unneeded entity */
63	<	e_ies(),                /* IES luminaire file */
64	<	e_include(),            /* include file */
61	<	e_sph(),                /* sphere */
62	<	e_cct(),                /* color temperature */
63	<	e_cmix(),               /* color mixtures */
64	<	e_cspec(),              /* color spectra */
65	<	e_cyl(),                /* cylinder */
66	<	e_cone(),               /* cone */
67	<	e_prism(),              /* prism */
68	<	e_ring(),               /* ring */
69	<	e_torus();              /* torus */
62	>	static void make_axes(FVECT u, FVECT v, FVECT w);
63	>	static int put_cxy(void);
64	>	static int put_cspec(void);
65
66	+	static int e_any_toss(int ac, char **av); /* discard an unwanted entity */
67	+	static int e_cspec(int ac, char **av); /* handle spectral color */
68	+	static int e_cmix(int ac, char **av); /* handle mixing of colors */
69	+	static int e_cct(int ac, char **av); /* handle color temperature */
70	+
71	+
72		/* alternate handler support functions */
73
74	<	static int      (*e_supp[MG_NENTITIES])();
74	>	static int      (*e_supp[MG_NENTITIES])(int ac, char **av);
75
76		static char     FLTFMT[] = "%.12g";
77
#	Line 78 | Line 79 | static int     warpconends;            /* hack for generating good n
79
80
81		void
82	<	mg_init()                       /* initialize alternate entity handlers */
82	>	mg_init(void)                   /* initialize alternate entity handlers */
83		{
84		unsigned long   ineed = 0, uneed = 0;
85		register int    i;
#	Line 117 | Line 118 | mg_init()                      /* initialize alternate entity handlers */
118		ineed |= 1L<<MG_E_POINT|1L<<MG_E_NORMAL|1L<<MG_E_VERTEX;
119		} else
120		uneed |= 1L<<MG_E_POINT|1L<<MG_E_NORMAL|1L<<MG_E_VERTEX|1L<<MG_E_XF;
121	+	if (mg_ehand[MG_E_FACE] == NULL)
122	+	mg_ehand[MG_E_FACE] = mg_ehand[MG_E_FACEH];
123	+	else if (mg_ehand[MG_E_FACEH] == NULL)
124	+	mg_ehand[MG_E_FACEH] = e_faceh;
125		if (mg_ehand[MG_E_COLOR] != NULL) {
126		if (mg_ehand[MG_E_CMIX] == NULL) {
127		mg_ehand[MG_E_CMIX] = e_cmix;
#	Line 175 | Line 180 | mg_init()                      /* initialize alternate entity handlers */
180
181
182		int
183	<	mg_entity(name)                 /* get entity number from its name */
184	<	char    *name;
183	>	mg_entity(                      /* get entity number from its name */
184	>	char    *name
185	>	)
186		{
187		static LUTAB    ent_tab = LU_SINIT(NULL,NULL);  /* lookup table */
188		register char   *cp;
#	Line 196 | Line 202 | char   *name;
202
203
204		int
205	<	mg_handle(en, ac, av)           /* pass entity to appropriate handler */
206	<	register int    en;
207	<	int     ac;
208	<	char    **av;
205	>	mg_handle(              /* pass entity to appropriate handler */
206	>	register int    en,
207	>	int     ac,
208	>	char    **av
209	>	)
210		{
211		int     rv;
212
213	<	if (en < 0 && (en = mg_entity(av[0])) < 0)
213	>	if (en < 0 && (en = mg_entity(av[0])) < 0) {    /* unknown entity */
214	>	if (mg_uhand != NULL)
215	>	return((*mg_uhand)(ac, av));
216		return(MG_EUNK);
217	<	if (e_supp[en] != NULL) {
217	>	}
218	>	if (e_supp[en] != NULL) {                       /* support handler */
219		if ((rv = (*e_supp[en])(ac, av)) != MG_OK)
220		return(rv);
221		}
222	<	return((*mg_ehand[en])(ac, av));
222	>	return((*mg_ehand[en])(ac, av));                /* assigned handler */
223		}
224
225
226		int
227	<	mg_open(ctx, fn)                        /* open new input file */
228	<	register MG_FCTXT       *ctx;
229	<	char    *fn;
227	>	mg_open(                        /* open new input file */
228	>	register MG_FCTXT       *ctx,
229	>	char    *fn
230	>	)
231		{
232		static int      nfids;
233		register char   *cp;
#	Line 231 | Line 242 | char   *fn;
242		return(MG_OK);
243		}
244		/* get name relative to this context */
245	<	if (mg_file != NULL && (cp = strrchr(mg_file->fname, '/')) != NULL) {
245	>	if (fn[0] != '/' && mg_file != NULL &&
246	>	(cp = strrchr(mg_file->fname, '/')) != NULL) {
247		strcpy(ctx->fname, mg_file->fname);
248		strcpy(ctx->fname+(cp-mg_file->fname+1), fn);
249		} else
#	Line 246 | Line 258 | char   *fn;
258
259
260		void
261	<	mg_close()                      /* close input file */
261	>	mg_close(void)                  /* close input file */
262		{
263		register MG_FCTXT       *ctx = mg_file;
264
265		mg_file = ctx->prev;            /* restore enclosing context */
266	<	if (ctx->fp == stdin)
267	<	return;                 /* don't close standard input */
256	<	fclose(ctx->fp);
266	>	if (ctx->fp != stdin)           /* close file if it's a file */
267	>	fclose(ctx->fp);
268		}
269
270
271		void
272	<	mg_fgetpos(pos)                 /* get current position in input file */
273	<	register MG_FPOS        *pos;
272	>	mg_fgetpos(                     /* get current position in input file */
273	>	register MG_FPOS        *pos
274	>	)
275		{
264	–	extern long     ftell();
265	–
276		pos->fid = mg_file->fid;
277		pos->lineno = mg_file->lineno;
278		pos->offset = ftell(mg_file->fp);
#	Line 270 | Line 280 | register MG_FPOS       *pos;
280
281
282		int
283	<	mg_fgoto(pos)                   /* reposition input file pointer */
284	<	register MG_FPOS        *pos;
283	>	mg_fgoto(                       /* reposition input file pointer */
284	>	register MG_FPOS        *pos
285	>	)
286		{
287		if (pos->fid != mg_file->fid)
288		return(MG_ESEEK);
#	Line 287 | Line 298 | register MG_FPOS       *pos;
298
299
300		int
301	<	mg_read()                       /* read next line from file */
301	>	mg_read(void)                   /* read next line from file */
302		{
303		register int    len = 0;
304
#	Line 295 | Line 306 | mg_read()                      /* read next line from file */
306		if (fgets(mg_file->inpline+len,
307		MG_MAXLINE-len, mg_file->fp) == NULL)
308		return(len);
298	–	mg_file->lineno++;
309		len += strlen(mg_file->inpline+len);
310	<	if (len > 1 && mg_file->inpline[len-2] == '\\')
311	<	mg_file->inpline[--len-1] = ' ';
312	<	} while (mg_file->inpline[len]);
310	>	if (len >= MG_MAXLINE-1)
311	>	return(len);
312	>	mg_file->lineno++;
313	>	} while (len > 1 && mg_file->inpline[len-2] == '\\');
314
315		return(len);
316		}
317
318
319		int
320	<	mg_parse()                      /* parse current input line */
320	>	mg_parse(void)                  /* parse current input line */
321		{
322		char    abuf[MG_MAXLINE];
323		char    *argv[MG_MAXARGC];
324	<	int     en;
325	<	register char   *cp, **ap;
326	<
327	<	strcpy(cp=abuf, mg_file->inpline);
328	<	ap = argv;                      /* break into words */
324	>	register char   *cp, *cp2, **ap;
325	>	/* copy line, removing escape chars */
326	>	cp = abuf; cp2 = mg_file->inpline;
327	>	while ((*cp++ = *cp2++))
328	>	if (cp2[0] == '\n' && cp2[-1] == '\\')
329	>	cp--;
330	>	cp = abuf; ap = argv;           /* break into words */
331		for ( ; ; ) {
332		while (isspace(*cp))
333		*cp++ = '\0';
#	Line 335 | Line 348 | mg_parse()                     /* parse current input line */
348
349
350		int
351	<	mg_load(fn)                     /* load an MGF file */
352	<	char    *fn;
351	>	mg_load(                        /* load an MGF file */
352	>	char    *fn
353	>	)
354		{
355		MG_FCTXT        cntxt;
356		int     rval;
357	+	register int    nbr;
358
359		if ((rval = mg_open(&cntxt, fn)) != MG_OK) {
360		fprintf(stderr, "%s: %s\n", fn, mg_err[rval]);
361		return(rval);
362		}
363	<	while (mg_read())               /* parse each line */
363	>	while ((nbr = mg_read()) > 0) { /* parse each line */
364	>	if (nbr >= MG_MAXLINE-1) {
365	>	fprintf(stderr, "%s: %d: %s\n", cntxt.fname,
366	>	cntxt.lineno, mg_err[rval=MG_ELINE]);
367	>	break;
368	>	}
369		if ((rval = mg_parse()) != MG_OK) {
370		fprintf(stderr, "%s: %d: %s:\n%s", cntxt.fname,
371		cntxt.lineno, mg_err[rval],
372		cntxt.inpline);
373		break;
374		}
375	+	}
376		mg_close();
377		return(rval);
378		}
379
380
381	+	int
382	+	mg_defuhand(            /* default handler for unknown entities */
383	+	int     ac,
384	+	char    **av
385	+	)
386	+	{
387	+	if (mg_nunknown++ == 0)         /* report first incident */
388	+	fprintf(stderr, "%s: %d: %s: %s\n", mg_file->fname,
389	+	mg_file->lineno, mg_err[MG_EUNK], av[0]);
390	+	return(MG_OK);
391	+	}
392	+
393	+
394		void
395	<	mg_clear()                      /* clear parser history */
395	>	mg_clear(void)                  /* clear parser history */
396		{
397		c_clearall();                   /* clear context tables */
398	<	mg_file = NULL;                 /* reset our context */
398	>	while (mg_file != NULL)         /* reset our file context */
399	>	mg_close();
400		}
401
402
#	Line 371 | Line 406 | mg_clear()                     /* clear parser history */
406
407
408		static int
409	<	e_any_toss(ac, av)              /* discard an unwanted entity */
410	<	int     ac;
411	<	char    **av;
409	>	e_any_toss(             /* discard an unwanted entity */
410	>	int     ac,
411	>	char    **av
412	>	)
413		{
414		return(MG_OK);
415		}
416
417
418	<	static int
419	<	e_include(ac, av)               /* include file */
420	<	int     ac;
421	<	char    **av;
418	>	int
419	>	e_include(              /* include file */
420	>	int     ac,
421	>	char    **av
422	>	)
423		{
424		char    *xfarg[MG_MAXARGC];
425		MG_FCTXT        ictx;
426		XF_SPEC *xf_orig = xf_context;
427	<	int     rv;
427	>	register int    rv;
428
429		if (ac < 2)
430		return(MG_EARGC);
#	Line 400 | Line 437 | char   **av;
437		for (i = 1; i < ac-1; i++)
438		xfarg[i] = av[i+1];
439		xfarg[ac-1] = NULL;
440	<	if ((rv = mg_handle(MG_E_XF, ac-1, xfarg)) != MG_OK)
440	>	if ((rv = mg_handle(MG_E_XF, ac-1, xfarg)) != MG_OK) {
441	>	mg_close();
442		return(rv);
443	+	}
444		}
445		do {
446	<	while (mg_read())
446	>	while ((rv = mg_read()) > 0) {
447	>	if (rv >= MG_MAXLINE-1) {
448	>	fprintf(stderr, "%s: %d: %s\n", ictx.fname,
449	>	ictx.lineno, mg_err[MG_ELINE]);
450	>	mg_close();
451	>	return(MG_EINCL);
452	>	}
453		if ((rv = mg_parse()) != MG_OK) {
454		fprintf(stderr, "%s: %d: %s:\n%s", ictx.fname,
455		ictx.lineno, mg_err[rv],
#	Line 412 | Line 457 | char   **av;
457		mg_close();
458		return(MG_EINCL);
459		}
460	+	}
461		if (ac > 2)
462	<	if ((rv = mg_handle(MG_E_XF, 1, xfarg)) != MG_OK)
462	>	if ((rv = mg_handle(MG_E_XF, 1, xfarg)) != MG_OK) {
463	>	mg_close();
464		return(rv);
465	+	}
466		} while (xf_context != xf_orig);
467		mg_close();
468		return(MG_OK);
469		}
470
471
472	+	int
473	+	e_faceh(                        /* replace face+holes with single contour */
474	+	int     ac,
475	+	char    **av
476	+	)
477	+	{
478	+	char    *newav[MG_MAXARGC];
479	+	int     lastp = 0;
480	+	register int    i, j;
481	+
482	+	newav[0] = mg_ename[MG_E_FACE];
483	+	for (i = 1; i < ac; i++)
484	+	if (av[i][0] == '-') {
485	+	if (i < 4)
486	+	return(MG_EARGC);
487	+	if (i >= ac-1)
488	+	break;
489	+	if (!lastp)
490	+	lastp = i-1;
491	+	for (j = i+1; j < ac-1 && av[j+1][0] != '-'; j++)
492	+	;
493	+	if (j - i < 3)
494	+	return(MG_EARGC);
495	+	newav[i] = av[j];       /* connect hole loop */
496	+	} else
497	+	newav[i] = av[i];       /* hole or perimeter vertex */
498	+	if (lastp)
499	+	newav[i++] = av[lastp];         /* finish seam to outside */
500	+	newav[i] = NULL;
501	+	return(mg_handle(MG_E_FACE, i, newav));
502	+	}
503	+
504	+
505		static void
506	<	make_axes(u, v, w)              /* compute u and v given w (normalized) */
507	<	FVECT   u, v, w;
506	>	make_axes(              /* compute u and v given w (normalized) */
507	>	FVECT   u,
508	>	FVECT   v,
509	>	FVECT   w
510	>	)
511		{
512		register int    i;
513
#	Line 438 | Line 522 | FVECT  u, v, w;
522		}
523
524
525	<	static int
526	<	e_sph(ac, av)                   /* expand a sphere into cones */
527	<	int     ac;
528	<	char    **av;
525	>	int
526	>	e_sph(                  /* expand a sphere into cones */
527	>	int     ac,
528	>	char    **av
529	>	)
530		{
531		static char     p2x[24], p2y[24], p2z[24], r1[24], r2[24];
532		static char     *v1ent[5] = {mg_ename[MG_E_VERTEX],"_sv1","=","_sv2"};
#	Line 490 | Line 575 | char   **av;
575		}
576
577
578	<	static int
579	<	e_torus(ac, av)                 /* expand a torus into cones */
580	<	int     ac;
581	<	char    **av;
578	>	int
579	>	e_torus(                        /* expand a torus into cones */
580	>	int     ac,
581	>	char    **av
582	>	)
583		{
584		static char     p2[3][24], r1[24], r2[24];
585		static char     *v1ent[5] = {mg_ename[MG_E_VERTEX],"_tv1","=","_tv2"};
#	Line 582 | Line 668 | char   **av;
668		}
669
670
671	<	static int
672	<	e_cyl(ac, av)                   /* replace a cylinder with equivalent cone */
673	<	int     ac;
674	<	char    **av;
671	>	int
672	>	e_cyl(                  /* replace a cylinder with equivalent cone */
673	>	int     ac,
674	>	char    **av
675	>	)
676		{
677		static char     *avnew[6] = {mg_ename[MG_E_CONE]};
678
#	Line 599 | Line 686 | char   **av;
686		}
687
688
689	<	static int
690	<	e_ring(ac, av)                  /* turn a ring into polygons */
691	<	int     ac;
692	<	char    **av;
689	>	int
690	>	e_ring(                 /* turn a ring into polygons */
691	>	int     ac,
692	>	char    **av
693	>	)
694		{
695		static char     p3[3][24], p4[3][24];
696		static char     *nzent[5] = {mg_ename[MG_E_NORMAL],"0","0","0"};
#	Line 697 | Line 785 | char   **av;
785		}
786
787
788	<	static int
789	<	e_cone(ac, av)                  /* turn a cone into polygons */
790	<	int     ac;
791	<	char    **av;
788	>	int
789	>	e_cone(                 /* turn a cone into polygons */
790	>	int     ac,
791	>	char    **av
792	>	)
793		{
794		static char     p3[3][24], p4[3][24], n3[3][24], n4[3][24];
795		static char     *v1ent[5] = {mg_ename[MG_E_VERTEX],"_cv1","="};
#	Line 712 | Line 801 | char   **av;
801		static char     *p4ent[5] = {mg_ename[MG_E_POINT],p4[0],p4[1],p4[2]};
802		static char     *n4ent[5] = {mg_ename[MG_E_NORMAL],n4[0],n4[1],n4[2]};
803		static char     *fent[6] = {mg_ename[MG_E_FACE],"_cv1","_cv2","_cv3","_cv4"};
804	+	char    *v1n;
805		register C_VERTEX       *cv1, *cv2;
806		register int    i, j;
807		FVECT   u, v, w;
#	Line 727 | Line 817 | char   **av;
817		if ((cv1 = c_getvert(av[1])) == NULL ||
818		(cv2 = c_getvert(av[3])) == NULL)
819		return(MG_EUNDEF);
820	+	v1n = av[1];
821		if (!isflt(av[2]) || !isflt(av[4]))
822		return(MG_ETYPE);
823		rad1 = atof(av[2]);
#	Line 737 | Line 828 | char   **av;
828		if (rad2 == 0.)
829		return(MG_EILL);
830		} else if (rad2 != 0.) {
831	<	if (rad1 < 0. ^ rad2 < 0.)
831	>	if ((rad1 < 0.) ^ (rad2 < 0.))
832		return(MG_EILL);
833		} else {                        /* swap */
834		C_VERTEX        *cv;
#	Line 745 | Line 836 | char   **av;
836		cv = cv1;
837		cv1 = cv2;
838		cv2 = cv;
839	+	v1n = av[3];
840		d = rad1;
841		rad1 = rad2;
842		rad2 = d;
#	Line 778 | Line 870 | char   **av;
870		if ((rv = mg_handle(MG_E_NORMAL, 4, n3ent)) != MG_OK)
871		return(rv);
872		if (rad1 == 0.) {               /* triangles */
873	<	v1ent[3] = av[1];
873	>	v1ent[3] = v1n;
874		if ((rv = mg_handle(MG_E_VERTEX, 4, v1ent)) != MG_OK)
875		return(rv);
876		for (j = 0; j < 3; j++)
#	Line 864 | Line 956 | char   **av;
956		}
957
958
959	<	static int
960	<	e_prism(ac, av)                 /* turn a prism into polygons */
961	<	int     ac;
962	<	char    **av;
959	>	int
960	>	e_prism(                        /* turn a prism into polygons */
961	>	int     ac,
962	>	char    **av
963	>	)
964		{
965		static char     p[3][24];
966		static char     *vent[5] = {mg_ename[MG_E_VERTEX],NULL,"="};
#	Line 972 | Line 1065 | char   **av;
1065
1066
1067		static int
1068	<	put_cxy()                       /* put out current xy chromaticities */
1068	>	put_cxy(void)                   /* put out current xy chromaticities */
1069		{
1070		static char     xbuf[24], ybuf[24];
1071		static char     *ccom[4] = {mg_ename[MG_E_CXY], xbuf, ybuf};
979	–	int     rv;
1072
1073		sprintf(xbuf, "%.4f", c_ccolor->cx);
1074		sprintf(ybuf, "%.4f", c_ccolor->cy);
1075	<	if ((rv = mg_handle(MG_E_CXY, 3, ccom)) != MG_OK)
984	<	return(rv);
985	<	return(MG_OK);
1075	>	return(mg_handle(MG_E_CXY, 3, ccom));
1076		}
1077
1078
1079		static int
1080	<	put_cspec()                     /* put out current color spectrum */
1080	>	put_cspec(void)                 /* put out current color spectrum */
1081		{
1082		char    wl[2][6], vbuf[C_CNSS][24];
1083		char    *newav[C_CNSS+4];
#	Line 1014 | Line 1104 | put_cspec()                    /* put out current color spectrum */
1104
1105
1106		static int
1107	<	e_cspec(ac, av)                 /* handle spectral color */
1108	<	int     ac;
1109	<	char    **av;
1107	>	e_cspec(                        /* handle spectral color */
1108	>	int     ac,
1109	>	char    **av
1110	>	)
1111		{
1112		/* convert to xy chromaticity */
1113		c_ccvt(c_ccolor, C_CSXY);
#	Line 1028 | Line 1119 | char   **av;
1119
1120
1121		static int
1122	<	e_cmix(ac, av)                  /* handle mixing of colors */
1123	<	int     ac;
1124	<	char    **av;
1122	>	e_cmix(                 /* handle mixing of colors */
1123	>	int     ac,
1124	>	char    **av
1125	>	)
1126		{
1127		/*
1128		* Contorted logic works as follows:
#	Line 1051 | Line 1143 | char   **av;
1143
1144
1145		static int
1146	<	e_cct(ac, av)                   /* handle color temperature */
1147	<	int     ac;
1148	<	char    **av;
1146	>	e_cct(                  /* handle color temperature */
1147	>	int     ac,
1148	>	char    **av
1149	>	)
1150		{
1151		/*
1152		* Logic is similar to e_cmix here.  Support handler has already

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)