ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/mgflib/parser.h
(Generate patch)

Comparing ray/src/cv/mgflib/parser.h (file contents):
Revision 1.22 by greg, Wed May 10 17:46:05 1995 UTC vs.
Revision 1.34 by schorsch, Sat Jun 7 01:11:17 2003 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1995 Regents of the University of California */
2 <
3 < /* SCCSid "$SunId$ LBL" */
4 <
1 > /* RCSid: $Id$ */
2   /*
3   * Header file for MGF interpreter
4   */
5 + #ifndef _MGF_PARSER_H_
6 + #define _MGF_PARSER_H_
7 + #ifdef __cplusplus
8 + extern "C" {
9 + #endif
10  
9 /* must include stdio.h before us */
11  
12 <                        /* Entities (order doesn't really matter) */
12 > #ifndef MG_VMAJOR
13 >
14 > /* must include stdio.h and stdlib.h before us */
15 >
16 > #define MG_VMAJOR       2               /* major version number */
17 > #define MG_VMINOR       0               /* minor version number */
18 >
19 >                        /* Entities (list is only appended, never modified) */
20   #define MG_E_COMMENT    0               /* #            */
21   #define MG_E_COLOR      1               /* c            */
22   #define MG_E_CCT        2               /* cct          */
# Line 37 | Line 45
45   #define MG_E_TS         25              /* ts           */
46   #define MG_E_VERTEX     26              /* v            */
47   #define MG_E_XF         27              /* xf           */
48 +                        /* end of Version 1 entities */
49 + #define MG_E_FACEH      28              /* fh           */
50 +                        /* end of Version 2 entities */
51  
52 < #define MG_NENTITIES    28              /* total # entities */
52 > #define MG_NENTITIES    29              /* total # entities */
53  
54 + #define MG_NELIST       {28,29}         /* entity count for version 1 and up */
55 +
56   #define MG_NAMELIST     {"#","c","cct","cone","cmix","cspec","cxy","cyl","ed",\
57                          "f","i","ies","ir","m","n","o","p","prism","rd",\
58 <                        "ring","rs","sides","sph","td","torus","ts","v","xf"}
58 >                        "ring","rs","sides","sph","td","torus","ts","v","xf",\
59 >                        "fh"}
60  
61   #define MG_MAXELEN      6
62  
63   extern char     mg_ename[MG_NENTITIES][MG_MAXELEN];
64  
65 <                        /* Handler routines for each entity */
52 <
53 < #ifdef NOPROTO
54 < extern int      (*mg_ehand[MG_NENTITIES])();
55 < #else
65 >                        /* Handler routines for each entity and unknown ones */
66   extern int      (*mg_ehand[MG_NENTITIES])(int argc, char **argv);
67 < #endif
67 > extern int      (*mg_uhand)(int argc, char **argv);
68 > extern int      mg_defuhand(int, char **);
69  
70 + extern unsigned mg_nunknown;            /* count of unknown entities */
71 +
72                          /* Error codes */
73   #define MG_OK           0               /* normal return value */
74   #define MG_EUNK         1               /* unknown entity */
# Line 68 | Line 81 | extern int     (*mg_ehand[MG_NENTITIES])(int argc, char **
81   #define MG_EMEM         8               /* out of memory */
82   #define MG_ESEEK        9               /* file seek error */
83   #define MG_EBADMAT      10              /* bad material specification */
84 + #define MG_ELINE        11              /* input line too long */
85 + #define MG_ECNTXT       12              /* unmatched context close */
86  
87 < #define MG_NERRS        11
87 > #define MG_NERRS        13
88  
89 < extern char     *mg_err[MG_NERRS];
89 > extern char     *mg_err[MG_NERRS];      /* list of error messages */
90  
91   /*
92   * The general process for running the parser is to fill in the mg_ehand
# Line 112 | Line 127 | typedef struct {
127  
128   extern MG_FCTXT *mg_file;               /* current file context */
129  
115 #ifdef NOPROTO
116 extern void     mg_init();              /* fill in mg_ehand array */
117 extern int      mg_load();              /* parse a file */
118 extern int      mg_open();              /* open new input file */
119 extern int      mg_read();              /* read next line */
120 extern int      mg_parse();             /* parse current line */
121 extern void     mg_fgetpos();           /* get position on input file */
122 extern int      mg_fgoto();             /* go to position on input file */
123 extern void     mg_close();             /* close input file */
124 extern void     mg_clear();             /* clear parser */
125 extern int      mg_handle();            /* handle an entity */
126 #else
130   extern void     mg_init(void);          /* fill in mg_ehand array */
131   extern int      mg_load(char *);        /* parse a file */
132   extern int      mg_open(MG_FCTXT *, char *);    /* open new input file */
# Line 134 | Line 137 | extern int     mg_fgoto(MG_FPOS *);    /* go to position on i
137   extern void     mg_close(void);         /* close input file */
138   extern void     mg_clear(void);         /* clear parser */
139   extern int      mg_handle(int, int, char **);   /* handle an entity */
137 #endif
140  
141   #ifndef MG_NQCD
142   #define MG_NQCD         5               /* default number of divisions */
# Line 146 | Line 148 | extern int     mg_nqcdivs;             /* divisions per quarter circl
148   * The following library routines are included for your convenience:
149   */
150  
149 #ifdef NOPROTO
150 extern int mg_entity();                 /* get entity number from its name */
151 extern int isint();                     /* non-zero if integer format */
152 extern int isflt();                     /* non-zero if floating point format */
153 extern int isname();                    /* non-zero if legal identifier name */
154 #else
151   extern int mg_entity(char *);           /* get entity number from its name */
152   extern int isint(char *);               /* non-zero if integer format */
153 + extern int isintd(char *, char *);      /* same with delimiter set */
154   extern int isflt(char *);               /* non-zero if floating point format */
155 + extern int isfltd(char *, char *);      /* same with delimiter set */
156   extern int isname(char *);              /* non-zero if legal identifier name */
157 < #endif
157 > extern int badarg(int, char **, char *);/* check argument format */
158 > extern int e_include(int, char **);     /* expand include entity */
159 > extern int e_pipe(int, char **);        /* expand piped command */
160 > extern int e_sph(int, char **);         /* expand sphere as other entities */
161 > extern int e_torus(int, char **);       /* expand torus as other entities */
162 > extern int e_cyl(int, char **);         /* expand cylinder as other entities */
163 > extern int e_ring(int, char **);        /* expand ring as other entities */
164 > extern int e_cone(int, char **);        /* expand cone as other entities */
165 > extern int e_prism(int, char **);       /* expand prism as other entities */
166 > extern int e_faceh(int, char **);       /* expand face w/ holes as face */
167  
168   /************************************************************************
169   *      Definitions for 3-d vector manipulation functions
# Line 183 | Line 190 | typedef FLOAT  FVECT[3];
190  
191   #define round0(x)       if (x <= FTINY && x >= -FTINY) x = 0
192  
186 #ifdef NOPROTO
187 extern double   normalize();            /* normalize a vector */
188 #else
193   extern double   normalize(FVECT);       /* normalize a vector */
194 < #endif
194 > extern void     fcross(FVECT,FVECT,FVECT);/* cross product of two vectors */
195  
196   /************************************************************************
197   *      Definitions for context handling routines
# Line 208 | Line 212 | extern double  normalize(FVECT);       /* normalize a vector
212   #define C_CSEFF         020             /* flag if efficacy set */
213  
214   typedef struct {
215 <        int     clock;                  /* incremented each change */
216 <        short   flags;                  /* what's been set */
217 <        short   ssamp[C_CNSS];          /* spectral samples, min wl to max */
218 <        long    ssum;                   /* straight sum of spectral values */
219 <        float   cx, cy;                 /* xy chromaticity value */
220 <        float   eff;                    /* efficacy (lumens/watt) */
215 >        int     clock;          /* incremented each change */
216 >        char    *client_data;   /* pointer to private client-owned data */
217 >        short   flags;          /* what's been set */
218 >        short   ssamp[C_CNSS];  /* spectral samples, min wl to max */
219 >        long    ssum;           /* straight sum of spectral values */
220 >        float   cx, cy;         /* xy chromaticity value */
221 >        float   eff;            /* efficacy (lumens/watt) */
222   } C_COLOR;
223  
224 < #define C_DEFCOLOR      { 1, C_CDXY|C_CSXY|C_CSSPEC|C_CSEFF,\
224 > #define C_DEFCOLOR      { 1, NULL, C_CDXY|C_CSXY|C_CSSPEC|C_CSEFF,\
225                          {C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
226                          C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
227                          C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
# Line 232 | Line 237 | typedef struct {
237  
238   typedef struct {
239          int     clock;          /* incremented each change -- resettable */
240 +        char    *client_data;   /* pointer to private client-owned data */
241          int     sided;          /* 1 if surface is 1-sided, 0 for 2-sided */
242          float   nr, ni;         /* index of refraction, real and imaginary */
243          float   rd;             /* diffuse reflectance */
# Line 250 | Line 256 | typedef struct {
256  
257   typedef struct {
258          int     clock;          /* incremented each change -- resettable */
259 +        char    *client_data;   /* pointer to private client-owned data */
260          FVECT   p, n;           /* point and normal */
261   } C_VERTEX;             /* vertex context */
262  
263 < #define C_DEFMATERIAL   {1,0,1.,0.,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,C_DEFCOLOR,\
264 <                                        0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
265 < #define C_DEFVERTEX     {1,{0.,0.,0.},{0.,0.,0.}}
263 > #define C_DEFMATERIAL   {1,NULL,0,1.,0.,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,\
264 >                                C_DEFCOLOR,0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
265 > #define C_DEFVERTEX     {1,NULL,{0.,0.,0.},{0.,0.,0.}}
266  
267   extern C_COLOR          *c_ccolor;      /* the current color */
268   extern char             *c_ccname;      /* current color name */
# Line 264 | Line 271 | extern char            *c_cmname;      /* current material name */
271   extern C_VERTEX         *c_cvertex;     /* the current vertex */
272   extern char             *c_cvname;      /* current vertex name */
273  
267 #ifdef NOPROTO
268 extern int      c_hcolor();                     /* handle color entity */
269 extern int      c_hmaterial();                  /* handle material entity */
270 extern int      c_hvertex();                    /* handle vertex entity */
271 extern void     c_clearall();                   /* clear context tables */
272 extern C_MATERIAL       *c_getmaterial();       /* get a named material */
273 extern C_VERTEX *c_getvert();                   /* get a named vertex */
274 extern C_COLOR  *c_getcolor();                  /* get a named color */
275 extern void     c_ccvt();                       /* fix color representation */
276 extern int      c_isgrey();                     /* check if color is grey */
277 #else
274   extern int      c_hcolor(int, char **);         /* handle color entity */
275   extern int      c_hmaterial(int, char **);      /* handle material entity */
276   extern int      c_hvertex(int, char **);        /* handle vertex entity */
# Line 284 | Line 280 | extern C_VERTEX        *c_getvert(char *);             /* get a named ve
280   extern C_COLOR  *c_getcolor(char *);            /* get a named color */
281   extern void     c_ccvt(C_COLOR *, int);         /* fix color representation */
282   extern int      c_isgrey(C_COLOR *);            /* check if color is grey */
287 #endif
283  
284   /*************************************************************************
285   *      Definitions for hierarchical object name handler
# Line 293 | Line 288 | extern int     c_isgrey(C_COLOR *);            /* check if color is
288   extern int      obj_nnames;             /* depth of name hierarchy */
289   extern char     **obj_name;             /* names in hierarchy */
290  
296 #ifdef NOPROTO
297 extern int      obj_handler();                  /* handle an object entity */
298 extern void     obj_clear();                    /* clear object stack */
299 #else
291   extern int      obj_handler(int, char **);      /* handle an object entity */
292   extern void     obj_clear(void);                /* clear object stack */
302 #endif
293  
294   /**************************************************************************
295   *      Definitions for hierarchical transformation handler
# Line 341 | Line 331 | struct xf_array {
331  
332   typedef struct xf_spec {
333          long    xid;                    /* unique transform id */
334 <        short   xav0;                   /* zeroeth argument in xf_argv array */
345 <        short   xac;                    /* transform argument count */
334 >        short   xac;                    /* context argument count */
335          short   rev;                    /* boolean true if vertices reversed */
336          XF      xf;                     /* cumulative transformation */
337          struct xf_array *xarr;          /* transformation array pointer */
338          struct xf_spec  *prev;          /* previous transformation context */
339   } XF_SPEC;                      /* followed by argument buffer */
340  
341 < extern int      xf_argc;                        /* total # transform args. */
342 < extern char     **xf_argv;                      /* transform arguments */
354 < extern XF_SPEC  *xf_context;                    /* current context */
341 > extern XF_SPEC  *xf_context;                    /* current transform context */
342 > extern char     **xf_argend;                    /* last transform argument */
343  
344 + #define xf_ac(xf)       ((xf)==NULL ? 0 : (xf)->xac)
345 + #define xf_av(xf)       (xf_argend - (xf)->xac)
346 +
347 + #define xf_argc         xf_ac(xf_context)
348 + #define xf_argv         xf_av(xf_context)
349 +
350   /*
351   * The transformation handler should do most of the work that needs
352   * doing.  Just pass it any xf entities, then use the associated
# Line 365 | Line 359 | extern XF_SPEC *xf_context;                    /* current context */
359   * puts the result into the first.
360   */
361  
368 #ifdef NOPROTO
362  
370 extern int      xf_handler();           /* handle xf entity */
371 extern void     xf_xfmpoint();          /* transform point */
372 extern void     xf_xfmvect();           /* transform vector */
373 extern void     xf_rotvect();           /* rotate vector */
374 extern double   xf_scale();             /* scale a value */
375 extern void     xf_clear();             /* clear xf stack */
376
377 /* The following are support routines you probably won't call directly */
378
379 extern void     multmat4();             /* m4a = m4b X m4c */
380 extern void     multv3();               /* v3a = v3b X m4 (vectors) */
381 extern void     multp3();               /* p3a = p3b X m4 (points) */
382 extern int      xf();                   /* interpret transform spec. */
383
384 #else
385
363   extern int      xf_handler(int, char **);       /* handle xf entity */
364   extern void     xf_xfmpoint(FVECT, FVECT);      /* transform point */
365   extern void     xf_xfmvect(FVECT, FVECT);       /* transform vector */
# Line 392 | Line 369 | extern void    xf_clear(void);                 /* clear xf stack */
369  
370   /* The following are support routines you probably won't call directly */
371  
372 + XF_SPEC         *new_xf(int, char **);          /* allocate new transform */
373 + void            free_xf(XF_SPEC *);             /* free a transform */
374 + int             xf_aname(struct xf_array *);    /* name this instance */
375 + long            comp_xfid(MAT4);                /* compute unique ID */
376   extern void     multmat4(MAT4, MAT4, MAT4);     /* m4a = m4b X m4c */
377   extern void     multv3(FVECT, FVECT, MAT4);     /* v3a = v3b X m4 (vectors) */
378   extern void     multp3(FVECT, FVECT, MAT4);     /* p3a = p3b X m4 (points) */
379   extern int      xf(XF *, int, char **);         /* interpret transform spec. */
380  
400 #endif
381  
382   /************************************************************************
383   *      Miscellaneous definitions
384   */
385  
386 + #ifndef  PI
387   #ifdef  M_PI
388 < #define  PI             M_PI
388 > #define  PI             ((double)M_PI)
389   #else
390   #define  PI             3.14159265358979323846
391   #endif
411
412 #ifdef DCL_ATOF
413 extern double   atof();
392   #endif
393  
394   #ifndef MEM_PTR
395   #define MEM_PTR         void *
396   #endif
397  
398 < extern MEM_PTR  malloc();
399 < extern MEM_PTR  calloc();
400 < extern MEM_PTR  realloc();
401 < extern void     free();
398 > #endif /*MG_VMAJOR*/
399 >
400 >
401 > #ifdef __cplusplus
402 > }
403 > #endif
404 > #endif /* _MGF_PARSER_H_ */
405 >

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines