parse_rda.hpp

Go to the documentation of this file.

#ifndef RDS2CPP_PARSE_RDA_HPP
#define RDS2CPP_PARSE_RDA_HPP
 
#include <memory>
#include <stdexcept>
#include <cstdint>
 
#include "RdaFile.hpp"
#include "utils_parse.hpp"
#include "SharedParseInfo.hpp"
#include "parse_pairlist.hpp"
 
#include "byteme/byteme.hpp"
#include "sanisizer/sanisizer.hpp"
 
namespace rds2cpp {
 
struct ParseRdaOptions {
    bool parallel = false;
 
    std::size_t buffer_size = sanisizer::cap<std::size_t>(65536);
};
 
template<class Reader_>
RdaFile parse_rda(Reader_& reader, const ParseRdaOptions& options) {
    std::unique_ptr<byteme::BufferedReader<unsigned char> > srcptr;
    if (options.parallel) {
        srcptr.reset(new byteme::SerialBufferedReader<unsigned char, Reader_*>(&reader, options.buffer_size));
    } else {
        srcptr.reset(new byteme::ParallelBufferedReader<unsigned char, Reader_*>(&reader, options.buffer_size));
    }
    auto& src = *srcptr; 
 
    RdaFile output;
 
    {
        try {
            std::string header(5, '\0');
            quick_extract(src, 5, reinterpret_cast<unsigned char*>(header.data()));
            if (header != "RDX2\n" && header != "RDX3\n") {
                throw std::runtime_error("only RDX2 or RDX3 formats are currently supported");
            }
 
            header.resize(2);
            quick_extract(src, 2, reinterpret_cast<unsigned char*>(header.data()));
            if (header != "X\n") {
                throw std::runtime_error("only RDA files in XDR format are currently supported");
            }
        } catch (std::exception& e) {
            throw traceback("failed to read the header from the RDA preamble", e);
        }
 
        output.format_version = 0;
        try {
            output.format_version = quick_integer<I<decltype(output.format_version)> >(src);
        } catch (std::exception& e) {
            throw traceback("failed to read the format version number from the RDA preamble", e);
        } 
 
        try {
            output.writer_version = parse_version(src);
        } catch (std::exception& e) {
            throw traceback("failed to read the writer version number from the RDA preamble", e);
        }
 
        try {
            output.reader_version = parse_version(src);
        } catch (std::exception& e) {
            throw traceback("failed to read the reader version number from the RDA preamble", e);
        }
    }
 
    // Reading this undocumented section about the string encoding.
    {
        std::int32_t encoding_length = 0;
        try {
            encoding_length = quick_integer<I<decltype(encoding_length)> >(src);
            if (encoding_length < 0) {
                throw std::runtime_error("encoding length should be non-negative");
            }
        } catch (std::exception& e) {
            throw traceback("failed to read the encoding length from the RDA preamble", e);
        }
 
        try {
            auto encoding = sanisizer::create<std::string>(encoding_length, '\0');
            quick_extract(src, encoding_length, reinterpret_cast<unsigned char*>(encoding.data()));
            output.encoding = string_encoding_from_name(encoding);
        } catch (std::exception& e) {
            throw traceback("failed to read the encoding string from the RDA preamble", e);
        }
    }
 
    // Now we can finally read the damn object.
    SharedParseInfo shared;
 
    auto details = parse_header(src);
    auto sexp_type = details[3];
    if (sexp_type != static_cast<unsigned char>(SEXPType::LIST)) {
        throw std::runtime_error("expected RDA file to contain a pairlist");
    }
 
    auto payload = parse_pairlist_body(src, details, shared);
    output.objects.reserve(payload->data.size());
    for (auto& x : payload->data) {
        if (!x.tag.has_value()) {
            throw std::runtime_error("expected RDA file to contain a tagged pairlist");
        }
        output.objects.emplace_back(std::move(*(x.tag)), std::move(x.value));
    }
 
    output.environments = std::move(shared.environments);
    output.symbols = std::move(shared.symbols);
    output.external_pointers = std::move(shared.external_pointers);
 
    return output;
}
 
inline RdaFile parse_rda(std::string file, const ParseRdaOptions& options) {
    byteme::GzipFileReader reader(file.c_str(), {});
    return parse_rda(reader, options);
}
 
}
 
#endif