* c-ppoutput.c (cb_include): Don't take a cpp_token.
* cppfiles.c: Don't undef strcmp.
(find_include_file): Don't take a cpp_token. Check for empty
file names.
(_cpp_execute_include, _cpp_compare_file_date): Don't take a cpp_token.
(cpp_push_include): Simplify.
* cpphash.h (_cpp_execute_include, _cpp_compare_file_date): Update.
* cpplib.c (glue_header_name): Return the file name, not a cpp_token.
(parse_include): Similary. Don't check for zero-length filenames.
(do_include_common, do_pragma_dependency): Update accordingly.
* cpplib.h (struct cpp_callbacks): Change prototype of include.
From-SVN: r65894
+2003-04-21 Neil Booth <neil@daikokuya.co.uk>
+
+ * c-ppoutput.c (cb_include): Don't take a cpp_token.
+ * cppfiles.c: Don't undef strcmp.
+ (find_include_file): Don't take a cpp_token. Check for empty
+ file names.
+ (_cpp_execute_include, _cpp_compare_file_date): Don't take a cpp_token.
+ (cpp_push_include): Simplify.
+ * cpphash.h (_cpp_execute_include, _cpp_compare_file_date): Update.
+ * cpplib.c (glue_header_name): Return the file name, not a cpp_token.
+ (parse_include): Similary. Don't check for zero-length filenames.
+ (do_include_common, do_pragma_dependency): Update accordingly.
+ * cpplib.h (struct cpp_callbacks): Change prototype of include.
+
2003-04-21 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* expr.c (store_constructor): Set RTX_UNCHANGING_P if readonly_field_p
static void cb_define PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
static void cb_undef PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
static void cb_include PARAMS ((cpp_reader *, unsigned int,
- const unsigned char *, const cpp_token *));
+ const unsigned char *, const char *, int));
static void cb_ident PARAMS ((cpp_reader *, unsigned int,
const cpp_string *));
static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
}
static void
-cb_include (pfile, line, dir, header)
- cpp_reader *pfile;
+cb_include (pfile, line, dir, header, angle_brackets)
+ cpp_reader *pfile ATTRIBUTE_UNUSED;
unsigned int line;
const unsigned char *dir;
- const cpp_token *header;
+ const char *header;
+ int angle_brackets;
{
maybe_print_line (print.map, line);
- fprintf (print.outf, "#%s %s\n", dir,
- cpp_token_as_text (pfile, header));
+ if (angle_brackets)
+ fprintf (print.outf, "#%s <%s>\n", dir, header);
+ else
+ fprintf (print.outf, "#%s \"%s\"\n", dir, header);
print.line++;
}
# define ENOTDIR 0
#endif
-/* Suppress warning about function macros used w/o arguments in traditional
- C. It is unlikely that glibc's strcmp macro helps this file at all. */
-#undef strcmp
-
/* This structure is used for the table of all includes. */
struct include_file {
const char *name; /* actual path name of file */
static struct cpp_path *search_from PARAMS ((cpp_reader *,
enum include_type));
static struct include_file *
- find_include_file PARAMS ((cpp_reader *, const cpp_token *,
+ find_include_file PARAMS ((cpp_reader *, const char *, int,
enum include_type));
static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
static struct include_file *validate_pch PARAMS ((cpp_reader *,
return 0;
}
-/* Search for HEADER. Return 0 if there is no such file (or it's
+/* Search for FNAME. Return 0 if there is no such file (or it's
un-openable), in which case an error code will be in errno. If
there is no include path to use it returns NO_INCLUDE_PATH,
otherwise an include_file structure. If this request originates
from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
static struct include_file *
-find_include_file (pfile, header, type)
+find_include_file (pfile, fname, angle_brackets, type)
cpp_reader *pfile;
- const cpp_token *header;
+ const char *fname;
+ int angle_brackets;
enum include_type type;
{
- const char *fname = (const char *) header->val.str.text;
struct cpp_path *path;
struct include_file *file;
char *name, *n;
+ if (*fname == '\0')
+ {
+ cpp_error (pfile, DL_ERROR, "empty file name");
+ return NO_INCLUDE_PATH;
+ }
+
if (IS_ABSOLUTE_PATHNAME (fname))
return open_file_pch (pfile, fname);
path use the normal search logic. */
if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
path = pfile->buffer->inc->foundhere->next;
- else if (header->type == CPP_HEADER_NAME)
+ else if (angle_brackets)
path = pfile->bracket_include;
else
path = search_from (pfile, type);
including HEADER, and the command line -imacros and -include.
Returns true if a buffer was stacked. */
bool
-_cpp_execute_include (pfile, header, type)
+_cpp_execute_include (pfile, fname, angle_brackets, type)
cpp_reader *pfile;
- const cpp_token *header;
+ const char *fname;
+ int angle_brackets;
enum include_type type;
{
bool stacked = false;
- struct include_file *inc = find_include_file (pfile, header, type);
+ struct include_file *inc;
+ inc = find_include_file (pfile, fname, angle_brackets, type);
if (inc == 0)
- handle_missing_header (pfile, (const char *) header->val.str.text,
- header->type == CPP_HEADER_NAME);
+ handle_missing_header (pfile, fname, angle_brackets);
else if (inc != NO_INCLUDE_PATH)
{
stacked = stack_include_file (pfile, inc);
file. If it cannot be located or dated, return -1, if it is newer
newer, return 1, otherwise 0. */
int
-_cpp_compare_file_date (pfile, header)
+_cpp_compare_file_date (pfile, fname, angle_brackets)
cpp_reader *pfile;
- const cpp_token *header;
+ const char *fname;
+ int angle_brackets;
{
- struct include_file *inc = find_include_file (pfile, header, 0);
+ struct include_file *inc;
+ inc = find_include_file (pfile, fname, angle_brackets, IT_INCLUDE);
if (inc == NULL || inc == NO_INCLUDE_PATH)
return -1;
cpp_reader *pfile;
const char *filename;
{
- cpp_token header;
-
- header.type = CPP_STRING;
- header.val.str.text = (const unsigned char *) filename;
- header.val.str.len = strlen (filename);
/* Make the command line directive take up a line. */
pfile->line++;
-
- return _cpp_execute_include (pfile, &header, IT_CMDLINE);
+ return _cpp_execute_include (pfile, filename, false, IT_CMDLINE);
}
/* Do appropriate cleanup when a file INC's buffer is popped off the
extern void _cpp_fake_include PARAMS ((cpp_reader *, const char *));
extern void _cpp_never_reread PARAMS ((struct include_file *));
extern bool _cpp_read_file PARAMS ((cpp_reader *, const char *));
-extern bool _cpp_execute_include PARAMS ((cpp_reader *,
- const cpp_token *,
- enum include_type));
-extern int _cpp_compare_file_date PARAMS ((cpp_reader *,
- const cpp_token *));
+extern bool _cpp_execute_include PARAMS ((cpp_reader *, const char *,
+ int, enum include_type));
+extern int _cpp_compare_file_date PARAMS ((cpp_reader *, const char *,
+ int));
extern void _cpp_report_missing_guards PARAMS ((cpp_reader *));
extern void _cpp_init_includes PARAMS ((cpp_reader *));
extern void _cpp_cleanup_includes PARAMS ((cpp_reader *));
PARAMS ((cpp_reader *, const directive *, int));
static void run_directive PARAMS ((cpp_reader *, int,
const char *, size_t));
-static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
-static const cpp_token *parse_include PARAMS ((cpp_reader *));
+static char *glue_header_name PARAMS ((cpp_reader *));
+static const char *parse_include PARAMS ((cpp_reader *, int *));
static void push_conditional PARAMS ((cpp_reader *, int, int,
const cpp_hashnode *));
static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
/* Helper routine used by parse_include. Reinterpret the current line
as an h-char-sequence (< ... >); we are looking at the first token
- after the <. Returns the header as a token, or NULL on failure. */
-static const cpp_token *
+ after the <. Returns a malloced filename. */
+static char *
glue_header_name (pfile)
cpp_reader *pfile;
{
- cpp_token *header = NULL;
const cpp_token *token;
- unsigned char *buffer;
+ char *buffer;
size_t len, total_len = 0, capacity = 1024;
/* To avoid lexed tokens overwriting our glued name, we can only
allocate from the string pool once we've lexed everything. */
- buffer = (unsigned char *) xmalloc (capacity);
+ buffer = xmalloc (capacity);
for (;;)
{
token = get_token_no_padding (pfile);
- if (token->type == CPP_GREATER || token->type == CPP_EOF)
+ if (token->type == CPP_GREATER)
break;
+ if (token->type == CPP_EOF)
+ {
+ cpp_error (pfile, DL_ERROR, "missing terminating > character");
+ break;
+ }
len = cpp_token_len (token);
if (total_len + len > capacity)
{
capacity = (capacity + len) * 2;
- buffer = (unsigned char *) xrealloc (buffer, capacity);
+ buffer = xrealloc (buffer, capacity);
}
if (token->flags & PREV_WHITE)
buffer[total_len++] = ' ';
- total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
- }
-
- if (token->type == CPP_EOF)
- cpp_error (pfile, DL_ERROR, "missing terminating > character");
- else
- {
- unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
- memcpy (token_mem, buffer, total_len);
- token_mem[total_len] = '\0';
-
- header = _cpp_temp_token (pfile);
- header->type = CPP_HEADER_NAME;
- header->flags = 0;
- header->val.str.len = total_len;
- header->val.str.text = token_mem;
+ total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len])
+ - (uchar *) buffer);
}
- free ((PTR) buffer);
- return header;
+ buffer[total_len] = '\0';
+ return buffer;
}
-/* Returns the header string of #include, #include_next, #import and
- #pragma dependency. Returns NULL on error. */
-static const cpp_token *
-parse_include (pfile)
+/* Returns the file name of #include, #include_next, #import and
+ #pragma dependency. The string is malloced and the caller should
+ free it. Returns NULL on error. */
+static const char *
+parse_include (pfile, pangle_brackets)
cpp_reader *pfile;
+ int *pangle_brackets;
{
- const unsigned char *dir;
+ char *fname;
const cpp_token *header;
- if (pfile->directive == &dtable[T_PRAGMA])
- dir = U"pragma dependency";
- else
- dir = pfile->directive->name;
-
/* Allow macro expansion. */
header = get_token_no_padding (pfile);
- if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
+ if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME)
{
- if (header->type != CPP_LESS)
- {
- cpp_error (pfile, DL_ERROR,
- "#%s expects \"FILENAME\" or <FILENAME>", dir);
- return NULL;
- }
-
- header = glue_header_name (pfile);
- if (header == NULL)
- return header;
+ fname = xmalloc (header->val.str.len + 1);
+ memcpy (fname, header->val.str.text, header->val.str.len);
+ fname[header->val.str.len] = '\0';
+ *pangle_brackets = header->type == CPP_HEADER_NAME;
}
-
- if (header->val.str.len == 0)
+ else if (header->type == CPP_LESS)
{
- cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
+ fname = glue_header_name (pfile);
+ *pangle_brackets = 1;
+ }
+ else
+ {
+ const unsigned char *dir;
+
+ if (pfile->directive == &dtable[T_PRAGMA])
+ dir = U"pragma dependency";
+ else
+ dir = pfile->directive->name;
+ cpp_error (pfile, DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
+ dir);
+
return NULL;
}
check_eol (pfile);
- return header;
+ return fname;
}
/* Handle #include, #include_next and #import. */
cpp_reader *pfile;
enum include_type type;
{
- const cpp_token *header = parse_include (pfile);
- if (!header)
+ const char *fname;
+ int angle_brackets;
+
+ fname = parse_include (pfile, &angle_brackets);
+ if (!fname)
return;
/* Prevent #include recursion. */
if (pfile->line_maps.depth >= CPP_STACK_MAX)
+ cpp_error (pfile, DL_ERROR, "#include nested too deeply");
+ else
{
- cpp_error (pfile, DL_ERROR, "#include nested too deeply");
- return;
- }
+ /* Get out of macro context, if we are. */
+ skip_rest_of_line (pfile);
- /* Get out of macro context, if we are. */
- skip_rest_of_line (pfile);
+ if (pfile->cb.include)
+ (*pfile->cb.include) (pfile, pfile->directive_line,
+ pfile->directive->name, fname, angle_brackets);
- if (pfile->cb.include)
- (*pfile->cb.include) (pfile, pfile->directive_line,
- pfile->directive->name, header);
+ _cpp_execute_include (pfile, fname, angle_brackets, type);
+ }
- _cpp_execute_include (pfile, header, type);
+ free ((PTR) fname);
}
static void
do_pragma_dependency (pfile)
cpp_reader *pfile;
{
- const cpp_token *header;
- int ordering;
+ const char *fname;
+ int angle_brackets, ordering;
- header = parse_include (pfile);
- if (!header)
+ fname = parse_include (pfile, &angle_brackets);
+ if (!fname)
return;
- ordering = _cpp_compare_file_date (pfile, header);
+ ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
if (ordering < 0)
- cpp_error (pfile, DL_WARNING, "cannot find source %s",
- cpp_token_as_text (pfile, header));
+ cpp_error (pfile, DL_WARNING, "cannot find source file %s", fname);
else if (ordering > 0)
{
- cpp_error (pfile, DL_WARNING, "current file is older than %s",
- cpp_token_as_text (pfile, header));
+ cpp_error (pfile, DL_WARNING, "current file is older than %s", fname);
if (cpp_get_token (pfile)->type != CPP_EOF)
{
_cpp_backup_tokens (pfile, 1);
do_diagnostic (pfile, DL_WARNING, 0);
}
}
+
+ free ((PTR) fname);
}
/* Get a token but skip padding. */
void (*line_change) PARAMS ((cpp_reader *, const cpp_token *, int));
void (*file_change) PARAMS ((cpp_reader *, const struct line_map *));
void (*include) PARAMS ((cpp_reader *, unsigned int,
- const unsigned char *, const cpp_token *));
+ const unsigned char *, const char *, int));
void (*define) PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
void (*undef) PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
void (*ident) PARAMS ((cpp_reader *, unsigned int, const cpp_string *));
projects / gcc.git / commitdiff