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
39 struct pp_status pp_status;
40
41 #define HASHKEY 2039
42
43 typedef struct pp_def_state
44 {
45 struct pp_def_state *next;
46 pp_entry_t *defines[HASHKEY];
47 } pp_def_state_t;
48
49 static pp_def_state_t *pp_def_state;
50
51 #define MAXIFSTACK 64
52 static pp_if_state_t if_stack[MAXIFSTACK];
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
pp_xmalloc(size_t size)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
pp_xrealloc(void * p,size_t size)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
pp_xstrdup(const char * str)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
wpp_default_lookup(const char * name,int type,const char * parent_name,char ** include_path,int include_path_count)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
wpp_default_open(const char * filename,int type)196 static void *wpp_default_open(const char *filename, int type) {
197 return fopen(filename,"rt");
198 }
199
wpp_default_close(void * file)200 static void wpp_default_close(void *file) {
201 fclose(file);
202 }
203
wpp_default_read(void * file,char * buffer,unsigned int len)204 static int wpp_default_read(void *file, char *buffer, unsigned int len){
205 return fread(buffer, 1, len, file);
206 }
207
wpp_default_write(const char * buffer,unsigned int len)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... */
pphash(const char * str)213 static int pphash(const char *str)
214 {
215 int sum = 0;
216 while(*str)
217 sum += *str++;
218 return sum % HASHKEY;
219 }
220
pplookup(const char * ident)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
free_pp_entry(pp_entry_t * ppp,int idx)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;
244 if(pp_includelogiclist)
245 pp_includelogiclist->prev = NULL;
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])
261 pp_def_state->defines[idx]->prev = NULL;
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 */
pp_push_define_state(void)274 int pp_push_define_state(void)
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;
282 pp_def_state = state;
283 return 0;
284 }
285
286 /* pop the current define state */
pp_pop_define_state(void)287 void pp_pop_define_state(void)
288 {
289 int i;
290 pp_entry_t *ppp;
291 pp_def_state_t *state;
292
293 for (i = 0; i < HASHKEY; i++)
294 {
295 while ((ppp = pp_def_state->defines[i]) != NULL) pp_del_define( ppp->ident );
296 }
297 state = pp_def_state;
298 pp_def_state = state->next;
299 free( state );
300 }
301
pp_del_define(const char * name)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
pp_add_define(const char * def,const char * text)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;
353 ppp->linenumber = pp_status.input ? pp_status.line_number : 0;
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
pp_add_macro(char * id,marg_t * args[],int nargs,mtext_t * exp)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 }
413 ppp->linenumber = pp_status.input ? pp_status.line_number : 0;
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
wpp_add_include_path(const char * path)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;
500 includepath[nincludepath] = dir;
501 nincludepath++;
502 }
503 tok = strtok(NULL, INCLUDESEPARATOR);
504 }
505 free(cpy);
506 return 0;
507 }
508
wpp_find_include(const char * name,const char * parent_name)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
pp_open_include(const char * name,int type,const char * parent_name,char ** newpath)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
pp_push_if(pp_if_state_t s)592 void pp_push_if(pp_if_state_t s)
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)
598 fprintf(stderr, "Push if %s:%d: %s(%d) -> %s(%d)\n", pp_status.input, pp_status.line_number, pp_if_state_str[pp_if_state()], if_stack_idx, pp_if_state_str[s], if_stack_idx+1);
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:
611 pp_push_ignore_state();
612 break;
613 default:
614 pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d)", (int)pp_if_state());
615 }
616 }
617
pp_pop_if(void)618 pp_if_state_t pp_pop_if(void)
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:
635 pp_pop_ignore_state();
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",
643 pp_status.input,
644 pp_status.line_number,
645 pp_if_state_str[pp_if_state()],
646 if_stack_idx,
647 pp_if_state_str[if_stack[if_stack_idx <= 1 ? if_true : if_stack_idx-2]],
648 if_stack_idx-1);
649
650 return if_stack[--if_stack_idx];
651 }
652
pp_if_state(void)653 pp_if_state_t pp_if_state(void)
654 {
655 if(!if_stack_idx)
656 return if_true;
657 else
658 return if_stack[if_stack_idx-1];
659 }
660
661
pp_next_if_state(int i)662 void pp_next_if_state(int i)
663 {
664 switch(pp_if_state())
665 {
666 case if_true:
667 case if_elsetrue:
668 pp_push_if(i ? if_true : if_false);
669 break;
670 case if_false:
671 case if_elsefalse:
672 case if_elif:
673 case if_ignore:
674 pp_push_if(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
pp_get_if_depth(void)681 int pp_get_if_depth(void)
682 {
683 return if_stack_idx;
684 }
685
686 /* #define WANT_NEAR_INDICATION */
687
generic_msg(const char * s,const char * t,const char * n,va_list ap)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",
691 pp_status.line_number, pp_status.char_number, t);
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
wpp_default_error(const char * file,int line,int col,const char * near,const char * msg,va_list ap)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
wpp_default_warning(const char * file,int line,int col,const char * near,const char * msg,va_list ap)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 {
724 wpp_default_lookup,
725 wpp_default_open,
726 wpp_default_close,
727 wpp_default_read,
728 wpp_default_write,
729 wpp_default_error,
730 wpp_default_warning,
731 };
732
733 const struct wpp_callbacks *wpp_callbacks = &default_callbacks;
734
ppy_error(const char * s,...)735 int ppy_error(const char *s, ...)
736 {
737 va_list ap;
738 va_start(ap, s);
739 wpp_callbacks->error(pp_status.input, pp_status.line_number, pp_status.char_number, ppy_text, s, ap);
740 va_end(ap);
741 pp_status.state = 1;
742 return 1;
743 }
744
ppy_warning(const char * s,...)745 int ppy_warning(const char *s, ...)
746 {
747 va_list ap;
748 va_start(ap, s);
749 wpp_callbacks->warning(pp_status.input, pp_status.line_number, pp_status.char_number, ppy_text, s, ap);
750 va_end(ap);
751 return 0;
752 }
753
pp_internal_error(const char * file,int line,const char * s,...)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 }
764