XFileDataObjectTemplate -> XFileDataNodeTemplate

pandatool/src/xfile/Sources.pp

@@ -23,9 +23,9 @@
      xFileDataObjectArray.cxx xFileDataObjectArray.I xFileDataObjectArray.h \
      xFileDataObjectDouble.cxx xFileDataObjectDouble.I xFileDataObjectDouble.h \
      xFileDataObjectInteger.cxx xFileDataObjectInteger.I xFileDataObjectInteger.h \
-     xFileDataObjectTemplate.cxx xFileDataObjectTemplate.I xFileDataObjectTemplate.h \
      xFileDataNode.cxx xFileDataNode.I xFileDataNode.h \
      xFileDataNodeReference.cxx xFileDataNodeReference.I xFileDataNodeReference.h \
+     xFileDataNodeTemplate.cxx xFileDataNodeTemplate.I xFileDataNodeTemplate.h \
      xFileNode.cxx xFileNode.I xFileNode.h \
      xFileParseData.cxx xFileParseData.I xFileParseData.h \
      xFileTemplate.cxx xFileTemplate.I xFileTemplate.h

pandatool/src/xfile/config_xfile.cxx

@@ -23,9 +23,9 @@
 #include "xFileDataObjectArray.h"
 #include "xFileDataObjectDouble.h"
 #include "xFileDataObjectInteger.h"
-#include "xFileDataObjectTemplate.h"
 #include "xFileDataNode.h"
 #include "xFileDataNodeReference.h"
+#include "xFileDataNodeTemplate.h"
 #include "xFileNode.h"
 #include "xFileTemplate.h"
 
@@ -66,9 +66,9 @@ init_libxfile() {
   XFileDataObjectArray::init_type();
   XFileDataObjectDouble::init_type();
   XFileDataObjectInteger::init_type();
-  XFileDataObjectTemplate::init_type();
   XFileDataNode::init_type();
   XFileDataNodeReference::init_type();
+  XFileDataNodeTemplate::init_type();
   XFileNode::init_type();
   XFileTemplate::init_type();
 }

pandatool/src/xfile/xFile.cxx

@@ -20,7 +20,7 @@
 #include "xParserDefs.h"
 #include "xLexerDefs.h"
 #include "xFileTemplate.h"
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "config_xfile.h"
 #include "standard_templates.h"
 #include "zStream.h"
@@ -250,12 +250,12 @@ find_template(const WindowsGuid &guid) const {
 //  Description: Returns the data object associated with the indicated
 //               name, if any, or NULL if none.
 ////////////////////////////////////////////////////////////////////
-XFileDataObjectTemplate *XFile::
+XFileDataNodeTemplate *XFile::
 find_data_object(const string &name) const {
   XFileNode *child = find_descendent(name);
   if (child != (XFileNode *)NULL &&
-      child->is_of_type(XFileDataObjectTemplate::get_class_type())) {
-    return DCAST(XFileDataObjectTemplate, child);
+      child->is_of_type(XFileDataNodeTemplate::get_class_type())) {
+    return DCAST(XFileDataNodeTemplate, child);
   }
 
   return NULL;
@@ -267,13 +267,13 @@ find_data_object(const string &name) const {
 //  Description: Returns the data object associated with the indicated
 //               GUID, if any, or NULL if none.
 ////////////////////////////////////////////////////////////////////
-XFileDataObjectTemplate *XFile::
+XFileDataNodeTemplate *XFile::
 find_data_object(const WindowsGuid &guid) const {
   NodesByGuid::const_iterator gi;
   gi = _nodes_by_guid.find(guid);
   if (gi != _nodes_by_guid.end() && 
-      (*gi).second->is_of_type(XFileDataObjectTemplate::get_class_type())) {
-    return DCAST(XFileDataObjectTemplate, (*gi).second);
+      (*gi).second->is_of_type(XFileDataNodeTemplate::get_class_type())) {
+    return DCAST(XFileDataNodeTemplate, (*gi).second);
   }
 
   return NULL;

pandatool/src/xfile/xFile.h

@@ -27,7 +27,7 @@
 #include "pointerTo.h"
 
 class XFileTemplate;
-class XFileDataObjectTemplate;
+class XFileDataNodeTemplate;
 
 ////////////////////////////////////////////////////////////////////
 //       Class : XFile
@@ -51,8 +51,8 @@ public:
   XFileTemplate *find_template(const string &name) const;
   XFileTemplate *find_template(const WindowsGuid &guid) const;
 
-  XFileDataObjectTemplate *find_data_object(const string &name) const;
-  XFileDataObjectTemplate *find_data_object(const WindowsGuid &guid) const;
+  XFileDataNodeTemplate *find_data_object(const string &name) const;
+  XFileDataNodeTemplate *find_data_object(const WindowsGuid &guid) const;
 
   virtual void write_text(ostream &out, int indent_level) const;
 

pandatool/src/xfile/xFileDataDef.cxx

@@ -22,7 +22,7 @@
 #include "xFileParseData.h"
 #include "xFileDataObjectInteger.h"
 #include "xFileDataObjectDouble.h"
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "xFileDataObjectArray.h"
 
 TypeHandle XFileDataDef::_type_handle;
@@ -294,8 +294,8 @@ 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(XFileDataObjectTemplate) data_value = 
-    new XFileDataObjectTemplate(get_x_file(), get_name(), _template);
+  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, 

pandatool/src/xfile/xFileDataNodeReference.I

@@ -32,7 +32,7 @@ get_template() const {
 //       Access: Public
 //  Description: Returns the actual data object being referenced.
 ////////////////////////////////////////////////////////////////////
-INLINE XFileDataObjectTemplate *XFileDataNodeReference::
+INLINE XFileDataNodeTemplate *XFileDataNodeReference::
 get_object() const {
   return _object;
 }

pandatool/src/xfile/xFileDataNodeReference.cxx

@@ -27,7 +27,7 @@ TypeHandle XFileDataNodeReference::_type_handle;
 //  Description:
 ////////////////////////////////////////////////////////////////////
 XFileDataNodeReference::
-XFileDataNodeReference(XFileDataObjectTemplate *object) :
+XFileDataNodeReference(XFileDataNodeTemplate *object) :
   XFileDataNode(object->get_x_file(), object->get_name()),
   _object(object)
 {

pandatool/src/xfile/xFileDataNodeReference.h

@@ -20,7 +20,7 @@
 #define XFILEDATANODEREFERENCE_H
 
 #include "pandatoolbase.h"
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "pointerTo.h"
 
 ////////////////////////////////////////////////////////////////////
@@ -30,10 +30,10 @@
 ////////////////////////////////////////////////////////////////////
 class XFileDataNodeReference : public XFileDataNode {
 public:
-  XFileDataNodeReference(XFileDataObjectTemplate *object);
+  XFileDataNodeReference(XFileDataNodeTemplate *object);
 
   INLINE XFileTemplate *get_template() const;
-  INLINE XFileDataObjectTemplate *get_object() const;
+  INLINE XFileDataNodeTemplate *get_object() const;
 
   virtual bool is_complex_object() const;
 
@@ -45,7 +45,7 @@ protected:
   virtual const XFileDataObject *get_element(const string &name) const;
 
 private:
-  PT(XFileDataObjectTemplate) _object;
+  PT(XFileDataNodeTemplate) _object;
 
 public:
   static TypeHandle get_class_type() {

pandatool/src/xfile/xFileDataObjectTemplate.I → pandatool/src/xfile/xFileDataNodeTemplate.I

@@ -1,4 +1,4 @@
-// Filename: xFileDataObjectTemplate.I
+// Filename: xFileDataNodeTemplate.I
 // Created by:  drose (03Oct04)
 //
 ////////////////////////////////////////////////////////////////////
@@ -18,11 +18,11 @@
 
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::get_template
+//     Function: XFileDataNodeTemplate::get_template
 //       Access: Public
 //  Description: Returns the template used to define this data object.
 ////////////////////////////////////////////////////////////////////
-INLINE XFileTemplate *XFileDataObjectTemplate::
+INLINE XFileTemplate *XFileDataNodeTemplate::
 get_template() const {
   return _template;
 }

pandatool/src/xfile/xFileDataObjectTemplate.cxx → pandatool/src/xfile/xFileDataNodeTemplate.cxx

@@ -1,4 +1,4 @@
-// Filename: xFileDataObjectTemplate.cxx
+// Filename: xFileDataNodeTemplate.cxx
 // Created by:  drose (03Oct04)
 //
 ////////////////////////////////////////////////////////////////////
@@ -16,20 +16,20 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "indent.h"
 #include "xFileParseData.h"
 #include "xLexerDefs.h"
 
-TypeHandle XFileDataObjectTemplate::_type_handle;
+TypeHandle XFileDataNodeTemplate::_type_handle;
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::Constructor
+//     Function: XFileDataNodeTemplate::Constructor
 //       Access: Public
 //  Description:
 ////////////////////////////////////////////////////////////////////
-XFileDataObjectTemplate::
-XFileDataObjectTemplate(XFile *x_file, const string &name,
+XFileDataNodeTemplate::
+XFileDataNodeTemplate(XFile *x_file, const string &name,
                         XFileTemplate *xtemplate) :
   XFileDataNode(x_file, name),
   _template(xtemplate)
@@ -37,25 +37,25 @@ XFileDataObjectTemplate(XFile *x_file, const string &name,
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::is_complex_object
+//     Function: XFileDataNodeTemplate::is_complex_object
 //       Access: Public, Virtual
 //  Description: Returns true if this kind of data object is a complex
 //               object that can hold nested data elements, false
 //               otherwise.
 ////////////////////////////////////////////////////////////////////
-bool XFileDataObjectTemplate::
+bool XFileDataNodeTemplate::
 is_complex_object() const {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::add_parse_double
+//     Function: XFileDataNodeTemplate::add_parse_double
 //       Access: Public
 //  Description: Adds the indicated list of doubles as a data element
 //               encountered in the parser.  It will later be
 //               processed by finalize_parse_data().
 ////////////////////////////////////////////////////////////////////
-void XFileDataObjectTemplate::
+void XFileDataNodeTemplate::
 add_parse_double(PTA_double double_list) {
   XFileParseData pdata;
   pdata._double_list = double_list;
@@ -65,13 +65,13 @@ add_parse_double(PTA_double double_list) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::add_parse_int
+//     Function: XFileDataNodeTemplate::add_parse_int
 //       Access: Public
 //  Description: Adds the indicated list of ints as a data element
 //               encountered in the parser.  It will later be
 //               processed by finalize_parse_data().
 ////////////////////////////////////////////////////////////////////
-void XFileDataObjectTemplate::
+void XFileDataNodeTemplate::
 add_parse_int(PTA_int int_list) {
   XFileParseData pdata;
   pdata._int_list = int_list;
@@ -81,13 +81,13 @@ add_parse_int(PTA_int int_list) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::add_parse_string
+//     Function: XFileDataNodeTemplate::add_parse_string
 //       Access: Public
 //  Description: Adds the indicated string as a data element
 //               encountered in the parser.  It will later be
 //               processed by finalize_parse_data().
 ////////////////////////////////////////////////////////////////////
-void XFileDataObjectTemplate::
+void XFileDataNodeTemplate::
 add_parse_string(const string &str) {
   XFileParseData pdata;
   pdata._string = str;
@@ -97,7 +97,7 @@ add_parse_string(const string &str) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::finalize_parse_data
+//     Function: XFileDataNodeTemplate::finalize_parse_data
 //       Access: Public
 //  Description: Processes all of the data elements added by
 //               add_parse_*(), checks them for syntactic and semantic
@@ -105,7 +105,7 @@ add_parse_string(const string &str) {
 //               stores the appropriate child data elements.  Returns
 //               true on success, false if there is a mismatch.
 ////////////////////////////////////////////////////////////////////
-bool XFileDataObjectTemplate::
+bool XFileDataNodeTemplate::
 finalize_parse_data() {
   // Recursively walk through our template definition, while
   // simultaneously walking through the list of parse data elements we
@@ -128,26 +128,26 @@ finalize_parse_data() {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::add_element
+//     Function: XFileDataNodeTemplate::add_element
 //       Access: Public, Virtual
 //  Description: Adds the indicated element as a nested data element,
 //               if this data object type supports it.  Returns true
 //               if added successfully, false if the data object type
 //               does not support nested data elements.
 ////////////////////////////////////////////////////////////////////
-bool XFileDataObjectTemplate::
+bool XFileDataNodeTemplate::
 add_element(XFileDataObject *element) {
   _nested_elements.push_back(element);
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::write_text
+//     Function: XFileDataNodeTemplate::write_text
 //       Access: Public, Virtual
 //  Description: Writes a suitable representation of this node to an
 //               .x file in text mode.
 ////////////////////////////////////////////////////////////////////
-void XFileDataObjectTemplate::
+void XFileDataNodeTemplate::
 write_text(ostream &out, int indent_level) const {
   indent(out, indent_level)
     << _template->get_name();
@@ -167,12 +167,12 @@ write_text(ostream &out, int indent_level) const {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::write_data
+//     Function: XFileDataNodeTemplate::write_data
 //       Access: Public, Virtual
 //  Description: Writes a suitable representation of this node to an
 //               .x file in text mode.
 ////////////////////////////////////////////////////////////////////
-void XFileDataObjectTemplate::
+void XFileDataNodeTemplate::
 write_data(ostream &out, int indent_level, const char *separator) const {
   if (!_nested_elements.empty()) {
     bool indented = false;
@@ -217,36 +217,36 @@ write_data(ostream &out, int indent_level, const char *separator) const {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::get_num_elements
+//     Function: XFileDataNodeTemplate::get_num_elements
 //       Access: Protected, Virtual
 //  Description: Returns the number of nested data elements within the
 //               object.  This may be, e.g. the size of the array, if
 //               it is an array.
 ////////////////////////////////////////////////////////////////////
-int XFileDataObjectTemplate::
+int XFileDataNodeTemplate::
 get_num_elements() const {
   return _nested_elements.size();
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::get_element
+//     Function: XFileDataNodeTemplate::get_element
 //       Access: Protected, Virtual
 //  Description: Returns the nth nested data element within the
 //               object.
 ////////////////////////////////////////////////////////////////////
-const XFileDataObject *XFileDataObjectTemplate::
+const XFileDataObject *XFileDataNodeTemplate::
 get_element(int n) const {
   nassertr(n >= 0 && n < (int)_nested_elements.size(), NULL);
   return _nested_elements[n];
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: XFileDataObjectTemplate::get_element
+//     Function: XFileDataNodeTemplate::get_element
 //       Access: Protected, Virtual
 //  Description: Returns the nested data element within the
 //               object that has the indicated name.
 ////////////////////////////////////////////////////////////////////
-const XFileDataObject *XFileDataObjectTemplate::
+const XFileDataObject *XFileDataNodeTemplate::
 get_element(const string &name) const {
   return NULL;
 }

pandatool/src/xfile/xFileDataObjectTemplate.h → pandatool/src/xfile/xFileDataNodeTemplate.h

@@ -1,4 +1,4 @@
-// Filename: xFileDataObjectTemplate.h
+// Filename: xFileDataNodeTemplate.h
 // Created by:  drose (03Oct04)
 //
 ////////////////////////////////////////////////////////////////////
@@ -16,8 +16,8 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-#ifndef XFILEDATAOBJECTTEMPLATE_H
-#define XFILEDATAOBJECTTEMPLATE_H
+#ifndef XFILEDATANODETEMPLATE_H
+#define XFILEDATANODETEMPLATE_H
 
 #include "pandatoolbase.h"
 #include "xFileDataNode.h"
@@ -28,16 +28,16 @@
 #include "pta_double.h"
 
 ////////////////////////////////////////////////////////////////////
-//       Class : XFileDataObjectTemplate
+//       Class : XFileDataNodeTemplate
 // Description : A data element that represents a combination of
 //               multiple data elements as defined by a template.  The
 //               individual data elements of the template may be
 //               obtained by walking through the children of this
 //               object.
 ////////////////////////////////////////////////////////////////////
-class XFileDataObjectTemplate : public XFileDataNode {
+class XFileDataNodeTemplate : public XFileDataNode {
 public:
-  XFileDataObjectTemplate(XFile *x_file, const string &name,
+  XFileDataNodeTemplate(XFile *x_file, const string &name,
                           XFileTemplate *xtemplate);
 
   INLINE XFileTemplate *get_template() const;
@@ -74,7 +74,7 @@ public:
   }
   static void init_type() {
     XFileDataNode::init_type();
-    register_type(_type_handle, "XFileDataObjectTemplate",
+    register_type(_type_handle, "XFileDataNodeTemplate",
                   XFileDataNode::get_class_type());
   }
   virtual TypeHandle get_type() const {
@@ -86,7 +86,7 @@ private:
   static TypeHandle _type_handle;
 };
 
-#include "xFileDataObjectTemplate.I"
+#include "xFileDataNodeTemplate.I"
 
 #endif
   

pandatool/src/xfile/xFileParseData.h

@@ -29,10 +29,10 @@
 ////////////////////////////////////////////////////////////////////
 //       Class : XFileParseData
 // Description : This class is used to fill up the data into an
-//               XFileDataObjectTemplate object as the data values are
+//               XFileDataNodeTemplate object as the data values are
 //               parsed out of the X file.  It only has a temporary
 //               lifespan; it will be converted into actual data by
-//               XFileDataObjectTemplate::finalize_parse_data().
+//               XFileDataNodeTemplate::finalize_parse_data().
 ////////////////////////////////////////////////////////////////////
 class XFileParseData {
 public:

pandatool/src/xfile/xParser.cxx.prebuilt

@@ -50,7 +50,7 @@
 #include "xFileTemplate.h"
 #include "xFileDataDef.h"
 #include "xFileArrayDef.h"
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "xFileDataNodeReference.h"
 #include "pointerTo.h"
 #include "dcast.h"
@@ -1215,8 +1215,8 @@ case 49:
   if (xtemplate == (XFileTemplate *)NULL) {
     yyerror("Unknown template: " + yyvsp[-2].str);
   } else {
-    XFileDataObjectTemplate *templ = 
-      new XFileDataObjectTemplate(x_file, yyvsp[-1].str, xtemplate);
+    XFileDataNodeTemplate *templ = 
+      new XFileDataNodeTemplate(x_file, yyvsp[-1].str, xtemplate);
     current_node->add_child(templ);
     current_node = templ;
   }
@@ -1225,8 +1225,8 @@ case 49:
 case 50:
 #line 349 "xParser.yxx"
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->finalize_parse_data();
 
   yyval.u.node = current_node;
@@ -1249,24 +1249,24 @@ case 54:
 case 55:
 #line 375 "xParser.yxx"
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_int(yyvsp[0].int_list);
 }
     break;
 case 56:
 #line 381 "xParser.yxx"
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_double(yyvsp[0].double_list);
 }
     break;
 case 57:
 #line 387 "xParser.yxx"
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_string(yyvsp[-1].str);
 }
     break;
@@ -1278,7 +1278,7 @@ case 58:
 case 64:
 #line 416 "xParser.yxx"
 {
-  XFileDataObjectTemplate *data_object = x_file->find_data_object(yyvsp[0].str);
+  XFileDataNodeTemplate *data_object = x_file->find_data_object(yyvsp[0].str);
   if (data_object == (XFileDataObject *)NULL) {
     yyerror("Unknown data_object: " + yyvsp[0].str);
   }
@@ -1289,7 +1289,7 @@ case 64:
 case 65:
 #line 425 "xParser.yxx"
 {
-  XFileDataObjectTemplate *data_object = x_file->find_data_object(yyvsp[0].guid);
+  XFileDataNodeTemplate *data_object = x_file->find_data_object(yyvsp[0].guid);
   if (data_object == (XFileDataObject *)NULL) {
     yyerror("Unknown data_object: " + yyvsp[-1].str);
   } else {

pandatool/src/xfile/xParser.yxx

@@ -16,7 +16,7 @@
 #include "xFileTemplate.h"
 #include "xFileDataDef.h"
 #include "xFileArrayDef.h"
-#include "xFileDataObjectTemplate.h"
+#include "xFileDataNodeTemplate.h"
 #include "xFileDataNodeReference.h"
 #include "pointerTo.h"
 #include "dcast.h"
@@ -339,16 +339,16 @@ object:
   if (xtemplate == (XFileTemplate *)NULL) {
     yyerror("Unknown template: " + $1);
   } else {
-    XFileDataObjectTemplate *templ = 
-      new XFileDataObjectTemplate(x_file, $2, xtemplate);
+    XFileDataNodeTemplate *templ = 
+      new XFileDataNodeTemplate(x_file, $2, xtemplate);
     current_node->add_child(templ);
     current_node = templ;
   }
 }
 	optional_class_id data_parts_list TOKEN_CBRACE
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->finalize_parse_data();
 
   $$ = current_node;
@@ -373,20 +373,20 @@ data_part:
 }
         | integer_list
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_int($1);
 }
         | realnum_list
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_double($1);
 }
 	| string list_separator
 {
-  XFileDataObjectTemplate *current_template = 
-    DCAST(XFileDataObjectTemplate, current_node);
+  XFileDataNodeTemplate *current_template = 
+    DCAST(XFileDataNodeTemplate, current_node);
   current_template->add_parse_string($1);
 }
         | list_separator
@@ -414,7 +414,7 @@ list_separator:
 data_reference:
         name
 {
-  XFileDataObjectTemplate *data_object = x_file->find_data_object($1);
+  XFileDataNodeTemplate *data_object = x_file->find_data_object($1);
   if (data_object == (XFileDataObject *)NULL) {
     yyerror("Unknown data_object: " + $1);
   }
@@ -423,7 +423,7 @@ data_reference:
 }
 	| name class_id
 {
-  XFileDataObjectTemplate *data_object = x_file->find_data_object($2);
+  XFileDataNodeTemplate *data_object = x_file->find_data_object($2);
   if (data_object == (XFileDataObject *)NULL) {
     yyerror("Unknown data_object: " + $1);
   } else {