| blob | d97a103833c2fa637462b19bdf2e250f0a7a3543 |
1 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//
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 /// Implements # directive processing for the Preprocessor.
11 ///
12 //===----------------------------------------------------------------------===//
48 #include <algorithm>
49 #include <cassert>
50 #include <cstring>
51 #include <new>
52 #include <optional>
53 #include <string>
54 #include <utility>
58 //===----------------------------------------------------------------------===//
59 // Utility Methods for Preprocessor Directive Handling.
60 //===----------------------------------------------------------------------===//
65 }
68 SourceLocation Loc) {
70 }
72 UndefMacroDirective *
75 }
77 VisibilityMacroDirective *
81 }
83 /// Read and discard all tokens remaining on the current line until
84 /// the tok::eod token is found.
86 Token Tmp;
87 SourceRange Res;
94 }
97 }
99 /// Enumerates possible cases of #define/#undef a reserved identifier.
103 MD_ReservedMacro //> #define of #undef reserved id, disabled by default
104 };
106 /// Enumerates possible %select values for the pp_err_elif_after_else and
107 /// pp_err_elif_without_if diagnostics.
109 PED_Elif,
110 PED_Elifdef,
111 PED_Elifndef
112 };
115 // list from:
116 // * https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html
117 // * https://docs.microsoft.com/en-us/cpp/c-runtime-library/security-features-in-the-crt?view=msvc-160
118 // * man 7 feature_test_macros
119 // The list must be sorted for correct binary search.
150 };
152 MacroName);
153 }
158 // If this is a macro with special handling (like __LINE__) then it's language
159 // defined.
162 // Builtin macros are defined in the builtin file
165 // C defines macros starting with __STDC, and C++ defines macros starting with
166 // __STDCPP
169 // C++ defines the __cplusplus macro
172 // C++ defines various feature-test macros starting with __cpp
175 // Anything else isn't language-defined
177 }
189 }
193 // Do not warn on keyword undef. It is generally harmless and widely used.
197 }
199 // Return true if we want to issue a diagnostic by default if we
200 // encounter this name in a #include with the wrong case. For now,
201 // this includes the standard C and C++ headers, Posix headers,
202 // and Boost headers. Improper case for these #includes is a
203 // potential portability issue.
205 // If the first component of the path is "boost", treat this like a standard header
206 // for the purposes of diagnostics.
210 // "condition_variable" is the longest standard header name at 18 characters.
211 // If the include file name is longer than that, it can't be a standard header.
216 // Lowercase and normalize the search string.
219 // In the ASCII range?
222 // ASCII lowercase:
225 // Normalize path separators for comparison purposes.
228 }
230 // The standard C/C++ and Posix headers
232 // C library headers
241 // C++ headers for C library facilities
249 // C++ library headers
262 // POSIX headers (which aren't also C headers)
276 }
278 /// Find a similar string in `Candidates`.
279 ///
280 /// \param LHS a string for a similar string in `Candidates`
281 ///
282 /// \param Candidates the candidates to find a similar string.
283 ///
284 /// \returns a similar string if exists. If no similar string exists,
285 /// returns std::nullopt.
288 // We need to check if `Candidates` has the exact case-insensitive string
289 // because the Levenshtein distance match does not care about it.
293 }
294 }
296 // Keep going with the Levenshtein distance match.
297 // If the LHS size is less than 3, use the LHS size minus 1 and if not,
298 // use the LHS size divided by 3.
307 // The first similar string found.
310 // More similar string found.
312 }
313 }
314 }
320 }
321 }
325 // Missing macro name?
334 // C++ 2.5p2: Alternative tokens behave the same as its primary token
335 // except for their spellings.
340 // Allow #defining |and| and friends for Microsoft compatibility or
341 // recovery when legacy C headers are included in C++.
342 }
345 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
347 }
349 // If defining/undefining reserved identifier or a keyword, we need to issue
350 // a warning.
359 }
363 // We do not want to warn on some patterns widely used in configuration
364 // scripts. This requires analyzing next tokens, so do not issue warnings
365 // now, only inform caller.
368 }
371 }
373 // Okay, we got a good identifier.
375 }
377 /// Lex and validate a macro name, which occurs after a
378 /// \#define or \#undef.
379 ///
380 /// This sets the token kind to eod and discards the rest of the macro line if
381 /// the macro name is invalid.
382 ///
383 /// \param MacroNameTok Token that is expected to be a macro name.
384 /// \param isDefineUndef Context in which macro is used.
385 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
388 // Read the token, don't allow macro expansion on it.
396 }
401 // Invalid macro name, read and discard the rest of the line and set the
402 // token kind to tok::eod if necessary.
406 }
407 }
409 /// Ensure that the next token is a tok::eod token.
410 ///
411 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
412 /// true, then we consider macros that expand to zero tokens as being ok.
413 ///
414 /// Returns the location of the end of the directive.
417 Token Tmp;
418 // Lex unexpanded tokens for most directives: macros might expand to zero
419 // tokens, causing us to miss diagnosing invalid lines. Some directives (like
420 // #line) allow empty macros.
423 else
426 // There should be no tokens after the directive, but we allow them as an
427 // extension.
434 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
435 // or if this is a macro-style preprocessing directive, because it is more
436 // trouble than it is worth to insert /**/ and check that there is no /**/
437 // in the range also.
438 FixItHint Hint;
444 }
448 // If this is a `.S` file, treat unknown # directives as non-preprocessor
449 // directives.
454 };
459 // Directive cannot be coming from macro.
468 }
469 }
471 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and
472 /// decided that the subsequent tokens are in the \#if'd out portion of the
473 /// file. Lex the rest of the file, until we see an \#endif. If
474 /// FoundNonSkipPortion is true, then we have already emitted code for part of
475 /// this \#if directive, so \#else/\#elif blocks should never be entered.
476 /// If ElseOk is true, then \#else directives are ok, if not, then we have
477 /// already seen one so a \#else directive is a duplicate. When this returns,
478 /// the caller can lex the first valid token.
480 SourceLocation IfTokenLoc,
483 SourceLocation ElseLoc) {
484 // In SkippingRangeStateTy we are depending on SkipExcludedConditionalBlock()
485 // not getting called recursively by storing the RecordedSkippedRanges
486 // DenseMap lookup pointer (field SkipRangePtr). SkippingRangeStateTy expects
487 // that RecordedSkippedRanges won't get modified and SkipRangePtr won't be
488 // invalidated. If this changes and there is a need to call
489 // SkipExcludedConditionalBlock() recursively, SkippingRangeStateTy should
490 // change to do a second lookup in endLexPass function instead of reusing the
491 // lookup pointer.
503 else
507 // Enter raw mode to disable identifier lookup (and thus macro expansion),
508 // disabling warnings, etc.
510 Token Tok;
511 SourceLocation endLoc;
513 /// Keeps track and caches skipped ranges and also retrieves a prior skipped
514 /// range if the same block is re-visited.
527 // Initiate a skipping block and adjust the lexer if we already skipped it
528 // before.
534 }
535 }
539 // Not doing normal lexing.
542 }
544 // Finished skipping a block, record the range if it's first time visited.
547 }
551 }
567 }
569 // If this is the end of the buffer, we have an error.
571 // We don't emit errors for unterminated conditionals here,
572 // Lexer::LexEndOfFile can do that properly.
573 // Just return and let the caller lex after this #include.
576 FoundNonSkipPortion,
579 }
581 // If this token is not a preprocessor directive, just skip it.
586 }
587 }
591 // We just parsed a # character at the start of a line, so we're in
592 // directive mode. Tell the lexer this so any newlines we see will be
593 // converted into an EOD token (this terminates the macro).
601 // Read the next token, the directive flavor.
604 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
605 // something bogus), skip it.
608 // Restore comment saving mode.
611 }
613 // If the first letter isn't i or e, it isn't intesting to us. We know that
614 // this is safe in the face of spelling differences, because there is no way
615 // to spell an i/e in a strange way that is another letter. Skipping this
616 // allows us to avoid looking up the identifier info for #define/#undef and
617 // other common directives.
624 // Restore comment saving mode.
627 }
629 // Get the identifier name without trigraphs or embedded newlines. Note
630 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
631 // when skipping.
633 StringRef Directive;
641 // Restore comment saving mode.
644 }
647 }
654 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
655 // bother parsing the condition.
662 }
666 PPConditionalInfo CondInfo;
672 // If we popped the outermost skipping block, we're done skipping!
675 // Restore the value of LexingRawMode so that trailing comments
676 // are handled correctly, if we've reached the outermost block.
685 }
687 // #else directive in a skipping conditional. If not in some other
688 // skipping conditional, and if #else hasn't already been seen, enter it
689 // as a non-skipping conditional.
695 // If this is a #else with a #else before it, report the error.
699 // Note that we've seen a #else in this conditional.
702 // If the conditional is at the top level, and the #if block wasn't
703 // entered, enter the #else block now.
706 // Restore the value of LexingRawMode so that trailing comments
707 // are handled correctly.
716 }
723 // If this is a #elif with a #else before it, report the error.
727 // If this is in a skipping block or if we're already handled this #if
728 // block, don't bother parsing the condition.
730 // FIXME: We should probably do at least some minimal parsing of the
731 // condition to verify that it is well-formed. The current state
732 // allows #elif* directives with completely malformed (or missing)
733 // conditions.
736 // Restore the value of LexingRawMode so that identifiers are
737 // looked up, etc, inside the #elif expression.
742 // Stop if Lexer became invalid after hitting code completion token.
752 }
753 // If this condition is true, enter it!
757 }
758 }
768 // Warn if using `#elifdef` & `#elifndef` in not C23 & C++23 mode even
769 // if this branch is in a skipping block.
774 else
779 // If this is a #elif with a #else before it, report the error.
784 // If this is in a skipping block or if we're already handled this #if
785 // block, don't bother parsing the condition.
787 // FIXME: We should probably do at least some minimal parsing of the
788 // condition to verify that it is well-formed. The current state
789 // allows #elif* directives with completely malformed (or missing)
790 // conditions.
793 // Restore the value of LexingRawMode so that identifiers are
794 // looked up, etc, inside the #elif[n]def expression.
797 Token MacroNameTok;
801 // If the macro name token is tok::eod, there was an error that was
802 // already reported.
804 // Skip code until we get to #endif. This helps with recovery by
805 // not emitting an error when the #endif is reached.
807 }
820 MD);
823 MD);
824 }
825 }
826 // If this condition is true, enter it!
830 }
831 }
834 }
837 }
840 // Restore comment saving mode.
842 }
844 // Finally, if we are out of the conditional (saw an #endif or ran off the end
845 // of the file, just stop skipping and return to lexing whatever came after
846 // the #if block.
849 // The last skipped range isn't actually skipped yet if it's truncated
850 // by the end of the preamble; we'll resume parsing after the preamble.
854 ? endLoc
857 }
862 // Try to determine the module of the include directive.
863 // FIXME: Look into directly passing the FileEntry from LookupFile instead.
866 // The include comes from an included file.
870 }
871 }
873 // This is either in the main file or not in a file at all. It belongs
874 // to the current module, if there is one.
878 }
880 OptionalFileEntryRef
882 SourceLocation Loc) {
886 // Walk up through the include stack, looking through textual headers of M
887 // until we hit a non-textual header that we can #include. (We assume textual
888 // headers of a module with non-textual headers aren't meant to be used to
889 // import entities from the module.)
897 // We want to find all possible modules that might contain this header, so
898 // search all enclosing directories for module maps and load them.
905 // It's in a private header; we can't #include it.
906 // FIXME: If there's a public header in some module that re-exports it,
907 // then we could suggest including that, but it's not clear that's the
908 // expected way to make this entity visible.
911 }
913 // Don't suggest explicitly excluded headers.
917 // We'll suggest including textual headers below if they're
918 // include-guarded.
922 // If we have a module import syntax, we shouldn't include a header to
923 // make a particular module visible. Let the caller know they should
924 // suggest an import instead.
928 // If this is an accessible, non-textual header of M's top-level module
929 // that transitively includes the given location and makes the
930 // corresponding module visible, this is the thing to #include.
932 }
934 // FIXME: If we're bailing out due to a private header, we shouldn't suggest
935 // an import either.
939 // If the header is includable and has an include guard, assume the
940 // intended way to expose its contents is by #include, not by importing a
941 // module that transitively includes it.
946 }
949 }
965 // If the header lookup mechanism may be relative to the current inclusion
966 // stack, record the parent #includes.
973 // If there is no file entry associated with this file, it must be the
974 // predefines buffer or the module includes buffer. Any other file is not
975 // lexed with a normal lexer, so it won't be scanned for preprocessor
976 // directives.
977 //
978 // If we have the predefines buffer, resolve #include references (which come
979 // from the -include command line argument) from the current working
980 // directory instead of relative to the main file.
981 //
982 // If we have the module includes buffer, resolve #include references (which
983 // come from header declarations in the module map) relative to the module
984 // map file.
998 }
1001 }
1003 // MSVC searches the current include stack from top to bottom for
1004 // headers included by quoted include directives.
1005 // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
1011 }
1012 }
1013 }
1018 // We're supposed to start looking from after a particular file. Search
1019 // the include path until we find that file or run out of files.
1027 // Keep looking as if this file did a #include_next.
1031 // Found it.
1035 }
1036 }
1037 }
1039 // Do a standard file entry lookup.
1050 }
1052 OptionalFileEntryRef CurFileEnt;
1053 // Otherwise, see if this is a subframework header. If so, this is relative
1054 // to one of the headers on the #include stack. Walk the list of the current
1055 // headers on the #include stack and pass them to HeaderInfo.
1060 SuggestedModule)) {
1066 }
1067 }
1068 }
1081 }
1082 }
1083 }
1084 }
1086 // Otherwise, we really couldn't find the file.
1088 }
1090 //===----------------------------------------------------------------------===//
1091 // Preprocessor Directive Handling.
1092 //===----------------------------------------------------------------------===//
1100 }
1104 }
1109 };
1111 /// Process a directive while looking for the through header or a #pragma
1112 /// hdrstop. The following directives are handled:
1113 /// #include (to check if it is the through header)
1114 /// #define (to warn about macros that don't match the PCH)
1115 /// #pragma (to check for pragma hdrstop).
1116 /// All other directives are completely discarded.
1118 SourceLocation HashLoc) {
1123 }
1127 }
1133 }
1134 }
1136 }
1138 /// HandleDirective - This callback is invoked when the lexer sees a # token
1139 /// at the start of a line. This consumes the directive, modifies the
1140 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
1141 /// read is the correct one.
1143 // FIXME: Traditional: # with whitespace before it not recognized by K&R?
1145 // We just parsed a # character at the start of a line, so we're in directive
1146 // mode. Tell the lexer this so any newlines we see will be converted into an
1147 // EOD token (which terminates the directive).
1157 // We are about to read a token. For the multiple-include optimization FA to
1158 // work, we have to remember if we had read any tokens *before* this
1159 // pp-directive.
1162 // Save the '#' token in case we need to return it later.
1165 // Read the next token, the directive flavor. This isn't expanded due to
1166 // C99 6.10.3p8.
1169 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
1170 // #define A(x) #x
1171 // A(abc
1172 // #warning blah
1173 // def)
1174 // If so, the user is relying on undefined behavior, emit a diagnostic. Do
1175 // not support this for #include-like directives, since that can result in
1176 // terrible diagnostics, and does not work in GCC.
1192 }
1193 }
1195 }
1197 // Temporarily enable macro expansion if set so
1198 // and reset to previous state when returning from this function.
1206 // Ignore the null directive with regards to the multiple-include
1207 // optimization, i.e. allow the null directive to appear outside of the
1208 // include guard and still enable the multiple-include optimization.
1218 // In a .S file "# 4" may be a comment so don't treat it as a preprocessor
1219 // directive. However do permit it in the predefines file, as we use line
1220 // markers to mark the builtin macros as being in a system header.
1229 // Ask what the preprocessor keyword ID is.
1232 // C99 6.10.1 - Conditional Inclusion.
1240 ReadAnyTokensBeforeDirective);
1251 // C99 6.10.2 - Source File Inclusion.
1253 // Handle #include.
1256 // Handle -imacros.
1259 // C99 6.10.3 - Macro Replacement.
1265 // C99 6.10.4 - Line Control.
1269 // C99 6.10.5 - Error Directive.
1273 // C99 6.10.6 - Pragma Directive.
1277 // GNU Extensions.
1289 else
1300 //isExtension = true; // FIXME: implement #assert
1303 //isExtension = true; // FIXME: implement #unassert
1315 }
1317 }
1319 // If this is a .S file, treat unknown # directives as non-preprocessor
1320 // directives. This is important because # may be a comment or introduce
1321 // various pseudo-ops. Just return the # token and push back the following
1322 // token to be lexed next time.
1325 // Return the # and the token after it.
1329 // If the second token is a hashhash token, then we need to translate it to
1330 // unknown so the token lexer doesn't try to perform token pasting.
1334 // Enter this token stream so that we re-lex the tokens. Make sure to
1335 // enable macro expansion, in case the token after the # is an identifier
1336 // that is expanded.
1339 }
1341 // If we reached here, the preprocessing token is not valid!
1342 // Start suggesting if a similar directive found.
1345 // Read the rest of the PP line.
1348 // Okay, we're done parsing the directive.
1349 }
1351 /// GetLineValue - Convert a numeric token into an unsigned value, emitting
1352 /// Diagnostic DiagID if it is invalid, and returning the value in Val.
1362 }
1372 // Verify that we have a simple digit-sequence, and compute the value. This
1373 // is always a simple digit string computed in decimal, so we do this manually
1374 // here.
1377 // C++1y [lex.fcon]p1:
1378 // Optional separating single quotes in a digit-sequence are ignored
1387 }
1394 }
1396 }
1403 }
1405 /// Handle a \#line directive: C99 6.10.4.
1406 ///
1407 /// The two acceptable forms are:
1408 /// \verbatim
1409 /// # line digit-sequence
1410 /// # line digit-sequence "s-char-sequence"
1411 /// \endverbatim
1413 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are
1414 // expanded.
1415 Token DigitTok;
1418 // Validate the number and convert it to an unsigned.
1426 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
1427 // number greater than 2147483647". C90 requires that the line # be <= 32767.
1437 Token StrTok;
1440 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1441 // string followed by eod.
1453 // Parse and validate the string, converting it into a unique ID.
1459 }
1464 }
1467 // Verify that there is nothing after the string, other than EOD. Because
1468 // of C99 6.10.4p5, macros that expand to empty tokens are ok.
1470 }
1472 // Take the file kind of the file containing the #line directive. #line
1473 // directives are often used for generated sources from the same codebase, so
1474 // the new file should generally be classified the same way as the current
1475 // file. This is visible in GCC's pre-processed output, which rewrites #line
1476 // to GNU line markers.
1486 }
1488 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1489 /// marker directive.
1494 Token FlagTok;
1511 // If we are leaving the current presumed file, check to make sure the
1512 // presumed include stack isn't empty!
1513 FileID CurFileID =
1519 // If there is no include loc (main file) or if the include loc is in a
1520 // different physical file, then we aren't in a "1" line marker flag region.
1527 }
1533 }
1535 // We must have 3 if there are still flags.
1540 }
1549 // We must have 4 if there is yet another flag.
1554 }
1561 // There are no more valid flags here.
1565 }
1567 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1568 /// one of the following forms:
1569 ///
1570 /// # 42
1571 /// # 42 "file" ('1' | '2')?
1572 /// # 42 "file" ('1' | '2')? '3' '4'?
1573 ///
1575 // Validate the number and convert it to an unsigned. GNU does not have a
1576 // line # limit other than it fit in 32-bits.
1582 Token StrTok;
1589 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1590 // string followed by eod.
1593 // Treat this like "#line NN", which doesn't change file characteristics.
1604 // Parse and validate the string, converting it into a unique ID.
1610 }
1615 }
1617 // If a filename was present, read any flags that are present.
1624 // Exiting to an empty string means pop to the including file, so leave
1625 // FilenameID as -1 in that case.
1628 }
1630 // Create a line note with this information.
1634 // If the preprocessor has callbacks installed, notify them of the #line
1635 // change. This is used so that the line marker comes out in -E mode for
1636 // example.
1645 }
1646 }
1648 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1649 ///
1652 // Read the rest of the line raw. We do this because we don't want macros
1653 // to be expanded and we don't require that the tokens be valid preprocessing
1654 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
1655 // collapse multiple consecutive white space between tokens, but this isn't
1656 // specified by the standard.
1660 // Find the first non-whitespace character, so that we can make the
1661 // diagnostic more succinct.
1666 else
1668 }
1670 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1671 ///
1673 // Yes, this directive is an extension.
1676 // Read the string argument.
1677 Token StrTok;
1680 // If the token kind isn't a string, it's a malformed directive.
1687 }
1693 }
1695 // Verify that there is nothing after the string, other than EOD.
1703 }
1704 }
1706 /// Handle a #public directive.
1708 Token MacroNameTok;
1711 // Error reading macro name? If so, diagnostic already issued.
1715 // Check to see if this is the last token on the #__public_macro line.
1719 // Okay, we finally have a valid identifier to undef.
1722 // If the macro is not defined, this is an error.
1726 }
1728 // Note that this macro has now been exported.
1731 }
1733 /// Handle a #private directive.
1735 Token MacroNameTok;
1738 // Error reading macro name? If so, diagnostic already issued.
1742 // Check to see if this is the last token on the #__private_macro line.
1746 // Okay, we finally have a valid identifier to undef.
1749 // If the macro is not defined, this is an error.
1753 }
1755 // Note that this macro has now been marked private.
1758 }
1760 //===----------------------------------------------------------------------===//
1761 // Preprocessor Include Directive Handling.
1762 //===----------------------------------------------------------------------===//
1764 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1765 /// checked and spelled filename, e.g. as an operand of \#include. This returns
1766 /// true if the input filename was in <>'s or false if it were in ""'s. The
1767 /// caller is expected to provide a buffer that is large enough to hold the
1768 /// spelling of the filename, but is also expected to handle the case when
1769 /// this method decides to use a different buffer.
1772 // Get the text form of the filename.
1775 // FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and
1776 // C++20 [lex.header]/2:
1777 //
1778 // If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then
1779 // in C: behavior is undefined
1780 // in C++: program is conditionally-supported with implementation-defined
1781 // semantics
1783 // Make sure the filename is <x> or "x".
1790 }
1797 }
1803 }
1805 // Diagnose #include "" as invalid.
1810 }
1812 // Skip the brackets.
1815 }
1817 /// Push a token onto the token stream containing an annotation.
1821 // FIXME: Produce this as the current token directly, rather than
1822 // allocating a new token for it.
1830 }
1832 /// Produce a diagnostic informing the user that a #include or similar
1833 /// was implicitly treated as a module import.
1837 SourceLocation PathEnd) {
1843 }
1865 }
1869 }
1871 // Given a vector of path components and a string containing the real
1872 // path to the file, build a properly-cased replacement in the vector,
1873 // and return true if the replacement should be suggested.
1875 StringRef RealPathName) {
1880 // Below is a best-effort to handle ".." in paths. It is admittedly
1881 // not 100% correct in the presence of symlinks.
1890 // If these path components differ by more than just case, then we
1891 // may be looking at symlinked paths. Bail on this diagnostic to avoid
1892 // noisy false positives.
1893 SuggestReplacement =
1898 }
1900 }
1901 }
1903 }
1913 ShadowingModule))
1924 // FIXME: Track the location at which the requirement was specified, and
1925 // use it here.
1928 }
1930 }
1934 // #include_next is like #include, except that we start searching after
1935 // the current found directory. If we can't do this, issue a
1936 // diagnostic.
1941 // If the main file is a header, then it's either for PCH/AST generation,
1942 // or libclang opened it. Either way, handle it as a normal include below
1943 // and do not complain about include_next.
1948 // Start looking up in the directory *after* the one in which the current
1949 // file would be found, if any.
1954 // The current file was not found by walking the include path. Either it
1955 // is the primary file (handled above), or it was found by absolute path,
1956 // or it was found relative to such a file.
1957 // FIXME: Track enough information so we know which case we're in.
1960 // Start looking up in the next directory.
1962 }
1965 }
1967 /// HandleIncludeDirective - The "\#include" tokens have just been read, read
1968 /// the file to be included from the lexer, then include it! This is a common
1969 /// routine with functionality shared between \#include, \#include_next and
1970 /// \#import. LookupFrom is set when this is a \#include_next directive, it
1971 /// specifies the file to start searching from.
1974 ConstSearchDirIterator LookupFrom,
1976 Token FilenameTok;
1985 }
1987 // Verify that there is nothing after the filename, other than EOD. Note
1988 // that we allow macros that expand to nothing after the filename, because
1989 // this falls into the category of "#include pp-tokens new-line" specified
1990 // in C99 6.10.2p4.
1991 SourceLocation EndLoc =
2019 }
2020 }
2037 // Give the clients a chance to silently skip this include.
2044 // If the file could not be located and it was included via angle
2045 // brackets, we can attempt a lookup as though it were a quoted path to
2046 // provide the user with a possible fixit.
2059 }
2060 }
2062 // Check for likely typos due to leading or trailing non-isAlphanumeric
2063 // characters
2066 // A heuristic to correct a typo file name by removing leading and
2067 // trailing non-isAlphanumeric characters.
2072 }
2074 };
2091 // We found the file, so set the Filename to the name after typo
2092 // correction.
2096 }
2097 }
2099 // If the file is still not found, just go with the vanilla diagnostic
2114 }
2117 }
2119 /// Handle either a #include-like directive or an import declaration that names
2120 /// a header file.
2121 ///
2122 /// \param HashLoc The location of the '#' token for an include, or
2123 /// SourceLocation() for an import declaration.
2124 /// \param IncludeTok The include / include_next / import token.
2125 /// \param FilenameTok The header-name token.
2126 /// \param EndLoc The location at which any imported macros become visible.
2127 /// \param LookupFrom For #include_next, the starting directory for the
2128 /// directory lookup.
2129 /// \param LookupFromFile For #include_next, the starting file for the directory
2130 /// lookup.
2139 CharSourceRange FilenameRange
2145 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
2146 // error.
2153 // Complain about attempts to #include files in an audit pragma.
2158 // Immediately leave the pragma.
2160 }
2162 // Complain about attempts to #include files in an assume-nonnull pragma.
2167 // Immediately leave the pragma.
2169 }
2172 // Map the filename with the brackets still attached. If the name doesn't
2173 // map to anything, fall back on the filename we've already gotten the
2174 // spelling for.
2178 }
2180 // Search include directories.
2186 // We get the raw path only if we have 'Callbacks' to which we later pass
2187 // the path.
2192 // Normalize slashes when compiling with -fms-extensions on non-Windows. This
2193 // is unnecessary on Windows since the filesystem there handles backslashes.
2201 }
2212 }
2214 // Should we enter the source file? Set to Skip if either the source file is
2215 // known to have no effect beyond its effect on module visibility -- that is,
2216 // if it's got an include guard that is already defined, set to Import if it
2217 // is a modular header we've already built and should import.
2219 // For C++20 Modules
2220 // [cpp.include]/7 If the header identified by the header-name denotes an
2221 // importable header, it is implementation-defined whether the #include
2222 // preprocessing directive is instead replaced by an import directive.
2223 // For this implementation, the translation is permitted when we are parsing
2224 // the Global Module Fragment, and not otherwise (the cases where it would be
2225 // valid to replace an include with an import are highly constrained once in
2226 // named module purview; this choice avoids considerable complexity in
2227 // determining valid cases).
2234 // If we've reached the max allowed include depth, it is usually due to an
2235 // include cycle. Don't enter already processed files again as it can lead to
2236 // reaching the max allowed include depth again.
2241 // FIXME: We do not have a good way to disambiguate C++ clang modules from
2242 // C++ standard modules (other than use/non-use of Header Units).
2248 // Maybe a usable Header Unit
2254 // This is a Header Unit that we do not include-translate
2257 }
2258 }
2259 // Maybe a usable clang header module.
2264 // Determine whether we should try to import the module for this #include, if
2265 // there is one. Don't do so if precompiled module support is disabled or we
2266 // are processing this module textually (because we're building the module).
2268 // If this include corresponds to a module but that module is
2269 // unavailable, diagnose the situation and bail out.
2270 // FIXME: Remove this; loadModule does the same check (but produces
2271 // slightly worse diagnostics).
2279 }
2281 // Compute the module access path corresponding to this module.
2282 // FIXME: Should we have a second loadModule() overload to avoid this
2283 // extra lookup step?
2290 // Warn that we're replacing the include/import with a module import.
2294 // Load the module to import its macros. We'll make the declarations
2295 // visible when the parser gets here.
2296 // FIXME: Pass SuggestedModule in here rather than converting it to a path
2297 // and making the module loader convert it back again.
2309 // We failed to find a submodule that we assumed would exist (because it
2310 // was in the directory of an umbrella header, for instance), but no
2311 // actual module containing it exists (because the umbrella header is
2312 // incomplete). Treat this as a textual inclusion.
2316 // On a configuration mismatch, enter the header textually. We still know
2317 // that it's part of the corresponding module.
2319 // We hit an error processing the import. Bail out.
2321 // With a fatal failure in the module loader, we abort parsing.
2327 }
2329 }
2330 }
2332 // The #included file will be considered to be a system header if either it is
2333 // in a system include directory, or if the #includer is a system include
2334 // header.
2340 // If this is a '#import' or an import-declaration, don't re-enter the file.
2341 //
2342 // FIXME: If we have a suggested module for a '#include', and we've already
2343 // visited this file, don't bother entering it again. We know it has no
2344 // further effect.
2346 IsImportDecl ||
2351 // Ask HeaderInfo if we should enter this #include file. If not, #including
2352 // this file will have no effect.
2356 IsFirstIncludeOfFile)) {
2357 // C++ standard modules:
2358 // If we are not in the GMF, then we textually include only
2359 // clang modules:
2360 // Even if we've already preprocessed this header once and know that we
2361 // don't need to see its contents again, we still need to import it if it's
2362 // modular because we might not have imported it from this submodule before.
2363 //
2364 // FIXME: We don't do this when compiling a PCH because the AST
2365 // serialization layer can't cope with it. This means we get local
2366 // submodule visibility semantics wrong in that case.
2369 else
2371 }
2373 // Check for circular inclusion of the main file.
2374 // We can't generate a consistent preamble with regard to the conditional
2375 // stack if the main file is included again as due to the preamble bounds
2376 // some directives (e.g. #endif of a header guard) will never be seen.
2377 // Since this will lead to confusing errors, avoid the inclusion.
2383 }
2386 // Notify the callback object that we've seen an inclusion directive.
2387 // FIXME: Use a different callback for a pp-import?
2392 FileCharacter);
2395 }
2400 // If this is a C++20 pp-import declaration, diagnose if we didn't find any
2401 // module corresponding to the named header.
2406 }
2408 // Issue a diagnostic if the name of the file on disk has a different case
2409 // than the one we're about to open.
2416 #if defined(_WIN32)
2417 // Skip UNC prefix if present. (tryGetRealPathName() always
2418 // returns a path with the prefix skipped.)
2421 #endif
2425 #if defined(_WIN32)
2426 // -Wnonportable-include-path is designed to diagnose includes using
2427 // case even on systems with a case-insensitive file system.
2428 // On Windows, RealPathName always starts with an upper-case drive
2429 // letter for absolute paths, but Name might start with either
2430 // case depending on if `cd c:\foo` or `cd C:\foo` was used in the shell.
2431 // ("foo" will always have on-disk case, no matter which case was
2432 // used in the cd command). To not emit this warning solely for
2433 // the drive letter, whose case is dependent on if `cd` is used
2434 // with upper- or lower-case drive letters, always consider the
2435 // given drive letter case as correct for the purpose of this warning.
2446 }
2447 #endif
2456 };
2459 // On POSIX, Components will contain a single '/' as first element
2460 // exactly if Name is an absolute path.
2461 // On Windows, it will contain "C:" followed by '\' for absolute paths.
2462 // The drive letter is optional for absolute paths on Windows, but
2463 // clang currently cannot process absolute paths in #include lines that
2464 // don't have a drive.
2465 // If the first entry in Components is a directory separator,
2466 // then the code at the bottom of this loop that keeps the original
2467 // directory separator style copies it. If the second entry is
2468 // a directory separator (the C:\ case), then that separator already
2469 // got copied when the C: was processed and we want to skip that entry.
2475 // Append the separator(s) the user used, or the close quote
2479 }
2481 do
2485 }
2487 #if defined(_WIN32)
2488 // Restore UNC prefix if it was there.
2491 #endif
2493 // For user files and known standard headers, issue a diagnostic.
2494 // For other system headers, don't. They can be controlled separately.
2501 }
2502 }
2506 // If we don't need to enter the file, stop now.
2512 // If we reached our include limit and don't want to enter any more files,
2513 // don't go any further.
2517 // If this is a module import, make it visible if needed.
2527 }
2531 }
2533 // Check that we don't have infinite #include recursion.
2538 }
2544 // Look up the file, create a File ID for it.
2546 // If the filename string was the result of macro expansions, set the include
2547 // position on the file where it will be included and after the expansions.
2554 }
2556 // If all is good, enter the new file!
2558 IsFirstIncludeOfFile))
2561 // Determine if we're switching to building a new submodule, and which one.
2562 // This does not apply for C++20 modules header units.
2565 // We are building a submodule that belongs to a shadowed module. This
2566 // means we find header files in the shadowed module.
2572 }
2573 // When building a pch, -fmodule-name tells the compiler to textually
2574 // include headers in the specified module. We are not building the
2575 // specified module.
2576 //
2577 // FIXME: This is the wrong way to handle this. We should produce a PCH
2578 // that behaves the same as the header would behave in a compilation using
2579 // that PCH, which means we should enter the submodule. We need to teach
2580 // the AST serialization layer to deal with the resulting AST.
2587 // Let the macro handling code know that any future macros are within
2588 // the new submodule.
2591 // Let the parser know that any future declarations are within the new
2592 // submodule.
2593 // FIXME: There's no point doing this if we're handling a #__include_macros
2594 // directive.
2596 }
2600 }
2602 /// HandleIncludeNextDirective - Implements \#include_next.
2603 ///
2613 LookupFromFile);
2614 }
2616 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2618 // The Microsoft #import directive takes a type library and generates header
2619 // files from it, and includes those. This is beyond the scope of what clang
2620 // does, so we ignore it and error out. However, #import can optionally have
2621 // trailing attributes that span multiple lines. We're going to eat those
2622 // so we can continue processing from there.
2625 // Read tokens until we get to the end of the directive. Note that the
2626 // directive can be split over multiple lines using the backslash character.
2628 }
2630 /// HandleImportDirective - Implements \#import.
2631 ///
2638 }
2640 }
2642 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2643 /// pseudo directive in the predefines buffer. This handles it by sucking all
2644 /// tokens through the preprocessor and discarding them (only keeping the side
2645 /// effects on the preprocessor).
2648 // This directive should only occur in the predefines buffer. If not, emit an
2649 // error and reject it.
2656 }
2658 // Treat this as a normal #include for checking purposes. If this is
2659 // successful, it will push a new lexer onto the include stack.
2662 Token TmpTok;
2667 }
2669 //===----------------------------------------------------------------------===//
2670 // Preprocessor Macro Directive Handling.
2671 //===----------------------------------------------------------------------===//
2673 /// ReadMacroParameterList - The ( starting a parameter list of a macro
2674 /// definition has just been read. Lex the rest of the parameters and the
2675 /// closing ), updating MI with what we learn. Return true if an error occurs
2676 /// parsing the param list.
2684 // Found the end of the parameter list.
2687 // Otherwise we have #define FOO(A,)
2696 // OpenCL v1.2 s6.9.e: variadic macros are not supported.
2699 }
2701 // Lex the token after the identifier.
2706 }
2707 // Add the __VA_ARGS__ identifier as a parameter.
2716 // Handle keywords and identifiers here to accept things like
2717 // #define Foo(for) for.
2720 // #define X(1
2723 }
2725 // If this is already used as a parameter, it is used multiple times (e.g.
2726 // #define X(A,A.
2730 }
2732 // Add the parameter to the macro info.
2735 // Lex the token after the identifier.
2748 // Diagnose extension.
2751 // Lex the token after the identifier.
2756 }
2761 }
2762 }
2763 }
2764 }
2771 // Macro that is identity, like '#define inline inline' is a valid pattern.
2775 // Macro that maps a keyword to the same keyword decorated with leading/
2776 // trailing underscores is a valid pattern:
2777 // #define inline __inline
2778 // #define inline __inline__
2779 // #define inline _inline (in MS compatibility mode)
2789 else
2795 }
2799 }
2800 }
2802 // #define inline
2806 }
2808 // ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the
2809 // entire line) of the macro's tokens and adds them to MacroInfo, and while
2810 // doing so performs certain validity checks including (but not limited to):
2811 // - # (stringization) is followed by a macro parameter
2812 //
2813 // Returns a nullptr if an invalid sequence of tokens is encountered or returns
2814 // a pointer to a MacroInfo object.
2820 // Create the new macro.
2823 Token Tok;
2826 // Ensure we consume the rest of the macro body if errors occur.
2828 // The flag indicates if we are still waiting for 'eod'.
2831 });
2833 // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk
2834 // within their appropriate context.
2837 // If this is a function-like macro definition, parse the argument list,
2838 // marking each of the identifiers as being used as macro arguments. Also,
2839 // check other constraints on the first token of the macro body.
2842 // Save this macro information since it may part of a header guard.
2845 }
2846 // If there is no body to this macro, we have no special handling here.
2848 // This is a normal token with leading space. Clear the leading space
2849 // marker on the first token to get proper expansion.
2852 // This is a function-like macro definition. Read the argument list.
2857 // If this is a definition of an ISO C/C++ variadic function-like macro (not
2858 // using the GNU named varargs extension) inform our variadic scope guard
2859 // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__)
2860 // allowed only within the definition of a variadic macro.
2864 }
2866 // Read the first token after the arg list for down below.
2869 // C99 requires whitespace between the macro definition and the body. Emit
2870 // a diagnostic for something like "#define X+".
2873 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
2874 // first character of a replacement list is not a character required by
2875 // subclause 5.2.1, then there shall be white-space separation between the
2876 // identifier and the replacement list.". 5.2.1 lists this set:
2877 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
2878 // is irrelevant here.
2883 // If we have an unknown token, it is something strange like "`". Since
2884 // all of valid characters would have lexed into a single character
2885 // token of some sort, we know this is not a valid case.
2887 }
2890 else
2892 }
2899 // Read the rest of the macro body.
2901 // Object-like macros are very simple, just read their body.
2905 // Get the next token of the macro.
2907 }
2909 // Otherwise, read the body of a function-like macro. While we are at it,
2910 // check C99 6.10.3.2p1: ensure that # operators are followed by macro
2911 // parameters in function-like macro expansions.
2922 // If we're already within a VAOPT, emit an error.
2926 }
2927 // Ensure VAOPT is followed by a '(' .
2932 }
2939 }
2945 "Must have seen at least __VA_OPT__( "
2950 }
2951 }
2954 }
2955 }
2956 // Get the next token of the macro.
2959 }
2961 // If we're in -traditional mode, then we should ignore stringification
2962 // and token pasting. Mark the tokens as unknown so as not to confuse
2963 // things.
2968 // Get the next token of the macro.
2971 }
2974 // If we see token pasting, check if it looks like the gcc comma
2975 // pasting extension. We'll use this information to suppress
2976 // diagnostics later on.
2978 // Get the next token of the macro.
2984 }
2990 // Things look ok, add the '##' token to the macro.
2993 }
2995 // Our Token is a stringization operator.
2996 // Get the next token of the macro.
2999 // Check for a valid macro arg identifier or __VA_OPT__.
3004 // If this is assembler-with-cpp mode, we accept random gibberish after
3005 // the '#' because '#' is often a comment character. However, change
3006 // the kind of the token to tok::unknown so that the preprocessor isn't
3007 // confused.
3016 }
3017 }
3019 // Things look ok, add the '#' and param name tokens to the macro.
3022 // If the token following '#' is VAOPT, let the next iteration handle it
3023 // and check it for correctness, otherwise add the token and prime the
3024 // loop with the next one.
3029 // Get the next token of the macro.
3031 }
3032 }
3039 }
3040 }
3045 }
3050 }
3052 /// HandleDefineDirective - Implements \#define. This consumes the entire macro
3053 /// line then lets the caller lex the next real token.
3058 Token MacroNameTok;
3062 // Error reading macro name? If so, diagnostic already issued.
3067 // Issue a final pragma warning if we're defining a macro that was has been
3068 // undefined and is being redefined.
3072 // If we are supposed to keep comments in #defines, reenable comment saving
3073 // mode.
3084 }
3085 // Check that there is no paste (##) operator at the beginning or end of the
3086 // replacement list.
3092 }
3096 }
3097 }
3099 // When skipping just warn about macros that do not match.
3106 // Issue the diagnostic but allow the change if msvc extensions are enabled
3109 }
3111 // Finally, if this identifier already had a macro defined for it, verify that
3112 // the macro bodies are identical, and issue diagnostics if they are not.
3114 // Final macros are hard-mode: they always warn. Even if the bodies are
3115 // identical. Even if they are in system headers. Even if they are things we
3116 // would silently allow in the past.
3120 // In Objective-C, ignore attempts to directly redefine the builtin
3121 // definitions of the ownership qualifiers. It's still possible to
3122 // #undef them.
3127 // Warn if it changes the tokens.
3133 }
3136 }
3138 // It is very common for system headers to have tons of macro redefinitions
3139 // and for warnings to be disabled in system headers. If this is the case,
3140 // then don't bother calling MacroInfo::isIdenticalTo.
3147 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
3148 // C++ [cpp.predefined]p4, but allow it as an extension.
3151 // Macros must be identical. This means all tokens and whitespace
3152 // separation must be the same. C99 6.10.3p2.
3158 }
3159 }
3162 }
3168 // If we need warning for not using the macro, add its location in the
3169 // warn-because-unused-macro set. If it gets used it will be removed from set.
3177 }
3179 // If the callbacks want to know, tell them about the macro definition.
3183 // If we're in MS compatibility mode and the macro being defined is the
3184 // assert macro, implicitly add a macro definition for static_assert to work
3185 // around their broken assert.h header file in C. Only do so if there isn't
3186 // already a static_assert macro defined.
3192 Token Tok;
3198 }
3199 }
3201 /// HandleUndefDirective - Implements \#undef.
3202 ///
3206 Token MacroNameTok;
3209 // Error reading macro name? If so, diagnostic already issued.
3213 // Check to see if this is the last token on the #undef line.
3216 // Okay, we have a valid identifier to undef.
3224 // If the macro is not defined, this is a noop undef.
3229 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4 and
3230 // C++ [cpp.predefined]p4, but allow it as an extension.
3238 }
3240 // If the callbacks want to know, tell them about the macro #undef.
3241 // Note: no matter if the macro was defined or not.
3247 }
3249 //===----------------------------------------------------------------------===//
3250 // Preprocessor Conditional Directive Handling.
3251 //===----------------------------------------------------------------------===//
3253 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
3254 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
3255 /// true if any tokens have been returned or pp-directives activated before this
3256 /// \#ifndef has been lexed.
3257 ///
3265 Token MacroNameTok;
3268 // Error reading macro name? If so, diagnostic already issued.
3270 // Skip code until we get to #endif. This helps with recovery by not
3271 // emitting an error when the #endif is reached.
3276 }
3280 // Check to see if this is the last token on the #if[n]def line.
3288 // If the start of a top-level #ifdef and if the macro is not defined,
3289 // inform MIOpt that this might be the start of a proper include guard.
3290 // Otherwise it is some other form of unknown conditional which we can't
3291 // handle.
3297 }
3299 // If there is a macro, process it.
3306 else
3308 }
3313 // Should we include the stuff contained by this directive?
3315 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3316 // the directive blocks.
3321 // Yes, remember that we are inside a conditional, then lex the next token.
3326 // No, skip the contents of this block.
3331 }
3332 }
3334 /// HandleIfDirective - Implements the \#if directive.
3335 ///
3341 // Parse and evaluate the conditional expression.
3345 // Lexer might become invalid if we hit code completion point while evaluating
3346 // expression.
3350 // If this condition is equivalent to #ifndef X, and if this is the first
3351 // directive seen, handle it for the multiple-include optimization.
3354 // FIXME: Pass in the location of the macro name, not the 'if' token.
3356 else
3358 }
3368 // Should we include the stuff contained by this directive?
3370 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3371 // the directive blocks.
3375 // Yes, remember that we are inside a conditional, then lex the next token.
3379 // No, skip the contents of this block.
3383 }
3384 }
3386 /// HandleEndifDirective - Implements the \#endif directive.
3387 ///
3391 // Check that this is the whole directive.
3394 PPConditionalInfo CondInfo;
3396 // No conditionals on the stack: this is an #endif without an #if.
3399 }
3401 // If this the end of a top-level #endif, inform MIOpt.
3410 }
3412 /// HandleElseDirective - Implements the \#else directive.
3413 ///
3417 // #else directive in a non-skipping conditional... start skipping.
3420 PPConditionalInfo CI;
3424 }
3426 // If this is a top-level #else, inform the MIOpt.
3430 // If this is a #else with a #else before it, report the error.
3440 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3441 // the directive blocks.
3445 }
3447 // Finally, skip the rest of the contents of this block.
3451 }
3453 /// Implements the \#elif, \#elifdef, and \#elifndef directives.
3462 // Warn if using `#elifdef` & `#elifndef` in not C23 & C++23 mode.
3470 else
3477 }
3479 // #elif directive in a non-skipping conditional... start skipping.
3480 // We don't care what the condition is, because we will always skip it (since
3481 // the block immediately before it was included).
3484 PPConditionalInfo CI;
3488 }
3490 // If this is a top-level #elif, inform the MIOpt.
3494 // If this is a #elif with a #else before it, report the error.
3513 }
3514 }
3520 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3521 // the directive blocks.
3525 }
3527 // Finally, skip the rest of the contents of this block.
3531 }