parse_rds.hpp

Go to the documentation of this file.

#ifndef RDS2CPP_PARSE_HPP
#define RDS2CPP_PARSE_HPP
 
#include <memory>
#include <stdexcept>
#include <cstdint>
 
#include "RdsFile.hpp"
#include "utils_parse.hpp"
#include "SharedParseInfo.hpp"
#include "parse_object.hpp"
 
#include "byteme/byteme.hpp"
#include "sanisizer/sanisizer.hpp"
 
namespace rds2cpp {
 
struct ParseRdsOptions {
    bool parallel = false;
 
    std::size_t buffer_size = sanisizer::cap<std::size_t>(65536);
};
 
template<class Reader_>
RdsFile parse_rds(Reader_& reader, const ParseRdsOptions& 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; 
 
    RdsFile output;
 
    {
        try {
            std::string header(2, '\0');
            quick_extract(src, 2, reinterpret_cast<unsigned char*>(header.data()));
            if (header != "X\n") {
                throw std::runtime_error("only RDS files in XDR format are currently supported");
            }
        } catch (std::exception& e) {
            throw traceback("failed to read the header from the RDS 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 RDS preamble", e);
        } 
 
        try {
            output.writer_version = parse_version(src);
        } catch (std::exception& e) {
            throw traceback("failed to read the writer version number from the RDS preamble", e);
        }
 
        try {
            output.reader_version = parse_version(src);
        } catch (std::exception& e) {
            throw traceback("failed to read the reader version number from the RDS 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 RDS 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 RDS preamble", e);
        }
    }
 
    // Now we can finally read the damn object.
    SharedParseInfo shared;
    output.object = parse_object(src, shared);
    output.environments = std::move(shared.environments);
    output.symbols = std::move(shared.symbols);
    output.external_pointers = std::move(shared.external_pointers);
 
    return output;
}
 
inline RdsFile parse_rds(std::string file, const ParseRdsOptions& options) {
    byteme::GzipFileReader reader(file.c_str(), {});
    return parse_rds(reader, options);
}
 
typedef RdsFile Parsed;
 
}
 
#endif