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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- clang/Lex/DependencyDirectivesSourceMinimizer.h - ----------*- C++ -*-//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This is the interface for minimizing header and source files to the
/// minimum necessary preprocessor directives for evaluating includes. It
/// reduces the source down to #define, #include, #import, @import, and any
/// conditional preprocessor logic that contains one of those.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
#define LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
namespace clang {
class DiagnosticsEngine;
namespace minimize_source_to_dependency_directives {
/// Represents the kind of preprocessor directive or a module declaration that
/// is tracked by the source minimizer in its token output.
enum TokenKind {
pp_none,
pp_include,
pp___include_macros,
pp_define,
pp_undef,
pp_import,
pp_pragma_import,
pp_pragma_once,
pp_pragma_push_macro,
pp_pragma_pop_macro,
pp_pragma_include_alias,
pp_include_next,
pp_if,
pp_ifdef,
pp_ifndef,
pp_elif,
pp_elifdef,
pp_elifndef,
pp_else,
pp_endif,
decl_at_import,
cxx_export_decl,
cxx_module_decl,
cxx_import_decl,
pp_eof,
};
/// Represents a simplified token that's lexed as part of the source
/// minimization. It's used to track the location of various preprocessor
/// directives that could potentially have an effect on the depedencies.
struct Token {
/// The kind of token.
TokenKind K = pp_none;
/// Offset into the output byte stream of where the directive begins.
int Offset = -1;
Token(TokenKind K, int Offset) : K(K), Offset(Offset) {}
};
/// Simplified token range to track the range of a potentially skippable PP
/// directive.
struct SkippedRange {
/// Offset into the output byte stream of where the skipped directive begins.
int Offset;
/// The number of bytes that can be skipped before the preprocessing must
/// resume.
int Length;
};
/// Computes the potential source ranges that can be skipped by the preprocessor
/// when skipping a directive like #if, #ifdef or #elsif.
///
/// \returns false on success, true on error.
bool computeSkippedRanges(ArrayRef<Token> Input,
llvm::SmallVectorImpl<SkippedRange> &Range);
} // end namespace minimize_source_to_dependency_directives
/// Minimize the input down to the preprocessor directives that might have
/// an effect on the dependencies for a compilation unit.
///
/// This function deletes all non-preprocessor code, and strips anything that
/// can't affect what gets included. It canonicalizes whitespace where
/// convenient to stabilize the output against formatting changes in the input.
///
/// Clears the output vectors at the beginning of the call.
///
/// \returns false on success, true on error. If the diagnostic engine is not
/// null, an appropriate error is reported using the given input location
/// with the offset that corresponds to the minimizer's current buffer offset.
bool minimizeSourceToDependencyDirectives(
llvm::StringRef Input, llvm::SmallVectorImpl<char> &Output,
llvm::SmallVectorImpl<minimize_source_to_dependency_directives::Token>
&Tokens,
DiagnosticsEngine *Diags = nullptr,
SourceLocation InputSourceLoc = SourceLocation());
} // end namespace clang
#endif // LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
