blob: 92e5ce5dc4d7d4d74884cd023c3e2f75d25a6552 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
/*
* Copyright (c) 2021, Itamar S. <itamar8910@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/FlyString.h>
#include <AK/Function.h>
#include <AK/HashMap.h>
#include <AK/Optional.h>
#include <AK/String.h>
#include <AK/StringView.h>
#include <AK/Vector.h>
#include <LibCpp/Token.h>
namespace Cpp {
class Preprocessor {
public:
explicit Preprocessor(const String& filename, StringView program);
Vector<Token> process_and_lex();
Vector<StringView> included_paths() const { return m_included_paths; }
struct Definition {
String key;
Vector<String> parameters;
String value;
FlyString filename;
size_t line { 0 };
size_t column { 0 };
};
using Definitions = HashMap<String, Definition>;
struct Substitution {
Vector<Token> original_tokens;
Definition defined_value;
String processed_value;
};
Definitions const& definitions() const { return m_definitions; }
Vector<Substitution> const& substitutions() const { return m_substitutions; }
void set_ignore_unsupported_keywords(bool ignore) { m_options.ignore_unsupported_keywords = ignore; }
void set_ignore_invalid_statements(bool ignore) { m_options.ignore_invalid_statements = ignore; }
void set_keep_include_statements(bool keep) { m_options.keep_include_statements = keep; }
Function<Definitions(StringView)> definitions_in_header_callback { nullptr };
Vector<Token> const& unprocessed_tokens() const { return m_unprocessed_tokens; }
private:
void handle_preprocessor_statement(StringView);
void handle_include_statement(StringView);
void handle_preprocessor_keyword(StringView keyword, GenericLexer& line_lexer);
String remove_escaped_newlines(StringView value);
size_t do_substitution(Vector<Token> const& tokens, size_t token_index, Definition const&);
Optional<Definition> create_definition(StringView line);
struct MacroCall {
Token name;
struct Argument {
Vector<Token> tokens;
};
Vector<Argument> arguments;
size_t end_token_index { 0 };
};
Optional<MacroCall> parse_macro_call(Vector<Token> const& tokens, size_t token_index);
String evaluate_macro_call(MacroCall const&, Definition const&);
String m_filename;
String m_program;
Vector<Token> m_unprocessed_tokens;
Vector<Token> m_processed_tokens;
Definitions m_definitions;
Vector<Substitution> m_substitutions;
size_t m_current_line { 0 };
size_t m_current_depth { 0 };
Vector<size_t> m_depths_of_taken_branches;
Vector<size_t> m_depths_of_not_taken_branches;
enum class State {
Normal,
SkipIfBranch,
SkipElseBranch
};
State m_state { State::Normal };
Vector<StringView> m_included_paths;
struct Options {
bool ignore_unsupported_keywords { false };
bool ignore_invalid_statements { false };
bool keep_include_statements { false };
} m_options;
};
}
|
