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.2 by greg, Wed Jun 22 15:33:42 1994 UTC vs.
Revision 1.36 by schorsch, Mon Jun 30 14:59:11 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 61 | 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 75 | 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  
98 – #ifdef NOPROTO
99 – extern void     mg_init();              /* fill in mg_ehand array */
100 – extern int      mg_load();              /* parse a file */
101 – extern int      mg_open();              /* open new input file */
102 – extern int      mg_read();              /* read next line */
103 – extern int      mg_parse();             /* parse current line */
104 – extern int      mg_rewind();            /* rewind input file */
105 – extern void     mg_close();             /* close input file */
106 – extern void     mg_clear();             /* clear parser */
107 – extern int      mg_iterate();
108 – #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));
118 < #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 127 | Line 148 | extern int     mg_nqcdivs;             /* divisions per quarter circl
148   * The following library routines are included for your convenience:
149   */
150  
130 – #ifdef NOPROTO
131 – extern int mg_entity();                 /* get entity number from its name */
132 – extern int isint();                     /* non-zero if integer format */
133 – extern int isflt();                     /* non-zero if floating point format */
134 – #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 < #ifdef SMLFLT
173 < #define FLOAT   float
172 > #ifdef  SMLFLT
173 > #define  RREAL          float
174 > #define  FTINY          (1e-3)
175   #else
176 < #define FLOAT   double
176 > #define  RREAL          double
177 > #define  FTINY          (1e-6)
178   #endif
179 + #define  FHUGE          (1e10)
180  
181 < typedef FLOAT  FVECT[3];
181 > typedef RREAL  FVECT[3];
182  
183 < #ifdef NOPROTO
184 < extern double   normalize();            /* normalize a vector */
185 < #else
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 < #endif
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 <        float   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 {
168 –        char    *name;          /* material name */
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          float   td;             /* diffuse transmittance */
# Line 182 | Line 255 | typedef struct {
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   {NULL,1,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,C_DEFCOLOR,\
265 <                                        0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
191 < #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  
197 – #ifdef NOPROTO
198 – extern int      c_hcolor();                     /* handle color entity */
199 – extern int      c_hmaterial();                  /* handle material entity */
200 – extern int      c_hvertex();                    /* handle vertex entity */
201 – extern void     c_clearall();                   /* clear context tables */
202 – extern C_VERTEX *c_getvert();                   /* get a named vertex */
203 – #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 215 | 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  
218 – #ifdef NOPROTO
219 – extern int      obj_handler();                  /* handle an object entity */
220 – extern void     obj_clear();                    /* clear object stack */
221 – #else
291   extern int      obj_handler(int, char **);      /* handle an object entity */
292   extern void     obj_clear(void);                /* clear object stack */
224 – #endif
293  
294   /**************************************************************************
295   *      Definitions for hierarchical transformation handler
296   */
297  
298 < typedef FLOAT  MAT4[4][4];
298 > typedef RREAL  MAT4[4][4];
299  
232 – #ifdef  BSD
233 – #define  copymat4(m4a,m4b)      bcopy((char *)m4b,(char *)m4a,sizeof(MAT4))
234 – #else
300   #define  copymat4(m4a,m4b)      (void)memcpy((char *)m4a,(char *)m4b,sizeof(MAT4))
236 – extern char  *memcpy();
237 – #endif
301  
302   #define  MAT4IDENT              { {1.,0.,0.,0.}, {0.,1.,0.,0.}, \
303                                  {0.,0.,1.,0.}, {0.,0.,0.,1.} }
# Line 245 | Line 308 | extern MAT4  m4ident;
308  
309                                  /* regular transformation */
310   typedef struct {
311 <        MAT4  xfm;                              /* transform matrix */
312 <        FLOAT  sca;                             /* scalefactor */
311 >        MAT4    xfm;                            /* transform matrix */
312 >        RREAL   sca;                            /* scalefactor */
313   }  XF;
314  
315   #define identxf(xp)             (void)(setident4((xp)->xfm),(xp)->sca=1.0)
316  
317 + #define XF_MAXDIM       8               /* maximum array dimensions */
318 +
319 + struct xf_array {
320 +        MG_FPOS spos;                   /* starting position on input */
321 +        int     ndim;                   /* number of array dimensions */
322 +        struct {
323 +                short   i, n;           /* current count and maximum */
324 +                char    arg[8];         /* string argument value */
325 +        } aarg[XF_MAXDIM];
326 + };
327 +
328   typedef struct xf_spec {
329 <        short   xac;            /* transform argument count */
330 <        short   xav0;           /* zeroeth argument in xf_argv array */
331 <        XF      xf;             /* cumulative transformation */
332 <        struct xf_spec  *prev;  /* previous transformation context */
333 < } XF_SPEC;
329 >        long    xid;                    /* unique transform id */
330 >        short   xac;                    /* context argument count */
331 >        short   rev;                    /* boolean true if vertices reversed */
332 >        XF      xf;                     /* cumulative transformation */
333 >        struct xf_array *xarr;          /* transformation array pointer */
334 >        struct xf_spec  *prev;          /* previous transformation context */
335 > } XF_SPEC;                      /* followed by argument buffer */
336  
337 < extern int      xf_argc;                        /* total # transform args. */
338 < extern char     **xf_argv;                      /* transform arguments */
263 < extern XF_SPEC  *xf_context;                    /* current context */
337 > extern XF_SPEC  *xf_context;                    /* current transform context */
338 > extern char     **xf_argend;                    /* last transform argument */
339  
340 + #define xf_ac(xf)       ((xf)==NULL ? 0 : (xf)->xac)
341 + #define xf_av(xf)       (xf_argend - (xf)->xac)
342 +
343 + #define xf_argc         xf_ac(xf_context)
344 + #define xf_argv         xf_av(xf_context)
345 +
346   /*
347   * The transformation handler should do most of the work that needs
348   * doing.  Just pass it any xf entities, then use the associated
# Line 274 | Line 355 | extern XF_SPEC *xf_context;                    /* current context */
355   * puts the result into the first.
356   */
357  
277 – #ifdef NOPROTO
358  
279 – extern int      xf_handler();           /* handle xf entity */
280 – extern void     xf_xfmpoint();          /* transform point */
281 – extern void     xf_xfmvect();           /* transform vector */
282 – extern void     xf_rotvect();           /* rotate vector */
283 – extern double   xf_scale();             /* scale a value */
284 – extern void     xf_clear();             /* clear xf stack */
285 –
286 – /* The following are support routines you probably won't call directly */
287 –
288 – extern void     multmat4();             /* m4a = m4b X m4c */
289 – extern void     multv3();               /* v3a = v3b X m4 (vectors) */
290 – extern void     multp3();               /* p3a = p3b X m4 (points) */
291 – extern int      xf();                   /* interpret transform spec. */
292 –
293 – #else
294 –
359   extern int      xf_handler(int, char **);       /* handle xf entity */
360   extern void     xf_xfmpoint(FVECT, FVECT);      /* transform point */
361   extern void     xf_xfmvect(FVECT, FVECT);       /* transform vector */
# Line 301 | Line 365 | extern void    xf_clear(void);                 /* clear xf stack */
365  
366   /* The following are support routines you probably won't call directly */
367  
368 + XF_SPEC         *new_xf(int, char **);          /* allocate new transform */
369 + void            free_xf(XF_SPEC *);             /* free a transform */
370 + int             xf_aname(struct xf_array *);    /* name this instance */
371 + long            comp_xfid(MAT4);                /* compute unique ID */
372   extern void     multmat4(MAT4, MAT4, MAT4);     /* m4a = m4b X m4c */
373   extern void     multv3(FVECT, FVECT, MAT4);     /* v3a = v3b X m4 (vectors) */
374   extern void     multp3(FVECT, FVECT, MAT4);     /* p3a = p3b X m4 (points) */
375 < extern int      xf(XF, int, char **);           /* interpret transform spec. */
375 > extern int      xf(XF *, int, char **);         /* interpret transform spec. */
376  
309 – #endif
377  
378   /************************************************************************
379   *      Miscellaneous definitions
380   */
381  
382 + #ifndef  PI
383   #ifdef  M_PI
384 < #define  PI             M_PI
384 > #define  PI             ((double)M_PI)
385   #else
386   #define  PI             3.14159265358979323846
387   #endif
320 –
321 – #ifdef DCL_ATOF
322 – extern double   atof();
388   #endif
389  
390   #ifndef MEM_PTR
391   #define MEM_PTR         void *
392   #endif
393  
394 < extern MEM_PTR  malloc();
395 < extern MEM_PTR  calloc();
396 < extern MEM_PTR  realloc();
394 > #endif /*MG_VMAJOR*/
395 >
396 >
397 > #ifdef __cplusplus
398 > }
399 > #endif
400 > #endif /* _MGF_PARSER_H_ */
401 >

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines