rodecomp/Recovered/jsoncons/include/jsoncons/source.hpp
ragnarok-clanker 9b9c369f0c Move exe-only code to Recovered/ and rebuild virtualised PakAuxiliary::Extract
Recovered/ holds the code linked only into the standalone exe (scripts/exe/build_exe.py), outside the Clank source dirs:
- jsoncons/ and nProtect/ moved from scripts/exe/; GameGuard stand-in follows main's renamed entry points.
- GPak/PakAuxiliary.cpp: Extract (virtualised in every build; 02-19 jumps out at 0x0065861E) rebuilt from the open GRF Editor decoder, after the visible 02-19 prologue; inline key and kRO keys 1-4. Apply traps (unreachable in 02-19).
- GGHash/GGHash.cpp: CGGHash::Load/Check/VerifyHash trap (RagHash.dat check unreachable in 02-19).
The whole client links: 984 units, 0 unresolved.
2026-11-06 19:33:10 +01:00

793 lines
23 KiB
C++

// Copyright 2013-2023 Daniel Parker
// Distributed under the Boost license, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See https://github.com/danielaparker/jsoncons for latest version
#ifndef JSONCONS_SOURCE_HPP
#define JSONCONS_SOURCE_HPP
#include <stdexcept>
#include <string>
#include <vector>
#include <istream>
#include <memory> // std::addressof
#include <cstring> // std::memcpy
#include <exception>
#include <iterator>
#include <type_traits> // std::enable_if
#include <jsoncons/config/jsoncons_config.hpp>
#include <jsoncons/byte_string.hpp> // jsoncons::byte_traits
#include <jsoncons/extension_traits.hpp>
namespace jsoncons {
template <class CharT>
class basic_null_istream : public std::basic_istream<CharT>
{
class null_buffer : public std::basic_streambuf<CharT>
{
null_buffer(const null_buffer&) = delete;
null_buffer& operator=(const null_buffer&) = delete;
public:
using typename std::basic_streambuf<CharT>::int_type;
using typename std::basic_streambuf<CharT>::traits_type;
null_buffer() = default;
null_buffer(null_buffer&&) = default;
null_buffer& operator=(null_buffer&&) = default;
int_type overflow( int_type ch = typename std::basic_streambuf<CharT>::traits_type::eof() ) override
{
return ch;
}
} nb_;
public:
basic_null_istream()
: std::basic_istream<CharT>(&nb_)
{
}
basic_null_istream(const null_buffer&) = delete;
basic_null_istream& operator=(const null_buffer&) = delete;
basic_null_istream(basic_null_istream&&) noexcept
: std::basic_istream<CharT>(&nb_)
{
}
basic_null_istream& operator=(basic_null_istream&&) noexcept
{
return *this;
}
};
template <class CharT>
struct char_result
{
CharT value;
bool eof;
};
// text sources
template <class CharT>
class stream_source
{
static constexpr std::size_t default_max_buffer_size = 16384;
public:
using value_type = CharT;
private:
using char_type = typename std::conditional<sizeof(CharT) == sizeof(char),char,CharT>::type;
basic_null_istream<char_type> null_is_;
std::basic_istream<char_type>* stream_ptr_;
std::basic_streambuf<char_type>* sbuf_;
std::size_t position_;
std::vector<value_type> buffer_;
const value_type* buffer_data_;
std::size_t buffer_length_;
// Noncopyable
stream_source(const stream_source&) = delete;
stream_source& operator=(const stream_source&) = delete;
public:
stream_source()
: stream_ptr_(&null_is_), sbuf_(null_is_.rdbuf()), position_(0),
buffer_(1), buffer_data_(buffer_.data()), buffer_length_(0)
{
}
stream_source(std::basic_istream<char_type>& is, std::size_t buf_size = default_max_buffer_size)
: stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()), position_(0),
buffer_(buf_size), buffer_data_(buffer_.data()), buffer_length_(0)
{
}
stream_source(stream_source&& other) noexcept
: stream_ptr_(&null_is_), sbuf_(null_is_.rdbuf()), position_(0),
buffer_(), buffer_data_(buffer_.data()), buffer_length_(0)
{
if (other.stream_ptr_ != &other.null_is_)
{
stream_ptr_ = other.stream_ptr_;
sbuf_ = other.sbuf_;
position_ = other.position_;
buffer_ = std::move(other.buffer_);
buffer_data_ = buffer_.data() + (other.buffer_data_ - other.buffer_.data());
buffer_length_ = other.buffer_length_;
other = stream_source();
}
}
~stream_source()
{
}
stream_source& operator=(stream_source&& other) noexcept
{
if (other.stream_ptr_ != &other.null_is_)
{
stream_ptr_ = other.stream_ptr_;
sbuf_ = other.sbuf_;
position_ = other.position_;
buffer_ = std::move(other.buffer_);
buffer_data_ = buffer_.data() + (other.buffer_data_ - other.buffer_.data());
buffer_length_ = other.buffer_length_;
other = stream_source();
}
else
{
stream_ptr_ = &null_is_;
sbuf_ = null_is_.rdbuf();
position_ = 0;
buffer_data_ = buffer_.data();
buffer_length_ = 0;
}
return *this;
}
bool eof() const
{
return buffer_length_ == 0 && stream_ptr_->eof();
}
bool is_error() const
{
return stream_ptr_->bad();
}
std::size_t position() const
{
return position_;
}
void ignore(std::size_t length)
{
std::size_t len = 0;
if (buffer_length_ > 0)
{
len = (std::min)(buffer_length_, length);
position_ += len;
buffer_data_ += len;
buffer_length_ -= len;
}
while (len < length)
{
fill_buffer();
if (buffer_length_ == 0)
{
break;
}
std::size_t len2 = (std::min)(buffer_length_, length-len);
position_ += len2;
buffer_data_ += len2;
buffer_length_ -= len2;
len += len2;
}
}
char_result<value_type> peek()
{
if (buffer_length_ == 0)
{
fill_buffer();
}
if (buffer_length_ > 0)
{
value_type c = *buffer_data_;
return char_result<value_type>{c, false};
}
else
{
return char_result<value_type>{0, true};
}
}
span<const value_type> read_buffer()
{
if (buffer_length_ == 0)
{
fill_buffer();
}
const value_type* data = buffer_data_;
std::size_t length = buffer_length_;
buffer_data_ += buffer_length_;
position_ += buffer_length_;
buffer_length_ = 0;
return span<const value_type>(data, length);
}
std::size_t read(value_type* p, std::size_t length)
{
std::size_t len = 0;
if (buffer_length_ > 0)
{
len = (std::min)(buffer_length_, length);
std::memcpy(p, buffer_data_, len*sizeof(value_type));
buffer_data_ += len;
buffer_length_ -= len;
position_ += len;
}
if (length - len == 0)
{
return len;
}
else if (length - len < buffer_.size())
{
fill_buffer();
if (buffer_length_ > 0)
{
std::size_t len2 = (std::min)(buffer_length_, length-len);
std::memcpy(p+len, buffer_data_, len2*sizeof(value_type));
buffer_data_ += len2;
buffer_length_ -= len2;
position_ += len2;
len += len2;
}
return len;
}
else
{
if (stream_ptr_->eof())
{
buffer_length_ = 0;
return 0;
}
JSONCONS_TRY
{
std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
std::size_t len2 = static_cast<std::size_t>(count);
if (len2 < length-len)
{
stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
}
len += len2;
position_ += len2;
return len;
}
JSONCONS_CATCH(const std::exception&)
{
stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
return 0;
}
}
}
private:
void fill_buffer()
{
if (stream_ptr_->eof())
{
buffer_length_ = 0;
return;
}
buffer_data_ = buffer_.data();
JSONCONS_TRY
{
std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_.data()), buffer_.size());
buffer_length_ = static_cast<std::size_t>(count);
if (buffer_length_ < buffer_.size())
{
stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
}
}
JSONCONS_CATCH(const std::exception&)
{
stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
buffer_length_ = 0;
}
}
};
// string_source
template <class CharT>
class string_source
{
public:
using value_type = CharT;
using string_view_type = jsoncons::basic_string_view<value_type>;
private:
const value_type* data_;
const value_type* current_;
const value_type* end_;
// Noncopyable
string_source(const string_source&) = delete;
string_source& operator=(const string_source&) = delete;
public:
string_source()
: data_(nullptr), current_(nullptr), end_(nullptr)
{
}
template <class Sourceable>
string_source(const Sourceable& s,
typename std::enable_if<extension_traits::is_sequence_of<Sourceable,value_type>::value>::type* = 0)
: data_(s.data()), current_(s.data()), end_(s.data()+s.size())
{
}
string_source(const value_type* data)
: data_(data), current_(data), end_(data+std::char_traits<value_type>::length(data))
{
}
string_source(string_source&& val) = default;
string_source& operator=(string_source&& val) = default;
bool eof() const
{
return current_ == end_;
}
bool is_error() const
{
return false;
}
std::size_t position() const
{
return (current_ - data_)/sizeof(value_type);
}
void ignore(std::size_t count)
{
std::size_t len;
if ((std::size_t)(end_ - current_) < count)
{
len = end_ - current_;
}
else
{
len = count;
}
current_ += len;
}
char_result<value_type> peek()
{
return current_ < end_ ? char_result<value_type>{*current_, false} : char_result<value_type>{0, true};
}
span<const value_type> read_buffer()
{
const value_type* data = current_;
std::size_t length = end_ - current_;
current_ = end_;
return span<const value_type>(data, length);
}
std::size_t read(value_type* p, std::size_t length)
{
std::size_t len;
if ((std::size_t)(end_ - current_) < length)
{
len = end_ - current_;
}
else
{
len = length;
}
std::memcpy(p, current_, len*sizeof(value_type));
current_ += len;
return len;
}
};
// iterator source
template <class IteratorT>
class iterator_source
{
public:
using value_type = typename std::iterator_traits<IteratorT>::value_type;
private:
static constexpr std::size_t default_max_buffer_size = 16384;
IteratorT current_;
IteratorT end_;
std::size_t position_;
std::vector<value_type> buffer_;
std::size_t buffer_length_;
using difference_type = typename std::iterator_traits<IteratorT>::difference_type;
using iterator_category = typename std::iterator_traits<IteratorT>::iterator_category;
// Noncopyable
iterator_source(const iterator_source&) = delete;
iterator_source& operator=(const iterator_source&) = delete;
public:
iterator_source(const IteratorT& first, const IteratorT& last, std::size_t buf_size = default_max_buffer_size)
: current_(first), end_(last), position_(0), buffer_(buf_size), buffer_length_(0)
{
}
iterator_source(iterator_source&& other) = default;
iterator_source& operator=(iterator_source&& other) = default;
bool eof() const
{
return !(current_ != end_);
}
bool is_error() const
{
return false;
}
std::size_t position() const
{
return position_;
}
void ignore(std::size_t count)
{
while (count-- > 0 && current_ != end_)
{
++position_;
++current_;
}
}
char_result<value_type> peek()
{
return current_ != end_ ? char_result<value_type>{*current_, false} : char_result<value_type>{0, true};
}
span<const value_type> read_buffer()
{
if (buffer_length_ == 0)
{
buffer_length_ = read(buffer_.data(), buffer_.size());
}
std::size_t length = buffer_length_;
buffer_length_ = 0;
return span<const value_type>(buffer_.data(), length);
}
template <class Category = iterator_category>
typename std::enable_if<std::is_same<Category,std::random_access_iterator_tag>::value, std::size_t>::type
read(value_type* data, std::size_t length)
{
std::size_t count = (std::min)(length, static_cast<std::size_t>(std::distance(current_, end_)));
//JSONCONS_COPY(current_, current_ + count, data);
auto end = current_ + count;
value_type* p = data;
while (current_ != end)
{
*p++ = *current_++;
}
//current_ += count;
position_ += count;
return count;
}
template <class Category = iterator_category>
typename std::enable_if<!std::is_same<Category,std::random_access_iterator_tag>::value, std::size_t>::type
read(value_type* data, std::size_t length)
{
value_type* p = data;
value_type* pend = data + length;
while (p < pend && current_ != end_)
{
*p = static_cast<value_type>(*current_);
++p;
++current_;
}
position_ += (p - data);
return p - data;
}
};
// binary sources
using binary_stream_source = stream_source<uint8_t>;
class bytes_source
{
public:
typedef uint8_t value_type;
private:
const value_type* data_;
const value_type* current_;
const value_type* end_;
// Noncopyable
bytes_source(const bytes_source&) = delete;
bytes_source& operator=(const bytes_source&) = delete;
public:
bytes_source()
: data_(nullptr), current_(nullptr), end_(nullptr)
{
}
template <class Sourceable>
bytes_source(const Sourceable& source,
typename std::enable_if<extension_traits::is_byte_sequence<Sourceable>::value,int>::type = 0)
: data_(reinterpret_cast<const value_type*>(source.data())),
current_(data_),
end_(data_+source.size())
{
}
bytes_source(bytes_source&&) = default;
bytes_source& operator=(bytes_source&&) = default;
bool eof() const
{
return current_ == end_;
}
bool is_error() const
{
return false;
}
std::size_t position() const
{
return current_ - data_;
}
void ignore(std::size_t count)
{
std::size_t len;
if ((std::size_t)(end_ - current_) < count)
{
len = end_ - current_;
}
else
{
len = count;
}
current_ += len;
}
char_result<value_type> peek()
{
return current_ < end_ ? char_result<value_type>{*current_, false} : char_result<value_type>{0, true};
}
span<const value_type> read_buffer()
{
const value_type* data = current_;
std::size_t length = end_ - current_;
current_ = end_;
return span<const value_type>(data, length);
}
std::size_t read(value_type* p, std::size_t length)
{
std::size_t len;
if ((std::size_t)(end_ - current_) < length)
{
len = end_ - current_;
}
else
{
len = length;
}
std::memcpy(p, current_, len*sizeof(value_type));
current_ += len;
return len;
}
};
// binary_iterator source
template <class IteratorT>
class binary_iterator_source
{
public:
using value_type = uint8_t;
private:
static constexpr std::size_t default_max_buffer_size = 16384;
IteratorT current_;
IteratorT end_;
std::size_t position_;
std::vector<value_type> buffer_;
std::size_t buffer_length_;
using difference_type = typename std::iterator_traits<IteratorT>::difference_type;
using iterator_category = typename std::iterator_traits<IteratorT>::iterator_category;
// Noncopyable
binary_iterator_source(const binary_iterator_source&) = delete;
binary_iterator_source& operator=(const binary_iterator_source&) = delete;
public:
binary_iterator_source(const IteratorT& first, const IteratorT& last, std::size_t buf_size = default_max_buffer_size)
: current_(first), end_(last), position_(0), buffer_(buf_size), buffer_length_(0)
{
}
binary_iterator_source(binary_iterator_source&& other) = default;
binary_iterator_source& operator=(binary_iterator_source&& other) = default;
bool eof() const
{
return !(current_ != end_);
}
bool is_error() const
{
return false;
}
std::size_t position() const
{
return position_;
}
void ignore(std::size_t count)
{
while (count-- > 0 && current_ != end_)
{
++position_;
++current_;
}
}
char_result<value_type> peek()
{
return current_ != end_ ? char_result<value_type>{static_cast<value_type>(*current_), false} : char_result<value_type>{0, true};
}
span<const value_type> read_buffer()
{
if (buffer_length_ == 0)
{
buffer_length_ = read(buffer_.data(), buffer_.size());
}
std::size_t length = buffer_length_;
buffer_length_ = 0;
return span<const value_type>(buffer_.data(), length);
}
template <class Category = iterator_category>
typename std::enable_if<std::is_same<Category,std::random_access_iterator_tag>::value, std::size_t>::type
read(value_type* data, std::size_t length)
{
std::size_t count = (std::min)(length, static_cast<std::size_t>(std::distance(current_, end_)));
//JSONCONS_COPY(current_, current_ + count, data);
auto end = current_ + count;
value_type* p = data;
while (current_ != end)
{
*p++ = *current_++;
}
//current_ += count;
position_ += count;
return count;
}
template <class Category = iterator_category>
typename std::enable_if<!std::is_same<Category,std::random_access_iterator_tag>::value, std::size_t>::type
read(value_type* data, std::size_t length)
{
value_type* p = data;
value_type* pend = data + length;
while (p < pend && current_ != end_)
{
*p = static_cast<value_type>(*current_);
++p;
++current_;
}
position_ += (p - data);
return p - data;
}
};
template <class Source>
struct source_reader
{
using value_type = typename Source::value_type;
static constexpr std::size_t max_buffer_length = 16384;
template <class Container>
static
typename std::enable_if<std::is_convertible<value_type,typename Container::value_type>::value &&
extension_traits::has_reserve<Container>::value &&
extension_traits::has_data_exact<value_type*,Container>::value
, std::size_t>::type
read(Source& source, Container& v, std::size_t length)
{
std::size_t unread = length;
std::size_t n = (std::min)(max_buffer_length, unread);
while (n > 0 && !source.eof())
{
std::size_t offset = v.size();
v.resize(v.size()+n);
std::size_t actual = source.read(v.data()+offset, n);
unread -= actual;
n = (std::min)(max_buffer_length, unread);
}
return length - unread;
}
template <class Container>
static
typename std::enable_if<std::is_convertible<value_type,typename Container::value_type>::value &&
extension_traits::has_reserve<Container>::value &&
!extension_traits::has_data_exact<value_type*, Container>::value
, std::size_t>::type
read(Source& source, Container& v, std::size_t length)
{
std::size_t unread = length;
std::size_t n = (std::min)(max_buffer_length, unread);
while (n > 0 && !source.eof())
{
v.reserve(v.size()+n);
std::size_t actual = 0;
while (actual < n)
{
typename Source::value_type c;
if (source.read(&c,1) != 1)
{
break;
}
v.push_back(c);
++actual;
}
unread -= actual;
n = (std::min)(max_buffer_length, unread);
}
return length - unread;
}
};
template <class Source>
constexpr std::size_t source_reader<Source>::max_buffer_length;
#if !defined(JSONCONS_NO_DEPRECATED)
using bin_stream_source = binary_stream_source;
#endif
} // namespace jsoncons
#endif