42c8742e0e
This consolidates some of the error handling around regex arguments to the tool, and sets up the APIs such that errors must be handled before their usage.
97 lines
3.6 KiB
C++
97 lines
3.6 KiB
C++
//===- RemarkUtilHelpers.cpp ----------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Helpers for remark utilites
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include "RemarkUtilHelpers.h"
|
|
|
|
namespace llvm {
|
|
namespace remarks {
|
|
/// \returns A MemoryBuffer for the input file on success, and an Error
|
|
/// otherwise.
|
|
Expected<std::unique_ptr<MemoryBuffer>>
|
|
getInputMemoryBuffer(StringRef InputFileName) {
|
|
auto MaybeBuf = MemoryBuffer::getFileOrSTDIN(InputFileName);
|
|
if (auto ErrorCode = MaybeBuf.getError())
|
|
return createStringError(ErrorCode,
|
|
Twine("Cannot open file '" + InputFileName +
|
|
"': " + ErrorCode.message()));
|
|
return std::move(*MaybeBuf);
|
|
}
|
|
|
|
/// \returns A ToolOutputFile which can be used for outputting the results of
|
|
/// some tool mode.
|
|
/// \p OutputFileName is the desired destination.
|
|
/// \p Flags controls whether or not the file is opened for writing in text
|
|
/// mode, as a binary, etc. See sys::fs::OpenFlags for more detail.
|
|
Expected<std::unique_ptr<ToolOutputFile>>
|
|
getOutputFileWithFlags(StringRef OutputFileName, sys::fs::OpenFlags Flags) {
|
|
if (OutputFileName == "")
|
|
OutputFileName = "-";
|
|
std::error_code ErrorCode;
|
|
auto OF = std::make_unique<ToolOutputFile>(OutputFileName, ErrorCode, Flags);
|
|
if (ErrorCode)
|
|
return errorCodeToError(ErrorCode);
|
|
return std::move(OF);
|
|
}
|
|
|
|
/// \returns A ToolOutputFile which can be used for writing remarks on success,
|
|
/// and an Error otherwise.
|
|
/// \p OutputFileName is the desired destination.
|
|
/// \p OutputFormat
|
|
Expected<std::unique_ptr<ToolOutputFile>>
|
|
getOutputFileForRemarks(StringRef OutputFileName, Format OutputFormat) {
|
|
assert((OutputFormat == Format::YAML || OutputFormat == Format::Bitstream) &&
|
|
"Expected one of YAML or Bitstream!");
|
|
return getOutputFileWithFlags(OutputFileName, OutputFormat == Format::YAML
|
|
? sys::fs::OF_TextWithCRLF
|
|
: sys::fs::OF_None);
|
|
}
|
|
|
|
Expected<FilterMatcher>
|
|
FilterMatcher::createRE(const llvm::cl::opt<std::string> &Arg) {
|
|
return createRE(Arg.ArgStr, Arg);
|
|
}
|
|
|
|
Expected<FilterMatcher>
|
|
FilterMatcher::createRE(StringRef Filter, const cl::list<std::string> &Arg) {
|
|
return createRE(Arg.ArgStr, Filter);
|
|
}
|
|
|
|
Expected<FilterMatcher> FilterMatcher::createRE(StringRef Arg,
|
|
StringRef Value) {
|
|
FilterMatcher FM(Value, true);
|
|
std::string Error;
|
|
if (!FM.FilterRE.isValid(Error))
|
|
return createStringError(make_error_code(std::errc::invalid_argument),
|
|
"invalid argument '--" + Arg + "=" + Value +
|
|
"': " + Error);
|
|
return std::move(FM);
|
|
}
|
|
|
|
Expected<std::optional<FilterMatcher>>
|
|
FilterMatcher::createExactOrRE(const llvm::cl::opt<std::string> &ExactArg,
|
|
const llvm::cl::opt<std::string> &REArg) {
|
|
if (!ExactArg.empty() && !REArg.empty())
|
|
return createStringError(make_error_code(std::errc::invalid_argument),
|
|
"conflicting arguments: --" + ExactArg.ArgStr +
|
|
" and --" + REArg.ArgStr);
|
|
|
|
if (!ExactArg.empty())
|
|
return createExact(ExactArg);
|
|
|
|
if (!REArg.empty())
|
|
return createRE(REArg);
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
} // namespace remarks
|
|
} // namespace llvm
|