#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
static void setup_callbacks PARAMS ((cpp_reader *));
static void scan_translation_unit PARAMS ((cpp_reader *));
static void scan_translation_unit_trad PARAMS ((cpp_reader *));
static void account_for_newlines PARAMS ((cpp_reader *, const uchar *,
size_t));
static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
static void print_line PARAMS ((cpp_reader *, const struct line_map *,
unsigned int, const char *));
static void maybe_print_line PARAMS ((cpp_reader *, const struct line_map *,
unsigned int));
static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
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 *));
static void cb_ident PARAMS ((cpp_reader *, unsigned int,
const cpp_string *));
static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
void
cpp_preprocess_file (pfile, in_fname, out_stream)
cpp_reader *pfile;
const char *in_fname;
FILE *out_stream;
{
pfile->print.line = (unsigned int) -1;
pfile->print.printed = 0;
pfile->print.prev = 0;
pfile->print.map = 0;
pfile->print.outf = out_stream;
setup_callbacks (pfile);
if (cpp_read_main_file (pfile, in_fname, NULL))
{
cpp_options *options = &pfile->opts;
cpp_finish_options (pfile);
if (options->no_output)
{
while (pfile->buffer->prev)
cpp_scan_nooutput (pfile);
cpp_scan_nooutput (pfile);
}
else if (options->traditional)
scan_translation_unit_trad (pfile);
else
scan_translation_unit (pfile);
if (options->dump_macros == dump_only)
cpp_forall_identifiers (pfile, dump_macro, NULL);
}
if (pfile->print.printed)
putc ('\n', pfile->print.outf);
}
static void
setup_callbacks (pfile)
cpp_reader *pfile;
{
cpp_options *options = &pfile->opts;
cpp_callbacks *cb = cpp_get_callbacks (pfile);
if (! options->no_output)
{
cb->line_change = cb_line_change;
if (options->lang != CLK_ASM)
{
cb->ident = cb_ident;
cb->def_pragma = cb_def_pragma;
}
if (! options->no_line_commands)
cb->file_change = cb_file_change;
}
if (options->dump_includes)
cb->include = cb_include;
if (options->dump_macros == dump_names
|| options->dump_macros == dump_definitions)
{
cb->define = cb_define;
cb->undef = cb_undef;
}
}
static void
scan_translation_unit (pfile)
cpp_reader *pfile;
{
bool avoid_paste = false;
pfile->print.source = NULL;
for (;;)
{
const cpp_token *token = cpp_get_token (pfile);
if (token->type == CPP_PADDING)
{
avoid_paste = true;
if (pfile->print.source == NULL
|| (!(pfile->print.source->flags & PREV_WHITE)
&& token->val.source == NULL))
pfile->print.source = token->val.source;
continue;
}
if (token->type == CPP_EOF)
break;
if (avoid_paste)
{
if (pfile->print.source == NULL)
pfile->print.source = token;
if (pfile->print.source->flags & PREV_WHITE
|| (pfile->print.prev
&& cpp_avoid_paste (pfile, pfile->print.prev, token))
|| (pfile->print.prev == NULL && token->type == CPP_HASH))
putc (' ', pfile->print.outf);
}
else if (token->flags & PREV_WHITE)
putc (' ', pfile->print.outf);
avoid_paste = false;
pfile->print.source = NULL;
pfile->print.prev = token;
cpp_output_token (token, pfile->print.outf);
if (token->type == CPP_COMMENT)
account_for_newlines (pfile, token->val.str.text, token->val.str.len);
}
}
static void
account_for_newlines (pfile, str, len)
cpp_reader *pfile;
const uchar *str;
size_t len;
{
while (len--)
if (*str++ == '\n')
pfile->print.line++;
}
static void
scan_translation_unit_trad (pfile)
cpp_reader *pfile;
{
while (_cpp_read_logical_line_trad (pfile))
{
size_t len = pfile->out.cur - pfile->out.base;
maybe_print_line (pfile, pfile->print.map, pfile->out.first_line);
fwrite (pfile->out.base, 1, len, pfile->print.outf);
pfile->print.printed = 1;
if (!CPP_OPTION (pfile, discard_comments))
account_for_newlines (pfile, pfile->out.base, len);
}
}
static void
maybe_print_line (pfile, map, line)
cpp_reader *pfile;
const struct line_map *map;
unsigned int line;
{
if (pfile->print.printed)
{
putc ('\n', pfile->print.outf);
pfile->print.line++;
pfile->print.printed = 0;
}
if (line >= pfile->print.line && line < pfile->print.line + 8)
{
while (line > pfile->print.line)
{
putc ('\n', pfile->print.outf);
pfile->print.line++;
}
}
else
print_line (pfile, map, line, "");
}
static void
print_line (pfile, map, line, special_flags)
cpp_reader *pfile;
const struct line_map *map;
unsigned int line;
const char *special_flags;
{
if (pfile->print.printed)
putc ('\n', pfile->print.outf);
pfile->print.printed = 0;
pfile->print.line = line;
if (! CPP_OPTION (pfile, no_line_commands))
{
size_t to_file_len = strlen (map->to_file);
unsigned char *to_file_quoted = alloca (to_file_len * 4 + 1);
unsigned char *p;
p = cpp_quote_string (to_file_quoted,
(unsigned char *)map->to_file, to_file_len);
*p = '\0';
fprintf (pfile->print.outf, "# %u \"%s\"%s",
SOURCE_LINE (map, pfile->print.line),
to_file_quoted, special_flags);
if (map->sysp == 2)
fputs (" 3 4", pfile->print.outf);
else if (map->sysp == 1)
fputs (" 3", pfile->print.outf);
putc ('\n', pfile->print.outf);
}
}
static void
cb_line_change (pfile, token, parsing_args)
cpp_reader *pfile;
const cpp_token *token;
int parsing_args;
{
if (token->type == CPP_EOF || parsing_args)
return;
maybe_print_line (pfile, pfile->print.map, token->line);
pfile->print.prev = 0;
pfile->print.source = 0;
if (!CPP_OPTION (pfile, traditional))
{
pfile->print.printed = 1;
if (token->col > 2)
{
unsigned int spaces = token->col - 2;
while (spaces--)
putc (' ', pfile->print.outf);
}
}
}
static void
cb_ident (pfile, line, str)
cpp_reader *pfile;
unsigned int line;
const cpp_string * str;
{
maybe_print_line (pfile, pfile->print.map, line);
fprintf (pfile->print.outf, "#ident \"%s\"\n", str->text);
pfile->print.line++;
}
static void
cb_define (pfile, line, node)
cpp_reader *pfile;
unsigned int line;
cpp_hashnode *node;
{
maybe_print_line (pfile, pfile->print.map, line);
fputs ("#define ", pfile->print.outf);
if (CPP_OPTION (pfile, dump_macros) == dump_definitions)
fputs ((const char *) cpp_macro_definition (pfile, node),
pfile->print.outf);
else
fputs ((const char *) NODE_NAME (node), pfile->print.outf);
putc ('\n', pfile->print.outf);
pfile->print.line++;
}
static void
cb_undef (pfile, line, node)
cpp_reader *pfile;
unsigned int line;
cpp_hashnode *node;
{
maybe_print_line (pfile, pfile->print.map, line);
fprintf (pfile->print.outf, "#undef %s\n", NODE_NAME (node));
pfile->print.line++;
}
static void
cb_include (pfile, line, dir, header)
cpp_reader *pfile;
unsigned int line;
const unsigned char *dir;
const cpp_token *header;
{
maybe_print_line (pfile, pfile->print.map, line);
fprintf (pfile->print.outf, "#%s %s\n", dir,
cpp_token_as_text (pfile, header));
pfile->print.line++;
}
static void
cb_file_change (pfile, map)
cpp_reader *pfile;
const struct line_map *map;
{
const char *flags = "";
if (pfile->print.map == NULL)
{
if (!CPP_OPTION (pfile, preprocessed))
print_line (pfile, map, map->from_line, flags);
}
else
{
if (map->reason == LC_ENTER)
maybe_print_line (pfile, map - 1, map->from_line - 1);
if (map->reason == LC_ENTER)
flags = " 1";
else if (map->reason == LC_LEAVE)
flags = " 2";
print_line (pfile, map, map->from_line, flags);
}
pfile->print.map = map;
}
static void
cb_def_pragma (pfile, line)
cpp_reader *pfile;
unsigned int line;
{
maybe_print_line (pfile, pfile->print.map, line);
fputs ("#pragma ", pfile->print.outf);
cpp_output_line (pfile, pfile->print.outf);
pfile->print.line++;
}
static int
dump_macro (pfile, node, v)
cpp_reader *pfile;
cpp_hashnode *node;
void *v ATTRIBUTE_UNUSED;
{
if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
{
fputs ("#define ", pfile->print.outf);
fputs ((const char *) cpp_macro_definition (pfile, node),
pfile->print.outf);
putc ('\n', pfile->print.outf);
pfile->print.line++;
}
return 1;
}