ReactOS  0.4.12-dev-375-g61fed54
preproc.c
Go to the documentation of this file.
1 /*
2  * Copyright 1998 Bertho A. Stultiens (BS)
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18 
19 #include "config.h"
20 #include "wine/port.h"
21 
22 #include <assert.h>
23 #include <ctype.h>
24 #include <fcntl.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #ifdef HAVE_IO_H
33 # include <io.h>
34 #endif
35 
36 #include "wine/wpp.h"
37 #include "wpp_private.h"
38 
40 
41 #define HASHKEY 2039
42 
43 typedef struct pp_def_state
44 {
45  struct pp_def_state *next;
48 
50 
51 #define MAXIFSTACK 64
53 static int if_stack_idx = 0;
54 
55 #if 0
56 void pp_print_status(void) __attribute__((destructor));
57 void pp_print_status(void)
58 {
59  int i;
60  int sum;
61  int total = 0;
62  pp_entry_t *ppp;
63 
64  fprintf(stderr, "Defines statistics:\n");
65  for(i = 0; i < HASHKEY; i++)
66  {
67  sum = 0;
68  for(ppp = pp_def_state->defines[i]; ppp; ppp = ppp->next)
69  sum++;
70  total += sum;
71  if (sum) fprintf(stderr, "%4d, %3d\n", i, sum);
72  }
73  fprintf(stderr, "Total defines: %d\n", total);
74 }
75 #endif
76 
77 void *pp_xmalloc(size_t size)
78 {
79  void *res;
80 
81  assert(size > 0);
82  res = malloc(size);
83  if(res == NULL)
84  {
85  /* Set the error flag */
86  pp_status.state = 1;
87  }
88  return res;
89 }
90 
91 void *pp_xrealloc(void *p, size_t size)
92 {
93  void *res;
94 
95  assert(size > 0);
96  res = realloc(p, size);
97  if(res == NULL)
98  {
99  /* Set the error flag */
100  pp_status.state = 1;
101  }
102  return res;
103 }
104 
105 char *pp_xstrdup(const char *str)
106 {
107  char *s;
108  int len;
109 
110  assert(str != NULL);
111  len = strlen(str)+1;
112  s = pp_xmalloc(len);
113  if(!s)
114  return NULL;
115  return memcpy(s, str, len);
116 }
117 
118 static char *wpp_default_lookup(const char *name, int type, const char *parent_name,
119  char **include_path, int include_path_count)
120 {
121  char *cpy;
122  char *cptr;
123  char *path;
124  const char *ccptr;
125  int i, fd;
126 
127  cpy = pp_xmalloc(strlen(name)+1);
128  if(!cpy)
129  return NULL;
130  cptr = cpy;
131 
132  for(ccptr = name; *ccptr; ccptr++)
133  {
134  /* Convert to forward slash */
135  if(*ccptr == '\\') {
136  /* kill double backslash */
137  if(ccptr[1] == '\\')
138  ccptr++;
139  *cptr = '/';
140  }else {
141  *cptr = *ccptr;
142  }
143  cptr++;
144  }
145  *cptr = '\0';
146 
147  if(type && parent_name)
148  {
149  /* Search directory of parent include and then -I path */
150  const char *p;
151 
152  if ((p = strrchr( parent_name, '/' ))) p++;
153  else p = parent_name;
154  path = pp_xmalloc( (p - parent_name) + strlen(cpy) + 1 );
155  if(!path)
156  {
157  free(cpy);
158  return NULL;
159  }
160  memcpy( path, parent_name, p - parent_name );
161  strcpy( path + (p - parent_name), cpy );
162  fd = open( path, O_RDONLY );
163  if (fd != -1)
164  {
165  close( fd );
166  free( cpy );
167  return path;
168  }
169  free( path );
170  }
171  /* Search -I path */
172  for(i = 0; i < include_path_count; i++)
173  {
174  path = pp_xmalloc(strlen(include_path[i]) + strlen(cpy) + 2);
175  if(!path)
176  {
177  free(cpy);
178  return NULL;
179  }
180  strcpy(path, include_path[i]);
181  strcat(path, "/");
182  strcat(path, cpy);
183  fd = open( path, O_RDONLY );
184  if (fd != -1)
185  {
186  close( fd );
187  free( cpy );
188  return path;
189  }
190  free( path );
191  }
192  free( cpy );
193  return NULL;
194 }
195 
196 static void *wpp_default_open(const char *filename, int type) {
197  return fopen(filename,"rt");
198 }
199 
200 static void wpp_default_close(void *file) {
201  fclose(file);
202 }
203 
204 static int wpp_default_read(void *file, char *buffer, unsigned int len){
205  return fread(buffer, 1, len, file);
206 }
207 
208 static void wpp_default_write( const char *buffer, unsigned int len ) {
209  fwrite(buffer, 1, len, ppy_out);
210 }
211 
212 /* Don't comment on the hash, it's primitive but functional... */
213 static int pphash(const char *str)
214 {
215  int sum = 0;
216  while(*str)
217  sum += *str++;
218  return sum % HASHKEY;
219 }
220 
221 pp_entry_t *pplookup(const char *ident)
222 {
223  int idx;
224  pp_entry_t *ppp;
225 
226  if(!ident)
227  return NULL;
228  idx = pphash(ident);
229  for(ppp = pp_def_state->defines[idx]; ppp; ppp = ppp->next)
230  {
231  if(!strcmp(ident, ppp->ident))
232  return ppp;
233  }
234  return NULL;
235 }
236 
237 static void free_pp_entry( pp_entry_t *ppp, int idx )
238 {
239  if(ppp->iep)
240  {
241  if(ppp->iep == pp_includelogiclist)
242  {
243  pp_includelogiclist = ppp->iep->next;
246  }
247  else
248  {
249  ppp->iep->prev->next = ppp->iep->next;
250  if(ppp->iep->next)
251  ppp->iep->next->prev = ppp->iep->prev;
252  }
253  free(ppp->iep->filename);
254  free(ppp->iep);
255  }
256 
257  if(pp_def_state->defines[idx] == ppp)
258  {
259  pp_def_state->defines[idx] = ppp->next;
260  if(pp_def_state->defines[idx])
262  }
263  else
264  {
265  ppp->prev->next = ppp->next;
266  if(ppp->next)
267  ppp->next->prev = ppp->prev;
268  }
269 
270  free(ppp);
271 }
272 
273 /* push a new (empty) define state */
275 {
276  pp_def_state_t *state = pp_xmalloc( sizeof(*state) );
277  if(!state)
278  return 1;
279 
280  memset( state->defines, 0, sizeof(state->defines) );
281  state->next = pp_def_state;
283  return 0;
284 }
285 
286 /* pop the current define state */
288 {
289  int i;
290  pp_entry_t *ppp;
292 
293  for (i = 0; i < HASHKEY; i++)
294  {
295  while ((ppp = pp_def_state->defines[i]) != NULL) pp_del_define( ppp->ident );
296  }
298  pp_def_state = state->next;
299  free( state );
300 }
301 
302 void pp_del_define(const char *name)
303 {
304  pp_entry_t *ppp;
305  int idx = pphash(name);
306 
307  if((ppp = pplookup(name)) == NULL)
308  {
309  if(pp_status.pedantic)
310  ppy_warning("%s was not defined", name);
311  return;
312  }
313 
314  if(pp_status.debug)
315  printf("Deleting (%s, %d) <%s>\n", pp_status.input, pp_status.line_number, name);
316 
317  free( ppp->ident );
318  free( ppp->subst.text );
319  free( ppp->filename );
320  free_pp_entry( ppp, idx );
321 }
322 
323 pp_entry_t *pp_add_define(const char *def, const char *text)
324 {
325  int len;
326  char *cptr;
327  int idx;
328  pp_entry_t *ppp;
329 
330  if(!def)
331  return NULL;
332  idx = pphash(def);
333  if((ppp = pplookup(def)) != NULL)
334  {
335  if(pp_status.pedantic)
336  ppy_warning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber);
337  pp_del_define(def);
338  }
339  ppp = pp_xmalloc(sizeof(pp_entry_t));
340  if(!ppp)
341  return NULL;
342  memset( ppp, 0, sizeof(*ppp) );
343  ppp->ident = pp_xstrdup(def);
344  if(!ppp->ident)
345  goto error;
346  ppp->type = def_define;
347  ppp->subst.text = text ? pp_xstrdup(text) : NULL;
348  if(text && !ppp->subst.text)
349  goto error;
350  ppp->filename = pp_xstrdup(pp_status.input ? pp_status.input : "<internal or cmdline>");
351  if(!ppp->filename)
352  goto error;
354  ppp->next = pp_def_state->defines[idx];
355  pp_def_state->defines[idx] = ppp;
356  if(ppp->next)
357  ppp->next->prev = ppp;
358  if(ppp->subst.text)
359  {
360  /* Strip trailing white space from subst text */
361  len = strlen(ppp->subst.text);
362  while(len && strchr(" \t\r\n", ppp->subst.text[len-1]))
363  {
364  ppp->subst.text[--len] = '\0';
365  }
366  /* Strip leading white space from subst text */
367  for(cptr = ppp->subst.text; *cptr && strchr(" \t\r", *cptr); cptr++)
368  ;
369  if(ppp->subst.text != cptr)
370  memmove(ppp->subst.text, cptr, strlen(cptr)+1);
371  }
372  if(pp_status.debug)
373  printf("Added define (%s, %d) <%s> to <%s>\n", pp_status.input, pp_status.line_number, ppp->ident, ppp->subst.text ? ppp->subst.text : "(null)");
374 
375  return ppp;
376 
377 error:
378  free(ppp->ident);
379  free(ppp->subst.text);
380  free(ppp);
381  return NULL;
382 }
383 
384 pp_entry_t *pp_add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
385 {
386  int idx;
387  pp_entry_t *ppp;
388 
389  if(!id)
390  return NULL;
391  idx = pphash(id);
392  if((ppp = pplookup(id)) != NULL)
393  {
394  if(pp_status.pedantic)
395  ppy_warning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber);
396  pp_del_define(id);
397  }
398  ppp = pp_xmalloc(sizeof(pp_entry_t));
399  if(!ppp)
400  return NULL;
401  memset( ppp, 0, sizeof(*ppp) );
402  ppp->ident = id;
403  ppp->type = def_macro;
404  ppp->margs = args;
405  ppp->nargs = nargs;
406  ppp->subst.mtext= exp;
407  ppp->filename = pp_xstrdup(pp_status.input ? pp_status.input : "<internal or cmdline>");
408  if(!ppp->filename)
409  {
410  free(ppp);
411  return NULL;
412  }
414  ppp->next = pp_def_state->defines[idx];
415  pp_def_state->defines[idx] = ppp;
416  if(ppp->next)
417  ppp->next->prev = ppp;
418 
419  if(pp_status.debug)
420  {
421  fprintf(stderr, "Added macro (%s, %d) <%s(%d)> to <", pp_status.input, pp_status.line_number, ppp->ident, nargs);
422  for(; exp; exp = exp->next)
423  {
424  switch(exp->type)
425  {
426  case exp_text:
427  fprintf(stderr, " \"%s\" ", exp->subst.text);
428  break;
429  case exp_stringize:
430  fprintf(stderr, " #(%d) ", exp->subst.argidx);
431  break;
432  case exp_concat:
433  fprintf(stderr, "##");
434  break;
435  case exp_subst:
436  fprintf(stderr, " <%d> ", exp->subst.argidx);
437  break;
438  }
439  }
440  fprintf(stderr, ">\n");
441  }
442  return ppp;
443 }
444 
445 
446 /*
447  *-------------------------------------------------------------------------
448  * Include management
449  *-------------------------------------------------------------------------
450  */
451 #if defined(_WIN32) || defined(__MSDOS__)
452 #define INCLUDESEPARATOR ";"
453 #else
454 #define INCLUDESEPARATOR ":"
455 #endif
456 
457 static char **includepath;
458 static int nincludepath = 0;
459 
460 int wpp_add_include_path(const char *path)
461 {
462  char *tok;
463  char *cpy = pp_xstrdup(path);
464  if(!cpy)
465  return 1;
466 
467  tok = strtok(cpy, INCLUDESEPARATOR);
468  while(tok)
469  {
470  if(*tok) {
471  char *dir;
472  char *cptr;
473  char **new_path;
474 
475  dir = pp_xstrdup(tok);
476  if(!dir)
477  {
478  free(cpy);
479  return 1;
480  }
481  for(cptr = dir; *cptr; cptr++)
482  {
483  /* Convert to forward slash */
484  if(*cptr == '\\')
485  *cptr = '/';
486  }
487  /* Kill eventual trailing '/' */
488  if(*(cptr = dir + strlen(dir)-1) == '/')
489  *cptr = '\0';
490 
491  /* Add to list */
492  new_path = pp_xrealloc(includepath, (nincludepath+1) * sizeof(*includepath));
493  if(!new_path)
494  {
495  free(dir);
496  free(cpy);
497  return 1;
498  }
499  includepath = new_path;
501  nincludepath++;
502  }
503  tok = strtok(NULL, INCLUDESEPARATOR);
504  }
505  free(cpy);
506  return 0;
507 }
508 
509 char *wpp_find_include(const char *name, const char *parent_name)
510 {
511  return wpp_default_lookup(name, !!parent_name, parent_name, includepath, nincludepath);
512 }
513 
514 void *pp_open_include(const char *name, int type, const char *parent_name, char **newpath)
515 {
516  char *path;
517  void *fp;
518 
519  if (!(path = wpp_callbacks->lookup(name, type, parent_name, includepath,
520  nincludepath))) return NULL;
521  fp = wpp_callbacks->open(path, type);
522 
523  if (fp)
524  {
525  if (pp_status.debug)
526  printf("Going to include <%s>\n", path);
527  if (newpath) *newpath = path;
528  else free( path );
529  return fp;
530  }
531  free( path );
532  return NULL;
533 }
534 
535 /*
536  *-------------------------------------------------------------------------
537  * #if, #ifdef, #ifndef, #else, #elif and #endif state management
538  *
539  * #if state transitions are made on basis of the current TOS and the next
540  * required state. The state transitions are required to housekeep because
541  * #if:s can be nested. The ignore case is activated to prevent output from
542  * within a false clause.
543  * Some special cases come from the fact that the #elif cases are not
544  * binary, but three-state. The problem is that all other elif-cases must
545  * be false when one true one has been found. A second problem is that the
546  * #else clause is a final clause. No extra #else:s may follow.
547  *
548  * The states mean:
549  * if_true Process input to output
550  * if_false Process input but no output
551  * if_ignore Process input but no output
552  * if_elif Process input but no output
553  * if_elsefalse Process input but no output
554  * if_elsettrue Process input to output
555  *
556  * The possible state-sequences are [state(stack depth)] (rest can be deduced):
557  * TOS #if 1 #else #endif
558  * if_true(n) if_true(n+1) if_elsefalse(n+1)
559  * if_false(n) if_ignore(n+1) if_ignore(n+1)
560  * if_elsetrue(n) if_true(n+1) if_elsefalse(n+1)
561  * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1)
562  * if_elif(n) if_ignore(n+1) if_ignore(n+1)
563  * if_ignore(n) if_ignore(n+1) if_ignore(n+1)
564  *
565  * TOS #if 1 #elif 0 #else #endif
566  * if_true(n) if_true(n+1) if_elif(n+1) if_elif(n+1)
567  * if_false(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
568  * if_elsetrue(n) if_true(n+1) if_elif(n+1) if_elif(n+1)
569  * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
570  * if_elif(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
571  * if_ignore(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
572  *
573  * TOS #if 0 #elif 1 #else #endif
574  * if_true(n) if_false(n+1) if_true(n+1) if_elsefalse(n+1)
575  * if_false(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
576  * if_elsetrue(n) if_false(n+1) if_true(n+1) if_elsefalse(n+1)
577  * if_elsefalse(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
578  * if_elif(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
579  * if_ignore(n) if_ignore(n+1) if_ignore(n+1) if_ignore(n+1)
580  *
581  *-------------------------------------------------------------------------
582  */
583 static const char * const pp_if_state_str[] = {
584  "if_false",
585  "if_true",
586  "if_elif",
587  "if_elsefalse",
588  "if_elsetrue",
589  "if_ignore"
590 };
591 
593 {
594  if(if_stack_idx >= MAXIFSTACK)
595  pp_internal_error(__FILE__, __LINE__, "#if-stack overflow; #{if,ifdef,ifndef} nested too deeply (> %d)", MAXIFSTACK);
596 
597  if(pp_flex_debug)
599 
600  if_stack[if_stack_idx++] = s;
601 
602  switch(s)
603  {
604  case if_true:
605  case if_elsetrue:
606  break;
607  case if_false:
608  case if_elsefalse:
609  case if_elif:
610  case if_ignore:
612  break;
613  default:
614  pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d)", (int)pp_if_state());
615  }
616 }
617 
619 {
620  if(if_stack_idx <= 0)
621  {
622  ppy_error("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)");
623  return if_error;
624  }
625 
626  switch(pp_if_state())
627  {
628  case if_true:
629  case if_elsetrue:
630  break;
631  case if_false:
632  case if_elsefalse:
633  case if_elif:
634  case if_ignore:
636  break;
637  default:
638  pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d)", (int)pp_if_state());
639  }
640 
641  if(pp_flex_debug)
642  fprintf(stderr, "Pop if %s:%d: %s(%d) -> %s(%d)\n",
646  if_stack_idx,
648  if_stack_idx-1);
649 
650  return if_stack[--if_stack_idx];
651 }
652 
654 {
655  if(!if_stack_idx)
656  return if_true;
657  else
658  return if_stack[if_stack_idx-1];
659 }
660 
661 
663 {
664  switch(pp_if_state())
665  {
666  case if_true:
667  case if_elsetrue:
669  break;
670  case if_false:
671  case if_elsefalse:
672  case if_elif:
673  case if_ignore:
675  break;
676  default:
677  pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #{if,ifdef,ifndef} directive", (int)pp_if_state());
678  }
679 }
680 
682 {
683  return if_stack_idx;
684 }
685 
686 /* #define WANT_NEAR_INDICATION */
687 
688 static void generic_msg(const char *s, const char *t, const char *n, va_list ap)
689 {
690  fprintf(stderr, "%s:%d:%d: %s: ", pp_status.input ? pp_status.input : "stdin",
692  vfprintf(stderr, s, ap);
693 #ifdef WANT_NEAR_INDICATION
694  {
695  char *cpy, *p;
696  if(n)
697  {
698  cpy = pp_xstrdup(n);
699  if(!cpy)
700  goto end;
701  for (p = cpy; *p; p++) if(!isprint(*p)) *p = ' ';
702  fprintf(stderr, " near '%s'", cpy);
703  free(cpy);
704  }
705  }
706 end:
707 #endif
708  fprintf(stderr, "\n");
709 }
710 
711 static void wpp_default_error(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
712 {
713  generic_msg(msg, "Error", near, ap);
714  exit(1);
715 }
716 
717 static void wpp_default_warning(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
718 {
719  generic_msg(msg, "Warning", near, ap);
720 }
721 
722 static const struct wpp_callbacks default_callbacks =
723 {
731 };
732 
734 
735 int ppy_error(const char *s, ...)
736 {
737  va_list ap;
738  va_start(ap, s);
740  va_end(ap);
741  pp_status.state = 1;
742  return 1;
743 }
744 
745 int ppy_warning(const char *s, ...)
746 {
747  va_list ap;
748  va_start(ap, s);
750  va_end(ap);
751  return 0;
752 }
753 
754 void pp_internal_error(const char *file, int line, const char *s, ...)
755 {
756  va_list ap;
757  va_start(ap, s);
758  fprintf(stderr, "Internal error (please report) %s %d: ", file, line);
759  vfprintf(stderr, s, ap);
760  fprintf(stderr, "\n");
761  va_end(ap);
762  exit(3);
763 }
#define realloc
Definition: debug_ros.c:6
pp_entry_t * pplookup(const char *ident)
Definition: preproc.c:221
int nargs
Definition: wpp_private.h:93
static void wpp_default_close(void *file)
Definition: preproc.c:200
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
char * text
Definition: wpp_private.h:96
includelogicentry_t * iep
Definition: wpp_private.h:101
#define error(str)
Definition: mkdosfs.c:1605
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
static int if_stack_idx
Definition: preproc.c:53
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:91
void *(* open)(const char *filename, int type)
Definition: wpp.h:38
static void * wpp_default_open(const char *filename, int type)
Definition: preproc.c:196
#define open
Definition: acwin.h:71
struct includelogicentry * next
Definition: wpp_private.h:37
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
void(* warning)(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: wpp.h:48
GLsizei const GLchar ** path
Definition: glext.h:7234
const WCHAR * text
Definition: package.c:1827
#define free
Definition: debug_ros.c:5
void pp_internal_error(const char *file, int line, const char *s,...)
Definition: preproc.c:754
static pp_def_state_t * pp_def_state
Definition: preproc.c:49
int line_number
Definition: wpp_private.h:233
char * filename
Definition: wpp_private.h:99
GLdouble GLdouble t
Definition: gl.h:2047
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
void pp_pop_ignore_state(void)
Definition: ppl.yy.c:4598
int pp_get_if_depth(void)
Definition: preproc.c:681
GLuint buffer
Definition: glext.h:5915
pp_if_state_t
Definition: wpp_private.h:110
static int fd
Definition: io.c:51
static void wpp_default_error(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: preproc.c:711
GLuint GLuint end
Definition: gl.h:1545
struct pp_def_state * next
Definition: preproc.c:45
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
_Check_return_opt_ _CRTIMP size_t __cdecl fwrite(_In_reads_bytes_(_Size *_Count) const void *_Str, _In_ size_t _Size, _In_ size_t _Count, _Inout_ FILE *_File)
#define __attribute__(Spec)
Definition: hlsl.tab.c:1213
const char * filename
Definition: ioapi.h:135
pp_if_state_t pp_pop_if(void)
Definition: preproc.c:618
Definition: match.c:390
marg_t ** margs
Definition: wpp_private.h:92
char * input
Definition: wpp_private.h:231
static void wpp_default_warning(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: preproc.c:717
#define HASHKEY
Definition: preproc.c:41
static char * wpp_default_lookup(const char *name, int type, const char *parent_name, char **include_path, int include_path_count)
Definition: preproc.c:118
GLuint n
Definition: s_context.h:57
pp_if_state_t pp_if_state(void)
Definition: preproc.c:653
static void wpp_default_write(const char *buffer, unsigned int len)
Definition: preproc.c:208
GLenum GLclampf GLint i
Definition: glfuncs.h:14
static int nincludepath
Definition: preproc.c:458
_Check_return_opt_ _CRTIMP size_t __cdecl fread(_Out_writes_bytes_(_ElementSize *_Count) void *_DstBuf, _In_ size_t _ElementSize, _In_ size_t _Count, _Inout_ FILE *_File)
#define va_end(ap)
Definition: acmsvcex.h:90
void pp_pop_define_state(void)
Definition: preproc.c:287
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
int wpp_add_include_path(const char *path)
Definition: preproc.c:460
unsigned int idx
Definition: utils.c:41
struct pp_entry * prev
Definition: wpp_private.h:89
const WCHAR * str
int char_number
Definition: wpp_private.h:234
UINT msg
Definition: msvc.h:92
char * wpp_find_include(const char *name, const char *parent_name)
Definition: preproc.c:509
smooth NULL
Definition: ftsmooth.c:416
static int pphash(const char *str)
Definition: preproc.c:213
Definition: parser.c:48
char * va_list
Definition: acmsvcex.h:78
static int wpp_default_read(void *file, char *buffer, unsigned int len)
Definition: preproc.c:204
unsigned int dir
Definition: maze.c:112
mtext_t * mtext
Definition: wpp_private.h:95
void * pp_xmalloc(size_t size)
Definition: preproc.c:77
int linenumber
Definition: wpp_private.h:100
static int sum(int x_, int y_)
Definition: ptr2_test.cpp:35
int ppy_error(const char *s,...)
Definition: preproc.c:735
_In_ ULONG _In_ ULONG_PTR ident
Definition: winddi.h:3993
int ppy_warning(const char *s,...)
Definition: preproc.c:745
char * ppy_text
Definition: ppl.yy.c:1051
GLsizeiptr size
Definition: glext.h:5919
char * ident
Definition: wpp_private.h:91
void pp_push_if(pp_if_state_t s)
Definition: preproc.c:592
Definition: wpp_private.h:87
static pp_if_state_t if_stack[MAXIFSTACK]
Definition: preproc.c:52
pp_entry_t * pp_add_define(const char *def, const char *text)
Definition: preproc.c:323
void pp_push_ignore_state(void)
Definition: ppl.yy.c:4593
char * pp_xstrdup(const char *str)
Definition: preproc.c:105
static char ** includepath
Definition: preproc.c:457
static const char *const pp_if_state_str[]
Definition: preproc.c:583
void pp_del_define(const char *name)
Definition: preproc.c:302
#define near
Definition: windef.h:115
static int state
Definition: maze.c:121
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
includelogicentry_t * pp_includelogiclist
Definition: ppl.yy.c:1342
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
#define close
Definition: acwin.h:74
pp_entry_t * defines[HASHKEY]
Definition: preproc.c:46
FILE * ppy_out
Definition: ppl.yy.c:370
#define MAXIFSTACK
Definition: preproc.c:51
pp_entry_t * pp_add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
Definition: preproc.c:384
struct pp_entry * next
Definition: wpp_private.h:88
static void generic_msg(const char *s, const char *t, const char *n, va_list ap)
Definition: preproc.c:688
void pp_next_if_state(int i)
Definition: preproc.c:662
Definition: services.c:325
void(* error)(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: wpp.h:47
int pp_push_define_state(void)
Definition: preproc.c:274
#define va_start(ap, A)
Definition: acmsvcex.h:91
char * strtok(char *String, const char *Delimiters)
Definition: utclib.c:338
char * strchr(const char *String, int ch)
Definition: utclib.c:501
int pp_flex_debug
Definition: wpp.c:31
#define isprint(c)
Definition: acclib.h:73
struct pp_def_state pp_def_state_t
def_type_t type
Definition: wpp_private.h:90
Definition: name.c:36
struct includelogicentry * prev
Definition: wpp_private.h:38
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
GLuint res
Definition: glext.h:9613
static const struct wpp_callbacks default_callbacks
Definition: preproc.c:722
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
DWORD exp
Definition: msg.c:15681
GLenum GLuint id
Definition: glext.h:5579
FILE * stderr
int pedantic
Definition: wpp_private.h:236
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define malloc
Definition: debug_ros.c:4
static void free_pp_entry(pp_entry_t *ppp, int idx)
Definition: preproc.c:237
void exit(int exitcode)
Definition: _exit.c:33
GLfloat GLfloat p
Definition: glext.h:8902
_Check_return_opt_ _CRTIMP int __cdecl vfprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
#define INCLUDESEPARATOR
Definition: preproc.c:454
#define memset(x, y, z)
Definition: compat.h:39
#define args
Definition: format.c:66
char *(* lookup)(const char *filename, int type, const char *parent_name, char **include_path, int include_path_count)
Definition: wpp.h:35
union pp_entry::@4026 subst
void * pp_open_include(const char *name, int type, const char *parent_name, char **newpath)
Definition: preproc.c:514
#define printf
Definition: config.h:203
#define O_RDONLY
Definition: acwin.h:82
Definition: fci.c:126