/// If `numRead` is provided, it is set to the number of consumed characters on
/// succesful parse. Otherwise, parsing fails if the entire string is not
/// consumed.
+/// Some internal copying can be skipped if the source string is known to be
+/// null terminated.
Attribute parseAttribute(llvm::StringRef attrStr, MLIRContext *context,
- Type type = {}, size_t *numRead = nullptr);
+ Type type = {}, size_t *numRead = nullptr,
+ bool isKnownNullTerminated = false);
/// This parses a single MLIR type to an MLIR context if it was valid. If not,
/// an error diagnostic is emitted to the context.
/// If `numRead` is provided, it is set to the number of consumed characters on
/// succesful parse. Otherwise, parsing fails if the entire string is not
/// consumed.
+/// Some internal copying can be skipped if the source string is known to be
+/// null terminated.
Type parseType(llvm::StringRef typeStr, MLIRContext *context,
- size_t *numRead = nullptr);
+ size_t *numRead = nullptr, bool isKnownNullTerminated = false);
/// This parses a single IntegerSet/AffineMap to an MLIR context if it was
/// valid. If not, an error message is emitted through a new
//===----------------------------------------------------------------------===//
/// Parses a symbol, of type 'T', and returns it if parsing was successful. If
-/// parsing failed, nullptr is returned. The number of bytes read from the input
-/// string is returned in 'numRead'.
+/// parsing failed, nullptr is returned.
template <typename T, typename ParserFn>
static T parseSymbol(StringRef inputStr, MLIRContext *context,
- size_t *numReadOut, ParserFn &&parserFn) {
+ size_t *numReadOut, bool isKnownNullTerminated,
+ ParserFn &&parserFn) {
// Set the buffer name to the string being parsed, so that it appears in error
// diagnostics.
- auto memBuffer = MemoryBuffer::getMemBuffer(inputStr, /*BufferName=*/inputStr,
- /*RequiresNullTerminator=*/true);
+ auto memBuffer =
+ isKnownNullTerminated
+ ? MemoryBuffer::getMemBuffer(inputStr,
+ /*BufferName=*/inputStr)
+ : MemoryBuffer::getMemBufferCopy(inputStr, /*BufferName=*/inputStr);
SourceMgr sourceMgr;
sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
SymbolState aliasState;
}
Attribute mlir::parseAttribute(StringRef attrStr, MLIRContext *context,
- Type type, size_t *numRead) {
+ Type type, size_t *numRead,
+ bool isKnownNullTerminated) {
return parseSymbol<Attribute>(
- attrStr, context, numRead,
+ attrStr, context, numRead, isKnownNullTerminated,
[type](Parser &parser) { return parser.parseAttribute(type); });
}
-Type mlir::parseType(StringRef typeStr, MLIRContext *context, size_t *numRead) {
- return parseSymbol<Type>(typeStr, context, numRead,
+Type mlir::parseType(StringRef typeStr, MLIRContext *context, size_t *numRead,
+ bool isKnownNullTerminated) {
+ return parseSymbol<Type>(typeStr, context, numRead, isKnownNullTerminated,
[](Parser &parser) { return parser.parseType(); });
}
size_t numRead = 0;
MLIRContext *context = fileLoc->getContext();
if constexpr (std::is_same_v<T, Type>)
- result = ::parseType(asmStr, context, &numRead);
+ result =
+ ::parseType(asmStr, context, &numRead, /*isKnownNullTerminated=*/true);
else
- result = ::parseAttribute(asmStr, context, Type(), &numRead);
+ result = ::parseAttribute(asmStr, context, Type(), &numRead,
+ /*isKnownNullTerminated=*/true);
if (!result)
return failure();
// Try to parse string attributes to obtain an attribute of element type.
if (auto stringAttr = attr.dyn_cast<StringAttr>()) {
auto parsedAttr = dyn_cast_if_present<TypedAttr>(
- parseAttribute(stringAttr, getContext(), elementType));
+ parseAttribute(stringAttr, getContext(), elementType,
+ /*numRead=*/nullptr, /*isKnownNullTerminated=*/true));
if (!parsedAttr || parsedAttr.getType() != elementType) {
auto diag = this->emitOpError("expects a padding that parses to ")
<< elementType << ", got " << std::get<0>(it);
SerializedAffineMap &value) {
assert(rawYamlContext);
auto *yamlContext = static_cast<LinalgYAMLContext *>(rawYamlContext);
- std::string nullTerminatedScalar(scalar);
- if (auto attr =
- mlir::parseAttribute(nullTerminatedScalar, yamlContext->mlirContext)
- .dyn_cast_or_null<AffineMapAttr>())
+ if (auto attr = mlir::parseAttribute(scalar, yamlContext->mlirContext)
+ .dyn_cast_or_null<AffineMapAttr>())
value.affineMapAttr = attr;
else if (!value.affineMapAttr || !value.affineMapAttr.isa<AffineMapAttr>())
return "could not parse as an affine map attribute";
b.getI64IntegerAttr(10));
EXPECT_EQ(numRead, size_t(4)); // includes trailing whitespace
}
+ { // Parse without null-terminator
+ StringRef attrAsm("999", 1);
+ Attribute attr = parseAttribute(attrAsm, &context);
+ EXPECT_EQ(attr, b.getI64IntegerAttr(9));
+ }
}
} // namespace