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.1 by greg, Tue Jun 21 14:45:41 1994 UTC vs.
Revision 1.34 by schorsch, Sat Jun 7 01:11:17 2003 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1994 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 < #define MG_E_COMMENT    0
13 < #define MG_E_COLOR      1
14 < #define MG_E_CONE       2
15 < #define MG_E_CXY        3
16 < #define MG_E_CYL        4
17 < #define MG_E_ED         5
18 < #define MG_E_FACE       6
19 < #define MG_E_INCLUDE    7
20 < #define MG_E_IES        8
21 < #define MG_E_MATERIAL   9
22 < #define MG_E_NORMAL     10
23 < #define MG_E_OBJECT     11
24 < #define MG_E_POINT      12
25 < #define MG_E_RD         13
26 < #define MG_E_RING       14
27 < #define MG_E_RS         15
28 < #define MG_E_SPH        16
29 < #define MG_E_TD         17
30 < #define MG_E_TORUS      18
31 < #define MG_E_TS         19
32 < #define MG_E_VERTEX     20
33 < #define MG_E_XF         21
12 > #ifndef MG_VMAJOR
13  
14 < #define MG_NENTITIES    22
14 > /* must include stdio.h and stdlib.h before us */
15  
16 < #define MG_NAMELIST     {"#","c","cone","cxy","cyl","ed","f","i","ies",\
17 <        "m","n","o","p","rd","ring","rs","sph","td","torus","ts","v","xf"}
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          */
23 + #define MG_E_CONE       3               /* cone         */
24 + #define MG_E_CMIX       4               /* cmix         */
25 + #define MG_E_CSPEC      5               /* cspec        */
26 + #define MG_E_CXY        6               /* cxy          */
27 + #define MG_E_CYL        7               /* cyl          */
28 + #define MG_E_ED         8               /* ed           */
29 + #define MG_E_FACE       9               /* f            */
30 + #define MG_E_INCLUDE    10              /* i            */
31 + #define MG_E_IES        11              /* ies          */
32 + #define MG_E_IR         12              /* ir           */
33 + #define MG_E_MATERIAL   13              /* m            */
34 + #define MG_E_NORMAL     14              /* n            */
35 + #define MG_E_OBJECT     15              /* o            */
36 + #define MG_E_POINT      16              /* p            */
37 + #define MG_E_PRISM      17              /* prism        */
38 + #define MG_E_RD         18              /* rd           */
39 + #define MG_E_RING       19              /* ring         */
40 + #define MG_E_RS         20              /* rs           */
41 + #define MG_E_SIDES      21              /* sides        */
42 + #define MG_E_SPH        22              /* sph          */
43 + #define MG_E_TD         23              /* td           */
44 + #define MG_E_TORUS      24              /* torus        */
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    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",\
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 */
45 <
46 < #ifdef NOPROTO
47 < extern int      (*mg_ehand[MG_NENTITIES])();
48 < #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 60 | Line 80 | extern int     (*mg_ehand[MG_NENTITIES])(int argc, char **
80   #define MG_EINCL        7               /* error in included file */
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        10
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 74 | Line 97 | extern char    *mg_err[MG_NERRS];
97   * To read from standard input, use NULL as the file name.
98   * For additional control over error reporting and file management,
99   * use mg_open, mg_read, mg_parse and mg_close instead of mg_load.
100 + * To pass an entity of your own construction to the parser, use
101 + * the mg_handle function rather than the mg_ehand routines directly.
102 + * (The first argument to mg_handle is the entity #, or -1.)
103   * To free any data structures and clear the parser, use mg_clear.
104 < * If there is an error, mg_load, mg_open, mg_parse, and mg_rewind
105 < * will return an error from the list above.  In addition, mg_load
106 < * will report the error to stderr.  The mg_read routine returns 0
107 < * when the end of file has been reached.
104 > * If there is an error, mg_load, mg_open, mg_parse, mg_handle and
105 > * mg_fgoto will return an error from the list above.  In addition,
106 > * mg_load will report the error to stderr.  The mg_read routine
107 > * returns 0 when the end of file has been reached.
108   */
109  
110 < #define MG_MAXLINE      512             /* maximum input line length */
110 > #define MG_MAXLINE      4096            /* maximum input line length */
111   #define MG_MAXARGC      (MG_MAXLINE/4)  /* maximum argument count */
112  
113   typedef struct mg_fctxt {
114 <        char    *fname;                         /* file name */
114 >        char    fname[96];                      /* file name */
115          FILE    *fp;                            /* stream pointer */
116 +        int     fid;                            /* unique file context id */
117          char    inpline[MG_MAXLINE];            /* input line */
118          int     lineno;                         /* line number */
119          struct mg_fctxt *prev;                  /* previous context */
120   } MG_FCTXT;
121  
122 + typedef struct {
123 +        int     fid;                            /* file this position is for */
124 +        int     lineno;                         /* line number in file */
125 +        long    offset;                         /* offset from beginning */
126 + } MG_FPOS;
127 +
128   extern MG_FCTXT *mg_file;               /* current file context */
129  
97 – #ifdef NOPROTO
98 – extern void     mg_init();              /* fill in mg_ehand array */
99 – extern int      mg_load();              /* parse a file */
100 – extern int      mg_open();              /* open new input file */
101 – extern int      mg_read();              /* read next line */
102 – extern int      mg_parse();             /* parse current line */
103 – extern int      mg_rewind();            /* rewind input file */
104 – extern void     mg_close();             /* close input file */
105 – extern void     mg_clear();             /* clear parser */
106 – extern int      mg_iterate();
107 – #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 */
133   extern int      mg_read(void);          /* read next line */
134   extern int      mg_parse(void);         /* parse current line */
135 < extern int      mg_rewind(void);        /* rewind input file */
135 > extern void     mg_fgetpos(MG_FPOS *);  /* get position on input file */
136 > extern int      mg_fgoto(MG_FPOS *);    /* go to position on input file */
137   extern void     mg_close(void);         /* close input file */
138   extern void     mg_clear(void);         /* clear parser */
139 < extern int      mg_iterate(int, char **, int (*)(void));
117 < #endif
139 > extern int      mg_handle(int, int, char **);   /* handle an entity */
140  
141   #ifndef MG_NQCD
142   #define MG_NQCD         5               /* default number of divisions */
# Line 126 | Line 148 | extern int     mg_nqcdivs;             /* divisions per quarter circl
148   * The following library routines are included for your convenience:
149   */
150  
129 – #ifdef NOPROTO
130 – extern int mg_entity();                 /* get entity number from its name */
131 – extern int isint();                     /* non-zero if integer format */
132 – extern int isflt();                     /* non-zero if floating point format */
133 – #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 < #endif
155 > extern int isfltd(char *, char *);      /* same with delimiter set */
156 > extern int isname(char *);              /* non-zero if legal identifier name */
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
170   */
171  
172 < typedef double  FVECT[3];
173 <
174 < #ifdef NOPROTO
146 < extern double   normalize();            /* normalize a vector */
172 > #ifdef  SMLFLT
173 > #define  FLOAT          float
174 > #define  FTINY          (1e-3)
175   #else
176 < extern double   normalize(FVECT);       /* normalize a vector */
176 > #define  FLOAT          double
177 > #define  FTINY          (1e-6)
178   #endif
179 + #define  FHUGE          (1e10)
180  
181 + typedef FLOAT  FVECT[3];
182 +
183 + #define  VCOPY(v1,v2)   ((v1)[0]=(v2)[0],(v1)[1]=(v2)[1],(v1)[2]=(v2)[2])
184 + #define  DOT(v1,v2)     ((v1)[0]*(v2)[0]+(v1)[1]*(v2)[1]+(v1)[2]*(v2)[2])
185 + #define  VSUM(vr,v1,v2,f)       ((vr)[0]=(v1)[0]+(f)*(v2)[0], \
186 +                                (vr)[1]=(v1)[1]+(f)*(v2)[1], \
187 +                                (vr)[2]=(v1)[2]+(f)*(v2)[2])
188 +
189 + #define is0vect(v)      (DOT(v,v) <= FTINY*FTINY)
190 +
191 + #define round0(x)       if (x <= FTINY && x >= -FTINY) x = 0
192 +
193 + extern double   normalize(FVECT);       /* normalize a vector */
194 + extern void     fcross(FVECT,FVECT,FVECT);/* cross product of two vectors */
195 +
196   /************************************************************************
197   *      Definitions for context handling routines
198   *      (materials, colors, vectors)
199   */
200  
201 + #define C_CMINWL        380             /* minimum wavelength */
202 + #define C_CMAXWL        780             /* maximum wavelength */
203 + #define C_CNSS          41              /* number of spectral samples */
204 + #define C_CWLI          ((C_CMAXWL-C_CMINWL)/(C_CNSS-1))
205 + #define C_CMAXV         10000           /* nominal maximum sample value */
206 + #define C_CLPWM         (683./C_CMAXV)  /* peak lumens/watt multiplier */
207 +
208 + #define C_CSSPEC        01              /* flag if spectrum is set */
209 + #define C_CDSPEC        02              /* flag if defined w/ spectrum */
210 + #define C_CSXY          04              /* flag if xy is set */
211 + #define C_CDXY          010             /* flag if defined w/ xy */
212 + #define C_CSEFF         020             /* flag if efficacy set */
213 +
214   typedef struct {
215 <        double  cx, cy;         /* XY chromaticity coordinates */
216 < } C_COLOR;              /* color context */
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, 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,\
228 +                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
229 +                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
230 +                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
231 +                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV},\
232 +                        (long)C_CNSS*C_CMAXV, 1./3., 1./3., 178.006 }
233 +
234 + #define c_cval(c,l)     ((double)(c)->ssamp[((l)-C_MINWL)/C_CWLI] / (c)->ssum)
235 +
236 + #define C_1SIDEDTHICK   0.005           /* assumed thickness of 1-sided mat. */
237 +
238   typedef struct {
239 <        double  rd;             /* diffuse reflectance */
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 */
244          C_COLOR rd_c;           /* diffuse reflectance color */
245 <        double  td;             /* diffuse transmittance */
245 >        float   td;             /* diffuse transmittance */
246          C_COLOR td_c;           /* diffuse transmittance color */
247 <        double  ed;             /* diffuse emittance */
247 >        float   ed;             /* diffuse emittance */
248          C_COLOR ed_c;           /* diffuse emittance color */
249 <        double  rs;             /* specular reflectance */
249 >        float   rs;             /* specular reflectance */
250          C_COLOR rs_c;           /* specular reflectance color */
251 <        double  rs_a;           /* specular reflectance roughness */
252 <        double  ts;             /* specular transmittance */
251 >        float   rs_a;           /* specular reflectance roughness */
252 >        float   ts;             /* specular transmittance */
253          C_COLOR ts_c;           /* specular transmittance color */
254 <        double  ts_a;           /* specular transmittance roughness */
254 >        float   ts_a;           /* specular transmittance roughness */
255   } C_MATERIAL;           /* material context */
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_DEFCOLOR      {.333,.333}
264 < #define C_DEFMATERIAL   {0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,C_DEFCOLOR,\
265 <                        0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
182 < #define C_DEFVERTEX     {{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 */
269   extern C_MATERIAL       *c_cmaterial;   /* the current material */
270 + 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  
188 – #ifdef NOPROTO
189 – extern int      c_hcolor();                     /* handle color entity */
190 – extern int      c_hmaterial();                  /* handle material entity */
191 – extern int      c_hvertex();                    /* handle vertex entity */
192 – extern void     c_clearall();                   /* clear context tables */
193 – extern C_VERTEX *c_getvert();                   /* get a named vertex */
194 – #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 */
277   extern void     c_clearall(void);               /* clear context tables */
278 + extern C_MATERIAL       *c_getmaterial(char *); /* get a named material */
279   extern C_VERTEX *c_getvert(char *);             /* get a named vertex */
280 < #endif
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 */
283  
284   /*************************************************************************
285   *      Definitions for hierarchical object name handler
# Line 206 | Line 288 | extern C_VERTEX        *c_getvert(char *);             /* get a named ve
288   extern int      obj_nnames;             /* depth of name hierarchy */
289   extern char     **obj_name;             /* names in hierarchy */
290  
209 – #ifdef NOPROTO
210 – extern int      obj_handler();                  /* handle an object entity */
211 – #else
291   extern int      obj_handler(int, char **);      /* handle an object entity */
292 < #endif
292 > extern void     obj_clear(void);                /* clear object stack */
293  
294   /**************************************************************************
295   *      Definitions for hierarchical transformation handler
296   */
297  
298 < typedef double  MAT4[4][4];
298 > typedef FLOAT  MAT4[4][4];
299  
300   #ifdef  BSD
301   #define  copymat4(m4a,m4b)      bcopy((char *)m4b,(char *)m4a,sizeof(MAT4))
302   #else
303   #define  copymat4(m4a,m4b)      (void)memcpy((char *)m4a,(char *)m4b,sizeof(MAT4))
225 – extern char  *memcpy();
304   #endif
305  
306   #define  MAT4IDENT              { {1.,0.,0.,0.}, {0.,1.,0.,0.}, \
# Line 234 | Line 312 | extern MAT4  m4ident;
312  
313                                  /* regular transformation */
314   typedef struct {
315 <        MAT4  xfm;                              /* transform matrix */
316 <        double  sca;                            /* scalefactor */
315 >        MAT4    xfm;                            /* transform matrix */
316 >        FLOAT   sca;                            /* scalefactor */
317   }  XF;
318  
319   #define identxf(xp)             (void)(setident4((xp)->xfm),(xp)->sca=1.0)
320  
321 + #define XF_MAXDIM       8               /* maximum array dimensions */
322 +
323 + struct xf_array {
324 +        MG_FPOS spos;                   /* starting position on input */
325 +        int     ndim;                   /* number of array dimensions */
326 +        struct {
327 +                short   i, n;           /* current count and maximum */
328 +                char    arg[8];         /* string argument value */
329 +        } aarg[XF_MAXDIM];
330 + };
331 +
332   typedef struct xf_spec {
333 <        short   xac;            /* transform argument count */
334 <        short   xav0;           /* zeroeth argument in xf_argv array */
335 <        XF      xf;             /* cumulative transformation */
336 <        struct xf_spec  *prev;  /* previous transformation context */
337 < } XF_SPEC;
333 >        long    xid;                    /* unique transform id */
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 */
252 < 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 263 | Line 359 | extern XF_SPEC *xf_context;                    /* current context */
359   * puts the result into the first.
360   */
361  
266 – #ifdef NOPROTO
362  
363 < extern int      xf_handler();           /* handle xf entity */
364 < extern void     xf_xfmpoint();          /* transform point */
365 < extern void     xf_xfmvect();           /* transform vector */
366 < extern void     xf_rotvect();           /* rotate vector */
367 < extern double   xf_scale();             /* scale a value */
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 */
366 > extern void     xf_rotvect(FVECT, FVECT);       /* rotate vector */
367 > extern double   xf_scale(double);               /* scale a value */
368 > extern void     xf_clear(void);                 /* clear xf stack */
369  
370   /* The following are support routines you probably won't call directly */
371  
372 < extern void     multmat4();             /* m4a = m4b X m4c */
373 < extern void     multv3();               /* v3a = v3b X m4 (vectors) */
374 < extern void     multp3();               /* p3a = p3b X m4 (points) */
375 < extern int      xf();                   /* interpret transform spec. */
280 <
281 < #else
282 <
283 < extern int      xf_handler();           /* handle xf entity */
284 < extern void     xf_xfmpoint();          /* transform point */
285 < extern void     xf_xfmvect();           /* transform vector */
286 < extern void     xf_rotvect();           /* rotate vector */
287 < extern double   xf_scale();             /* scale a value */
288 <
289 < /* The following are support routines you probably won't call directly */
290 <
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. */
379 > extern int      xf(XF *, int, char **);         /* interpret transform spec. */
380  
296 – #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
307 –
308 – #ifdef DCL_ATOF
309 – 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();
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