-/* CPP Library.
+/* CPP Library. (Directive handling.)
Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
#include "cpphash.h"
#include "intl.h"
#include "obstack.h"
-#include "symcat.h"
/* Chained list of answers to an assertion. */
struct answer
struct if_stack *next;
cpp_lexer_pos pos; /* line and column where condition started */
const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
- int was_skipping; /* value of pfile->skipping before this if */
- int type; /* type of last directive seen in this group */
+ bool skip_elses; /* Can future #else / #elif be skipped? */
+ bool was_skipping; /* If were skipping on entry. */
+ int type; /* Most recent conditional, for diagnostics. */
};
/* Values for the origin field of struct directive. KANDR directives
static void skip_rest_of_line PARAMS ((cpp_reader *));
static void check_eol PARAMS ((cpp_reader *));
+static void start_directive PARAMS ((cpp_reader *));
+static void end_directive PARAMS ((cpp_reader *, int));
static void run_directive PARAMS ((cpp_reader *, int,
- const char *, size_t,
- const char *));
+ enum cpp_buffer_type,
+ const char *, size_t));
static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
static int parse_include PARAMS ((cpp_reader *, cpp_token *));
static void push_conditional PARAMS ((cpp_reader *, int, int,
const cpp_hashnode *));
-static int read_line_number PARAMS ((cpp_reader *, int *));
+static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
unsigned long *));
-static void do_diagnostic PARAMS ((cpp_reader *, enum error_type));
-static cpp_hashnode *
- lex_macro_node PARAMS ((cpp_reader *));
-static void unwind_if_stack PARAMS ((cpp_reader *, cpp_buffer *));
+static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
+static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
+static void do_include_common PARAMS ((cpp_reader *, enum include_type));
static void do_pragma_once PARAMS ((cpp_reader *));
static void do_pragma_poison PARAMS ((cpp_reader *));
static void do_pragma_system_header PARAMS ((cpp_reader *));
D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
-D(elif, T_ELIF, KANDR, COND) /* 610 */ \
+D(elif, T_ELIF, STDC89, COND) /* 610 */ \
D(error, T_ERROR, STDC89, 0) /* 475 */ \
D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
instead of void, because some old compilers have trouble with
pointers to functions returning void. */
-/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
#define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
DIRECTIVE_TABLE
#undef D
#define D(n, tag, o, f) tag,
enum
{
- T_BAD_DIRECTIVE,
DIRECTIVE_TABLE
N_DIRECTIVES
};
#undef D
-/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
#define D(name, t, origin, flags) \
{ CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
sizeof STRINGX(name) - 1, origin, flags },
#undef D
#undef DIRECTIVE_TABLE
+#define SEEN_EOL() (pfile->lexer_pos.output_line > pfile->line)
+
/* Skip any remaining tokens in a directive. */
static void
skip_rest_of_line (pfile)
{
cpp_token token;
+ /* Discard all input lookaheads. */
+ while (pfile->la_read)
+ _cpp_release_lookahead (pfile);
+
/* Discard all stacked contexts. */
while (pfile->context != &pfile->base_context)
_cpp_pop_context (pfile);
- /* Sweep up all tokens remaining on the line. We need to read
- tokens from lookahead, but cannot just drop the lookahead buffers
- because they may be saving tokens prior to this directive for an
- external client. So we use _cpp_get_token, with macros disabled. */
- pfile->state.prevent_expansion++;
- while (!pfile->state.skip_newlines)
- _cpp_get_token (pfile, &token);
- pfile->state.prevent_expansion--;
+ /* Sweep up all tokens remaining on the line. */
+ while (! SEEN_EOL ())
+ _cpp_lex_token (pfile, &token);
}
/* Ensure there are no stray tokens at the end of a directive. */
check_eol (pfile)
cpp_reader *pfile;
{
- if (!pfile->state.skip_newlines)
+ if (! SEEN_EOL ())
{
cpp_token token;
}
}
+/* Called when entering a directive, _Pragma or command-line directive. */
+static void
+start_directive (pfile)
+ cpp_reader *pfile;
+{
+ /* Setup in-directive state. */
+ pfile->state.in_directive = 1;
+ pfile->state.save_comments = 0;
+
+ /* Some handlers need the position of the # for diagnostics. */
+ pfile->directive_pos = pfile->lexer_pos;
+ pfile->directive_line = pfile->line;
+
+ /* Don't save directive tokens for external clients. */
+ pfile->la_saved = pfile->la_write;
+ pfile->la_write = 0;
+}
+
+/* Called when leaving a directive, _Pragma or command-line directive. */
+static void
+end_directive (pfile, skip_line)
+ cpp_reader *pfile;
+ int skip_line;
+{
+ /* We don't skip for an assembler #. */
+ if (skip_line)
+ {
+ skip_rest_of_line (pfile);
+ /* "Accept" the newline now. */
+ pfile->line++;
+ }
+
+ /* Restore state. */
+ pfile->la_write = pfile->la_saved;
+ pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
+ pfile->state.in_directive = 0;
+ pfile->state.angled_headers = 0;
+ pfile->state.line_extension = 0;
+ pfile->directive = 0;
+}
+
/* Check if a token's name matches that of a known directive. Put in
this file to save exporting dtable and other unneeded information. */
int
{
const directive *dir = 0;
cpp_token dname;
- int not_asm = 1;
-
- /* Some handlers need the position of the # for diagnostics. */
- pfile->directive_pos = pfile->lexer_pos;
+ int skip = 1;
- /* We're now in a directive. This ensures we get pedantic warnings
- about /v and /f in whitespace. */
- pfile->state.in_directive = 1;
- pfile->state.save_comments = 0;
+ start_directive (pfile);
/* Lex the directive name directly. */
_cpp_lex_token (pfile, &dname);
skipped conditional groups. Complain about this form if
we're being pedantic, but not if this is regurgitated input
(preprocessed or fed back in by the C++ frontend). */
- if (!pfile->skipping && !CPP_OPTION (pfile, lang_asm))
+ if (! pfile->state.skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
{
dir = &dtable[T_LINE];
+ pfile->state.line_extension = 1;
_cpp_push_token (pfile, &dname, &pfile->directive_pos);
- if (CPP_PEDANTIC (pfile) && CPP_BUFFER (pfile)->inc
- && ! CPP_OPTION (pfile, preprocessed))
+ if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
cpp_pedwarn (pfile, "# followed by integer");
}
}
/* If we are rescanning preprocessed input, only directives tagged
with IN_I are honored, and the warnings below are suppressed. */
- if (! CPP_OPTION (pfile, preprocessed) || dir->flags & IN_I)
+ if (CPP_OPTION (pfile, preprocessed))
+ {
+ /* Kluge alert. In order to be sure that code like this
+ #define HASH #
+ HASH define foo bar
+ does not cause '#define foo bar' to get executed when
+ compiled with -save-temps, we recognize directives in
+ -fpreprocessed mode only if the # is in column 1 and the
+ directive name starts in column 2. This output can only
+ be generated by the directive callbacks in cppmain.c (see
+ also the special case in scan_buffer). */
+ if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
+ (*dir->handler) (pfile);
+ /* That check misses '# 123' linemarkers. Let them through too. */
+ else if (dname.type == CPP_NUMBER)
+ (*dir->handler) (pfile);
+ else
+ {
+ /* We don't want to process this directive. Put back the
+ tokens so caller will see them (and issue an error,
+ probably). */
+ _cpp_push_token (pfile, &dname, &pfile->directive_pos);
+ skip = 0;
+ }
+ }
+ else
{
/* Traditionally, a directive is ignored unless its # is in
column 1. Therefore in code intended to work with K+R
conditional blocks. */
if (CPP_WTRADITIONAL (pfile))
{
- if (indented && dir->origin == KANDR)
+ if (dir == &dtable[T_ELIF])
+ cpp_warning (pfile,
+ "suggest not using #elif in traditional C");
+ else if (indented && dir->origin == KANDR)
cpp_warning (pfile,
"traditional C ignores #%s with the # indented",
dir->name);
/* If we are skipping a failed conditional group, all
non-conditional directives are ignored. */
- if (!pfile->skipping || (dir->flags & COND))
+ if (! pfile->state.skipping || (dir->flags & COND))
{
/* Issue -pedantic warnings for extensions. */
if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
/* If we have a directive that is not an opening
conditional, invalidate any control macro. */
if (! (dir->flags & IF_COND))
- pfile->mi_state = MI_FAILED;
+ pfile->mi_valid = false;
(*dir->handler) (pfile);
}
}
}
- else if (dname.type == CPP_EOF)
- {
- /* The null directive. */
- if (indented && CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile, "traditional C ignores #\\n with the # indented");
- }
- else
+ else if (dname.type != CPP_EOF && ! pfile->state.skipping)
{
/* An unknown directive. Don't complain about it in assembly
source: we don't know where the comments are, and # may
introduce assembler pseudo-ops. Don't complain about invalid
directives in skipped conditional groups (6.10 p4). */
- if (CPP_OPTION (pfile, lang_asm))
+ if (CPP_OPTION (pfile, lang) == CLK_ASM)
{
/* Output the # and lookahead token for the assembler. */
- not_asm = 0;
_cpp_push_token (pfile, &dname, &pfile->directive_pos);
+ skip = 0;
}
- else if (!pfile->skipping)
+ else
cpp_error (pfile, "invalid preprocessing directive #%s",
cpp_token_as_text (pfile, &dname));
}
- /* Save the lookahead token for assembler. */
- if (not_asm)
- skip_rest_of_line (pfile);
- pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
- pfile->state.in_directive = 0;
- pfile->state.angled_headers = 0;
- pfile->directive = 0;
-
- return not_asm;
+ if (pfile->state.in_directive)
+ end_directive (pfile, skip);
+ return skip;
}
/* Directive handler wrapper used by the command line option
processor. */
static void
-run_directive (pfile, dir_no, buf, count, name)
+run_directive (pfile, dir_no, type, buf, count)
cpp_reader *pfile;
int dir_no;
+ enum cpp_buffer_type type;
const char *buf;
size_t count;
- const char *name;
{
- unsigned int output_line = pfile->lexer_pos.output_line;
+ cpp_buffer *buffer;
- if (cpp_push_buffer (pfile, (const U_CHAR *) buf, count) != NULL)
- {
- const struct directive *dir = &dtable[dir_no], *orig_dir;
- unsigned char orig_in_directive;
-
- if (name)
- CPP_BUFFER (pfile)->nominal_fname = name;
- else
- CPP_BUFFER (pfile)->nominal_fname = _("<command line>");
-
- /* A kludge to avoid line markers for _Pragma. */
- if (dir_no == T_PRAGMA)
- pfile->lexer_pos.output_line = output_line;
-
- /* Save any in-process directive; _Pragma can appear in one. */
- orig_dir = pfile->directive;
- orig_in_directive = pfile->state.in_directive;
-
- /* For _Pragma, the text is passed through preprocessing stage 3
- only, i.e. no trigraphs, no escaped newline removal, and no
- macro expansion. Do the same for command-line directives. */
- pfile->buffer->from_stage3 = 1;
- pfile->state.in_directive = 1;
- pfile->directive = dir;
- pfile->state.prevent_expansion++;
- (void) (*dir->handler) (pfile);
- pfile->state.prevent_expansion--;
- pfile->directive = orig_dir;
- pfile->state.in_directive = orig_in_directive;
-
- skip_rest_of_line (pfile);
- if (pfile->buffer->cur != pfile->buffer->rlimit)
- cpp_error (pfile, "extra text after end of #%s directive",
- dtable[dir_no].name);
- cpp_pop_buffer (pfile);
- }
+ buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0, 1);
+ start_directive (pfile);
+ pfile->state.prevent_expansion++;
+ pfile->directive = &dtable[dir_no];
+ (void) (*pfile->directive->handler) (pfile);
+ pfile->state.prevent_expansion--;
+ check_eol (pfile);
+ end_directive (pfile, 1);
+ _cpp_pop_buffer (pfile);
}
/* Checks for validity the macro name in #define, #undef, #ifdef and
cpp_reader *pfile;
{
cpp_token token;
+ cpp_hashnode *node;
/* Lex the macro name directly. */
_cpp_lex_token (pfile, &token);
/* The token immediately after #define must be an identifier. That
- identifier is not allowed to be "defined". See predefined macro
- names (6.10.8.4). In C++, it is not allowed to be any of the
- <iso646.h> macro names (which are keywords in C++) either. */
+ identifier may not be "defined", per C99 6.10.8p4.
+ In C++, it may not be any of the "named operators" either,
+ per C++98 [lex.digraph], [lex.key].
+ Finally, the identifier may not have been poisoned. (In that case
+ the lexer has issued the error message for us.) */
if (token.type != CPP_NAME)
{
pfile->directive->name);
else if (token.flags & NAMED_OP)
cpp_error (pfile,
- "\"%s\" cannot be used as a macro name as it is an operator in C++",
- token.val.node->name);
+ "\"%s\" cannot be used as a macro name as it is an operator in C++",
+ NODE_NAME (token.val.node));
else
cpp_error (pfile, "macro names must be identifiers");
+
+ return 0;
}
- else
+
+ node = token.val.node;
+ if (node->flags & NODE_POISONED)
+ return 0;
+
+ if (node == pfile->spec_nodes.n_defined)
{
- cpp_hashnode *node = token.val.node;
-
- /* In Objective C, some keywords begin with '@', but general
- identifiers do not, and you're not allowed to #define them. */
- if (node == pfile->spec_nodes.n_defined || node->name[0] == '@')
- cpp_error (pfile, "\"%s\" cannot be used as a macro name", node->name);
- else if (!(node->flags & NODE_POISONED))
- return node;
+ cpp_error (pfile, "\"%s\" cannot be used as a macro name",
+ NODE_NAME (node));
+ return 0;
}
- return 0;
+ return node;
}
/* Process a #define directive. Most work is done in cppmacro.c. */
if (node)
{
- /* Use the permanent pool for storage. */
- pfile->string_pool = &pfile->ident_pool;
-
if (_cpp_create_definition (pfile, node))
if (pfile->cb.define)
- (*pfile->cb.define) (pfile, node);
-
- /* Revert to the temporary pool. */
- pfile->string_pool = &pfile->temp_string_pool;
+ (*pfile->cb.define) (pfile, pfile->directive_line, node);
}
}
if (node && node->type == NT_MACRO)
{
if (pfile->cb.undef)
- (*pfile->cb.undef) (pfile, node);
+ (*pfile->cb.undef) (pfile, pfile->directive_line, node);
- if (node->flags & NODE_BUILTIN)
- cpp_warning (pfile, "undefining \"%s\"", node->name);
+ if (node->flags & NODE_WARN)
+ cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
_cpp_free_definition (node);
}
buffer = (unsigned char *) xmalloc (capacity);
for (;;)
{
- _cpp_get_token (pfile, &token);
+ cpp_get_token (pfile, &token);
if (token.type == CPP_GREATER || token.type == CPP_EOF)
break;
if (total_len + len > capacity)
{
capacity = (capacity + len) * 2;
- buffer = (unsigned char *) realloc (buffer, capacity);
+ buffer = (unsigned char *) xrealloc (buffer, capacity);
}
if (token.flags & PREV_WHITE)
cpp_error (pfile, "missing terminating > character");
else
{
- token_mem = _cpp_pool_alloc (pfile->string_pool, total_len);
+ token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
memcpy (token_mem, buffer, total_len);
+ token_mem[total_len] = '\0';
header->type = CPP_HEADER_NAME;
header->flags &= ~PREV_WHITE;
cpp_reader *pfile;
cpp_token *header;
{
- int is_pragma = pfile->directive == &dtable[T_PRAGMA];
const unsigned char *dir;
- if (is_pragma)
+ if (pfile->directive == &dtable[T_PRAGMA])
dir = U"pragma dependency";
else
dir = pfile->directive->name;
return 1;
}
- if (!is_pragma)
- {
- check_eol (pfile);
- /* Get out of macro context, if we are. */
- skip_rest_of_line (pfile);
- if (pfile->cb.include)
- (*pfile->cb.include) (pfile, dir, header);
- }
-
return 0;
}
+/* Handle #include, #include_next and #import. */
static void
-do_include (pfile)
- cpp_reader *pfile;
-{
- cpp_token header;
-
- if (!parse_include (pfile, &header))
- _cpp_execute_include (pfile, &header, 0, 0);
-}
-
-static void
-do_import (pfile)
+do_include_common (pfile, type)
cpp_reader *pfile;
+ enum include_type type;
{
cpp_token header;
- if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
+ /* For #include_next, if this is the primary source file, warn and
+ use the normal search logic. */
+ if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
+ {
+ cpp_warning (pfile, "#include_next in primary source file");
+ type = IT_INCLUDE;
+ }
+ else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
{
- pfile->import_warning = 1;
+ CPP_OPTION (pfile, warn_import) = 0;
cpp_warning (pfile,
"#import is obsolete, use an #ifndef wrapper in the header file");
}
if (!parse_include (pfile, &header))
- _cpp_execute_include (pfile, &header, 1, 0);
+ {
+ /* Prevent #include recursion. */
+ if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
+ cpp_fatal (pfile, "#include nested too deeply");
+ else
+ {
+ check_eol (pfile);
+ /* Get out of macro context, if we are. */
+ end_directive (pfile, 1);
+ if (pfile->cb.include)
+ (*pfile->cb.include) (pfile, pfile->directive_line,
+ pfile->directive->name, &header);
+
+ _cpp_execute_include (pfile, &header, type);
+ }
+ }
}
static void
-do_include_next (pfile)
+do_include (pfile)
cpp_reader *pfile;
{
- cpp_token header;
- struct file_name_list *search_start = 0;
-
- if (parse_include (pfile, &header))
- return;
+ do_include_common (pfile, IT_INCLUDE);
+}
- /* For #include_next, skip in the search path past the dir in which
- the current file was found. If this is the last directory in the
- search path, don't include anything. If the current file was
- specified with an absolute path, use the normal search logic. If
- this is the primary source file, use the normal search logic and
- generate a warning. */
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
- {
- if (CPP_BUFFER (pfile)->inc->foundhere)
- {
- search_start = CPP_BUFFER (pfile)->inc->foundhere->next;
- if (!search_start)
- return;
- }
- }
- else
- cpp_warning (pfile, "#include_next in primary source file");
+static void
+do_import (pfile)
+ cpp_reader *pfile;
+{
+ do_include_common (pfile, IT_IMPORT);
+}
- _cpp_execute_include (pfile, &header, 0, search_start);
+static void
+do_include_next (pfile)
+ cpp_reader *pfile;
+{
+ do_include_common (pfile, IT_INCLUDE_NEXT);
}
-/* Subroutine of do_line. Read next token from PFILE without adding it to
- the output buffer. If it is a number between 1 and 4, store it in *NUM
- and return 1; otherwise, return 0 and complain if we aren't at the end
- of the directive. */
+/* Subroutine of do_line. Read possible flags after file name. LAST
+ is the last flag seen; 0 if this is the first flag. Return the flag
+ if it is valid, 0 at the end of the directive. Otherwise complain. */
-static int
-read_line_number (pfile, num)
+static unsigned int
+read_flag (pfile, last)
cpp_reader *pfile;
- int *num;
+ unsigned int last;
{
cpp_token token;
- unsigned int val;
_cpp_lex_token (pfile, &token);
if (token.type == CPP_NUMBER && token.val.str.len == 1)
{
- val = token.val.str.text[0] - '1';
- if (val <= 3)
- {
- *num = val + 1;
- return 1;
- }
+ unsigned int flag = token.val.str.text[0] - '0';
+
+ if (flag > last && flag <= 4
+ && (flag != 4 || last == 3)
+ && (flag != 2 || last == 0))
+ return flag;
}
if (token.type != CPP_EOF)
- cpp_error (pfile, "invalid format #line");
+ cpp_error (pfile, "invalid flag \"%s\" in line directive",
+ cpp_token_as_text (pfile, &token));
return 0;
}
do_line (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
+ cpp_buffer *buffer = pfile->buffer;
+ enum lc_reason reason = LC_RENAME;
unsigned long new_lineno;
- /* C99 raised the minimum limit on #line numbers. */
- unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
- int enter = 0, leave = 0, rename = 0;
+ unsigned int cap, sysp = pfile->map->sysp;
cpp_token token;
+ /* C99 raised the minimum limit on #line numbers. */
+ cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
+
/* #line commands expand macros. */
- _cpp_get_token (pfile, &token);
+ cpp_get_token (pfile, &token);
if (token.type != CPP_NUMBER
|| strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
{
return;
}
- if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
+ if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
+ && (new_lineno == 0 || new_lineno > cap))
cpp_pedwarn (pfile, "line number out of range");
- _cpp_get_token (pfile, &token);
-
- if (token.type != CPP_EOF)
+ cpp_get_token (pfile, &token);
+ if (token.type == CPP_STRING)
{
- char *fname;
- unsigned int len;
- int action_number = 0;
+ buffer->nominal_fname = (const char *) token.val.str.text;
- if (token.type != CPP_STRING)
+ /* Only accept flags for the # 55 form. */
+ if (pfile->state.line_extension)
{
- cpp_error (pfile, "\"%s\" is not a valid filename",
- cpp_token_as_text (pfile, &token));
- return;
- }
+ int flag;
- len = token.val.str.len;
- fname = alloca (len + 1);
- memcpy (fname, token.val.str.text, len);
- fname[len] = '\0';
-
- if (strcmp (fname, ip->nominal_fname))
- {
- rename = 1;
- if (!strcmp (fname, ip->inc->name))
- ip->nominal_fname = ip->inc->name;
- else
- ip->nominal_fname = _cpp_fake_include (pfile, fname);
- }
-
- if (read_line_number (pfile, &action_number) != 0)
- {
- if (! CPP_OPTION (pfile, preprocessed) && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "extra tokens at end of #line directive");
-
- if (action_number == 1)
- {
- enter = 1;
- cpp_make_system_header (pfile, ip, 0);
- read_line_number (pfile, &action_number);
- }
- else if (action_number == 2)
+ sysp = 0;
+ flag = read_flag (pfile, 0);
+ if (flag == 1)
{
- leave = 1;
- cpp_make_system_header (pfile, ip, 0);
- read_line_number (pfile, &action_number);
+ reason = LC_ENTER;
+ /* Fake an include for cpp_included (). */
+ _cpp_fake_include (pfile, buffer->nominal_fname);
+ flag = read_flag (pfile, flag);
}
- if (action_number == 3)
+ else if (flag == 2)
{
- cpp_make_system_header (pfile, ip, 1);
- read_line_number (pfile, &action_number);
+ reason = LC_LEAVE;
+ flag = read_flag (pfile, flag);
}
- if (action_number == 4)
+ if (flag == 3)
{
- cpp_make_system_header (pfile, ip, 2);
- read_line_number (pfile, &action_number);
+ sysp = 1;
+ flag = read_flag (pfile, flag);
+ if (flag == 4)
+ sysp = 2;
}
}
check_eol (pfile);
}
+ else if (token.type != CPP_EOF)
+ {
+ cpp_error (pfile, "\"%s\" is not a valid filename",
+ cpp_token_as_text (pfile, &token));
+ return;
+ }
+
+ end_directive (pfile, 1);
+ _cpp_do_file_change (pfile, reason, (const char *) buffer->nominal_fname,
+ new_lineno, sysp);
+}
+
+/* Arrange the file_change callback. pfile->line has changed to
+ FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
+ header, 2 for a sytem header that needs to be extern "C" protected,
+ and zero otherwise. */
+void
+_cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
+ cpp_reader *pfile;
+ enum lc_reason reason;
+ const char *to_file;
+ unsigned int file_line;
+ unsigned int sysp;
+{
+ pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
+ pfile->line, to_file, file_line);
- /* Our line number is incremented after the directive is processed. */
- ip->lineno = new_lineno - 1;
- pfile->lexer_pos.output_line = ip->lineno;
- if (enter && pfile->cb.enter_file)
- (*pfile->cb.enter_file) (pfile);
- if (leave && pfile->cb.leave_file)
- (*pfile->cb.leave_file) (pfile);
- if (rename && pfile->cb.rename_file)
- (*pfile->cb.rename_file) (pfile);
+ if (pfile->cb.file_change)
+ (*pfile->cb.file_change) (pfile, pfile->map);
}
/*
*/
static void
-do_diagnostic (pfile, code)
+do_diagnostic (pfile, code, print_dir)
cpp_reader *pfile;
enum error_type code;
+ int print_dir;
{
if (_cpp_begin_message (pfile, code, NULL, 0))
{
- fprintf (stderr, "#%s ", pfile->directive->name);
+ if (print_dir)
+ fprintf (stderr, "#%s ", pfile->directive->name);
pfile->state.prevent_expansion++;
cpp_output_line (pfile, stderr);
pfile->state.prevent_expansion--;
do_error (pfile)
cpp_reader *pfile;
{
- do_diagnostic (pfile, ERROR);
+ do_diagnostic (pfile, ERROR, 1);
}
static void
do_warning (pfile)
cpp_reader *pfile;
{
- do_diagnostic (pfile, WARNING);
+ /* We want #warning diagnostics to be emitted in system headers too. */
+ do_diagnostic (pfile, WARNING_SYSHDR, 1);
}
/* Report program identification. */
{
cpp_token str;
- _cpp_get_token (pfile, &str);
+ cpp_get_token (pfile, &str);
if (str.type != CPP_STRING)
cpp_error (pfile, "invalid #ident");
else if (pfile->cb.ident)
- (*pfile->cb.ident) (pfile, &str.val.str);
+ (*pfile->cb.ident) (pfile, pfile->directive_line, &str.val.str);
check_eol (pfile);
}
to the front end. C99 defines three pragmas and says that no macro
expansion is to be performed on them; whether or not macro
expansion happens for other pragmas is implementation defined.
- This implementation never macro-expands the text after #pragma.
-
- We currently do not support the _Pragma operator. Support for that
- has to be coordinated with the front end. Proposed implementation:
- both #pragma blah blah and _Pragma("blah blah") become
- __builtin_pragma(blah blah) and we teach the parser about that. */
+ This implementation never macro-expands the text after #pragma. */
/* Sub-handlers for the pragmas needing treatment here.
- They return 1 if the token buffer is to be popped, 0 if not. */
+ They return 1 if the token buffer is to be popped, 0 if not. */
+typedef void (*pragma_cb) PARAMS ((cpp_reader *));
struct pragma_entry
{
struct pragma_entry *next;
size_t len;
int isnspace;
union {
- void (*handler) PARAMS ((cpp_reader *));
+ pragma_cb handler;
struct pragma_entry *space;
} u;
};
cpp_reader *pfile;
const char *space;
const char *name;
- void (*handler) PARAMS ((cpp_reader *));
+ pragma_cb handler;
{
struct pragma_entry **x, *new;
size_t len;
do_pragma (pfile)
cpp_reader *pfile;
{
+ pragma_cb handler = NULL;
const struct pragma_entry *p;
cpp_token tok;
- const cpp_hashnode *node;
- const U_CHAR *name;
- size_t len;
- int drop = 0;
p = pfile->pragmas;
pfile->state.prevent_expansion++;
cpp_get_token (pfile, &tok);
if (tok.type == CPP_NAME)
{
- node = tok.val.node;
- name = node->name;
- len = node->length;
+ const cpp_hashnode *node = tok.val.node;
+ size_t len = NODE_LEN (node);
+
while (p)
{
- if (strlen (p->name) == len && !memcmp (p->name, name, len))
+ if (strlen (p->name) == len
+ && !memcmp (p->name, NODE_NAME (node), len))
{
if (p->isnspace)
{
}
else
{
- (*p->u.handler) (pfile);
- drop = 1;
+ handler = p->u.handler;
break;
}
}
}
}
- cpp_stop_lookahead (pfile, drop);
+ cpp_stop_lookahead (pfile, handler != NULL);
pfile->state.prevent_expansion--;
- if (!drop && pfile->cb.def_pragma)
- (*pfile->cb.def_pragma) (pfile);
+ if (handler)
+ (*handler) (pfile);
+ else if (pfile->cb.def_pragma)
+ (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
}
static void
do_pragma_once (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
-
cpp_warning (pfile, "#pragma once is obsolete");
- if (CPP_PREV_BUFFER (ip) == NULL)
+ if (pfile->buffer->prev == NULL)
cpp_warning (pfile, "#pragma once in main file");
else
- ip->inc->cmacro = NEVER_REREAD;
+ _cpp_never_reread (pfile->buffer->inc);
check_eol (pfile);
}
continue;
if (hp->type == NT_MACRO)
- cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
+ cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
_cpp_free_definition (hp);
hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
}
pfile->state.poisoned_ok = 0;
-
-#if 0 /* Doesn't quite work yet. */
- if (tok.type == CPP_EOF && pfile->cb.poison)
- (*pfile->cb.poison) (pfile);
-#endif
}
/* Mark the current header as a system header. This will suppress
do_pragma_system_header (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- if (CPP_PREV_BUFFER (ip) == NULL)
- cpp_warning (pfile, "#pragma system_header outside include file");
- else
- cpp_make_system_header (pfile, ip, 1);
+ cpp_buffer *buffer = pfile->buffer;
- check_eol (pfile);
+ if (buffer->prev == 0)
+ cpp_warning (pfile, "#pragma system_header ignored outside include file");
+ else
+ {
+ check_eol (pfile);
+ end_directive (pfile, 1);
+ cpp_make_system_header (pfile, 1, 0);
+ }
}
/* Check the modified date of the current include file against a specified
cpp_start_lookahead (pfile);
cpp_get_token (pfile, &msg);
cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
- if (msg.type != CPP_EOF && _cpp_begin_message (pfile, WARNING, NULL, 0))
- cpp_output_line (pfile, stderr);
+ if (msg.type != CPP_EOF)
+ do_diagnostic (pfile, WARNING, 0);
}
}
cpp_token string;
unsigned char *buffer;
unsigned int len;
+ cpp_lexer_pos orig_pos;
+ orig_pos = pfile->lexer_pos;
if (get__Pragma_string (pfile, &string))
+ cpp_error (pfile, "_Pragma takes a parenthesized string literal");
+ else
{
- cpp_error (pfile, "_Pragma takes a parenthesized string literal");
- return;
+ buffer = destringize (&string.val.str, &len);
+ run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
+ free ((PTR) buffer);
+ pfile->lexer_pos = orig_pos;
+ pfile->line = pfile->lexer_pos.line;
}
-
- buffer = destringize (&string.val.str, &len);
- run_directive (pfile, T_PRAGMA, (char *) buffer, len, _("<_Pragma>"));
- free ((PTR) buffer);
}
/* Just ignore #sccs, on systems where we define it at all. */
{
int skip = 1;
- if (! pfile->skipping)
+ if (! pfile->state.skipping)
{
const cpp_hashnode *node = lex_macro_node (pfile);
if (node)
skip = node->type != NT_MACRO;
+
+ if (node)
+ check_eol (pfile);
}
push_conditional (pfile, skip, T_IFDEF, 0);
int skip = 1;
const cpp_hashnode *node = 0;
- if (! pfile->skipping)
+ if (! pfile->state.skipping)
{
node = lex_macro_node (pfile);
if (node)
skip = node->type == NT_MACRO;
+
+ if (node)
+ check_eol (pfile);
}
push_conditional (pfile, skip, T_IFNDEF, node);
}
-/* #if cooperates with parse_defined to handle multiple-include
- optimisations. If macro expansions or identifiers appear in the
- expression, we cannot treat it as a controlling conditional, since
- their values could change in the future. */
+/* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
+ pfile->mi_ind_cmacro so we can handle multiple-include
+ optimisations. If macro expansion occurs in the expression, we
+ cannot treat it as a controlling conditional, since the expansion
+ could change in the future. That is handled by cpp_get_token. */
static void
do_if (pfile)
cpp_reader *pfile;
{
int skip = 1;
- const cpp_hashnode *cmacro = 0;
- if (!pfile->skipping)
- {
- /* Controlling macro of #if ! defined () */
- pfile->mi_ind_cmacro = 0;
- skip = _cpp_parse_expr (pfile) == 0;
- cmacro = pfile->mi_ind_cmacro;
- }
+ if (! pfile->state.skipping)
+ skip = _cpp_parse_expr (pfile) == 0;
- push_conditional (pfile, skip, T_IF, cmacro);
+ push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
}
-/* #else flips pfile->skipping and continues without changing
+/* Flip skipping state if appropriate and continue without changing
if_stack; this is so that the error message for missing #endif's
etc. will point to the original #if. */
do_else (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
cpp_error (pfile, "#else without #if");
cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
"the conditional began here");
}
+ ifs->type = T_ELSE;
+
+ /* Skip any future (erroneous) #elses or #elifs. */
+ pfile->state.skipping = ifs->skip_elses;
+ ifs->skip_elses = true;
/* Invalidate any controlling macro. */
ifs->mi_cmacro = 0;
- ifs->type = T_ELSE;
- if (! ifs->was_skipping)
- {
- /* If pfile->skipping is 2, one of the blocks in an #if
- #elif ... chain succeeded, so we skip the else block. */
- if (pfile->skipping < 2)
- pfile->skipping = ! pfile->skipping;
- }
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
}
-
- check_eol (pfile);
}
/* handle a #elif directive by not changing if_stack either. see the
do_elif (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
+ cpp_error (pfile, "#elif without #if");
+ else
{
- cpp_error (pfile, "#elif without #if");
- return;
- }
-
- if (ifs->type == T_ELSE)
- {
- cpp_error (pfile, "#elif after #else");
- cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
- "the conditional began here");
- }
-
- /* Invalidate any controlling macro. */
- ifs->mi_cmacro = 0;
+ if (ifs->type == T_ELSE)
+ {
+ cpp_error (pfile, "#elif after #else");
+ cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
+ "the conditional began here");
+ }
+ ifs->type = T_ELIF;
- ifs->type = T_ELIF;
- if (ifs->was_skipping)
- return; /* Don't evaluate a nested #if */
+ /* Only evaluate this if we aren't skipping elses. During
+ evaluation, set skipping to false to get lexer warnings. */
+ if (ifs->skip_elses)
+ pfile->state.skipping = 1;
+ else
+ {
+ pfile->state.skipping = 0;
+ pfile->state.skipping = ! _cpp_parse_expr (pfile);
+ ifs->skip_elses = ! pfile->state.skipping;
+ }
- if (pfile->skipping != 1)
- {
- pfile->skipping = 2; /* one block succeeded, so don't do any others */
- return;
+ /* Invalidate any controlling macro. */
+ ifs->mi_cmacro = 0;
}
-
- pfile->skipping = ! _cpp_parse_expr (pfile);
}
-/* #endif pops the if stack and resets pfile->skipping. */
+/* #endif pops the if stack and resets pfile->state.skipping. */
static void
do_endif (pfile)
cpp_reader *pfile;
{
- struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
cpp_error (pfile, "#endif without #if");
else
{
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
+
/* If potential control macro, we go back outside again. */
if (ifs->next == 0 && ifs->mi_cmacro)
{
- pfile->mi_state = MI_OUTSIDE;
+ pfile->mi_valid = true;
pfile->mi_cmacro = ifs->mi_cmacro;
}
- CPP_BUFFER (pfile)->if_stack = ifs->next;
- pfile->skipping = ifs->was_skipping;
- obstack_free (pfile->buffer_ob, ifs);
+ buffer->if_stack = ifs->next;
+ pfile->state.skipping = ifs->was_skipping;
+ obstack_free (&pfile->buffer_ob, ifs);
}
-
- check_eol (pfile);
}
-/* Push an if_stack entry and set pfile->skipping accordingly.
- If this is a #ifndef starting at the beginning of a file,
- CMACRO is the macro name tested by the #ifndef. */
+/* Push an if_stack entry and set pfile->state.skipping accordingly.
+ If this is a #if or #ifndef, CMACRO is a potentially controlling
+ macro - we need to check here that we are at the top of the file. */
static void
push_conditional (pfile, skip, type, cmacro)
const cpp_hashnode *cmacro;
{
struct if_stack *ifs;
+ cpp_buffer *buffer = pfile->buffer;
- ifs = xobnew (pfile->buffer_ob, struct if_stack);
+ ifs = xobnew (&pfile->buffer_ob, struct if_stack);
ifs->pos = pfile->directive_pos;
- ifs->next = CPP_BUFFER (pfile)->if_stack;
- ifs->was_skipping = pfile->skipping;
+ ifs->next = buffer->if_stack;
+ ifs->skip_elses = pfile->state.skipping || !skip;
+ ifs->was_skipping = pfile->state.skipping;
ifs->type = type;
- if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
+ /* This condition is effectively a test for top-of-file. */
+ if (pfile->mi_valid && pfile->mi_cmacro == 0)
ifs->mi_cmacro = cmacro;
else
ifs->mi_cmacro = 0;
- if (!pfile->skipping)
- pfile->skipping = skip;
-
- CPP_BUFFER (pfile)->if_stack = ifs;
-}
-
-/* Called when we reach the end of a file. Walk back up the
- conditional stack till we reach its level at entry to this file,
- issuing error messages. Then force skipping off. */
-static void
-unwind_if_stack (pfile, pbuf)
- cpp_reader *pfile;
- cpp_buffer *pbuf;
-{
- struct if_stack *ifs;
-
- /* No need to free stack - they'll all go away with the buffer. */
- for (ifs = pbuf->if_stack; ifs; ifs = ifs->next)
- cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
- "unterminated #%s", dtable[ifs->type].name);
-
- pfile->skipping = 0;
+ pfile->state.skipping = skip;
+ buffer->if_stack = ifs;
}
/* Read the tokens of the answer into the macro pool. Only commit the
token = &answer->first[answer->count];
}
- _cpp_get_token (pfile, token);
+ cpp_get_token (pfile, token);
if (token->type == CPP_CLOSE_PAREN)
break;
/* Parses an assertion, returning a pointer to the hash node of the
predicate, or 0 on error. If an answer was supplied, it is placed
- in ANSWERP, otherwise it is set to 0. We use _cpp_get_raw_token,
- since we cannot assume tokens are consecutive in a #if statement
- (we may be in a macro), and we don't want to macro expand. */
+ in ANSWERP, otherwise it is set to 0. */
static cpp_hashnode *
parse_assertion (pfile, answerp, type)
cpp_reader *pfile;
/* We don't expand predicates or answers. */
pfile->state.prevent_expansion++;
- /* Use the permanent pool for storage (for the answers). */
- pfile->string_pool = &pfile->ident_pool;
-
*answerp = 0;
- _cpp_get_token (pfile, &predicate);
+ cpp_get_token (pfile, &predicate);
if (predicate.type == CPP_EOF)
cpp_error (pfile, "assertion without predicate");
else if (predicate.type != CPP_NAME)
cpp_error (pfile, "predicate must be an identifier");
else if (parse_answer (pfile, answerp, type) == 0)
{
- unsigned int len = predicate.val.node->length;
+ unsigned int len = NODE_LEN (predicate.val.node);
unsigned char *sym = alloca (len + 1);
/* Prefix '#' to get it out of macro namespace. */
sym[0] = '#';
- memcpy (sym + 1, predicate.val.node->name, len);
+ memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
result = cpp_lookup (pfile, sym, len + 1);
}
- pfile->string_pool = &pfile->temp_string_pool;
pfile->state.prevent_expansion--;
return result;
}
{
if (*find_answer (node, new_answer))
{
- cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
+ cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
return;
}
new_answer->next = node->value.answers;
/* Process the string STR as if it appeared as the body of a #define.
If STR is just an identifier, define it with value 1.
If STR has anything after the identifier, then it should
- be identifier=definition. */
+ be identifier=definition. */
void
cpp_define (pfile, str)
buf[count++] = '1';
}
- run_directive (pfile, T_DEFINE, buf, count, 0);
+ run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
}
-/* Slight variant of the above for use by initialize_builtins, which (a)
- knows how to set up the buffer itself, (b) needs a different "filename"
- tag. */
+/* Slight variant of the above for use by initialize_builtins. */
void
_cpp_define_builtin (pfile, str)
cpp_reader *pfile;
const char *str;
{
- run_directive (pfile, T_DEFINE, str, strlen (str), _("<builtin>"));
+ run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
}
/* Process MACRO as if it appeared as the body of an #undef. */
cpp_reader *pfile;
const char *macro;
{
- run_directive (pfile, T_UNDEF, macro, strlen (macro), 0);
+ run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
}
-/* Process the string STR as if it appeared as the body of a #assert. */
+/* Process the string STR as if it appeared as the body of a #assert. */
void
cpp_assert (pfile, str)
cpp_reader *pfile;
handle_assertion (pfile, str, T_ASSERT);
}
-/* Process STR as if it appeared as the body of an #unassert. */
+/* Process STR as if it appeared as the body of an #unassert. */
void
cpp_unassert (pfile, str)
cpp_reader *pfile;
str = buf;
}
- run_directive (pfile, type, str, count, 0);
+ run_directive (pfile, type, BUF_CL_OPTION, str, count);
}
-/* Determine whether the identifier ID, of length LEN, is a defined macro. */
-int
-cpp_defined (pfile, id, len)
+/* The number of errors for a given reader. */
+unsigned int
+cpp_errors (pfile)
cpp_reader *pfile;
- const U_CHAR *id;
- int len;
{
- cpp_hashnode *hp = cpp_lookup (pfile, id, len);
+ return pfile->errors;
+}
- /* If it's of type NT_MACRO, it cannot be poisoned. */
- return hp->type == NT_MACRO;
+/* The options structure. */
+cpp_options *
+cpp_get_options (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->opts;
}
-/* Allocate a new cpp_buffer for PFILE, and push it on the input
- buffer stack. If BUFFER != NULL, then use the LENGTH characters in
- BUFFER as the new input buffer. Return the new buffer, or NULL on
- failure. */
+/* The callbacks structure. */
+cpp_callbacks *
+cpp_get_callbacks (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->cb;
+}
+
+/* The line map set. */
+const struct line_maps *
+cpp_get_line_maps (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->line_maps;
+}
+
+/* Copy the given callbacks structure to our own. */
+void
+cpp_set_callbacks (pfile, cb)
+ cpp_reader *pfile;
+ cpp_callbacks *cb;
+{
+ pfile->cb = *cb;
+}
+/* Push a new buffer on the buffer stack. Returns the new buffer; it
+ doesn't fail. It does not generate a file change call back; that
+ is the responsibility of the caller. */
cpp_buffer *
-cpp_push_buffer (pfile, buffer, length)
+cpp_push_buffer (pfile, buffer, len, type, filename, return_at_eof)
cpp_reader *pfile;
const U_CHAR *buffer;
- long length;
+ size_t len;
+ enum cpp_buffer_type type;
+ const char *filename;
+ int return_at_eof;
{
- cpp_buffer *buf = CPP_BUFFER (pfile);
- cpp_buffer *new;
- if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
- {
- cpp_fatal (pfile, "#include nested too deeply");
- return NULL;
- }
+ cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
+
+ if (type == BUF_BUILTIN)
+ filename = _("<builtin>");
+ else if (type == BUF_CL_OPTION)
+ filename = _("<command line>");
+ else if (type == BUF_PRAGMA)
+ filename = "<_Pragma>";
- new = xobnew (pfile->buffer_ob, cpp_buffer);
/* Clears, amongst other things, if_stack and mi_cmacro. */
memset (new, 0, sizeof (cpp_buffer));
- pfile->lexer_pos.output_line = 1;
new->line_base = new->buf = new->cur = buffer;
- new->rlimit = buffer + length;
- new->prev = buf;
- new->pfile = pfile;
- /* Preprocessed files don't do trigraph and escaped newline processing. */
- new->from_stage3 = CPP_OPTION (pfile, preprocessed);
+ new->rlimit = buffer + len;
+
/* No read ahead or extra char initially. */
new->read_ahead = EOF;
new->extra_char = EOF;
- pfile->state.skip_newlines = 1;
- CPP_BUFFER (pfile) = new;
+ /* Preprocessed files, builtins, _Pragma and command line
+ options don't do trigraph and escaped newline processing. */
+ new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
+
+ if (*filename == '\0')
+ new->nominal_fname = _("<stdin>");
+ else
+ new->nominal_fname = filename;
+ new->type = type;
+ new->prev = pfile->buffer;
+ new->pfile = pfile;
+ new->return_at_eof = return_at_eof;
+
+ pfile->buffer_stack_depth++;
+ pfile->buffer = new;
+
return new;
}
-cpp_buffer *
-cpp_pop_buffer (pfile)
+/* If called from do_line, pops a single buffer. Otherwise pops all
+ buffers until a real file is reached. Generates appropriate
+ call-backs. */
+void
+_cpp_pop_buffer (pfile)
cpp_reader *pfile;
{
- int wfb;
- cpp_buffer *buf = CPP_BUFFER (pfile);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs;
- unwind_if_stack (pfile, buf);
- wfb = (buf->inc != 0);
- if (wfb)
- _cpp_pop_file_buffer (pfile, buf);
+ /* Walk back up the conditional stack till we reach its level at
+ entry to this file, issuing error messages. */
+ for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
+ cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
+ "unterminated #%s", dtable[ifs->type].name);
- CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
- obstack_free (pfile->buffer_ob, buf);
+ /* Update the reader's buffer before _cpp_do_file_change. */
+ pfile->buffer = buffer->prev;
pfile->buffer_stack_depth--;
- if (CPP_BUFFER (pfile) && wfb && pfile->cb.leave_file)
- (*pfile->cb.leave_file) (pfile);
-
- return CPP_BUFFER (pfile);
+ if (buffer->type == BUF_FILE)
+ {
+ /* Callbacks are not generated for popping the main file. */
+ if (buffer->prev)
+ _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
+
+ _cpp_pop_file_buffer (pfile, buffer);
+ }
+
+ obstack_free (&pfile->buffer_ob, buffer);
+
+ /* The output line can fall out of sync if we missed the final
+ newline from the previous buffer, for example because of an
+ unterminated comment. Similarly, skipping needs to be cleared in
+ case of a missing #endif. */
+ pfile->lexer_pos.output_line = pfile->line;
+ pfile->state.skipping = 0;
}
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
void
-_cpp_init_stacks (pfile)
+_cpp_init_directives (pfile)
cpp_reader *pfile;
{
- int i;
+ unsigned int i;
cpp_hashnode *node;
- pfile->buffer_ob = xnew (struct obstack);
- obstack_init (pfile->buffer_ob);
-
/* Register the directives. */
- for (i = 1; i < N_DIRECTIVES; i++)
+ for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
{
- node = cpp_lookup (pfile, dtable[i - 1].name, dtable[i - 1].length);
- node->directive_index = i;
+ node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
+ node->directive_index = i + 1;
}
}
-
-void
-_cpp_cleanup_stacks (pfile)
- cpp_reader *pfile;
-{
- obstack_free (pfile->buffer_ob, 0);
- free (pfile->buffer_ob);
-}
OSDN Git Service
