mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-04 02:42:49 -04:00
547 lines
17 KiB
C++
547 lines
17 KiB
C++
// Filename: xFileDataDef.cxx
|
|
// Created by: drose (03Oct04)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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 "xFileDataDef.h"
|
|
#include "indent.h"
|
|
#include "xLexerDefs.h"
|
|
#include "xFileParseData.h"
|
|
#include "xFileDataObjectInteger.h"
|
|
#include "xFileDataObjectDouble.h"
|
|
#include "xFileDataObjectString.h"
|
|
#include "xFileDataNodeTemplate.h"
|
|
#include "xFileDataObjectArray.h"
|
|
#include "string_utils.h"
|
|
|
|
TypeHandle XFileDataDef::_type_handle;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::Destructor
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
XFileDataDef::
|
|
~XFileDataDef() {
|
|
clear();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::clear
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
void XFileDataDef::
|
|
clear() {
|
|
XFileNode::clear();
|
|
_array_def.clear();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::add_array_def
|
|
// Access: Public
|
|
// Description: Adds an additional array dimension to the data
|
|
// description.
|
|
////////////////////////////////////////////////////////////////////
|
|
void XFileDataDef::
|
|
add_array_def(const XFileArrayDef &array_def) {
|
|
_array_def.push_back(array_def);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::write_text
|
|
// Access: Public, Virtual
|
|
// Description: Writes a suitable representation of this node to an
|
|
// .x file in text mode.
|
|
////////////////////////////////////////////////////////////////////
|
|
void XFileDataDef::
|
|
write_text(ostream &out, int indent_level) const {
|
|
indent(out, indent_level);
|
|
|
|
if (!_array_def.empty()) {
|
|
out << "array ";
|
|
}
|
|
|
|
switch (_type) {
|
|
case T_word:
|
|
out << "WORD";
|
|
break;
|
|
|
|
case T_dword:
|
|
out << "DWORD";
|
|
break;
|
|
|
|
case T_float:
|
|
out << "FLOAT";
|
|
break;
|
|
|
|
case T_double:
|
|
out << "DOUBLE";
|
|
break;
|
|
|
|
case T_char:
|
|
out << "CHAR";
|
|
break;
|
|
|
|
case T_uchar:
|
|
out << "UCHAR";
|
|
break;
|
|
|
|
case T_sword:
|
|
out << "SWORD";
|
|
break;
|
|
|
|
case T_sdword:
|
|
out << "SDWORD";
|
|
break;
|
|
|
|
case T_string:
|
|
out << "STRING";
|
|
break;
|
|
|
|
case T_cstring:
|
|
out << "CSTRING";
|
|
break;
|
|
|
|
case T_unicode:
|
|
out << "UNICODE";
|
|
break;
|
|
|
|
case T_template:
|
|
out << _template->get_name();
|
|
break;
|
|
}
|
|
|
|
if (has_name()) {
|
|
out << " " << get_name();
|
|
}
|
|
|
|
ArrayDef::const_iterator ai;
|
|
for (ai = _array_def.begin(); ai != _array_def.end(); ++ai) {
|
|
(*ai).output(out);
|
|
}
|
|
|
|
out << ";\n";
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::repack_data
|
|
// Access: Public, Virtual
|
|
// Description: This is called on the template that defines an
|
|
// object, once the data for the object has been parsed.
|
|
// It is responsible for identifying which component of
|
|
// the template owns each data element, and packing the
|
|
// data elements appropriately back into the object.
|
|
//
|
|
// It returns true on success, or false on an error
|
|
// (e.g. too many semicolons, not enough data elements,
|
|
// mismatched data type).
|
|
////////////////////////////////////////////////////////////////////
|
|
bool XFileDataDef::
|
|
repack_data(XFileDataObject *object,
|
|
const XFileParseDataList &parse_data_list,
|
|
XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index) const {
|
|
if (index >= parse_data_list._list.size()) {
|
|
xyyerror("Not enough data elements in structure.");
|
|
return false;
|
|
}
|
|
|
|
// We'll fill this in with the data value we pack, if any.
|
|
PT(XFileDataObject) data_value;
|
|
|
|
// What kind of data element are we expecting?
|
|
switch (_type) {
|
|
case T_word:
|
|
case T_dword:
|
|
case T_char:
|
|
case T_uchar:
|
|
case T_sword:
|
|
case T_sdword:
|
|
// Expected integer data.
|
|
data_value = unpack_value(parse_data_list, 0,
|
|
prev_data, index, sub_index,
|
|
&XFileDataDef::unpack_integer_value);
|
|
break;
|
|
|
|
case T_float:
|
|
case T_double:
|
|
data_value = unpack_value(parse_data_list, 0,
|
|
prev_data, index, sub_index,
|
|
&XFileDataDef::unpack_double_value);
|
|
break;
|
|
|
|
case T_string:
|
|
case T_cstring:
|
|
case T_unicode:
|
|
data_value = unpack_value(parse_data_list, 0,
|
|
prev_data, index, sub_index,
|
|
&XFileDataDef::unpack_string_value);
|
|
break;
|
|
|
|
case T_template:
|
|
data_value = unpack_value(parse_data_list, 0,
|
|
prev_data, index, sub_index,
|
|
&XFileDataDef::unpack_template_value);
|
|
break;
|
|
}
|
|
|
|
if (data_value != (XFileDataObject *)NULL) {
|
|
object->add_element(data_value);
|
|
prev_data[this] = data_value;
|
|
}
|
|
|
|
return XFileNode::repack_data(object, parse_data_list,
|
|
prev_data, index, sub_index);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::fill_zero_data
|
|
// Access: Public, Virtual
|
|
// Description: This is similar to repack_data(), except it is used
|
|
// to fill the initial values for a newly-created
|
|
// template object to zero.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool XFileDataDef::
|
|
fill_zero_data(XFileDataObject *object) const {
|
|
PT(XFileDataObject) data_value;
|
|
|
|
// What kind of data element are we expecting?
|
|
switch (_type) {
|
|
case T_word:
|
|
case T_dword:
|
|
case T_char:
|
|
case T_uchar:
|
|
case T_sword:
|
|
case T_sdword:
|
|
data_value = zero_fill_value(0, &XFileDataDef::zero_fill_integer_value);
|
|
break;
|
|
|
|
case T_float:
|
|
case T_double:
|
|
data_value = zero_fill_value(0, &XFileDataDef::zero_fill_double_value);
|
|
break;
|
|
|
|
case T_string:
|
|
case T_cstring:
|
|
case T_unicode:
|
|
data_value = zero_fill_value(0, &XFileDataDef::zero_fill_string_value);
|
|
break;
|
|
|
|
case T_template:
|
|
data_value = zero_fill_value(0, &XFileDataDef::zero_fill_template_value);
|
|
break;
|
|
}
|
|
|
|
if (data_value != (XFileDataObject *)NULL) {
|
|
object->add_element(data_value);
|
|
}
|
|
|
|
return XFileNode::fill_zero_data(object);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::matches
|
|
// Access: Public, Virtual
|
|
// Description: Returns true if the node, particularly a template
|
|
// node, is structurally equivalent to the other node
|
|
// (which must be of the same type). This checks data
|
|
// element types, but does not compare data element
|
|
// names.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool XFileDataDef::
|
|
matches(const XFileNode *other) const {
|
|
if (!XFileNode::matches(other)) {
|
|
return false;
|
|
}
|
|
|
|
const XFileDataDef *data_def = DCAST(XFileDataDef, other);
|
|
if (data_def->get_data_type() != get_data_type()) {
|
|
return false;
|
|
}
|
|
|
|
if (get_data_type() == T_template &&
|
|
!get_template()->matches(data_def->get_template())) {
|
|
return false;
|
|
}
|
|
|
|
if (data_def->get_num_array_defs() != get_num_array_defs()) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < get_num_array_defs(); i++) {
|
|
if (!get_array_def(i).matches(data_def->get_array_def(i),
|
|
this, data_def)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::unpack_integer_value
|
|
// Access: Private
|
|
// Description: Unpacks and returns the next sequential integer value
|
|
// from the parse_data_list.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
unpack_integer_value(const XFileParseDataList &parse_data_list,
|
|
const XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index) const {
|
|
nassertr(index < parse_data_list._list.size(), NULL);
|
|
const XFileParseData &parse_data = parse_data_list._list[index];
|
|
|
|
PT(XFileDataObject) data_value;
|
|
|
|
if ((parse_data._parse_flags & XFileParseData::PF_int) != 0) {
|
|
nassertr(sub_index < parse_data._int_list.size(), false);
|
|
int value = parse_data._int_list[sub_index];
|
|
data_value = new XFileDataObjectInteger(this, value);
|
|
|
|
sub_index++;
|
|
if (sub_index >= parse_data._int_list.size()) {
|
|
index++;
|
|
sub_index = 0;
|
|
}
|
|
|
|
} else {
|
|
parse_data.yyerror("Expected integer data for " + get_name());
|
|
}
|
|
|
|
return data_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::unpack_double_value
|
|
// Access: Private
|
|
// Description: Unpacks and returns the next sequential double value
|
|
// from the parse_data_list.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
unpack_double_value(const XFileParseDataList &parse_data_list,
|
|
const XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index) const {
|
|
nassertr(index < parse_data_list._list.size(), NULL);
|
|
const XFileParseData &parse_data = parse_data_list._list[index];
|
|
|
|
PT(XFileDataObject) data_value;
|
|
|
|
if ((parse_data._parse_flags & XFileParseData::PF_double) != 0) {
|
|
nassertr(sub_index < parse_data._double_list.size(), false);
|
|
double value = parse_data._double_list[sub_index];
|
|
data_value = new XFileDataObjectDouble(this, value);
|
|
|
|
sub_index++;
|
|
if (sub_index >= parse_data._double_list.size()) {
|
|
index++;
|
|
sub_index = 0;
|
|
}
|
|
|
|
} else if ((parse_data._parse_flags & XFileParseData::PF_int) != 0) {
|
|
nassertr(sub_index < parse_data._int_list.size(), false);
|
|
int value = parse_data._int_list[sub_index];
|
|
data_value = new XFileDataObjectDouble(this, value);
|
|
|
|
sub_index++;
|
|
if (sub_index >= parse_data._int_list.size()) {
|
|
index++;
|
|
sub_index = 0;
|
|
}
|
|
|
|
} else {
|
|
parse_data.yyerror("Expected floating-point data for " + get_name());
|
|
}
|
|
|
|
return data_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::unpack_string_value
|
|
// Access: Private
|
|
// Description: Unpacks and returns the next sequential string value
|
|
// from the parse_data_list.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
unpack_string_value(const XFileParseDataList &parse_data_list,
|
|
const XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index) const {
|
|
nassertr(index < parse_data_list._list.size(), NULL);
|
|
const XFileParseData &parse_data = parse_data_list._list[index];
|
|
|
|
PT(XFileDataObject) data_value;
|
|
|
|
if ((parse_data._parse_flags & XFileParseData::PF_string) != 0) {
|
|
data_value = new XFileDataObjectString(this, parse_data._string);
|
|
index++;
|
|
sub_index = 0;
|
|
|
|
} else {
|
|
parse_data.yyerror("Expected string data for " + get_name());
|
|
}
|
|
|
|
return data_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::unpack_template_value
|
|
// Access: Private
|
|
// Description: Unpacks a nested template object's data.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
unpack_template_value(const XFileParseDataList &parse_data_list,
|
|
const XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index) const {
|
|
PT(XFileDataNodeTemplate) data_value =
|
|
new XFileDataNodeTemplate(get_x_file(), get_name(), _template);
|
|
|
|
PrevData nested_prev_data(prev_data);
|
|
if (!_template->repack_data(data_value, parse_data_list,
|
|
nested_prev_data, index, sub_index)) {
|
|
return NULL;
|
|
}
|
|
|
|
return data_value.p();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::unpack_value
|
|
// Access: Private
|
|
// Description: Unpacks and returns the next sequential value, of the
|
|
// type supported by the unpack_method. If the value
|
|
// is an array type, unpacks all the elements of the
|
|
// array.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
unpack_value(const XFileParseDataList &parse_data_list, int array_index,
|
|
const XFileDataDef::PrevData &prev_data,
|
|
size_t &index, size_t &sub_index,
|
|
XFileDataDef::UnpackMethod unpack_method) const {
|
|
PT(XFileDataObject) data_value;
|
|
|
|
if (array_index == (int)_array_def.size()) {
|
|
data_value = (this->*unpack_method)(parse_data_list, prev_data,
|
|
index, sub_index);
|
|
|
|
} else {
|
|
data_value = new XFileDataObjectArray(this);
|
|
int array_size = _array_def[array_index].get_size(prev_data);
|
|
|
|
for (int i = 0; i < array_size; i++) {
|
|
if (index >= parse_data_list._list.size()) {
|
|
xyyerror(string("Expected ") + format_string(array_size)
|
|
+ " array elements, found " + format_string(i));
|
|
return data_value;
|
|
}
|
|
|
|
PT(XFileDataObject) array_element =
|
|
unpack_value(parse_data_list, array_index + 1,
|
|
prev_data, index, sub_index,
|
|
unpack_method);
|
|
if (array_element == (XFileDataObject *)NULL) {
|
|
return NULL;
|
|
}
|
|
data_value->add_element(array_element);
|
|
}
|
|
}
|
|
|
|
return data_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::zero_fill_integer_value
|
|
// Access: Private
|
|
// Description: Returns a newly-allocated zero integer value.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
zero_fill_integer_value() const {
|
|
return new XFileDataObjectInteger(this, 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::zero_fill_double_value
|
|
// Access: Private
|
|
// Description: Returns a newly-allocated zero floating-point value.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
zero_fill_double_value() const {
|
|
return new XFileDataObjectDouble(this, 0.0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::zero_fill_string_value
|
|
// Access: Private
|
|
// Description: Returns a newly-allocated empty string value.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
zero_fill_string_value() const {
|
|
return new XFileDataObjectString(this, "");
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::zero_fill_template_value
|
|
// Access: Private
|
|
// Description: Returns a newly-allocated zero-filled nested template
|
|
// value.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
zero_fill_template_value() const {
|
|
PT(XFileDataObject) data_value =
|
|
new XFileDataNodeTemplate(get_x_file(), get_name(), _template);
|
|
if (!_template->fill_zero_data(data_value)) {
|
|
return NULL;
|
|
}
|
|
|
|
return data_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: XFileDataDef::zero_fill_value
|
|
// Access: Private
|
|
// Description: Creates a zero-valued element for the next sequential
|
|
// value, of the type returned by the zero_fill_method.
|
|
// If the value is a fixed-size array type, zero-fills
|
|
// all the elements of the array.
|
|
////////////////////////////////////////////////////////////////////
|
|
PT(XFileDataObject) XFileDataDef::
|
|
zero_fill_value(int array_index,
|
|
XFileDataDef::ZeroFillMethod zero_fill_method) const {
|
|
PT(XFileDataObject) data_value;
|
|
|
|
if (array_index == (int)_array_def.size()) {
|
|
data_value = (this->*zero_fill_method)();
|
|
|
|
} else {
|
|
data_value = new XFileDataObjectArray(this);
|
|
int array_size = 0;
|
|
if (_array_def[array_index].is_fixed_size()) {
|
|
array_size = _array_def[array_index].get_fixed_size();
|
|
}
|
|
|
|
for (int i = 0; i < array_size; i++) {
|
|
PT(XFileDataObject) array_element =
|
|
zero_fill_value(array_index + 1, zero_fill_method);
|
|
if (array_element == (XFileDataObject *)NULL) {
|
|
return NULL;
|
|
}
|
|
data_value->add_element(array_element);
|
|
}
|
|
}
|
|
|
|
return data_value;
|
|
}
|