MultipleIncludeOpt.h revision 1eb4433ac451dc16f4133a88af2d002ac26c58ef 
1//===--- MultipleIncludeOpt.h - Header Multiple-Include Optzn ---*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file defines the MultipleIncludeOpt interface.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_MULTIPLEINCLUDEOPT_H
15#define LLVM_CLANG_MULTIPLEINCLUDEOPT_H
16
17namespace clang {
18class IdentifierInfo;
19
20/// MultipleIncludeOpt - This class implements the simple state machine that the
21/// Lexer class uses to detect files subject to the 'multiple-include'
22/// optimization.  The public methods in this class are triggered by various
23/// events that occur when a file is lexed, and after the entire file is lexed,
24/// information about which macro (if any) controls the header is returned.
25class MultipleIncludeOpt {
26  /// ReadAnyTokens - This is set to false when a file is first opened and true
27  /// any time a token is returned to the client or a (non-multiple-include)
28  /// directive is parsed.  When the final #endif is parsed this is reset back
29  /// to false, that way any tokens before the first #ifdef or after the last
30  /// #endif can be easily detected.
31  bool ReadAnyTokens;
32
33  /// ReadAnyTokens - This is set to false when a file is first opened and true
34  /// any time a token is returned to the client or a (non-multiple-include)
35  /// directive is parsed.  When the final #endif is parsed this is reset back
36  /// to false, that way any tokens before the first #ifdef or after the last
37  /// #endif can be easily detected.
38  bool DidMacroExpansion;
39
40  /// TheMacro - The controlling macro for a file, if valid.
41  ///
42  const IdentifierInfo *TheMacro;
43public:
44  MultipleIncludeOpt() {
45    ReadAnyTokens = false;
46    DidMacroExpansion = false;
47    TheMacro = 0;
48  }
49
50  /// Invalidate - Permenantly mark this file as not being suitable for the
51  /// include-file optimization.
52  void Invalidate() {
53    // If we have read tokens but have no controlling macro, the state-machine
54    // below can never "accept".
55    ReadAnyTokens = true;
56    TheMacro = 0;
57  }
58
59  /// getHasReadAnyTokensVal - This is used for the #ifndef hande-shake at the
60  /// top of the file when reading preprocessor directives.  Otherwise, reading
61  /// the "ifndef x" would count as reading tokens.
62  bool getHasReadAnyTokensVal() const { return ReadAnyTokens; }
63
64  // If a token is read, remember that we have seen a side-effect in this file.
65  void ReadToken() { ReadAnyTokens = true; }
66
67  /// ExpandedMacro - When a macro is expanded with this lexer as the current
68  /// buffer, this method is called to disable the MIOpt if needed.
69  void ExpandedMacro() { DidMacroExpansion = true; }
70
71  /// EnterTopLevelIFNDEF - When entering a top-level #ifndef directive (or the
72  /// "#if !defined" equivalent) without any preceding tokens, this method is
73  /// called.
74  ///
75  /// Note, we don't care about the input value of 'ReadAnyTokens'.  The caller
76  /// ensures that this is only called if there are no tokens read before the
77  /// #ifndef.  The caller is required to do this, because reading the #if line
78  /// obviously reads in in tokens.
79  void EnterTopLevelIFNDEF(const IdentifierInfo *M) {
80    // If the macro is already set, this is after the top-level #endif.
81    if (TheMacro)
82      return Invalidate();
83
84    // If we have already expanded a macro by the end of the #ifndef line, then
85    // there is a macro expansion *in* the #ifndef line.  This means that the
86    // condition could evaluate differently when subsequently #included.  Reject
87    // this.
88    if (DidMacroExpansion)
89      return Invalidate();
90
91    // Remember that we're in the #if and that we have the macro.
92    ReadAnyTokens = true;
93    TheMacro = M;
94  }
95
96  /// EnterTopLevelConditional - This is invoked when a top level conditional
97  /// (except #ifndef) is found.
98  void EnterTopLevelConditional() {
99    /// If a conditional directive (except #ifndef) is found at the top level,
100    /// there is a chunk of the file not guarded by the controlling macro.
101    Invalidate();
102  }
103
104  /// ExitTopLevelConditional - This method is called when the lexer exits the
105  /// top-level conditional.
106  void ExitTopLevelConditional() {
107    // If we have a macro, that means the top of the file was ok.  Set our state
108    // back to "not having read any tokens" so we can detect anything after the
109    // #endif.
110    if (!TheMacro) return Invalidate();
111
112    // At this point, we haven't "read any tokens" but we do have a controlling
113    // macro.
114    ReadAnyTokens = false;
115  }
116
117  /// GetControllingMacroAtEndOfFile - Once the entire file has been lexed, if
118  /// there is a controlling macro, return it.
119  const IdentifierInfo *GetControllingMacroAtEndOfFile() const {
120    // If we haven't read any tokens after the #endif, return the controlling
121    // macro if it's valid (if it isn't, it will be null).
122    if (!ReadAnyTokens)
123      return TheMacro;
124    return 0;
125  }
126};
127
128}  // end namespace clang
129
130#endif
131