llvm/mlir/lib/Parser/ParserState.h
Mehdi Amini 387f95541b Add a new interface allowing to set a default dialect to be used for printing/parsing regions
Currently the builtin dialect is the default namespace used for parsing
and printing. As such module and func don't need to be prefixed.
In the case of some dialects that defines new regions for their own
purpose (like SpirV modules for example), it can be beneficial to
change the default dialect in order to improve readability.

Differential Revision: https://reviews.llvm.org/D107236
2021-08-31 17:52:40 +00:00

98 lines
3.5 KiB
C++

//===- ParserState.h - MLIR ParserState -------------------------*- 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 MLIR_LIB_PARSER_PARSERSTATE_H
#define MLIR_LIB_PARSER_PARSERSTATE_H
#include "Lexer.h"
#include "mlir/IR/Attributes.h"
#include "llvm/ADT/StringMap.h"
namespace mlir {
namespace detail {
//===----------------------------------------------------------------------===//
// SymbolState
//===----------------------------------------------------------------------===//
/// This class contains record of any parsed top-level symbols.
struct SymbolState {
// A map from attribute alias identifier to Attribute.
llvm::StringMap<Attribute> attributeAliasDefinitions;
// A map from type alias identifier to Type.
llvm::StringMap<Type> typeAliasDefinitions;
/// A set of locations into the main parser memory buffer for each of the
/// active nested parsers. Given that some nested parsers, i.e. custom dialect
/// parsers, operate on a temporary memory buffer, this provides an anchor
/// point for emitting diagnostics.
SmallVector<llvm::SMLoc, 1> nestedParserLocs;
/// The top-level lexer that contains the original memory buffer provided by
/// the user. This is used by nested parsers to get a properly encoded source
/// location.
Lexer *topLevelLexer = nullptr;
};
//===----------------------------------------------------------------------===//
// ParserState
//===----------------------------------------------------------------------===//
/// This class refers to all of the state maintained globally by the parser,
/// such as the current lexer position etc.
struct ParserState {
ParserState(const llvm::SourceMgr &sourceMgr, MLIRContext *ctx,
SymbolState &symbols, AsmParserState *asmState)
: context(ctx), lex(sourceMgr, ctx), curToken(lex.lexToken()),
symbols(symbols), parserDepth(symbols.nestedParserLocs.size()),
asmState(asmState) {
// Set the top level lexer for the symbol state if one doesn't exist.
if (!symbols.topLevelLexer)
symbols.topLevelLexer = &lex;
}
~ParserState() {
// Reset the top level lexer if it refers the lexer in our state.
if (symbols.topLevelLexer == &lex)
symbols.topLevelLexer = nullptr;
}
ParserState(const ParserState &) = delete;
void operator=(const ParserState &) = delete;
/// The context we're parsing into.
MLIRContext *const context;
/// The lexer for the source file we're parsing.
Lexer lex;
/// This is the next token that hasn't been consumed yet.
Token curToken;
/// The current state for symbol parsing.
SymbolState &symbols;
/// The depth of this parser in the nested parsing stack.
size_t parserDepth;
/// An optional pointer to a struct containing high level parser state to be
/// populated during parsing.
AsmParserState *asmState;
// Contains the stack of default dialect to use when parsing regions.
// A new dialect get pushed to the stack before parsing regions nested
// under an operation implementing `OpAsmOpInterface`, and
// popped when done. At the top-level we start with "builtin" as the
// default, so that the top-level `module` operation parses as-is.
SmallVector<StringRef> defaultDialectStack{"builtin"};
};
} // end namespace detail
} // end namespace mlir
#endif // MLIR_LIB_PARSER_PARSERSTATE_H