50e1ad6ed2
D155499 fixed an issue with implicit continuations. The fixes included a
nested parenthesis check during definition of a macro which is then
carried over in the scanner state.
This leads to the following corner case to fail:
subroutine foo(a, d)
implicit none
integer :: a
integer :: d
! An implicit continuation won't be considered unless
! the definition of "bar" above is removed/commented
call sub(1,
2)
end subroutine foo
The definition of bar is indeed unbalanced but it is not even used in
the code, so it should not impact whether we apply implicit continuation
in the expansion of sub.
This change aims at addressing this issue by removing the balance check
and constraining a bit more when we consider implicit continuations:
only when we see a left parenthesis after a function-like macro, not a
object-like macro. In this case I think it is OK to (unconditionally)
implicitly continue to the next line in search of the corresponding
right parenthesis. This is, to my understanding, similar to what the C
preprocessor would do according to the description in [1].
[1] https://www.spinellis.gr/blog/20060626/
Differential Revision: https://reviews.llvm.org/D157414
103 lines
3.5 KiB
C++
103 lines
3.5 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 &);
|
|
bool IsFunctionLikeDefinition(const CharBlock &);
|
|
|
|
std::optional<TokenSequence> MacroReplacement(
|
|
const TokenSequence &, Prescanner &);
|
|
|
|
// Implements a preprocessor directive.
|
|
void Directive(const TokenSequence &, Prescanner &);
|
|
|
|
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 &);
|
|
|
|
AllSources &allSources_;
|
|
std::list<std::string> names_;
|
|
std::unordered_map<CharBlock, Definition> definitions_;
|
|
std::stack<CanDeadElseAppear> ifStack_;
|
|
};
|
|
} // namespace Fortran::parser
|
|
#endif // FORTRAN_PARSER_PREPROCESSOR_H_
|