1//===- Parser.h - MLIR Base Parser Class ------------------------*- C++ -*-===//
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#ifndef MLIR_LIB_ASMPARSER_PARSER_H
10#define MLIR_LIB_ASMPARSER_PARSER_H
11
12#include "ParserState.h"
13#include "mlir/IR/Builders.h"
14#include "mlir/IR/OpImplementation.h"
15#include <optional>
16
17namespace mlir {
18namespace detail {
19
20//===----------------------------------------------------------------------===//
21// Parser
22//===----------------------------------------------------------------------===//
23
24/// This class implement support for parsing global entities like attributes and
25/// types. It is intended to be subclassed by specialized subparsers that
26/// include state.
27class Parser {
28public:
29 using Delimiter = OpAsmParser::Delimiter;
30
31 Builder builder;
32
33 Parser(ParserState &state)
34 : builder(state.config.getContext()), state(state) {}
35
36 // Helper methods to get stuff from the parser-global state.
37 ParserState &getState() const { return state; }
38 MLIRContext *getContext() const { return state.config.getContext(); }
39 const llvm::SourceMgr &getSourceMgr() { return state.lex.getSourceMgr(); }
40
41 /// Parse a comma-separated list of elements up until the specified end token.
42 ParseResult
43 parseCommaSeparatedListUntil(Token::Kind rightToken,
44 function_ref<ParseResult()> parseElement,
45 bool allowEmptyList = true);
46
47 /// Parse a list of comma-separated items with an optional delimiter. If a
48 /// delimiter is provided, then an empty list is allowed. If not, then at
49 /// least one element will be parsed.
50 ParseResult
51 parseCommaSeparatedList(Delimiter delimiter,
52 function_ref<ParseResult()> parseElementFn,
53 StringRef contextMessage = StringRef());
54
55 /// Parse a comma separated list of elements that must have at least one entry
56 /// in it.
57 ParseResult
58 parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {
59 return parseCommaSeparatedList(delimiter: Delimiter::None, parseElementFn);
60 }
61
62 /// Parse the body of a dialect symbol, which starts and ends with <>'s, and
63 /// may be recursive. Return with the 'body' StringRef encompassing the entire
64 /// body. `isCodeCompletion` is set to true if the body contained a code
65 /// completion location, in which case the body is only populated up to the
66 /// completion.
67 ParseResult parseDialectSymbolBody(StringRef &body, bool &isCodeCompletion);
68 ParseResult parseDialectSymbolBody(StringRef &body) {
69 bool isCodeCompletion = false;
70 return parseDialectSymbolBody(body, isCodeCompletion);
71 }
72
73 // We have two forms of parsing methods - those that return a non-null
74 // pointer on success, and those that return a ParseResult to indicate whether
75 // they returned a failure. The second class fills in by-reference arguments
76 // as the results of their action.
77
78 //===--------------------------------------------------------------------===//
79 // Error Handling
80 //===--------------------------------------------------------------------===//
81
82 /// Emit an error and return failure.
83 InFlightDiagnostic emitError(const Twine &message = {});
84 InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});
85
86 /// Emit an error about a "wrong token". If the current token is at the
87 /// start of a source line, this will apply heuristics to back up and report
88 /// the error at the end of the previous line, which is where the expected
89 /// token is supposed to be.
90 InFlightDiagnostic emitWrongTokenError(const Twine &message = {});
91
92 /// Encode the specified source location information into an attribute for
93 /// attachment to the IR.
94 Location getEncodedSourceLocation(SMLoc loc) {
95 return state.lex.getEncodedSourceLocation(loc);
96 }
97
98 //===--------------------------------------------------------------------===//
99 // Token Parsing
100 //===--------------------------------------------------------------------===//
101
102 /// Return the current token the parser is inspecting.
103 const Token &getToken() const { return state.curToken; }
104 StringRef getTokenSpelling() const { return state.curToken.getSpelling(); }
105
106 /// Return the last parsed token.
107 const Token &getLastToken() const { return state.lastToken; }
108
109 /// If the current token has the specified kind, consume it and return true.
110 /// If not, return false.
111 bool consumeIf(Token::Kind kind) {
112 if (state.curToken.isNot(k: kind))
113 return false;
114 consumeToken(kind);
115 return true;
116 }
117
118 /// Advance the current lexer onto the next token.
119 void consumeToken() {
120 assert(state.curToken.isNot(Token::eof, Token::error) &&
121 "shouldn't advance past EOF or errors");
122 state.lastToken = state.curToken;
123 state.curToken = state.lex.lexToken();
124 }
125
126 /// Advance the current lexer onto the next token, asserting what the expected
127 /// current token is. This is preferred to the above method because it leads
128 /// to more self-documenting code with better checking.
129 void consumeToken(Token::Kind kind) {
130 assert(state.curToken.is(kind) && "consumed an unexpected token");
131 consumeToken();
132 }
133
134 /// Reset the parser to the given lexer position. Resetting the parser/lexer
135 /// position does not update 'state.lastToken'. 'state.lastToken' is the
136 /// last parsed token, and is used to provide the scope end location for
137 /// OperationDefinitions. To ensure the correctness of the end location, the
138 /// last consumed token of an OperationDefinition needs to be the last token
139 /// belonging to it.
140 void resetToken(const char *tokPos) {
141 state.lex.resetPointer(newPointer: tokPos);
142 state.curToken = state.lex.lexToken();
143 }
144
145 /// Consume the specified token if present and return success. On failure,
146 /// output a diagnostic and return failure.
147 ParseResult parseToken(Token::Kind expectedToken, const Twine &message);
148
149 /// Parses a quoted string token if present.
150 ParseResult parseOptionalString(std::string *string);
151
152 /// Parse an optional integer value from the stream.
153 OptionalParseResult parseOptionalInteger(APInt &result);
154
155 /// Parse an optional integer value only in decimal format from the stream.
156 OptionalParseResult parseOptionalDecimalInteger(APInt &result);
157
158 /// Parse a floating point value from a literal.
159 ParseResult parseFloatFromLiteral(std::optional<APFloat> &result,
160 const Token &tok, bool isNegative,
161 const llvm::fltSemantics &semantics);
162
163 /// Parse a floating point value from an integer literal token.
164 ParseResult parseFloatFromIntegerLiteral(std::optional<APFloat> &result,
165 const Token &tok, bool isNegative,
166 const llvm::fltSemantics &semantics);
167
168 /// Returns true if the current token corresponds to a keyword.
169 bool isCurrentTokenAKeyword() const {
170 return getToken().isAny(k1: Token::bare_identifier, k2: Token::inttype) ||
171 getToken().isKeyword();
172 }
173
174 /// Parse a keyword, if present, into 'keyword'.
175 ParseResult parseOptionalKeyword(StringRef *keyword);
176
177 /// Parse an optional keyword or string and set instance into 'result'.`
178 ParseResult parseOptionalKeywordOrString(std::string *result);
179
180 //===--------------------------------------------------------------------===//
181 // Resource Parsing
182 //===--------------------------------------------------------------------===//
183
184 /// Parse a handle to a dialect resource within the assembly format.
185 FailureOr<AsmDialectResourceHandle>
186 parseResourceHandle(const OpAsmDialectInterface *dialect, std::string &name);
187 FailureOr<AsmDialectResourceHandle> parseResourceHandle(Dialect *dialect);
188
189 //===--------------------------------------------------------------------===//
190 // Type Parsing
191 //===--------------------------------------------------------------------===//
192
193 /// Invoke the `getChecked` method of the given Attribute or Type class, using
194 /// the provided location to emit errors in the case of failure. Note that
195 /// unlike `OpBuilder::getType`, this method does not implicitly insert a
196 /// context parameter.
197 template <typename T, typename... ParamsT>
198 T getChecked(SMLoc loc, ParamsT &&...params) {
199 return T::getChecked([&] { return emitError(loc); },
200 std::forward<ParamsT>(params)...);
201 }
202
203 ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
204 ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
205 ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
206
207 /// Optionally parse a type.
208 OptionalParseResult parseOptionalType(Type &type);
209
210 /// Parse an arbitrary type.
211 Type parseType();
212
213 /// Parse a complex type.
214 Type parseComplexType();
215
216 /// Parse an extended type.
217 Type parseExtendedType();
218
219 /// Parse a function type.
220 Type parseFunctionType();
221
222 /// Parse a memref type.
223 Type parseMemRefType();
224
225 /// Parse a non function type.
226 Type parseNonFunctionType();
227
228 /// Parse a tensor type.
229 Type parseTensorType();
230
231 /// Parse a tuple type.
232 Type parseTupleType();
233
234 /// Parse a vector type.
235 VectorType parseVectorType();
236 ParseResult parseVectorDimensionList(SmallVectorImpl<int64_t> &dimensions,
237 SmallVectorImpl<bool> &scalableDims);
238 ParseResult parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
239 bool allowDynamic = true,
240 bool withTrailingX = true);
241 ParseResult parseIntegerInDimensionList(int64_t &value);
242 ParseResult parseXInDimensionList();
243
244 //===--------------------------------------------------------------------===//
245 // Attribute Parsing
246 //===--------------------------------------------------------------------===//
247
248 /// Parse an arbitrary attribute with an optional type.
249 Attribute parseAttribute(Type type = {});
250
251 /// Parse an optional attribute with the provided type.
252 OptionalParseResult parseOptionalAttribute(Attribute &attribute,
253 Type type = {});
254 OptionalParseResult parseOptionalAttribute(ArrayAttr &attribute, Type type);
255 OptionalParseResult parseOptionalAttribute(StringAttr &attribute, Type type);
256 OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type);
257
258 /// Parse an optional attribute that is demarcated by a specific token.
259 template <typename AttributeT>
260 OptionalParseResult parseOptionalAttributeWithToken(Token::Kind kind,
261 AttributeT &attr,
262 Type type = {}) {
263 if (getToken().isNot(k: kind))
264 return std::nullopt;
265
266 if (Attribute parsedAttr = parseAttribute(type)) {
267 attr = cast<AttributeT>(parsedAttr);
268 return success();
269 }
270 return failure();
271 }
272
273 /// Parse an attribute dictionary.
274 ParseResult parseAttributeDict(NamedAttrList &attributes);
275
276 /// Parse a distinct attribute.
277 Attribute parseDistinctAttr(Type type);
278
279 /// Parse an extended attribute.
280 Attribute parseExtendedAttr(Type type);
281
282 /// Parse a float attribute.
283 Attribute parseFloatAttr(Type type, bool isNegative);
284
285 /// Parse a decimal or a hexadecimal literal, which can be either an integer
286 /// or a float attribute.
287 Attribute parseDecOrHexAttr(Type type, bool isNegative);
288
289 /// Parse a dense elements attribute.
290 Attribute parseDenseElementsAttr(Type attrType);
291 ShapedType parseElementsLiteralType(SMLoc loc, Type type);
292
293 /// Parse a dense resource elements attribute.
294 Attribute parseDenseResourceElementsAttr(Type attrType);
295
296 /// Parse a DenseArrayAttr.
297 Attribute parseDenseArrayAttr(Type type);
298
299 /// Parse a sparse elements attribute.
300 Attribute parseSparseElementsAttr(Type attrType);
301
302 /// Parse a strided layout attribute.
303 Attribute parseStridedLayoutAttr();
304
305 //===--------------------------------------------------------------------===//
306 // Location Parsing
307 //===--------------------------------------------------------------------===//
308
309 /// Parse a raw location instance.
310 ParseResult parseLocationInstance(LocationAttr &loc);
311
312 /// Parse a callsite location instance.
313 ParseResult parseCallSiteLocation(LocationAttr &loc);
314
315 /// Parse a fused location instance.
316 ParseResult parseFusedLocation(LocationAttr &loc);
317
318 /// Parse a name or FileLineCol location instance.
319 ParseResult parseNameOrFileLineColRange(LocationAttr &loc);
320
321 //===--------------------------------------------------------------------===//
322 // Affine Parsing
323 //===--------------------------------------------------------------------===//
324
325 /// Parse a reference to either an affine map, expr, or an integer set.
326 ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
327 IntegerSet &set);
328 ParseResult parseAffineMapReference(AffineMap &map);
329 ParseResult
330 parseAffineExprReference(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
331 AffineExpr &expr);
332 ParseResult parseIntegerSetReference(IntegerSet &set);
333
334 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
335 ParseResult
336 parseAffineMapOfSSAIds(AffineMap &map,
337 function_ref<ParseResult(bool)> parseElement,
338 Delimiter delimiter);
339
340 /// Parse an AffineExpr where dim and symbol identifiers are SSA ids.
341 ParseResult
342 parseAffineExprOfSSAIds(AffineExpr &expr,
343 function_ref<ParseResult(bool)> parseElement);
344
345 //===--------------------------------------------------------------------===//
346 // Code Completion
347 //===--------------------------------------------------------------------===//
348
349 /// The set of various code completion methods. Every completion method
350 /// returns `failure` to signal that parsing should abort after any desired
351 /// completions have been enqueued. Note that `failure` is does not mean
352 /// completion failed, it's just a signal to the parser to stop.
353
354 ParseResult codeCompleteDialectName();
355 ParseResult codeCompleteOperationName(StringRef dialectName);
356 ParseResult codeCompleteDialectOrElidedOpName(SMLoc loc);
357 ParseResult codeCompleteStringDialectOrOperationName(StringRef name);
358 ParseResult codeCompleteExpectedTokens(ArrayRef<StringRef> tokens);
359 ParseResult codeCompleteOptionalTokens(ArrayRef<StringRef> tokens);
360
361 Attribute codeCompleteAttribute();
362 Type codeCompleteType();
363 Attribute
364 codeCompleteDialectSymbol(const llvm::StringMap<Attribute> &aliases);
365 Type codeCompleteDialectSymbol(const llvm::StringMap<Type> &aliases);
366
367protected:
368 /// The Parser is subclassed and reinstantiated. Do not add additional
369 /// non-trivial state here, add it to the ParserState class.
370 ParserState &state;
371};
372} // namespace detail
373} // namespace mlir
374
375#endif // MLIR_LIB_ASMPARSER_PARSER_H
376

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of mlir/lib/AsmParser/Parser.h