--- vendor/wine/libs/wpp/current/ppl.l 2005-02-19 22:16:09 UTC (rev 13647)
+++ vendor/wine/libs/wpp/current/ppl.l 2005-02-19 22:18:00 UTC (rev 13648)
@@ -1,1476 +1,1476 @@
-/*
- * Wrc preprocessor lexical analysis
- *
- * Copyright 1999-2000 Bertho A. Stultiens (BS)
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- * History:
- * 24-Apr-2000 BS - Started from scratch to restructure everything
- * and reintegrate the source into the wine-tree.
- * 04-Jan-2000 BS - Added comments about the lexicographical
- * grammar to give some insight in the complexity.
- * 28-Dec-1999 BS - Eliminated backing-up of the flexer by running
- * `flex -b' on the source. This results in some
- * weirdo extra rules, but a much faster scanner.
- * 23-Dec-1999 BS - Started this file
- *
- *-------------------------------------------------------------------------
- * The preprocessor's lexographical grammar (approximately):
- *
- * pp := {ws} # {ws} if {ws} {expr} {ws} \n
- * | {ws} # {ws} ifdef {ws} {id} {ws} \n
- * | {ws} # {ws} ifndef {ws} {id} {ws} \n
- * | {ws} # {ws} elif {ws} {expr} {ws} \n
- * | {ws} # {ws} else {ws} \n
- * | {ws} # {ws} endif {ws} \n
- * | {ws} # {ws} include {ws} < {anytext} > \n
- * | {ws} # {ws} include {ws} " {anytext} " \n
- * | {ws} # {ws} define {ws} {anytext} \n
- * | {ws} # {ws} define( {arglist} ) {ws} {expansion} \n
- * | {ws} # {ws} pragma {ws} {anytext} \n
- * | {ws} # {ws} ident {ws} {anytext} \n
- * | {ws} # {ws} error {ws} {anytext} \n
- * | {ws} # {ws} warning {ws} {anytext} \n
- * | {ws} # {ws} line {ws} " {anytext} " {number} \n
- * | {ws} # {ws} {number} " {anytext} " {number} [ {number} [{number}] ] \n
- * | {ws} # {ws} \n
- *
- * ws := [ \t\r\f\v]*
- *
- * expr := {expr} [+-*%^/|&] {expr}
- * | {expr} {logor|logand} {expr}
- * | [!~+-] {expr}
- * | {expr} ? {expr} : {expr}
- *
- * logor := ||
- *
- * logand := &&
- *
- * id := [a-zA-Z_][a-zA-Z0-9_]*
- *
- * anytext := [^\n]* (see note)
- *
- * arglist :=
- * | {id}
- * | {arglist} , {id}
- * | {arglist} , {id} ...
- *
- * expansion := {id}
- * | # {id}
- * | {anytext}
- * | {anytext} ## {anytext}
- *
- * number := [0-9]+
- *
- * Note: "anytext" is not always "[^\n]*". This is because the
- * trailing context must be considered as well.
- *
- * The only certain assumption for the preprocessor to make is that
- * directives start at the beginning of the line, followed by a '#'
- * and end with a newline.
- * Any directive may be suffixed with a line-continuation. Also
- * classical comment / *...* / (note: no comments within comments,
- * therefore spaces) is considered to be a line-continuation
- * (according to gcc and egcs AFAIK, ANSI is a bit vague).
- * Comments have not been added to the above grammar for simplicity
- * reasons. However, it is allowed to enter comment anywhere within
- * the directives as long as they do not interfere with the context.
- * All comments are considered to be deletable whitespace (both
- * classical form "/ *...* /" and C++ form "//...\n").
- *
- * All recursive scans, except for macro-expansion, are done by the
- * parser, whereas the simple state transitions of non-recursive
- * directives are done in the scanner. This results in the many
- * exclusive start-conditions of the scanner.
- *
- * Macro expansions are slightly more difficult because they have to
- * prescan the arguments. Parameter substitution is literal if the
- * substitution is # or ## (either side). This enables new identifiers
- * to be created (see 'info cpp' node Macro|Pitfalls|Prescan for more
- * information).
- *
- * FIXME: Variable macro parameters is recognized, but not yet
- * expanded. I have to reread the ANSI standard on the subject (yes,
- * ANSI defines it).
- *
- * The following special defines are supported:
- * __FILE__ -> "thissource.c"
- * __LINE__ -> 123
- * __DATE__ -> "May 1 2000"
- * __TIME__ -> "23:59:59"
- * These macros expand, as expected, into their ANSI defined values.
- *
- * The same include prevention is implemented as gcc and egcs does.
- * This results in faster processing because we do not read the text
- * at all. Some wine-sources attempt to include the same file 4 or 5
- * times. This strategy also saves a lot blank output-lines, which in
- * its turn improves the real resource scanner/parser.
- *
- */
-
-/*
- * Special flex options and exclusive scanner start-conditions
- */
-%option stack
-%option never-interactive
-
-%x pp_pp
-%x pp_eol
-%x pp_inc
-%x pp_dqs
-%x pp_sqs
-%x pp_iqs
-%x pp_comment
-%x pp_def
-%x pp_define
-%x pp_macro
-%x pp_mbody
-%x pp_macign
-%x pp_macscan
-%x pp_macexp
-%x pp_if
-%x pp_ifd
-%x pp_endif
-%x pp_line
-%x pp_defined
-%x pp_ignore
-%x RCINCL
-
-ws [ \v\f\t\r]
-cident [a-zA-Z_][0-9a-zA-Z_]*
-ul [uUlL]|[uUlL][lL]|[lL][uU]|[lL][lL][uU]|[uU][lL][lL]|[lL][uU][lL]
-
-%{
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-
-#include "wpp_private.h"
-#include "y.tab.h"
-
-/*
- * Make sure that we are running an appropriate version of flex.
- */
-#if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
-#error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
-#endif
-
-#define YY_USE_PROTOS
-#define YY_NO_UNPUT
-#define YY_READ_BUF_SIZE 65536 /* So we read most of a file at once */
-
-#define yy_current_state() YY_START
-#define yy_pp_state(x) yy_pop_state(); yy_push_state(x)
-
-/*
- * Always update the current character position within a line
- */
-#define YY_USER_ACTION pp_status.char_number+=ppleng;
-
-/*
- * Buffer management for includes and expansions
- */
-#define MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */
-
-typedef struct bufferstackentry {
- YY_BUFFER_STATE bufferstate; /* Buffer to switch back to */
- pp_entry_t *define; /* Points to expanding define or NULL if handling includes */
- int line_number; /* Line that we were handling */
- int char_number; /* The current position on that line */
- const char *filename; /* Filename that we were handling */
- int if_depth; /* How many #if:s deep to check matching #endif:s */
- int ncontinuations; /* Remember the continuation state */
- int should_pop; /* Set if we must pop the start-state on EOF */
- /* Include management */
- include_state_t incl;
- char *include_filename;
- int pass_data;
-} bufferstackentry_t;
-
-#define ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */
-
-/*
- * Macro expansion nesting
- * We need the stack to handle expansions while scanning
- * a macro's arguments. The TOS must always be the macro
- * that receives the current expansion from the scanner.
- */
-#define MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */
-
-typedef struct macexpstackentry {
- pp_entry_t *ppp; /* This macro we are scanning */
- char **args; /* With these arguments */
- char **ppargs; /* Resulting in these preprocessed arguments */
- int *nnls; /* Number of newlines per argument */
- int nargs; /* And this many arguments scanned */
- int parentheses; /* Nesting level of () */
- int curargsize; /* Current scanning argument's size */
- int curargalloc; /* Current scanning argument's block allocated */
- char *curarg; /* Current scanning argument's content */
-} macexpstackentry_t;
-
-#define MACROPARENTHESES() (top_macro()->parentheses)
-
-/*
- * Prototypes
- */
-static void newline(int);
-static int make_number(int radix, YYSTYPE *val, const char *str, int len);
-static void put_buffer(const char *s, int len);
-/* Buffer management */
-static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop);
-static bufferstackentry_t *pop_buffer(void);
-/* String functions */
-static void new_string(void);
-static void add_string(const char *str, int len);
-static char *get_string(void);
-static void put_string(void);
-static int string_start(void);
-/* Macro functions */
-static void push_macro(pp_entry_t *ppp);
-static macexpstackentry_t *top_macro(void);
-static macexpstackentry_t *pop_macro(void);
-static void free_macro(macexpstackentry_t *mep);
-static void add_text_to_macro(const char *text, int len);
-static void macro_add_arg(int last);
-static void macro_add_expansion(void);
-/* Expansion */
-static void expand_special(pp_entry_t *ppp);
-static void expand_define(pp_entry_t *ppp);
-static void expand_macro(macexpstackentry_t *mep);
-
-/*
- * Local variables
- */
-static int ncontinuations;
-
-static int strbuf_idx = 0;
-static int strbuf_alloc = 0;
-static char *strbuffer = NULL;
-static int str_startline;
-
-static macexpstackentry_t *macexpstack[MAXMACEXPSTACK];
-static int macexpstackidx = 0;
-
-static bufferstackentry_t bufferstack[MAXBUFFERSTACK];
-static int bufferstackidx = 0;
-
-static int pass_data=1;
-
-/*
- * Global variables
- */
-include_state_t pp_incl_state =
-{
- -1, /* state */
- NULL, /* ppp */
- 0, /* ifdepth */
- 0 /* seen_junk */
-};
-
-includelogicentry_t *pp_includelogiclist = NULL;
-
-%}
-
-/*
- **************************************************************************
- * The scanner starts here
- **************************************************************************
- */
-
-%%
- /*
- * Catch line-continuations.
- * Note: Gcc keeps the line-continuations in, for example, strings
- * intact. However, I prefer to remove them all so that the next
- * scanner will not need to reduce the continuation state.
- *
- * <*>\\\n newline(0);
- */
-
- /*
- * Detect the leading # of a preprocessor directive.
- */
-<INITIAL,pp_ignore>^{ws}*# pp_incl_state.seen_junk++; yy_push_state(pp_pp);
-
- /*
- * Scan for the preprocessor directives
- */
-<pp_pp>{ws}*include{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_inc); return tINCLUDE;} else {yy_pp_state(pp_eol);}
-<pp_pp>{ws}*define{ws}* yy_pp_state(yy_current_state() != pp_ignore ? pp_def : pp_eol);
-<pp_pp>{ws}*error{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tERROR;
-<pp_pp>{ws}*warning{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tWARNING;
-<pp_pp>{ws}*pragma{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPRAGMA;
-<pp_pp>{ws}*ident{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPPIDENT;
-<pp_pp>{ws}*undef{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_ifd); return tUNDEF;} else {yy_pp_state(pp_eol);}
-<pp_pp>{ws}*ifdef{ws}* yy_pp_state(pp_ifd); return tIFDEF;
-<pp_pp>{ws}*ifndef{ws}* pp_incl_state.seen_junk--; yy_pp_state(pp_ifd); return tIFNDEF;
-<pp_pp>{ws}*if{ws}* yy_pp_state(pp_if); return tIF;
-<pp_pp>{ws}*elif{ws}* yy_pp_state(pp_if); return tELIF;
-<pp_pp>{ws}*else{ws}* yy_pp_state(pp_endif); return tELSE;
-<pp_pp>{ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF;
-<pp_pp>{ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);}
-<pp_pp>{ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);}
-<pp_pp>{ws}*[a-z]+ pperror("Invalid preprocessor token '%s'", pptext);
-<pp_pp>\r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */
-<pp_pp>\\\r?\n newline(0);
-<pp_pp>\\\r? pperror("Preprocessor junk '%s'", pptext);
-<pp_pp>. return *pptext;
-
- /*
- * Handle #include and #line
- */
-<pp_line>[0-9]+ return make_number(10, &pplval, pptext, ppleng);
-<pp_inc>\< new_string(); add_string(pptext, ppleng); yy_push_state(pp_iqs);
-<pp_inc,pp_line>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
-<pp_inc,pp_line>{ws}+ ;
-<pp_inc,pp_line>\n newline(1); yy_pop_state(); return tNL;
-<pp_inc,pp_line>\\\r?\n newline(0);
-<pp_inc,pp_line>(\\\r?)|(.) pperror(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line");
-
- /*
- * Ignore all input when a false clause is parsed
- */
-<pp_ignore>[^#/\\\n]+ ;
-<pp_ignore>\n newline(1);
-<pp_ignore>\\\r?\n newline(0);
-<pp_ignore>(\\\r?)|(.) ;
-
- /*
- * Handle #if and #elif.
- * These require conditionals to be evaluated, but we do not
- * want to jam the scanner normally when we see these tokens.
- * Note: tIDENT is handled below.
- */
-
-<pp_if>0[0-7]*{ul}? return make_number(8, &pplval, pptext, ppleng);
-<pp_if>0[0-7]*[8-9]+{ul}? pperror("Invalid octal digit");
-<pp_if>[1-9][0-9]*{ul}? return make_number(10, &pplval, pptext, ppleng);
-<pp_if>0[xX][0-9a-fA-F]+{ul}? return make_number(16, &pplval, pptext, ppleng);
-<pp_if>0[xX] pperror("Invalid hex number");
-<pp_if>defined yy_push_state(pp_defined); return tDEFINED;
-<pp_if>"<<" return tLSHIFT;
-<pp_if>">>" return tRSHIFT;
-<pp_if>"&&" return tLOGAND;
-<pp_if>"||" return tLOGOR;
-<pp_if>"==" return tEQ;
-<pp_if>"!=" return tNE;
-<pp_if>"<=" return tLTE;
-<pp_if>">=" return tGTE;
-<pp_if>\n newline(1); yy_pop_state(); return tNL;
-<pp_if>\\\r?\n newline(0);
-<pp_if>\\\r? pperror("Junk in conditional expression");
-<pp_if>{ws}+ ;
-<pp_if>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
-<pp_if>\" pperror("String constants not allowed in conditionals");
-<pp_if>. return *pptext;
-
- /*
- * Handle #ifdef, #ifndef and #undef
- * to get only an untranslated/unexpanded identifier
- */
-<pp_ifd>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
-<pp_ifd>{ws}+ ;
-<pp_ifd>\n newline(1); yy_pop_state(); return tNL;
-<pp_ifd>\\\r?\n newline(0);
-<pp_ifd>(\\\r?)|(.) pperror("Identifier expected");
-
- /*
- * Handle #else and #endif.
- */
-<pp_endif>{ws}+ ;
-<pp_endif>\n newline(1); yy_pop_state(); return tNL;
-<pp_endif>\\\r?\n newline(0);
-<pp_endif>. pperror("Garbage after #else or #endif.");
-
- /*
- * Handle the special 'defined' keyword.
- * This is necessary to get the identifier prior to any
- * substitutions.
- */
-<pp_defined>{cident} yy_pop_state(); pplval.cptr = pp_xstrdup(pptext); return tIDENT;
-<pp_defined>{ws}+ ;
-<pp_defined>(\()|(\)) return *pptext;
-<pp_defined>\\\r?\n newline(0);
-<pp_defined>(\\.)|(\n)|(.) pperror("Identifier expected");
-
- /*
- * Handle #error, #warning, #pragma and #ident.
- * Pass everything literally to the parser, which
- * will act appropriately.
- * Comments are stripped from the literal text.
- */
-<pp_eol>[^/\\\n]+ if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
-<pp_eol>\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
-<pp_eol>(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
-<pp_eol>\n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; }
-<pp_eol>\\\r?\n newline(0);
-
- /*
- * Handle left side of #define
- */
-<pp_def>{cident}\( pplval.cptr = pp_xstrdup(pptext); pplval.cptr[ppleng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO;
-<pp_def>{cident} pplval.cptr = pp_xstrdup(pptext); yy_pp_state(pp_define); return tDEFINE;
-<pp_def>{ws}+ ;
-<pp_def>\\\r?\n newline(0);
-<pp_def>(\\\r?)|(\n)|(.) perror("Identifier expected");
-
- /*
- * Scan the substitution of a define
- */
-<pp_define>[^'"/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
-<pp_define>(\\\r?)|(\/[^/*]) pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
-<pp_define>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL;
-<pp_define>\\\r?\n newline(0);
-<pp_define>\n newline(1); yy_pop_state(); return tNL;
-<pp_define>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
-<pp_define>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
-
- /*
- * Scan the definition macro arguments
- */
-<pp_macro>\){ws}* yy_pp_state(pp_mbody); return tMACROEND;
-<pp_macro>{ws}+ ;
-<pp_macro>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
-<pp_macro>, return ',';
-<pp_macro>"..." return tELIPSIS;
-<pp_macro>(\\\r?)|(\n)|(.)|(\.\.?) pperror("Argument identifier expected");
-<pp_macro>\\\r?\n newline(0);
-
- /*
- * Scan the substitution of a macro
- */
-<pp_mbody>[^a-zA-Z0-9'"#/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
-<pp_mbody>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
-<pp_mbody>\#\# return tCONCAT;
-<pp_mbody>\# return tSTRINGIZE;
-<pp_mbody>[0-9][^'"#/\\\n]* pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
-<pp_mbody>(\\\r?)|(\/[^/*'"#\\\n]*) pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
-<pp_mbody>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL;
-<pp_mbody>\\\r?\n newline(0);
-<pp_mbody>\n newline(1); yy_pop_state(); return tNL;
-<pp_mbody>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
-<pp_mbody>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
-
- /*
- * Macro expansion text scanning.
- * This state is active just after the identifier is scanned
- * that triggers an expansion. We *must* delete the leading
- * whitespace before we can start scanning for arguments.
- *
- * If we do not see a '(' as next trailing token, then we have
- * a false alarm. We just continue with a nose-bleed...
- */
-<pp_macign>{ws}*/\( yy_pp_state(pp_macscan);
-<pp_macign>{ws}*\n {
- if(yy_top_state() != pp_macscan)
- newline(0);
- }
-<pp_macign>{ws}*\\\r?\n newline(0);
-<pp_macign>{ws}+|{ws}*\\\r?|. {
- macexpstackentry_t *mac = pop_macro();
- yy_pop_state();
- put_buffer(mac->ppp->ident, strlen(mac->ppp->ident));
- put_buffer(pptext, ppleng);
- free_macro(mac);
- }
-
- /*
- * Macro expansion argument text scanning.
- * This state is active when a macro's arguments are being read for expansion.
- */
-<pp_macscan>\( {
- if(++MACROPARENTHESES() > 1)
- add_text_to_macro(pptext, ppleng);
- }
-<pp_macscan>\) {
- if(--MACROPARENTHESES() == 0)
- {
- yy_pop_state();
- macro_add_arg(1);
- }
- else
- add_text_to_macro(pptext, ppleng);
- }
-<pp_macscan>, {
- if(MACROPARENTHESES() > 1)
- add_text_to_macro(pptext, ppleng);
- else
- macro_add_arg(0);
- }
-<pp_macscan>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
-<pp_macscan>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
-<pp_macscan>"/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1);
-<pp_macscan>\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(pptext, ppleng);
-<pp_macscan>([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(pptext, ppleng);
-<pp_macscan>\\\r?\n newline(0);
-
- /*
- * Comment handling (almost all start-conditions)
- */
-<INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,RCINCL>"/*" yy_push_state(pp_comment);
-<pp_comment>[^*\n]*|"*"+[^*/\n]* ;
-<pp_comment>\n newline(0);
-<pp_comment>"*"+"/" yy_pop_state();
-
- /*
- * Remove C++ style comment (almost all start-conditions)
- */
-<INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,pp_macscan,RCINCL>"//"[^\n]* {
- if(pptext[ppleng-1] == '\\')
- ppwarning("C++ style comment ends with an escaped newline (escape ignored)");
- }
-
- /*
- * Single, double and <> quoted constants
- */
-<INITIAL,pp_macexp>\" pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
-<INITIAL,pp_macexp>\' pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
-<pp_dqs>[^"\\\n]+ add_string(pptext, ppleng);
-<pp_dqs>\" {
- add_string(pptext, ppleng);
- yy_pop_state();
- switch(yy_current_state())
- {
- case pp_pp:
- case pp_define:
- case pp_mbody:
- case pp_inc:
- case pp_line:
- case RCINCL:
- if (yy_current_state()==RCINCL) yy_pop_state();
- pplval.cptr = get_string();
- return tDQSTRING;
- default:
- put_string();
- }
- }
-<pp_sqs>[^'\\\n]+ add_string(pptext, ppleng);
-<pp_sqs>\' {
- add_string(pptext, ppleng);
- yy_pop_state();
- switch(yy_current_state())
- {
- case pp_if:
- case pp_define:
- case pp_mbody:
- pplval.cptr = get_string();
- return tSQSTRING;
- default:
- put_string();
- }
- }
-<pp_iqs>[^\>\\\n]+ add_string(pptext, ppleng);
-<pp_iqs>\> {
- add_string(pptext, ppleng);
- yy_pop_state();
- pplval.cptr = get_string();
- return tIQSTRING;
- }
-<pp_dqs>\\\r?\n {
- /*
- * This is tricky; we need to remove the line-continuation
- * from preprocessor strings, but OTOH retain them in all
- * other strings. This is because the resource grammar is
- * even more braindead than initially analysed and line-
- * continuations in strings introduce, sigh, newlines in
- * the output. There goes the concept of non-breaking, non-
- * spacing whitespace.
- */
- switch(yy_top_state())
- {
- case pp_pp:
- case pp_define:
- case pp_mbody:
- case pp_inc:
- case pp_line:
- newline(0);
- break;
- default:
- add_string(pptext, ppleng);
- newline(-1);
- }
- }
-<pp_iqs,pp_dqs,pp_sqs>\\. add_string(pptext, ppleng);
-<pp_iqs,pp_dqs,pp_sqs>\n {
- newline(1);
- add_string(pptext, ppleng);
- ppwarning("Newline in string constant encounterd (started line %d)", string_start());
- }
-
- /*
- * Identifier scanning
- */
-<INITIAL,pp_if,pp_inc,pp_macexp>{cident} {
- pp_entry_t *ppp;
- pp_incl_state.seen_junk++;
- if(!(ppp = pplookup(pptext)))
- {
- if(yy_current_state() == pp_inc)
- pperror("Expected include filename");
-
- if(yy_current_state() == pp_if)
- {
- pplval.cptr = pp_xstrdup(pptext);
- return tIDENT;
- }
- else {
- if((yy_current_state()==INITIAL) && (strcasecmp(pptext,"RCINCLUDE")==0)){
- yy_push_state(RCINCL);
- return tRCINCLUDE;
- }
- else put_buffer(pptext, ppleng);
- }
- }
- else if(!ppp->expanding)
- {
- switch(ppp->type)
- {
- case def_special:
- expand_special(ppp);
- break;
- case def_define:
- expand_define(ppp);
- break;
- case def_macro:
- yy_push_state(pp_macign);
- push_macro(ppp);
- break;
- default:
- pp_internal_error(__FILE__, __LINE__, "Invalid define type %d\n", ppp->type);
- }
- }
- }
-
- /*
- * Everything else that needs to be passed and
- * newline and continuation handling
- */
-<INITIAL,pp_macexp>[^a-zA-Z_#'"/\\\n \r\t\f\v]+|(\/|\\)[^a-zA-Z_/*'"\\\n \r\t\v\f]* pp_incl_state.seen_junk++; put_buffer(pptext, ppleng);
-<INITIAL,pp_macexp>{ws}+ put_buffer(pptext, ppleng);
-<INITIAL>\n newline(1);
-<INITIAL>\\\r?\n newline(0);
-<INITIAL>\\\r? pp_incl_state.seen_junk++; put_buffer(pptext, ppleng);
-
- /*
- * Special catcher for macro argmument expansion to prevent
- * newlines to propagate to the output or admin.
- */
-<pp_macexp>(\n)|(.)|(\\\r?(\n|.)) put_buffer(pptext, ppleng);
-
-<RCINCL>[A-Za-z0-9_\.\\/]+ {
- pplval.cptr=pp_xstrdup(pptext);
- yy_pop_state();
- return tRCINCLUDEPATH;
- }
-
-<RCINCL>{ws}+ ;
-
-<RCINCL>\" {
- new_string(); add_string(pptext,ppleng);yy_push_state(pp_dqs);
- }
-
- /*
- * This is a 'catch-all' rule to discover errors in the scanner
- * in an orderly manner.
- */
-<*>. pp_incl_state.seen_junk++; ppwarning("Unmatched text '%c' (0x%02x); please report\n", isprint(*pptext & 0xff) ? *pptext : ' ', *pptext);
-
-<<EOF>> {
- YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
- bufferstackentry_t *bep = pop_buffer();
-
- if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth))
- ppwarning("Unmatched #if/#endif at end of file");
-
- if(!bep)
- {
- if(YY_START != INITIAL)
- pperror("Unexpected end of file during preprocessing");
- yyterminate();
- }
- else if(bep->should_pop == 2)
- {
- macexpstackentry_t *mac;
- mac = pop_macro();
- expand_macro(mac);
- }
- pp_delete_buffer(b);
- }
-
-%%
-/*
- **************************************************************************
- * Support functions
- **************************************************************************
- */
-
-#ifndef ppwrap
-int ppwrap(void)
-{
- return 1;
-}
-#endif
-
-
-/*
- *-------------------------------------------------------------------------
- * Output newlines or set them as continuations
- *
- * Input: -1 - Don't count this one, but update local position (see pp_dqs)
- * 0 - Line-continuation seen and cache output
- * 1 - Newline seen and flush output
- *-------------------------------------------------------------------------
- */
-static void newline(int dowrite)
-{
- pp_status.line_number++;
- pp_status.char_number = 1;
-
- if(dowrite == -1)
- return;
-
- ncontinuations++;
- if(dowrite)
- {
- for(;ncontinuations; ncontinuations--)
- put_buffer("\n", 1);
- }
-}
-
-
-/*
- *-------------------------------------------------------------------------
- * Make a number out of an any-base and suffixed string
- *
- * Possible number extensions:
- * - "" int
- * - "L" long int
- * - "LL" long long int
- * - "U" unsigned int
- * - "UL" unsigned long int
- * - "ULL" unsigned long long int
- * - "LU" unsigned long int
- * - "LLU" unsigned long long int
- * - "LUL" invalid
- *
- * FIXME:
- * The sizes of resulting 'int' and 'long' are compiler specific.
- * I depend on sizeof(int) > 2 here (although a relatively safe
- * assumption).
- * Long longs are not yet implemented because this is very compiler
- * specific and I don't want to think too much about the problems.
- *
- *-------------------------------------------------------------------------
- */
-static int make_number(int radix, YYSTYPE *val, const char *str, int len)
-{
- int is_l = 0;
- int is_ll = 0;
- int is_u = 0;
- char ext[4];
-
- ext[3] = '\0';
- ext[2] = toupper(str[len-1]);
- ext[1] = len > 1 ? toupper(str[len-2]) : ' ';
- ext[0] = len > 2 ? toupper(str[len-3]) : ' ';
-
- if(!strcmp(ext, "LUL"))
- pperror("Invalid constant suffix");
- else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL"))
- {
- is_ll++;
- is_u++;
- }
- else if(!strcmp(ext+1, "LU") || !strcmp(ext+1, "UL"))
- {
- is_l++;
- is_u++;
- }
- else if(!strcmp(ext+1, "LL"))
- {
- is_ll++;
- }
- else if(!strcmp(ext+2, "L"))
- {
- is_l++;
- }
- else if(!strcmp(ext+2, "U"))
- {
- is_u++;
- }
-
- if(is_ll)
- pp_internal_error(__FILE__, __LINE__, "long long constants not implemented yet");
-
- if(is_u && is_l)
- {
- val->ulong = strtoul(str, NULL, radix);
- return tULONG;
- }
- else if(!is_u && is_l)
- {
- val->slong = strtol(str, NULL, radix);
- return tSLONG;
- }
- else if(is_u && !is_l)
- {
- val->uint = (unsigned int)strtoul(str, NULL, radix);
- return tUINT;
- }
-
- /* Else it must be an int... */
- val->sint = (int)strtol(str, NULL, radix);
- return tSINT;
-}
-
-
-/*
- *-------------------------------------------------------------------------
- * Macro and define expansion support
- *
- * FIXME: Variable macro arguments.
- *-------------------------------------------------------------------------
- */
-static void expand_special(pp_entry_t *ppp)
-{
- const char *dbgtext = "?";
- static char *buf = NULL;
-
- assert(ppp->type == def_special);
-
- if(!strcmp(ppp->ident, "__LINE__"))
- {
- dbgtext = "def_special(__LINE__)";
- buf = pp_xrealloc(buf, 32);
- sprintf(buf, "%d", pp_status.line_number);
- }
- else if(!strcmp(ppp->ident, "__FILE__"))
- {
- dbgtext = "def_special(__FILE__)";
- buf = pp_xrealloc(buf, strlen(pp_status.input) + 3);
- sprintf(buf, "\"%s\"", pp_status.input);
- }
- else
- pp_internal_error(__FILE__, __LINE__, "Special macro '%s' not found...\n", ppp->ident);
-
- if(pp_flex_debug)
- fprintf(stderr, "expand_special(%d): %s:%d: '%s' -> '%s'\n",
- macexpstackidx,
- pp_status.input,
- pp_status.line_number,
- ppp->ident,
- buf ? buf : "");
-
- if(buf && buf[0])
- {
- push_buffer(ppp, NULL, NULL, 0);
- yy_scan_string(buf);
- }
-}
-
-static void expand_define(pp_entry_t *ppp)
-{
- assert(ppp->type == def_define);
-
- if(pp_flex_debug)
- fprintf(stderr, "expand_define(%d): %s:%d: '%s' -> '%s'\n",
- macexpstackidx,
- pp_status.input,
- pp_status.line_number,
- ppp->ident,
- ppp->subst.text);
- if(ppp->subst.text && ppp->subst.text[0])
- {
- push_buffer(ppp, NULL, NULL, 0);
- yy_scan_string(ppp->subst.text);
- }
-}
-
-static int curdef_idx = 0;
-static int curdef_alloc = 0;
-static char *curdef_text = NULL;
-
-static void add_text(const char *str, int len)
-{
- if(len == 0)
- return;
- if(curdef_idx >= curdef_alloc || curdef_alloc - curdef_idx < len)
- {
- curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
- curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0]));
- if(curdef_alloc > 65536)
- ppwarning("Reallocating macro-expansion buffer larger than 64kB");
- }
- memcpy(&curdef_text[curdef_idx], str, len);
- curdef_idx += len;
-}
-
-static mtext_t *add_expand_text(mtext_t *mtp, macexpstackentry_t *mep, int *nnl)
-{
- char *cptr;
- char *exp;
- int tag;
- int n;
-
- if(mtp == NULL)
- return NULL;
-
- switch(mtp->type)
- {
- case exp_text:
- if(pp_flex_debug)
- fprintf(stderr, "add_expand_text: exp_text: '%s'\n", mtp->subst.text);
- add_text(mtp->subst.text, strlen(mtp->subst.text));
- break;
-
- case exp_stringize:
- if(pp_flex_debug)
- fprintf(stderr, "add_expand_text: exp_stringize(%d): '%s'\n",
- mtp->subst.argidx,
- mep->args[mtp->subst.argidx]);
- cptr = mep->args[mtp->subst.argidx];
- add_text("\"", 1);
- while(*cptr)
- {
- if(*cptr == '"' || *cptr == '\\')
- add_text("\\", 1);
- add_text(cptr, 1);
- cptr++;
- }
- add_text("\"", 1);
- break;
-
- case exp_concat:
- if(pp_flex_debug)
- fprintf(stderr, "add_expand_text: exp_concat\n");
- /* Remove trailing whitespace from current expansion text */
- while(curdef_idx)
- {
- if(isspace(curdef_text[curdef_idx-1] & 0xff))
- curdef_idx--;
- else
- break;
- }
- /* tag current position and recursively expand the next part */
- tag = curdef_idx;
- mtp = add_expand_text(mtp->next, mep, nnl);
-
- /* Now get rid of the leading space of the expansion */
- cptr = &curdef_text[tag];
- n = curdef_idx - tag;
- while(n)
- {
- if(isspace(*cptr & 0xff))
- {
- cptr++;
- n--;
- }
- else
- break;
- }
- if(cptr != &curdef_text[tag])
- {
- memmove(&curdef_text[tag], cptr, n);
- curdef_idx -= (curdef_idx - tag) - n;
- }
- break;
-
- case exp_subst:
- if((mtp->next && mtp->next->type == exp_concat) || (mtp->prev && mtp->prev->type == exp_concat))
[truncated at 1000 lines; 3286 more skipped]