1 //===- clang/Lex/DependencyDirectivesSourceMinimizer.h - ----------*- C++ -*-// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// This is the interface for minimizing header and source files to the 11 /// minimum necessary preprocessor directives for evaluating includes. It 12 /// reduces the source down to #define, #include, #import, @import, and any 13 /// conditional preprocessor logic that contains one of those. 14 /// 15 //===----------------------------------------------------------------------===// 16 17 #ifndef LLVM_CLANG_LEX_DEPENDENCY_DIRECTIVES_SOURCE_MINIMIZER_H 18 #define LLVM_CLANG_LEX_DEPENDENCY_DIRECTIVES_SOURCE_MINIMIZER_H 19 20 #include "clang/Basic/SourceLocation.h" 21 #include "llvm/ADT/ArrayRef.h" 22 #include "llvm/ADT/SmallVector.h" 23 #include "llvm/ADT/StringRef.h" 24 25 namespace clang { 26 27 class DiagnosticsEngine; 28 29 namespace minimize_source_to_dependency_directives { 30 31 /// Represents the kind of preprocessor directive or a module declaration that 32 /// is tracked by the source minimizer in its token output. 33 enum TokenKind { 34 pp_none, 35 pp_include, 36 pp___include_macros, 37 pp_define, 38 pp_undef, 39 pp_import, 40 pp_pragma_import, 41 pp_pragma_once, 42 pp_include_next, 43 pp_if, 44 pp_ifdef, 45 pp_ifndef, 46 pp_elif, 47 pp_elifdef, 48 pp_elifndef, 49 pp_else, 50 pp_endif, 51 decl_at_import, 52 cxx_export_decl, 53 cxx_module_decl, 54 cxx_import_decl, 55 pp_eof, 56 }; 57 58 /// Represents a simplified token that's lexed as part of the source 59 /// minimization. It's used to track the location of various preprocessor 60 /// directives that could potentially have an effect on the depedencies. 61 struct Token { 62 /// The kind of token. 63 TokenKind K = pp_none; 64 65 /// Offset into the output byte stream of where the directive begins. 66 int Offset = -1; 67 TokenToken68 Token(TokenKind K, int Offset) : K(K), Offset(Offset) {} 69 }; 70 71 /// Simplified token range to track the range of a potentially skippable PP 72 /// directive. 73 struct SkippedRange { 74 /// Offset into the output byte stream of where the skipped directive begins. 75 int Offset; 76 77 /// The number of bytes that can be skipped before the preprocessing must 78 /// resume. 79 int Length; 80 }; 81 82 /// Computes the potential source ranges that can be skipped by the preprocessor 83 /// when skipping a directive like #if, #ifdef or #elsif. 84 /// 85 /// \returns false on success, true on error. 86 bool computeSkippedRanges(ArrayRef<Token> Input, 87 llvm::SmallVectorImpl<SkippedRange> &Range); 88 89 } // end namespace minimize_source_to_dependency_directives 90 91 /// Minimize the input down to the preprocessor directives that might have 92 /// an effect on the dependencies for a compilation unit. 93 /// 94 /// This function deletes all non-preprocessor code, and strips anything that 95 /// can't affect what gets included. It canonicalizes whitespace where 96 /// convenient to stabilize the output against formatting changes in the input. 97 /// 98 /// Clears the output vectors at the beginning of the call. 99 /// 100 /// \returns false on success, true on error. If the diagnostic engine is not 101 /// null, an appropriate error is reported using the given input location 102 /// with the offset that corresponds to the minimizer's current buffer offset. 103 bool minimizeSourceToDependencyDirectives( 104 llvm::StringRef Input, llvm::SmallVectorImpl<char> &Output, 105 llvm::SmallVectorImpl<minimize_source_to_dependency_directives::Token> 106 &Tokens, 107 DiagnosticsEngine *Diags = nullptr, 108 SourceLocation InputSourceLoc = SourceLocation()); 109 110 } // end namespace clang 111 112 #endif // LLVM_CLANG_LEX_DEPENDENCY_DIRECTIVES_SOURCE_MINIMIZER_H 113