ReactOS 0.4.15-dev-6662-g1b3eed5
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
43typedef struct pp_def_state
44{
45 struct pp_def_state *next;
48
50
51#define MAXIFSTACK 64
53static int if_stack_idx = 0;
54
55#if 0
56void pp_print_status(void) __attribute__((destructor));
57void 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
77void *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
91void *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
105char *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
118static 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
196static void *wpp_default_open(const char *filename, int type) {
197 return fopen(filename,"rt");
198}
199
200static void wpp_default_close(void *file) {
201 fclose(file);
202}
203
204static int wpp_default_read(void *file, char *buffer, unsigned int len){
205 return fread(buffer, 1, len, file);
206}
207
208static 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... */
213static int pphash(const char *str)
214{
215 int sum = 0;
216 while(*str)
217 sum += *str++;
218 return sum % HASHKEY;
219}
220
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
237static void free_pp_entry( pp_entry_t *ppp, int idx )
238{
239 if(ppp->iep)
240 {
241 if(ppp->iep == pp_includelogiclist)
242 {
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;
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
302void 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 {
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
323pp_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 {
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
377error:
378 free(ppp->ident);
379 free(ppp->subst.text);
380 free(ppp);
381 return NULL;
382}
383
384pp_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 {
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
457static char **includepath;
458static int nincludepath = 0;
459
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 }
504 }
505 free(cpy);
506 return 0;
507}
508
509char *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
514void *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 */
583static 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{
595 pp_internal_error(__FILE__, __LINE__, "#if-stack overflow; #{if,ifdef,ifndef} nested too deeply (> %d)", MAXIFSTACK);
596
597 if(pp_flex_debug)
599
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",
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
688static 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 }
706end:
707#endif
708 fprintf(stderr, "\n");
709}
710
711static 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
717static 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
722static const struct wpp_callbacks default_callbacks =
723{
731};
732
734
735int 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
745int ppy_warning(const char *s, ...)
746{
747 va_list ap;
748 va_start(ap, s);
750 va_end(ap);
751 return 0;
752}
753
754void 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}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define isprint(c)
Definition: acclib.h:73
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
char * strtok(char *String, const char *Delimiters)
Definition: utclib.c:338
char * strchr(const char *String, int ch)
Definition: utclib.c:501
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define O_RDONLY
Definition: acwin.h:108
#define open
Definition: acwin.h:95
#define close
Definition: acwin.h:98
static int state
Definition: maze.c:121
unsigned int dir
Definition: maze.c:112
#define msg(x)
Definition: auth_time.c:54
int WINAPIV ppy_error(const char *msg,...)
Definition: compiler.c:135
int WINAPIV ppy_warning(const char *msg,...)
Definition: compiler.c:149
#define realloc
Definition: debug_ros.c:6
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
static void free_pp_entry(pp_entry_t *ppp, int idx)
Definition: preproc.c:111
static pp_if_state_t if_stack[MAXIFSTACK]
Definition: preproc.c:42
pp_entry_t * pp_add_define(const char *def, const char *text)
Definition: preproc.c:194
pp_if_state_t pp_if_state(void)
Definition: preproc.c:405
char * pp_xstrdup(const char *str)
Definition: preproc.c:73
int pp_get_if_depth(void)
Definition: preproc.c:433
struct pp_def_state pp_def_state_t
void * pp_open_include(const char *name, int type, const char *parent_name, char **newpath)
Definition: preproc.c:290
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:59
#define MAXIFSTACK
Definition: preproc.c:41
void * pp_xmalloc(size_t size)
Definition: preproc.c:45
int pp_push_define_state(void)
Definition: preproc.c:148
void pp_next_if_state(int i)
Definition: preproc.c:414
static int pphash(const char *str)
Definition: preproc.c:87
static int if_stack_idx
Definition: preproc.c:43
void pp_push_if(pp_if_state_t s)
Definition: preproc.c:357
pp_entry_t * pplookup(const char *ident)
Definition: preproc.c:95
void pp_pop_define_state(void)
Definition: preproc.c:161
pp_if_state_t pp_pop_if(void)
Definition: preproc.c:380
pp_entry_t * pp_add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
Definition: preproc.c:252
static pp_def_state_t * pp_def_state
Definition: preproc.c:39
void WINAPIV pp_internal_error(const char *file, int line, const char *s,...)
Definition: preproc.c:438
void pp_del_define(const char *name)
Definition: preproc.c:176
#define HASHKEY
Definition: preproc.c:31
void pp_push_ignore_state(void)
pp_if_state_t
Definition: wpp_private.h:118
@ if_true
Definition: wpp_private.h:120
@ if_elif
Definition: wpp_private.h:121
@ if_elsefalse
Definition: wpp_private.h:122
@ if_elsetrue
Definition: wpp_private.h:123
@ if_error
Definition: wpp_private.h:125
@ if_false
Definition: wpp_private.h:119
@ if_ignore
Definition: wpp_private.h:124
void pp_pop_ignore_state(void)
char * ppy_text
#define __attribute__(x)
Definition: wpp_private.h:207
FILE * ppy_out
@ exp_stringize
Definition: wpp_private.h:71
@ exp_text
Definition: wpp_private.h:69
@ exp_subst
Definition: wpp_private.h:72
@ exp_concat
Definition: wpp_private.h:70
includelogicentry_t * pp_includelogiclist
@ def_define
Definition: wpp_private.h:90
@ def_macro
Definition: wpp_private.h:91
unsigned int idx
Definition: utils.c:41
const WCHAR * text
Definition: package.c:1799
#define assert(x)
Definition: debug.h:53
#define printf
Definition: freeldr.h:94
size_t total
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLdouble s
Definition: gl.h:2039
GLuint GLuint end
Definition: gl.h:1545
GLdouble GLdouble t
Definition: gl.h:2047
GLsizeiptr size
Definition: glext.h:5919
GLdouble n
Definition: glext.h:7729
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLuint id
Definition: glext.h:5910
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define stderr
Definition: stdio.h:100
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
_Check_return_opt_ _CRTIMP int __cdecl vfprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
_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)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_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)
const char * filename
Definition: ioapi.h:137
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
DWORD exp
Definition: msg.c:16058
static int sum(int x_, int y_)
Definition: ptr2_test.cpp:35
const WCHAR * str
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define exit(n)
Definition: config.h:202
static int fd
Definition: io.c:51
#define memset(x, y, z)
Definition: compat.h:39
#define args
Definition: format.c:66
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
static void * wpp_default_open(const char *filename, int type)
Definition: preproc.c:196
#define INCLUDESEPARATOR
Definition: preproc.c:454
static int nincludepath
Definition: preproc.c:458
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
static const char *const pp_if_state_str[]
Definition: preproc.c:583
char * wpp_find_include(const char *name, const char *parent_name)
Definition: preproc.c:509
static void generic_msg(const char *s, const char *t, const char *n, va_list ap)
Definition: preproc.c:688
int wpp_add_include_path(const char *path)
Definition: preproc.c:460
static void wpp_default_write(const char *buffer, unsigned int len)
Definition: preproc.c:208
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
static const struct wpp_callbacks default_callbacks
Definition: preproc.c:722
static char ** includepath
Definition: preproc.c:457
static int wpp_default_read(void *file, char *buffer, unsigned int len)
Definition: preproc.c:204
static void wpp_default_close(void *file)
Definition: preproc.c:200
#define HASHKEY
Definition: preproc.c:41
Definition: match.c:390
Definition: fci.c:127
struct includelogicentry * next
Definition: wpp_private.h:45
struct includelogicentry * prev
Definition: wpp_private.h:46
Definition: parser.c:49
Definition: name.c:39
struct pp_def_state * next
Definition: preproc.c:35
pp_entry_t * defines[HASHKEY]
Definition: preproc.c:36
Definition: wpp_private.h:95
struct pp_entry * next
Definition: wpp_private.h:96
mtext_t * mtext
Definition: wpp_private.h:103
int linenumber
Definition: wpp_private.h:108
marg_t ** margs
Definition: wpp_private.h:100
int nargs
Definition: wpp_private.h:101
includelogicentry_t * iep
Definition: wpp_private.h:109
char * text
Definition: wpp_private.h:104
char * filename
Definition: wpp_private.h:107
def_type_t type
Definition: wpp_private.h:98
struct pp_entry * prev
Definition: wpp_private.h:97
char * ident
Definition: wpp_private.h:99
union pp_entry::@237 subst
int pedantic
Definition: wpp_private.h:225
int char_number
Definition: wpp_private.h:223
char * input
Definition: wpp_private.h:220
int line_number
Definition: wpp_private.h:222
void(* warning)(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: wpp.h:48
void *(* open)(const char *filename, int type)
Definition: wpp.h:38
char *(* lookup)(const char *filename, int type, const char *parent_name, char **include_path, int include_path_count)
Definition: wpp.h:35
void(* error)(const char *file, int line, int col, const char *near, const char *msg, va_list ap)
Definition: wpp.h:47
_In_ ULONG _In_ ULONG_PTR ident
Definition: winddi.h:3994
#define near
Definition: windef.h:115
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36
int pp_flex_debug
Definition: wpp.c:31