blob: 30de40dd54a09614df6a675b2d7adc1ce3bcf2d4 [file] [log] [blame]
//===- RemarkParser.cpp --------------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// This file provides utility methods used by clients that want to use the
// parser for remark diagnostics in LLVM.
#include "llvm/Remarks/RemarkParser.h"
#include "YAMLRemarkParser.h"
#include "llvm-c/Remarks.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/CBindingWrapping.h"
using namespace llvm;
using namespace llvm::remarks;
Parser::Parser(StringRef Buf) : Impl(llvm::make_unique<YAMLParserImpl>(Buf)) {}
Parser::~Parser() = default;
static Expected<const Remark *> getNextYAML(YAMLParserImpl &Impl) {
YAMLRemarkParser &YAMLParser = Impl.YAMLParser;
// Check for EOF.
if (Impl.YAMLIt == Impl.YAMLParser.Stream.end())
return nullptr;
auto CurrentIt = Impl.YAMLIt;
// Try to parse an entry.
if (Error E = YAMLParser.parseYAMLElement(*CurrentIt)) {
// Set the iterator to the end, in case the user calls getNext again.
Impl.YAMLIt = Impl.YAMLParser.Stream.end();
return std::move(E);
// Move on.
// Return the just-parsed remark.
if (const Optional<YAMLRemarkParser::ParseState> &State = YAMLParser.State)
return &State->TheRemark;
return createStringError(std::make_error_code(std::errc::invalid_argument),
"unexpected error while parsing.");
Expected<const Remark *> Parser::getNext() const {
if (auto *Impl = dyn_cast<YAMLParserImpl>(this->Impl.get()))
return getNextYAML(*Impl);
llvm_unreachable("Get next called with an unknown parsing implementation.");
// Create wrappers for C Binding types (see CBindingWrapping.h).
extern "C" LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
uint64_t Size) {
return wrap(
new remarks::Parser(StringRef(static_cast<const char *>(Buf), Size)));
static void handleYAMLError(remarks::YAMLParserImpl &Impl, Error E) {
[&](const YAMLParseError &PE) {
Twine(PE.getMessage()) + Twine('\n'));
[&](const ErrorInfoBase &EIB) { EIB.log(Impl.YAMLParser.ErrorStream); });
Impl.HasErrors = true;
extern "C" LLVMRemarkEntryRef
LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
remarks::Parser &TheParser = *unwrap(Parser);
Expected<const remarks::Remark *> RemarkOrErr = TheParser.getNext();
if (!RemarkOrErr) {
// Error during parsing.
if (auto *Impl = dyn_cast<remarks::YAMLParserImpl>(TheParser.Impl.get()))
handleYAMLError(*Impl, RemarkOrErr.takeError());
llvm_unreachable("unkown parser implementation.");
return nullptr;
if (*RemarkOrErr == nullptr)
return nullptr;
// Valid remark.
return wrap(*RemarkOrErr);
extern "C" LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser) {
if (auto *Impl =
return Impl->HasErrors;
llvm_unreachable("unkown parser implementation.");
extern "C" const char *
LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser) {
if (auto *Impl =
return Impl->YAMLParser.ErrorStream.str().c_str();
llvm_unreachable("unkown parser implementation.");
extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {
delete unwrap(Parser);