6fac3f7b2e
The prescanner performs implicit line continuation when it looks like the parenthesized arguments of a call to a function-like macro may span multiple lines. In an attempt to work more like a Fortran-oblivious C preprocessor, the prescanner will act as if the following lines had been continuations so that the function-like macro could be invoked. This still seems like a good idea, but a recent bug report on LLVM's GitHub issue tracker shows one way in which it could trigger inadvertently and mess up a program. So this patch makes the conditions for implicit line continuation much more strict. First, the leading parenthesis has to have been preceded by an identifier that's known to be a macro name. (It doesn't have to be a function-like macro, since it's possible for a keyword-like macro to expand to the name of a function-like macro.) Second, no macro definition can ever have had unbalanced parentheses in its replacement text. Also cleans up some parenthesis recognition code to fix some issues found in testing, so that a token with leading or trailing spaces can still be recognized as a parenthesis or comma. Fixes https://github.com/llvm/llvm-project/issues/63844. Differential Revision: https://reviews.llvm.org/D155499
109 lines
3.7 KiB
C++
109 lines
3.7 KiB
C++
//===-- lib/Parser/preprocessor.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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef FORTRAN_PARSER_PREPROCESSOR_H_
|
|
#define FORTRAN_PARSER_PREPROCESSOR_H_
|
|
|
|
// A Fortran-aware preprocessing module used by the prescanner to implement
|
|
// preprocessing directives and macro replacement. Intended to be efficient
|
|
// enough to always run on all source files even when no preprocessing is
|
|
// performed, so that special compiler command options &/or source file name
|
|
// extensions for preprocessing will not be necessary.
|
|
|
|
#include "token-sequence.h"
|
|
#include "flang/Parser/char-block.h"
|
|
#include "flang/Parser/provenance.h"
|
|
#include <cstddef>
|
|
#include <list>
|
|
#include <stack>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace Fortran::parser {
|
|
|
|
class Prescanner;
|
|
class Preprocessor;
|
|
|
|
// Defines a macro
|
|
class Definition {
|
|
public:
|
|
Definition(const TokenSequence &, std::size_t firstToken, std::size_t tokens);
|
|
Definition(const std::vector<std::string> &argNames, const TokenSequence &,
|
|
std::size_t firstToken, std::size_t tokens, bool isVariadic = false);
|
|
Definition(const std::string &predefined, AllSources &);
|
|
|
|
bool isFunctionLike() const { return isFunctionLike_; }
|
|
std::size_t argumentCount() const { return argumentCount_; }
|
|
bool isVariadic() const { return isVariadic_; }
|
|
bool isDisabled() const { return isDisabled_; }
|
|
bool isPredefined() const { return isPredefined_; }
|
|
const TokenSequence &replacement() const { return replacement_; }
|
|
|
|
bool set_isDisabled(bool disable);
|
|
|
|
TokenSequence Apply(const std::vector<TokenSequence> &args, Prescanner &);
|
|
|
|
private:
|
|
static TokenSequence Tokenize(const std::vector<std::string> &argNames,
|
|
const TokenSequence &token, std::size_t firstToken, std::size_t tokens);
|
|
|
|
bool isFunctionLike_{false};
|
|
std::size_t argumentCount_{0};
|
|
bool isVariadic_{false};
|
|
bool isDisabled_{false};
|
|
bool isPredefined_{false};
|
|
TokenSequence replacement_;
|
|
};
|
|
|
|
// Preprocessing state
|
|
class Preprocessor {
|
|
public:
|
|
explicit Preprocessor(AllSources &);
|
|
|
|
const AllSources &allSources() const { return allSources_; }
|
|
AllSources &allSources() { return allSources_; }
|
|
|
|
void DefineStandardMacros();
|
|
void Define(std::string macro, std::string value);
|
|
void Undefine(std::string macro);
|
|
bool IsNameDefined(const CharBlock &);
|
|
|
|
std::optional<TokenSequence> MacroReplacement(
|
|
const TokenSequence &, Prescanner &);
|
|
|
|
// Implements a preprocessor directive.
|
|
void Directive(const TokenSequence &, Prescanner &);
|
|
|
|
bool anyMacroWithUnbalancedParentheses() const {
|
|
return anyMacroWithUnbalancedParentheses_;
|
|
}
|
|
|
|
private:
|
|
enum class IsElseActive { No, Yes };
|
|
enum class CanDeadElseAppear { No, Yes };
|
|
|
|
CharBlock SaveTokenAsName(const CharBlock &);
|
|
TokenSequence ReplaceMacros(const TokenSequence &, Prescanner &);
|
|
void SkipDisabledConditionalCode(
|
|
const std::string &, IsElseActive, Prescanner &, ProvenanceRange);
|
|
bool IsIfPredicateTrue(const TokenSequence &expr, std::size_t first,
|
|
std::size_t exprTokens, Prescanner &);
|
|
void LineDirective(const TokenSequence &, std::size_t, Prescanner &);
|
|
void CheckForUnbalancedParentheses(
|
|
const TokenSequence &, std::size_t first, std::size_t tokens);
|
|
|
|
AllSources &allSources_;
|
|
std::list<std::string> names_;
|
|
std::unordered_map<CharBlock, Definition> definitions_;
|
|
std::stack<CanDeadElseAppear> ifStack_;
|
|
bool anyMacroWithUnbalancedParentheses_{false};
|
|
};
|
|
} // namespace Fortran::parser
|
|
#endif // FORTRAN_PARSER_PREPROCESSOR_H_
|