blob: b30602c6c38915c75f20da39d733d3ad6db0e8a3 [file] [log] [blame]
peter klausler90cd9ba2018-01-30 19:54:311#ifndef FORTRAN_PREPROCESSOR_H_
2#define FORTRAN_PREPROCESSOR_H_
3
4// A Fortran-aware preprocessing module used by the prescanner to implement
5// preprocessing directives and macro replacement. Intended to be efficient
6// enough to always run on all source files even when no preprocessing is
7// needed, so that special compiler command options &/or source file name
8// extensions for preprocessing will not be necessary.
9
10#include "idioms.h"
peter klausler09865ff2018-02-09 22:04:1111#include "provenance.h"
peter klausler90cd9ba2018-01-30 19:54:3112#include <cctype>
13#include <cstring>
14#include <functional>
15#include <list>
peter klausler55fe4d22018-02-02 23:52:4316#include <sstream>
peter klausler16c6f532018-02-05 22:29:2617#include <stack>
peter klausler90cd9ba2018-01-30 19:54:3118#include <string>
19#include <unordered_map>
20#include <vector>
21
22namespace Fortran {
peter klausler0ba1a142018-02-07 20:04:4223namespace parser {
peter klausler90cd9ba2018-01-30 19:54:3124
peter klausler09865ff2018-02-09 22:04:1125class CookedSource;
peter klausler90cd9ba2018-01-30 19:54:3126class Prescanner;
27
28// Just a const char pointer with an associated length; does not own the
29// referenced data. Used to describe buffered tokens and hash table keys.
peter klausler33d78542018-01-30 20:21:2530class CharPointerWithLength {
peter klauslerbdea10d2018-02-05 20:54:3631public:
peter klausler90cd9ba2018-01-30 19:54:3132 CharPointerWithLength() {}
peter klausler33d78542018-01-30 20:21:2533 CharPointerWithLength(const char *x, size_t n) : data_{x}, bytes_{n} {}
peter klauslerad7125f2018-02-01 23:01:2334 CharPointerWithLength(const std::string &s)
35 : data_{s.data()}, bytes_{s.size()} {}
peter klausler90cd9ba2018-01-30 19:54:3136 CharPointerWithLength(const CharPointerWithLength &that)
peter klausler33d78542018-01-30 20:21:2537 : data_{that.data_}, bytes_{that.bytes_} {}
peter klausler90cd9ba2018-01-30 19:54:3138 CharPointerWithLength &operator=(const CharPointerWithLength &that) {
peter klausler33d78542018-01-30 20:21:2539 data_ = that.data_;
40 bytes_ = that.bytes_;
peter klausler90cd9ba2018-01-30 19:54:3141 return *this;
42 }
43
peter klausler33d78542018-01-30 20:21:2544 bool empty() const { return bytes_ == 0; }
45 size_t size() const { return bytes_; }
peter klausler33d78542018-01-30 20:21:2546 const char &operator[](size_t j) const { return data_[j]; }
peter klausler90cd9ba2018-01-30 19:54:3147
peter klausler55fe4d22018-02-02 23:52:4348 bool IsBlank() const;
peter klauslerad7125f2018-02-01 23:01:2349 std::string ToString() const { return std::string{data_, bytes_}; }
50
peter klauslerbdea10d2018-02-05 20:54:3651private:
peter klausler33d78542018-01-30 20:21:2552 const char *data_{nullptr};
53 size_t bytes_{0};
peter klausler90cd9ba2018-01-30 19:54:3154};
peter klausler0ba1a142018-02-07 20:04:4255} // namespace parser
peter klausler90cd9ba2018-01-30 19:54:3156} // namespace Fortran
57
58// Specializations to enable std::unordered_map<CharPointerWithLength, ...>
peter klausler0ba1a142018-02-07 20:04:4259template<> struct std::hash<Fortran::parser::CharPointerWithLength> {
60 size_t operator()(const Fortran::parser::CharPointerWithLength &x) const {
peter klauslerbe830d62018-02-05 20:48:0961 size_t hash{0}, bytes{x.size()};
62 for (size_t j{0}; j < bytes; ++j) {
63 hash = (hash * 31) ^ x[j];
peter klausler90cd9ba2018-01-30 19:54:3164 }
65 return hash;
66 }
67};
68
peter klausler0ba1a142018-02-07 20:04:4269template<> struct std::equal_to<Fortran::parser::CharPointerWithLength> {
70 bool operator()(const Fortran::parser::CharPointerWithLength &x,
71 const Fortran::parser::CharPointerWithLength &y) const {
peter klausler33d78542018-01-30 20:21:2572 return x.size() == y.size() &&
peter klausler16c6f532018-02-05 22:29:2673 std::memcmp(static_cast<const void *>(&x[0]),
74 static_cast<const void *>(&y[0]), x.size()) == 0;
peter klausler90cd9ba2018-01-30 19:54:3175 }
76};
77
78namespace Fortran {
peter klausler0ba1a142018-02-07 20:04:4279namespace parser {
peter klausler90cd9ba2018-01-30 19:54:3180
81// Buffers a contiguous sequence of characters that has been partitioned into
peter klausler09865ff2018-02-09 22:04:1182// a sequence of preprocessing tokens with provenances.
peter klausler90cd9ba2018-01-30 19:54:3183class TokenSequence {
peter klauslerbdea10d2018-02-05 20:54:3684public:
peter klausler90cd9ba2018-01-30 19:54:3185 TokenSequence() {}
peter klausler09865ff2018-02-09 22:04:1186 TokenSequence(const TokenSequence &that) { Put(that); }
87 TokenSequence(const TokenSequence &that, size_t at, size_t count = 1) {
88 Put(that, at, count);
89 }
peter klausler90cd9ba2018-01-30 19:54:3190 TokenSequence(TokenSequence &&that)
peter klauslerf5202dd2018-02-12 19:56:4291 : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
92 char_{std::move(that.char_)}, provenances_{std::move(that.provenances_)} {
93 }
peter klausler97a7c502018-02-12 22:43:1694 TokenSequence(const std::string &s, Provenance p) { Put(s, p); }
peter klauslerad7125f2018-02-01 23:01:2395
96 TokenSequence &operator=(const TokenSequence &that) {
97 clear();
peter klausler09865ff2018-02-09 22:04:1198 Put(that);
peter klauslerad7125f2018-02-01 23:01:2399 return *this;
100 }
peter klausler90cd9ba2018-01-30 19:54:31101 TokenSequence &operator=(TokenSequence &&that) {
102 start_ = std::move(that.start_);
103 nextStart_ = that.nextStart_;
104 char_ = std::move(that.char_);
105 return *this;
106 }
107
peter klauslerad7125f2018-02-01 23:01:23108 CharPointerWithLength operator[](size_t token) const {
peter klausler09865ff2018-02-09 22:04:11109 return {&char_[start_[token]], TokenBytes(token)};
peter klausler90cd9ba2018-01-30 19:54:31110 }
111
peter klausler09865ff2018-02-09 22:04:11112 bool empty() const { return start_.empty(); }
113 size_t size() const { return start_.size(); }
114 const char *data() const { return &char_[0]; }
115 void clear();
116 void pop_back();
117 void shrink_to_fit();
peter klausler6f94e842018-01-30 23:22:26118
peter klausler09865ff2018-02-09 22:04:11119 void PutNextTokenChar(char ch, Provenance provenance) {
120 char_.emplace_back(ch);
121 provenances_.Put({provenance, 1});
122 }
123
124 void CloseToken() {
peter klausler90cd9ba2018-01-30 19:54:31125 start_.emplace_back(nextStart_);
126 nextStart_ = char_.size();
127 }
128
peter klausler6f94e842018-01-30 23:22:26129 void ReopenLastToken() {
130 nextStart_ = start_.back();
131 start_.pop_back();
132 }
133
peter klausler09865ff2018-02-09 22:04:11134 void Put(const TokenSequence &);
135 void Put(const TokenSequence &, size_t at, size_t tokens = 1);
136 void Put(const char *, size_t, Provenance);
137 void Put(const CharPointerWithLength &, Provenance);
138 void Put(const std::string &, Provenance);
139 void Put(const std::stringstream &, Provenance);
140 void EmitWithCaseConversion(CookedSource *) const;
peter klausler55fe4d22018-02-02 23:52:43141 std::string ToString() const;
peter klausler09865ff2018-02-09 22:04:11142 ProvenanceRange GetProvenance(size_t token, size_t offset = 0) const;
peter klausler90cd9ba2018-01-30 19:54:31143
peter klauslerbdea10d2018-02-05 20:54:36144private:
peter klausler09865ff2018-02-09 22:04:11145 size_t TokenBytes(size_t token) const {
146 return (token + 1 >= start_.size() ? char_.size() : start_[token + 1]) -
147 start_[token];
148 }
149
150 std::vector<size_t> start_;
peter klausler90cd9ba2018-01-30 19:54:31151 size_t nextStart_{0};
152 std::vector<char> char_;
peter klausler09865ff2018-02-09 22:04:11153 OffsetToProvenanceMappings provenances_;
peter klausler90cd9ba2018-01-30 19:54:31154};
155
156// Defines a macro
157class Definition {
peter klauslerbdea10d2018-02-05 20:54:36158public:
peter klausler90cd9ba2018-01-30 19:54:31159 Definition(const TokenSequence &, size_t firstToken, size_t tokens);
160 Definition(const std::vector<std::string> &argNames, const TokenSequence &,
peter klausler16c6f532018-02-05 22:29:26161 size_t firstToken, size_t tokens, bool isVariadic = false);
peter klausler97a7c502018-02-12 22:43:16162 Definition(const std::string &predefined, AllSources *);
peter klausler90cd9ba2018-01-30 19:54:31163
164 bool isFunctionLike() const { return isFunctionLike_; }
165 size_t argumentCount() const { return argumentCount_; }
166 bool isVariadic() const { return isVariadic_; }
167 bool isDisabled() const { return isDisabled_; }
peter klauslerad7125f2018-02-01 23:01:23168 bool isPredefined() const { return isPredefined_; }
peter klausler90cd9ba2018-01-30 19:54:31169 const TokenSequence &replacement() const { return replacement_; }
170
171 bool set_isDisabled(bool disable);
172
peter klausler97a7c502018-02-12 22:43:16173 TokenSequence Apply(
174 const std::vector<TokenSequence> &args, const Prescanner &);
peter klausler90cd9ba2018-01-30 19:54:31175
peter klauslerbdea10d2018-02-05 20:54:36176private:
peter klausler90cd9ba2018-01-30 19:54:31177 static TokenSequence Tokenize(const std::vector<std::string> &argNames,
peter klausler16c6f532018-02-05 22:29:26178 const TokenSequence &token, size_t firstToken, size_t tokens);
peter klausler90cd9ba2018-01-30 19:54:31179
180 bool isFunctionLike_{false};
181 size_t argumentCount_{0};
182 bool isVariadic_{false};
183 bool isDisabled_{false};
peter klauslerad7125f2018-02-01 23:01:23184 bool isPredefined_{false};
peter klausler90cd9ba2018-01-30 19:54:31185 TokenSequence replacement_;
186};
187
188// Preprocessing state
189class Preprocessor {
peter klauslerbdea10d2018-02-05 20:54:36190public:
peter klauslerad7125f2018-02-01 23:01:23191 explicit Preprocessor(Prescanner &);
peter klausler90cd9ba2018-01-30 19:54:31192
193 // When the input contains macros to be replaced, the new token sequence
194 // is appended to the output and the returned value is true. When
195 // no macro replacement is necessary, the output is unmodified and the
196 // return value is false.
197 bool MacroReplacement(const TokenSequence &, TokenSequence *);
198
peter klausler55fe4d22018-02-02 23:52:43199 // Implements a preprocessor directive; returns true when no fatal error.
200 bool Directive(const TokenSequence &);
peter klausler90cd9ba2018-01-30 19:54:31201
peter klauslerbdea10d2018-02-05 20:54:36202private:
peter klausler93cf3ae2018-02-01 20:08:02203 enum class IsElseActive { No, Yes };
204 enum class CanDeadElseAppear { No, Yes };
peter klauslerad7125f2018-02-01 23:01:23205
peter klausler55fe4d22018-02-02 23:52:43206 void Complain(const std::string &);
peter klausler97a7c502018-02-12 22:43:16207 CharPointerWithLength SaveTokenAsName(const CharPointerWithLength &);
peter klausler93cf3ae2018-02-01 20:08:02208 bool IsNameDefined(const CharPointerWithLength &);
peter klauslerad7125f2018-02-01 23:01:23209 TokenSequence ReplaceMacros(const TokenSequence &);
peter klausler55fe4d22018-02-02 23:52:43210 bool SkipDisabledConditionalCode(const std::string &dirName, IsElseActive);
peter klausler16c6f532018-02-05 22:29:26211 bool IsIfPredicateTrue(
212 const TokenSequence &expr, size_t first, size_t exprTokens);
peter klausler93cf3ae2018-02-01 20:08:02213
peter klauslerad7125f2018-02-01 23:01:23214 Prescanner &prescanner_;
peter klausler90cd9ba2018-01-30 19:54:31215 std::list<std::string> names_;
216 std::unordered_map<CharPointerWithLength, Definition> definitions_;
peter klausler93cf3ae2018-02-01 20:08:02217 std::stack<CanDeadElseAppear> ifStack_;
peter klausler90cd9ba2018-01-30 19:54:31218};
peter klausler0ba1a142018-02-07 20:04:42219} // namespace parser
peter klausler90cd9ba2018-01-30 19:54:31220} // namespace Fortran
221#endif // FORTRAN_PREPROCESSOR_H_