RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/direct/src/dcparser/dcPacker.cxx

871 lines
26 KiB
C++
Executable File
Raw Blame History

// Filename: dcPacker.cxx
// Created by: drose (15Jun04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
#include "dcPacker.h"
#include "dcParserDefs.h"
#include "dcLexerDefs.h"
////////////////////////////////////////////////////////////////////
// Function: DCPacker::Constructor
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
DCPacker::
DCPacker() {
_mode = M_idle;
_unpack_data = NULL;
_unpack_length = 0;
_owns_unpack_data = false;
_unpack_p = 0;
_root = NULL;
_catalog = NULL;
_live_catalog = NULL;
_current_field = NULL;
_current_parent = NULL;
_current_field_index = 0;
_num_nested_fields = 0;
_pack_error = false;
_range_error = false;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::Destructor
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
DCPacker::
~DCPacker() {
clear();
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::begin_pack
// Access: Published
// Description: Begins a packing session. The parameter is the DC
// object that describes the packing format; it may be a
// DCParameter or DCField.
////////////////////////////////////////////////////////////////////
void DCPacker::
begin_pack(const DCPackerInterface *root) {
nassertv(_mode == M_idle);
_mode = M_pack;
_pack_error = false;
_range_error = false;
_pack_data.clear();
_root = root;
_catalog = NULL;
_live_catalog = NULL;
_current_field = root;
_current_parent = NULL;
_current_field_index = 0;
_num_nested_fields = 0;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::end_pack
// Access: Published, Virtual
// Description: Finishes a packing session.
//
// The return value is true on success, or false if
// there has been some error during packing.
////////////////////////////////////////////////////////////////////
bool DCPacker::
end_pack() {
nassertr(_mode == M_pack, false);
_mode = M_idle;
if (!_stack.empty() || _current_field != NULL || _current_parent != NULL) {
_pack_error = true;
}
clear();
return !_pack_error && !_range_error;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::begin_unpack
// Access: Published
// Description: Begins an unpacking session. Unlike the other
// version of begin_unpack(), this version makes a copy
// of the data string.
////////////////////////////////////////////////////////////////////
void DCPacker::
begin_unpack(const string &data, const DCPackerInterface *root) {
_unpack_str = data;
begin_unpack(_unpack_str.data(), _unpack_str.length(), root);
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::begin_unpack
// Access: Public
// Description: Begins an unpacking session. The data pointer is
// used directly; the data buffer is not copied.
// Therefore, you must not delete or modify the data
// pointer until you call end_unpack().
////////////////////////////////////////////////////////////////////
void DCPacker::
begin_unpack(const char *data, size_t length,
const DCPackerInterface *root) {
nassertv(_mode == M_idle);
_mode = M_unpack;
_pack_error = false;
_range_error = false;
set_unpack_data(data, length, false);
_unpack_p = 0;
_root = root;
_catalog = NULL;
_live_catalog = NULL;
_current_field = root;
_current_parent = NULL;
_current_field_index = 0;
_num_nested_fields = 0;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::end_unpack
// Access: Published
// Description: Finishes the unpacking session.
//
// The return value is true on success, or false if
// there has been some error during unpacking (or if all
// fields have not been unpacked).
////////////////////////////////////////////////////////////////////
bool DCPacker::
end_unpack() {
nassertr(_mode == M_unpack, false);
_mode = M_idle;
if (!_stack.empty() || _current_field != NULL || _current_parent != NULL) {
// This happens if we have not unpacked all of the fields.
// However, this is not an error if we have called seek() during
// the unpack session (in which case the _catalog will be
// non-NULL). On the other hand, if the catalog is still NULL,
// then we have never called seek() and it is an error not to
// unpack all values.
if (_catalog == (DCPackerCatalog *)NULL) {
_pack_error = true;
}
}
clear();
return !_pack_error && !_range_error;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::begin_repack
// Access: Published
// Description: Begins an repacking session. Unlike the other
// version of begin_repack(), this version makes a copy
// of the data string.
////////////////////////////////////////////////////////////////////
void DCPacker::
begin_repack(const string &data, const DCPackerInterface *root) {
_unpack_str = data;
begin_repack(_unpack_str.data(), _unpack_str.length(), root);
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::begin_repack
// Access: Public
// Description: Begins an repacking session. The data pointer is
// used directly; the data buffer is not copied.
// Therefore, you must not delete or modify the data
// pointer until you call end_repack().
//
// When repacking, unlike in packing or unpacking modes,
// you may not walk through the fields from beginning to
// end, or even pack two consecutive fields at once.
// Instead, you must call seek() for each field you wish
// to modify and pack only that one field; then call
// seek() again to modify another field.
////////////////////////////////////////////////////////////////////
void DCPacker::
begin_repack(const char *data, size_t length,
const DCPackerInterface *root) {
nassertv(_mode == M_idle);
_mode = M_repack;
_pack_error = false;
_range_error = false;
set_unpack_data(data, length, false);
_unpack_p = 0;
// In repack mode, we immediately get the catalog, since we know
// we'll need it.
_root = root;
_catalog = _root->get_catalog();
_live_catalog = _catalog->get_live_catalog(_unpack_data, _unpack_length);
// We don't begin at the first field in repack mode. Instead, you
// must explicitly call seek().
_current_field = NULL;
_current_parent = NULL;
_current_field_index = 0;
_num_nested_fields = 0;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::end_repack
// Access: Published
// Description: Finishes the repacking session.
//
// The return value is true on success, or false if
// there has been some error during repacking (or if all
// fields have not been repacked).
////////////////////////////////////////////////////////////////////
bool DCPacker::
end_repack() {
nassertr(_mode == M_repack, false);
// Put the rest of the data onto the pack stream.
_pack_data.append_data(_unpack_data + _unpack_p, _unpack_length - _unpack_p);
_mode = M_idle;
clear();
return !_pack_error && !_range_error;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::seek
// Access: Published
// Description: Sets the current unpack (or repack) position to the
// named field. In unpack mode, the next call to
// unpack_*() or push() will begin to read the named
// field. In repack mode, the next call to pack_*() or
// push() will modify the named field.
//
// Returns true if successful, false if the field is not
// known (or if the packer is in an invalid mode).
////////////////////////////////////////////////////////////////////
bool DCPacker::
seek(const string &field_name) {
if (_mode == M_unpack) {
if (_catalog == (DCPackerCatalog *)NULL) {
_catalog = _root->get_catalog();
_live_catalog = _catalog->get_live_catalog(_unpack_data, _unpack_length);
}
nassertr(_catalog != (DCPackerCatalog *)NULL, false);
int entry_index = _catalog->find_entry_by_name(field_name);
if (entry_index < 0) {
// The field was not known.
_pack_error = true;
return false;
}
const DCPackerCatalog::Entry &entry = _catalog->get_entry(entry_index);
// If we are seeking, we don't need to remember our current stack
// position.
_stack.clear();
_current_field = entry._field;
_current_parent = entry._parent;
_current_field_index = entry._field_index;
_num_nested_fields = _current_parent->get_num_nested_fields();
_unpack_p = _live_catalog->get_begin(entry_index);
return true;
} else if (_mode == M_repack) {
nassertr(_catalog != (DCPackerCatalog *)NULL, false);
if (!_stack.empty() || _current_field != (DCPackerInterface *)NULL) {
// It is an error to reseek while the stack is nonempty--that
// means we haven't finished packing the current field.
_pack_error = true;
return false;
}
int entry_index = _catalog->find_entry_by_name(field_name);
if (entry_index < 0) {
// The field was not known.
_pack_error = true;
return false;
}
const DCPackerCatalog::Entry &entry = _catalog->get_entry(entry_index);
size_t begin = _live_catalog->get_begin(entry_index);
if (begin < _unpack_p) {
// Whoops, we are seeking fields out-of-order. That means we
// need to write the entire record and start again.
_pack_data.append_data(_unpack_data + _unpack_p, _unpack_length - _unpack_p);
size_t length = _pack_data.get_length();
char *buffer = _pack_data.take_data();
set_unpack_data(buffer, length, true);
_unpack_p = 0;
_catalog->release_live_catalog(_live_catalog);
_live_catalog = _catalog->get_live_catalog(_unpack_data, _unpack_length);
begin = _live_catalog->get_begin(entry_index);
}
// Now copy the bytes from _unpack_p to begin from the
// _unpack_data to the _pack_data. These are the bytes we just
// skipped over with the call to seek().
_pack_data.append_data(_unpack_data + _unpack_p, begin - _unpack_p);
// And set the packer up to pack the indicated field (but no
// subsequent fields).
_current_field = entry._field;
_current_parent = entry._parent;
_current_field_index = entry._field_index;
_num_nested_fields = 0; // this makes advance() stop after this field.
_unpack_p = _live_catalog->get_end(entry_index);
return true;
}
// Invalid mode.
_pack_error = true;
return false;
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::push
// Access: Published
// Description: Marks the beginning of a nested series of fields.
//
// This must be called before filling the elements of an
// array or the individual fields in a structure field.
// It must also be balanced by a matching pop().
//
// It is necessary to use push() / pop() only if
// has_nested_fields() returns true.
////////////////////////////////////////////////////////////////////
void DCPacker::
push() {
if (!has_nested_fields()) {
_pack_error = true;
} else {
StackElement element;
element._current_parent = _current_parent;
element._current_field_index = _current_field_index;
element._push_marker = _push_marker;
_stack.push_back(element);
_current_parent = _current_field;
// Now deal with the length prefix that might or might not be
// before a sequence of nested fields.
int num_nested_fields = _current_parent->get_num_nested_fields();
size_t length_bytes = _current_parent->get_num_length_bytes();
if (_mode == M_pack || _mode == M_repack) {
// Reserve length_bytes for when we figure out what the length
// is.
_push_marker = _pack_data.get_length();
_pack_data.append_junk(length_bytes);
} else if (_mode == M_unpack) {
// Read length_bytes to determine the end of this nested
// sequence.
_push_marker = 0;
if (length_bytes != 0) {
if (_unpack_p + length_bytes > _unpack_length) {
_pack_error = true;
} else {
size_t length;
if (length_bytes == 4) {
length = DCPackerInterface::do_unpack_uint32
(_unpack_data + _unpack_p);
_unpack_p += 4;
_push_marker = _unpack_p + length;
} else {
length = DCPackerInterface::do_unpack_uint16
(_unpack_data + _unpack_p);
_unpack_p += 2;
}
_push_marker = _unpack_p + length;
// The explicit length trumps the number of nested fields
// reported by get_num_nested_fields().
if (length == 0) {
num_nested_fields = 0;
} else {
num_nested_fields = _current_parent->calc_num_nested_fields(length);
}
}
}
} else {
_pack_error = true;
}
// Now point to the first field in the nested range.
_num_nested_fields = num_nested_fields;
_current_field_index = 0;
if (_num_nested_fields >= 0 &&
_current_field_index >= _num_nested_fields) {
_current_field = NULL;
} else {
_current_field = _current_parent->get_nested_field(_current_field_index);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::pop
// Access: Published
// Description: Marks the end of a nested series of fields.
//
// This must be called to match a previous push() only
// after all the expected number of nested fields have
// been packed. It is an error to call it too early, or
// too late.
////////////////////////////////////////////////////////////////////
void DCPacker::
pop() {
if (_current_field != NULL && _num_nested_fields >= 0) {
// Oops, didn't pack or unpack enough values.
_pack_error = true;
} else if (_mode == M_unpack && _push_marker != 0 &&
_unpack_p != _push_marker) {
// Didn't unpack the right number of values.
_pack_error = true;
}
if (_stack.empty()) {
// Unbalanced pop().
_pack_error = true;
} else {
if (!_current_parent->validate_num_nested_fields(_current_field_index)) {
// Incorrect number of nested elements.
_pack_error = true;
}
if (_mode == M_pack || _mode == M_repack) {
size_t length_bytes = _current_parent->get_num_length_bytes();
if (length_bytes != 0) {
// Now go back and fill in the length of the array.
size_t length = _pack_data.get_length() - _push_marker - length_bytes;
if (length_bytes == 4) {
DCPackerInterface::do_pack_uint32
(_pack_data.get_rewrite_pointer(_push_marker, 4), length);
} else {
DCPackerInterface::validate_uint_limits(length, 16, _range_error);
DCPackerInterface::do_pack_uint16
(_pack_data.get_rewrite_pointer(_push_marker, 2), length);
}
}
}
_current_field = _current_parent;
_current_parent = _stack.back()._current_parent;
_current_field_index = _stack.back()._current_field_index;
_push_marker = _stack.back()._push_marker;
_num_nested_fields = (_current_parent == NULL) ? 0 : _current_parent->get_num_nested_fields();
_stack.pop_back();
}
advance();
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::unpack_validate
// Access: Published
// Description: Internally unpacks the current numeric or string
// value and validates it against the type range limits,
// but does not return the value. If the current field
// contains nested fields, validates all of them.
////////////////////////////////////////////////////////////////////
void DCPacker::
unpack_validate() {
nassertv(_mode == M_unpack);
if (_current_field == NULL) {
_pack_error = true;
} else {
if (_current_field->unpack_validate(_unpack_data, _unpack_length, _unpack_p,
_pack_error, _range_error)) {
advance();
} else {
// If the single field couldn't be validated, try validating
// nested fields.
push();
while (more_nested_fields()) {
unpack_validate();
}
pop();
}
}
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::unpack_skip
// Access: Published
// Description: Skips the current field without unpacking it and
// advances to the next field. If the current field
// contains nested fields, skips all of them.
////////////////////////////////////////////////////////////////////
void DCPacker::
unpack_skip() {
nassertv(_mode == M_unpack);
if (_current_field == NULL) {
_pack_error = true;
} else if (_current_field->has_fixed_byte_size()) {
_unpack_p += _current_field->get_fixed_byte_size();
advance();
} else {
if (_current_field->unpack_skip(_unpack_data, _unpack_length, _unpack_p)) {
advance();
} else {
// If the single field couldn't be skipped, try skipping nested fields.
push();
while (more_nested_fields()) {
unpack_skip();
}
pop();
}
}
}
#ifdef HAVE_PYTHON
////////////////////////////////////////////////////////////////////
// Function: DCPacker::pack_object
// Access: Published
// Description: Packs the Python object of whatever type into the
// packer. Each numeric object and string object maps
// to the corresponding pack_value() call; a tuple or
// sequence maps to a push() followed by all of the
// tuple's contents followed by a pop().
////////////////////////////////////////////////////////////////////
void DCPacker::
pack_object(PyObject *object) {
nassertv(_mode == M_pack || _mode == M_repack);
PyObject *str = PyObject_Str(object);
Py_DECREF(str);
if (PyInt_Check(object)) {
pack_int(PyInt_AS_LONG(object));
} else if (PyFloat_Check(object)) {
pack_double(PyFloat_AS_DOUBLE(object));
} else if (PyLong_Check(object)) {
pack_int64(PyLong_AsLongLong(object));
} else if (PyString_Check(object) || PyUnicode_Check(object)) {
char *buffer;
int length;
PyString_AsStringAndSize(object, &buffer, &length);
if (buffer) {
pack_string(string(buffer, length));
}
} else if (PySequence_Check(object)) {
push();
int size = PySequence_Size(object);
for (int i = 0; i < size; i++) {
PyObject *element = PySequence_GetItem(object, i);
pack_object(element);
Py_DECREF(element);
}
pop();
}
}
#endif // HAVE_PYTHON
#ifdef HAVE_PYTHON
////////////////////////////////////////////////////////////////////
// Function: DCPacker::unpack_object
// Access: Published
// Description: Unpacks a Python object of the appropriate type from
// the stream for the current field. This may be an
// integer or a string for a simple field object; if the
// current field represents a list of fields it will be
// a tuple.
////////////////////////////////////////////////////////////////////
PyObject *DCPacker::
unpack_object() {
PyObject *object = NULL;
DCPackType pack_type = get_pack_type();
switch (pack_type) {
case PT_invalid:
object = Py_None;
unpack_skip();
break;
case PT_double:
{
double value = unpack_double();
object = PyFloat_FromDouble(value);
}
break;
case PT_int:
{
int value = unpack_int();
object = PyInt_FromLong(value);
}
break;
case PT_uint:
{
unsigned int value = unpack_uint();
if (value & 0x80000000) {
object = PyLong_FromUnsignedLong(value);
} else {
object = PyInt_FromLong(value);
}
}
break;
case PT_int64:
{
PN_int64 value = unpack_int64();
object = PyLong_FromLongLong(value);
}
break;
case PT_uint64:
{
PN_uint64 value = unpack_uint64();
object = PyLong_FromUnsignedLongLong(value);
}
break;
case PT_string:
{
string str = unpack_string();
object = PyString_FromStringAndSize(str.data(), str.size());
}
break;
default:
{
// First, build up a list from the nested objects.
object = PyList_New(0);
push();
while (more_nested_fields()) {
PyObject *element = unpack_object();
PyList_Append(object, element);
Py_DECREF(element);
}
pop();
if (pack_type != PT_array) {
// For these other kinds of objects, we'll convert the list
// into a tuple.
PyObject *tuple = PyList_AsTuple(object);
Py_DECREF(object);
object = tuple;
}
}
break;
}
return object;
}
#endif // HAVE_PYTHON
////////////////////////////////////////////////////////////////////
// Function: DCPacker::parse_and_pack
// Access: Published
// Description: Parses an object's value according to the DC file
// syntax (e.g. as a default value string) and packs it.
// Returns true on success, false on a parse error.
////////////////////////////////////////////////////////////////////
bool DCPacker::
parse_and_pack(const string &formatted_object) {
istringstream strm(formatted_object);
return parse_and_pack(strm);
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::parse_and_pack
// Access: Published
// Description: Parses an object's value according to the DC file
// syntax (e.g. as a default value string) and packs it.
// Returns true on success, false on a parse error.
////////////////////////////////////////////////////////////////////
bool DCPacker::
parse_and_pack(istream &in) {
dc_init_parser_parameter_value(in, "parse_and_pack", *this);
dcyyparse();
dc_cleanup_parser();
return (dc_error_count() == 0);
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::unpack_and_format
// Access: Published
// Description: Unpacks an object and formats its value into a syntax
// suitable for parsing in the dc file (e.g. as a
// default value), or as an input to parse_object.
////////////////////////////////////////////////////////////////////
string DCPacker::
unpack_and_format() {
ostringstream strm;
unpack_and_format(strm);
return strm.str();
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::unpack_and_format
// Access: Published
// Description: Unpacks an object and formats its value into a syntax
// suitable for parsing in the dc file (e.g. as a
// default value), or as an input to parse_object.
////////////////////////////////////////////////////////////////////
void DCPacker::
unpack_and_format(ostream &out) {
DCPackType pack_type = get_pack_type();
switch (pack_type) {
case PT_invalid:
out << "<invalid>";
break;
case PT_double:
out << unpack_double();
break;
case PT_int:
out << unpack_int();
break;
case PT_uint:
out << unpack_uint();
break;
case PT_int64:
out << unpack_int64();
break;
case PT_uint64:
out << unpack_uint64();
break;
case PT_string:
out << '"' << unpack_string() << '"';
break;
default:
{
switch (pack_type) {
case PT_array:
out << '[';
break;
case PT_field:
out << '(';
break;
case PT_class:
default:
out << '{';
break;
}
push();
while (more_nested_fields()) {
unpack_and_format(out);
if (more_nested_fields()) {
out << ", ";
}
}
pop();
switch (pack_type) {
case PT_array:
out << ']';
break;
case PT_field:
out << ')';
break;
case PT_class:
default:
out << '}';
break;
}
}
break;
}
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::clear
// Access: Private
// Description: Resets the data structures after a pack or unpack
// sequence.
////////////////////////////////////////////////////////////////////
void DCPacker::
clear() {
_stack.clear();
_current_field = NULL;
_current_parent = NULL;
_current_field_index = 0;
_num_nested_fields = 0;
if (_live_catalog != (DCPackerCatalog::LiveCatalog *)NULL) {
_catalog->release_live_catalog(_live_catalog);
_live_catalog = NULL;
}
_catalog = NULL;
_root = NULL;
set_unpack_data(NULL, 0, false);
}
////////////////////////////////////////////////////////////////////
// Function: DCPacker::set_unpack_data
// Access: Private
// Description: Sets up the unpack_data pointer.
////////////////////////////////////////////////////////////////////
void DCPacker::
set_unpack_data(const char *unpack_data, size_t unpack_length,
bool owns_unpack_data) {
if (_owns_unpack_data) {
delete[] _unpack_data;
}
_unpack_data = unpack_data;
_unpack_length = unpack_length;
_owns_unpack_data = owns_unpack_data;
}
Reference in New Issue View Git Blame Copy Permalink