KOKO\Mimi
268 lines
9.6 KiB
C++
268 lines
9.6 KiB
C++
#include "fesa/io/abaqus/input_reader.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <iterator>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <system_error>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace fesa {
|
|
namespace {
|
|
|
|
std::filesystem::path NormalizedPath(const std::filesystem::path& path) {
|
|
std::error_code error;
|
|
const auto absolute = std::filesystem::absolute(path, error);
|
|
return (error ? path : absolute).lexically_normal();
|
|
}
|
|
|
|
bool IsAsciiWhitespace(char value) noexcept {
|
|
return value == ' ' || value == '\t' || value == '\r' || value == '\n' ||
|
|
value == '\f' || value == '\v';
|
|
}
|
|
|
|
bool IsAllowedInputCharacter(unsigned char value) noexcept {
|
|
return value == '\t' || (value >= 0x20U && value <= 0x7eU);
|
|
}
|
|
|
|
std::string Trim(std::string_view text) {
|
|
while (!text.empty() && IsAsciiWhitespace(text.front())) {
|
|
text.remove_prefix(1U);
|
|
}
|
|
while (!text.empty() && IsAsciiWhitespace(text.back())) {
|
|
text.remove_suffix(1U);
|
|
}
|
|
return std::string{text};
|
|
}
|
|
|
|
std::string UppercaseAscii(std::string value) {
|
|
std::transform(value.begin(), value.end(), value.begin(), [](char character) {
|
|
if (character >= 'a' && character <= 'z') {
|
|
return static_cast<char>(character - 'a' + 'A');
|
|
}
|
|
return character;
|
|
});
|
|
return value;
|
|
}
|
|
|
|
std::vector<std::string> SplitFields(std::string_view line) {
|
|
std::vector<std::string> fields;
|
|
std::size_t field_start = 0U;
|
|
while (true) {
|
|
const std::size_t separator = line.find(',', field_start);
|
|
if (separator == std::string_view::npos) {
|
|
fields.push_back(Trim(line.substr(field_start)));
|
|
break;
|
|
}
|
|
fields.push_back(Trim(line.substr(field_start, separator - field_start)));
|
|
field_start = separator + 1U;
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
bool IsKeywordContinuation(std::string_view trimmed_line) noexcept {
|
|
return !trimmed_line.empty() && trimmed_line.back() == ',';
|
|
}
|
|
|
|
bool AppendKeywordParameters(KeywordBlock& block,
|
|
const std::vector<std::string>& fields,
|
|
std::size_t first_field,
|
|
bool has_continuation) {
|
|
if (has_continuation && fields.empty()) {
|
|
return false;
|
|
}
|
|
const std::size_t field_count =
|
|
has_continuation ? fields.size() - 1U : fields.size();
|
|
if (field_count < first_field) {
|
|
return false;
|
|
}
|
|
for (std::size_t index = first_field; index < field_count; ++index) {
|
|
const std::string& field = fields[index];
|
|
if (field.empty()) {
|
|
return false;
|
|
}
|
|
|
|
const std::size_t equals = field.find('=');
|
|
const std::string parameter_name =
|
|
Trim(std::string_view{field}.substr(0U, equals));
|
|
if (parameter_name.empty()) {
|
|
return false;
|
|
}
|
|
|
|
KeywordParameter parameter{UppercaseAscii(parameter_name), std::nullopt};
|
|
if (equals != std::string::npos) {
|
|
parameter.value = Trim(std::string_view{field}.substr(equals + 1U));
|
|
}
|
|
block.parameters.push_back(std::move(parameter));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// @brief Computes the stable identity of the exact source bytes.
|
|
/// @note This runs before line-ending handling so parser provenance is not
|
|
/// affected by text normalization.
|
|
std::string ContentIdentity(const std::string& bytes) {
|
|
constexpr std::uint64_t kOffsetBasis = 14695981039346656037ULL;
|
|
constexpr std::uint64_t kPrime = 1099511628211ULL;
|
|
std::uint64_t hash = kOffsetBasis;
|
|
// Hash the binary input before CRLF handling so provenance follows the
|
|
// exact file bytes rather than a normalized text representation.
|
|
for (const unsigned char byte : bytes) {
|
|
hash ^= static_cast<std::uint64_t>(byte);
|
|
hash *= kPrime;
|
|
}
|
|
|
|
std::ostringstream formatted;
|
|
formatted << "fnv1a64:" << std::hex << std::setfill('0') << std::setw(16)
|
|
<< hash;
|
|
return formatted.str();
|
|
}
|
|
|
|
Result<ParsedInput> Failure(const std::filesystem::path& source_path,
|
|
std::size_t line, std::string code,
|
|
std::string keyword, std::string message) {
|
|
Diagnostic diagnostic{Severity::kError,
|
|
std::move(code),
|
|
{source_path, line},
|
|
std::move(keyword),
|
|
"",
|
|
std::move(message)};
|
|
return Result<ParsedInput>::Failure(
|
|
Status::Failure(FailureCategory::kInput, {std::move(diagnostic)}));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Result<ParsedInput> AbaqusInputReader::Read(
|
|
const std::filesystem::path& input_path) const {
|
|
const auto source_path = NormalizedPath(input_path);
|
|
std::ifstream stream{source_path, std::ios::binary};
|
|
if (!stream) {
|
|
return Failure(source_path, 0U, "input-file-unreadable", "",
|
|
"The Abaqus input file could not be opened for reading.");
|
|
}
|
|
|
|
const std::string bytes{std::istreambuf_iterator<char>{stream},
|
|
std::istreambuf_iterator<char>{}};
|
|
if (stream.bad()) {
|
|
return Failure(source_path, 0U, "input-file-unreadable", "",
|
|
"The Abaqus input file could not be read completely.");
|
|
}
|
|
|
|
struct PhysicalLine {
|
|
std::string original_line;
|
|
std::string trimmed_line;
|
|
std::size_t line_number;
|
|
};
|
|
|
|
std::vector<PhysicalLine> physical_lines;
|
|
std::size_t line_start = 0U;
|
|
std::size_t line_number = 1U;
|
|
while (line_start < bytes.size()) {
|
|
const std::size_t newline = bytes.find('\n', line_start);
|
|
const std::size_t line_end =
|
|
newline == std::string::npos ? bytes.size() : newline;
|
|
std::string original_line = bytes.substr(line_start, line_end - line_start);
|
|
if (!original_line.empty() && original_line.back() == '\r') {
|
|
original_line.pop_back();
|
|
}
|
|
if (original_line.size() > 256U) {
|
|
return Failure(source_path, line_number, "input-line-too-long", "",
|
|
"Each physical input line is limited to 256 ASCII bytes.");
|
|
}
|
|
for (const unsigned char character : original_line) {
|
|
if (!IsAllowedInputCharacter(character)) {
|
|
return Failure(source_path, line_number, "invalid-input-character", "",
|
|
"Input lines must use printable 7-bit ASCII or tabs.");
|
|
}
|
|
}
|
|
|
|
physical_lines.push_back(
|
|
{original_line, Trim(original_line), line_number});
|
|
|
|
if (newline == std::string::npos) {
|
|
break;
|
|
}
|
|
line_start = newline + 1U;
|
|
++line_number;
|
|
}
|
|
|
|
ParsedInput parsed{source_path, ContentIdentity(bytes), {}};
|
|
for (std::size_t line_index = 0U; line_index < physical_lines.size();
|
|
++line_index) {
|
|
const PhysicalLine& line = physical_lines[line_index];
|
|
const std::string& trimmed_line = line.trimmed_line;
|
|
if (!trimmed_line.empty() && trimmed_line.rfind("**", 0U) != 0U) {
|
|
if (trimmed_line.front() == '*') {
|
|
const auto fields = SplitFields(trimmed_line);
|
|
const std::string keyword_text =
|
|
fields.empty() ? std::string{}
|
|
: Trim(std::string_view{fields[0]}.substr(1U));
|
|
if (keyword_text.empty()) {
|
|
return Failure(source_path, line.line_number, "malformed-keyword",
|
|
trimmed_line,
|
|
"A keyword line requires a non-empty keyword name.");
|
|
}
|
|
|
|
KeywordBlock block{UppercaseAscii(keyword_text),
|
|
line.original_line,
|
|
{line.original_line},
|
|
{},
|
|
{},
|
|
{source_path, line.line_number}};
|
|
bool continuation = IsKeywordContinuation(trimmed_line);
|
|
if (!AppendKeywordParameters(block, fields, 1U, continuation)) {
|
|
return Failure(source_path, line.line_number, "malformed-keyword",
|
|
block.canonical_name,
|
|
"A keyword parameter name cannot be empty.");
|
|
}
|
|
|
|
while (continuation) {
|
|
++line_index;
|
|
if (line_index >= physical_lines.size()) {
|
|
return Failure(source_path, line.line_number, "malformed-keyword",
|
|
block.canonical_name,
|
|
"A keyword continuation requires a following line.");
|
|
}
|
|
const PhysicalLine& continuation_line = physical_lines[line_index];
|
|
if (continuation_line.trimmed_line.empty() ||
|
|
continuation_line.trimmed_line.rfind("**", 0U) == 0U ||
|
|
continuation_line.trimmed_line.front() == '*') {
|
|
return Failure(source_path, continuation_line.line_number,
|
|
"malformed-keyword", block.canonical_name,
|
|
"A keyword continuation cannot be interrupted.");
|
|
}
|
|
const auto continuation_fields =
|
|
SplitFields(continuation_line.trimmed_line);
|
|
continuation =
|
|
IsKeywordContinuation(continuation_line.trimmed_line);
|
|
if (!AppendKeywordParameters(block, continuation_fields, 0U,
|
|
continuation)) {
|
|
return Failure(source_path, continuation_line.line_number,
|
|
"malformed-keyword", block.canonical_name,
|
|
"A keyword parameter name cannot be empty.");
|
|
}
|
|
block.physical_lines.push_back(continuation_line.original_line);
|
|
}
|
|
parsed.blocks.push_back(std::move(block));
|
|
} else {
|
|
if (parsed.blocks.empty()) {
|
|
return Failure(source_path, line.line_number, "orphan-data-line", "",
|
|
"A data line must follow a keyword line.");
|
|
}
|
|
parsed.blocks.back().data.push_back(
|
|
{SplitFields(line.original_line), {source_path, line.line_number}});
|
|
}
|
|
}
|
|
}
|
|
|
|
return Result<ParsedInput>::Success(std::move(parsed));
|
|
}
|
|
|
|
} // namespace fesa
|