CPPPreprocessor();

void set_verbose(int verbose);

int get_verbose() const;

void copy_filepos(const CPPPreprocessor &other);

CPPFile get_file() const;

int get_line_number() const;

int get_col_number() const;

CPPToken get_next_token();

CPPToken peek_next_token();

#ifdef CPP_VERBOSE_LEX

CPPToken get_next_token0();

int _token_index;

#endif

void warning(const std::string &message);

void warning(const std::string &message, const YYLTYPE &loc);

void error(const std::string &message);

void error(const std::string &message, const YYLTYPE &loc);

void show_line(const YYLTYPE &loc);

CPPCommentBlock *get_comment_before(int line, CPPFile file);

CPPCommentBlock *get_comment_on(int line, CPPFile file);

int get_warning_count() const;

int get_error_count() const;

typedef std::map<std::string, CPPManifest *> Manifests;

Manifests _manifests;

typedef pvector<CPPManifest *> ManifestStack;

std::map<std::string, ManifestStack> _manifest_stack;

pvector<CPPFile::Source> _quote_include_kind;

DSearchPath _quote_include_path;

DSearchPath _angle_include_path;

bool _noangles;

CPPComments _comments;

typedef std::set<CPPFile> ParsedFiles;

ParsedFiles _parsed_files;

typedef std::set<std::string> Includes;

Includes _quote_includes;

Includes _angle_includes;

std::set<Filename> _explicit_files;

// This is normally true, to indicate that the preprocessor should decode

// identifiers like foo::bar<snarf> into a single IDENTIFIER,

// TYPENAME_IDENTIFIER, or SCOPING token for yacc's convenience. When

// false, it leaves them alone and returns a sequence of SIMPLE_IDENTIFIER

// and SCOPE tokens instead.

bool _resolve_identifiers;

// The default _verbose level is 1, which will output normal error and

// warning messages but nothing else. Set this to 0 to make the warning

// messages go away (although the counts will still be incremented), or set

// it higher to get more debugging information.

int _verbose;

// The location of the last token.

cppyyltype _last_token_loc;

bool init_cpp(const CPPFile &file);

bool init_const_expr(const std::string &expr);

bool init_type(const std::string &type);

bool push_file(const CPPFile &file);

bool push_string(const std::string &input, bool lock_position);

std::string expand_manifests(const std::string &input_expr, bool expand_undefined,

const YYLTYPE &loc);

CPPExpression *parse_expr(const std::string &expr, CPPScope *current_scope,

CPPScope *global_scope, const YYLTYPE &loc);

CPPToken internal_get_next_token();

int check_digraph(int c);

int check_trigraph(int c);

int skip_whitespace(int c);

int skip_comment(int c);

int skip_c_comment(int c);

int skip_cpp_comment(int c);

int skip_digit_separator(int c);

int process_directive(int c);

int get_preprocessor_command(int c, std::string &command);

int get_preprocessor_args(int c, std::string &args);

void handle_define_directive(const std::string &args, const YYLTYPE &loc);

void handle_undef_directive(const std::string &args, const YYLTYPE &loc);

void handle_ifdef_directive(const std::string &args, const YYLTYPE &loc);

void handle_ifndef_directive(const std::string &args, const YYLTYPE &loc);

void handle_if_directive(const std::string &args, const YYLTYPE &loc);

void handle_include_directive(const std::string &args, const YYLTYPE &loc);

void handle_pragma_directive(const std::string &args, const YYLTYPE &loc);

void handle_error_directive(const std::string &args, const YYLTYPE &loc);

void skip_false_if_block(bool consider_elifs);

bool is_manifest_defined(const std::string &manifest_name);

bool find_include(Filename &filename, bool angle_quotes, CPPFile::Source &source);

CPPToken get_quoted_char(int c);

CPPToken get_quoted_string(int c);

CPPToken get_identifier(int c);

CPPToken get_literal(int token, YYLTYPE loc, const std::string &str,

const YYSTYPE &result = YYSTYPE());

CPPToken expand_manifest(const CPPManifest *manifest);

void extract_manifest_args(const std::string &name, int num_args,

int va_arg, vector_string &args);

void expand_defined_function(std::string &expr, size_t q, size_t &p);

void expand_has_include_function(std::string &expr, size_t q, size_t &p, YYLTYPE loc);

void expand_manifest_inline(std::string &expr, size_t q, size_t &p,

const CPPManifest *manifest);

void extract_manifest_args_inline(const std::string &name, int num_args,

int va_arg, vector_string &args,

const std::string &expr, size_t &p);

CPPToken get_number(int c);

static int check_keyword(const std::string &name);

int scan_escape_sequence(int c);

std::string scan_quoted(int c);

std::string scan_raw(int c);

bool should_ignore_manifest(const CPPManifest *manifest) const;

bool should_ignore_preprocessor() const;

int get();

int peek();

void unget(int c);

CPPTemplateParameterList *

nested_parse_template_instantiation(CPPTemplateScope *scope);

void skip_to_end_nested();

void skip_to_angle_bracket();

class InputFile {

public:

InputFile();

~InputFile();

bool open(const CPPFile &file);

bool connect_input(const std::string &input);

int get();

int peek();

const CPPManifest *_ignore_manifest;

CPPFile _file;

std::string _input;

std::istream *_in;

int _line_number;

int _col_number;

int _next_line_number;

int _next_col_number;

bool _lock_position;

int _prev_last_c;

};

// This must be a list and not a vector because we don't have a good copy

// constructor defined for InputFile.

typedef std::list<InputFile> Files;

Files _files;

enum State {

S_normal, S_eof, S_nested, S_end_nested

};

State _state;

int _paren_nesting;

bool _parsing_template_params;

bool _parsing_attribute;

bool _start_of_line;

int _unget;

int _last_c;

bool _last_cpp_comment;

bool _save_comments;

std::vector<CPPToken> _saved_tokens;

int _warning_count;

int _error_count;

bool _error_abort;