diff --git a/direct/src/dcparse/Makefile.gnu b/direct/src/dcparse/Makefile.gnu index e8ccff4bb9..5fe25bf4c8 100644 --- a/direct/src/dcparse/Makefile.gnu +++ b/direct/src/dcparse/Makefile.gnu @@ -1,12 +1,12 @@ OFILES = \ dcParser.o dcLexer.o \ - dcAtomicField.o dcClass.o dcFile.o dcMolecularField.o \ + dcAtomicField.o dcClass.o dcField.o dcFile.o dcMolecularField.o \ dcSubatomicType.o indent.o \ dcparse.o # Cheesy dependencies. HFILES = \ - dcAtomicField.h dcClass.h dcClassDescription.h dcFile.h \ + dcAtomicField.h dcClass.h dcClassDescription.h dcField.h dcFile.h \ dcLexerDefs.h dcMolecularField.h dcParser.h dcParserDefs.h \ dcSubatomicType.h dcbase.h indent.h diff --git a/direct/src/dcparse/Sources.pp b/direct/src/dcparse/Sources.pp index 5338bf00ec..e340f6fa90 100644 --- a/direct/src/dcparse/Sources.pp +++ b/direct/src/dcparse/Sources.pp @@ -6,7 +6,7 @@ #define SOURCES \ dcAtomicField.cxx dcAtomicField.h dcClass.cxx dcClass.h \ - dcFile.cxx dcFile.h dcLexer.lxx dcLexerDefs.h \ + dcField.cxx dcField.h dcFile.cxx dcFile.h dcLexer.lxx dcLexerDefs.h \ dcMolecularField.cxx dcMolecularField.h dcParser.yxx \ dcParserDefs.h dcSubatomicType.cxx dcSubatomicType.h dcbase.h \ indent.cxx indent.h diff --git a/direct/src/dcparse/dc.dsp b/direct/src/dcparse/dc.dsp index 5502433804..669edf3cc5 100644 --- a/direct/src/dcparse/dc.dsp +++ b/direct/src/dcparse/dc.dsp @@ -93,6 +93,10 @@ SOURCE=.\dcClass.cxx # End Source File # Begin Source File +SOURCE=.\dcField.cxx +# End Source File +# Begin Source File + SOURCE=.\dcFile.cxx # End Source File # Begin Source File @@ -141,6 +145,10 @@ SOURCE=.\dcClassDescription.h # End Source File # Begin Source File +SOURCE=.\dcField.h +# End Source File +# Begin Source File + SOURCE=.\dcFile.h # End Source File # Begin Source File diff --git a/direct/src/dcparse/dcAtomicField.cxx b/direct/src/dcparse/dcAtomicField.cxx index e08b24be2f..c7b9a269c6 100644 --- a/direct/src/dcparse/dcAtomicField.cxx +++ b/direct/src/dcparse/dcAtomicField.cxx @@ -18,25 +18,15 @@ operator << (ostream &out, const DCAtomicField::ElementType &et) { } //////////////////////////////////////////////////////////////////// -// Function: DCAtomicField::get_number -// Access: Public -// Description: Returns a unique index number associated with this -// field. This is defined implicitly when the .dc -// file(s) are read. +// Function: DCAtomicField::as_atomic_field +// Access: Public, Virtual +// Description: Returns the same field pointer converted to an atomic +// field pointer, if this is in fact an atomic field; +// otherwise, returns NULL. //////////////////////////////////////////////////////////////////// -int DCAtomicField:: -get_number() const { - return _number; -} - -//////////////////////////////////////////////////////////////////// -// Function: DCAtomicField::get_name -// Access: Public -// Description: Returns the name of this field. -//////////////////////////////////////////////////////////////////// -string DCAtomicField:: -get_name() const { - return _name; +DCAtomicField *DCAtomicField:: +as_atomic_field() { + return this; } //////////////////////////////////////////////////////////////////// @@ -188,7 +178,7 @@ DCAtomicField() { //////////////////////////////////////////////////////////////////// // Function: DCAtomicField::write -// Access: Public +// Access: Public, Virtual // Description: Generates a parseable description of the object to // the indicated output stream. //////////////////////////////////////////////////////////////////// @@ -236,5 +226,5 @@ write(ostream &out, int indent_level) const { out << " airecv"; } - out << "; // atomic " << _number << "\n"; + out << "; // field " << _number << "\n"; } diff --git a/direct/src/dcparse/dcAtomicField.h b/direct/src/dcparse/dcAtomicField.h index 331595635e..f51ea35c59 100644 --- a/direct/src/dcparse/dcAtomicField.h +++ b/direct/src/dcparse/dcAtomicField.h @@ -7,6 +7,7 @@ #define DCATOMICFIELD_H #include "dcbase.h" +#include "dcField.h" #include "dcSubatomicType.h" #include @@ -18,10 +19,9 @@ // Distributed Class, and is always implemented as a // remote procedure method. //////////////////////////////////////////////////////////////////// -class DCAtomicField { +class DCAtomicField : public DCField { PUBLISHED: - int get_number() const; - string get_name() const; + virtual DCAtomicField *as_atomic_field(); int get_num_elements() const; DCSubatomicType get_element_type(int n) const; @@ -39,14 +39,11 @@ PUBLISHED: public: DCAtomicField(); - void write(ostream &out, int indent_level = 0) const; + virtual void write(ostream &out, int indent_level = 0) const; public: // These members define the primary interface to the atomic field // definition as read from the file. - int _number; - string _name; - class ElementType { public: DCSubatomicType _type; diff --git a/direct/src/dcparse/dcClass.cxx b/direct/src/dcparse/dcClass.cxx index 9a1b4bc760..dd4bbde748 100644 --- a/direct/src/dcparse/dcClass.cxx +++ b/direct/src/dcparse/dcClass.cxx @@ -55,181 +55,92 @@ get_parent() const { } //////////////////////////////////////////////////////////////////// -// Function: DCClass::get_num_atomics +// Function: DCClass::get_num_fields // Access: Public -// Description: Returns the number of atomic fields defined directly -// in this class, ignoring inheritance. +// Description: Returns the number of fields defined directly in this +// class, ignoring inheritance. //////////////////////////////////////////////////////////////////// int DCClass:: -get_num_atomics() { - return _atomic_fields.size(); +get_num_fields() { + return _fields.size(); } //////////////////////////////////////////////////////////////////// -// Function: DCClass::get_atomic +// Function: DCClass::get_field // Access: Public -// Description: Returns the nth atomic field in the class. This is -// not necessarily the field with index n; this is the -// nth field defined in the class directly, ignoring +// Description: Returns the nth field in the class. This is not +// necessarily the field with index n; this is the nth +// field defined in the class directly, ignoring // inheritance. //////////////////////////////////////////////////////////////////// -DCAtomicField *DCClass:: -get_atomic(int n) { - assert(n >= 0 && n < (int)_atomic_fields.size()); - return _atomic_fields[n]; +DCField *DCClass:: +get_field(int n) { + assert(n >= 0 && n < (int)_fields.size()); + return _fields[n]; } //////////////////////////////////////////////////////////////////// -// Function: DCClass::get_atomic_by_name +// Function: DCClass::get_field_by_name // Access: Public -// Description: Returns a pointer to the DCAtomicField that shares -// the indicated name. If the named field is not found -// in the current class, the parent classes will be +// Description: Returns a pointer to the DCField that shares the +// indicated name. If the named field is not found in +// the current class, the parent classes will be // searched, so the value returned may not actually be a // field within this class. Returns NULL if there is no // such field defined. //////////////////////////////////////////////////////////////////// -DCAtomicField *DCClass:: -get_atomic_by_name(const string &name) { - AtomicsByName::const_iterator ni; - ni = _atomics_by_name.find(name); - if (ni != _atomics_by_name.end()) { +DCField *DCClass:: +get_field_by_name(const string &name) { + FieldsByName::const_iterator ni; + ni = _fields_by_name.find(name); + if (ni != _fields_by_name.end()) { return (*ni).second; } // We didn't have such a field, so check our parents. Parents::iterator pi; for (pi = _parents.begin(); pi != _parents.end(); ++pi) { - DCAtomicField *result = (*pi)->get_atomic_by_name(name); - if (result != (DCAtomicField *)NULL) { + DCField *result = (*pi)->get_field_by_name(name); + if (result != (DCField *)NULL) { return result; } } // Nobody knew what this field is. - return (DCAtomicField *)NULL; + return (DCField *)NULL; } //////////////////////////////////////////////////////////////////// -// Function: DCClass::get_num_inherited_atomics +// Function: DCClass::get_num_inherited_fields // Access: Public -// Description: Returns the total number of atomic fields defined in +// Description: Returns the total number of field fields defined in // this class and all ancestor classes. //////////////////////////////////////////////////////////////////// int DCClass:: -get_num_inherited_atomics() { +get_num_inherited_fields() { if (!_parents.empty()) { // This won't work for multiple dclass inheritance. - return _parents.front()->get_num_atomics() + get_num_atomics(); + return _parents.front()->get_num_fields() + get_num_fields(); } - return get_num_atomics(); + return get_num_fields(); } //////////////////////////////////////////////////////////////////// -// Function: DCClass::get_inherited_atomic +// Function: DCClass::get_inherited_field // Access: Public -// Description: Returns the nth atomic field in the class and all of +// Description: Returns the nth field field in the class and all of // its ancestors. This *is* the field corresponding to // the given index number, since the fields are ordered // consecutively beginning at the earliest inherited // fields. //////////////////////////////////////////////////////////////////// -DCAtomicField *DCClass:: -get_inherited_atomic(int n) { +DCField *DCClass:: +get_inherited_field(int n) { if (!_parents.empty()) { // This won't work for multiple dclass inheritance. - n -= _parents.front()->get_num_inherited_atomics(); + n -= _parents.front()->get_num_inherited_fields(); } - return get_atomic(n); -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::get_num_moleculars -// Access: Public -// Description: Returns the number of molecular fields defined directly -// in this class, ignoring inheritance. -//////////////////////////////////////////////////////////////////// -int DCClass:: -get_num_moleculars() { - return _molecular_fields.size(); -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::get_molecular -// Access: Public -// Description: Returns the nth molecular field in the class. This is -// not necessarily the field with index n; this is the -// nth field defined in the class directly, ignoring -// inheritance. -//////////////////////////////////////////////////////////////////// -DCMolecularField *DCClass:: -get_molecular(int n) { - assert(n >= 0 && n < (int)_molecular_fields.size()); - return _molecular_fields[n]; -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::get_molecular_by_name -// Access: Public -// Description: Returns a pointer to the DCMolecularField that shares -// the indicated name. If the named field is not found -// in the current class, the parent classes will be -// searched, so the value returned may not actually be a -// field within this class. Returns NULL if there is no -// such field defined. -//////////////////////////////////////////////////////////////////// -DCMolecularField *DCClass:: -get_molecular_by_name(const string &name) { - MolecularsByName::const_iterator ni; - ni = _moleculars_by_name.find(name); - if (ni != _moleculars_by_name.end()) { - return (*ni).second; - } - - // We didn't have such a field, so check our parents. - Parents::iterator pi; - for (pi = _parents.begin(); pi != _parents.end(); ++pi) { - DCMolecularField *result = (*pi)->get_molecular_by_name(name); - if (result != (DCMolecularField *)NULL) { - return result; - } - } - - // Nobody knew what this field is. - return (DCMolecularField *)NULL; -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::get_num_inherited_moleculars -// Access: Public -// Description: Returns the total number of molecular fields defined in -// this class and all ancestor classes. -//////////////////////////////////////////////////////////////////// -int DCClass:: -get_num_inherited_moleculars() { - if (!_parents.empty()) { - // This won't work for multiple dclass inheritance. - return _parents.front()->get_num_moleculars() + get_num_moleculars(); - } - return get_num_moleculars(); -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::get_inherited_molecular -// Access: Public -// Description: Returns the nth molecular field in the class and all of -// its ancestors. This *is* the field corresponding to -// the given index number, since the fields are ordered -// consecutively beginning at the earliest inherited -// fields. -//////////////////////////////////////////////////////////////////// -DCMolecularField *DCClass:: -get_inherited_molecular(int n) { - if (!_parents.empty()) { - // This won't work for multiple dclass inheritance. - n -= _parents.front()->get_num_inherited_moleculars(); - } - return get_molecular(n); + return get_field(n); } //////////////////////////////////////////////////////////////////// @@ -248,14 +159,10 @@ DCClass() { //////////////////////////////////////////////////////////////////// DCClass:: ~DCClass() { - AtomicFields::iterator ai; - for (ai = _atomic_fields.begin(); ai != _atomic_fields.end(); ++ai) { + Fields::iterator ai; + for (ai = _fields.begin(); ai != _fields.end(); ++ai) { delete (*ai); } - MolecularFields::iterator mi; - for (mi = _molecular_fields.begin(); mi != _molecular_fields.end(); ++mi) { - delete (*mi); - } } //////////////////////////////////////////////////////////////////// @@ -280,61 +187,33 @@ write(ostream &out, int indent_level) const { } out << " { // index " << _number << "\n"; - AtomicFields::const_iterator ai; - for (ai = _atomic_fields.begin(); ai != _atomic_fields.end(); ++ai) { + Fields::const_iterator ai; + for (ai = _fields.begin(); ai != _fields.end(); ++ai) { (*ai)->write(out, indent_level + 2); } - MolecularFields::const_iterator mi; - for (mi = _molecular_fields.begin(); mi != _molecular_fields.end(); ++mi) { - (*mi)->write(out, indent_level + 2); - } - indent(out, indent_level) << "};\n"; } //////////////////////////////////////////////////////////////////// // Function: DCClass::add_field // Access: Public -// Description: Adds the newly-allocated atomic field to the class. -// The class becomes the owner of the pointer and will +// Description: Adds the newly-allocated field to the class. The +// class becomes the owner of the pointer and will // delete it when it destructs. Returns true if the // field is successfully added, or false if there was a // name conflict. //////////////////////////////////////////////////////////////////// bool DCClass:: -add_field(DCAtomicField *field) { - bool inserted = _atomics_by_name.insert - (AtomicsByName::value_type(field->_name, field)).second; +add_field(DCField *field) { + bool inserted = _fields_by_name.insert + (FieldsByName::value_type(field->_name, field)).second; if (!inserted) { return false; } - field->_number = get_num_inherited_atomics(); - _atomic_fields.push_back(field); - return true; -} - -//////////////////////////////////////////////////////////////////// -// Function: DCClass::add_field -// Access: Public -// Description: Adds the newly-allocated molecular field to the class. -// The class becomes the owner of the pointer and will -// delete it when it destructs. Returns true if the -// field is successfully added, or false if there was a -// name conflict. -//////////////////////////////////////////////////////////////////// -bool DCClass:: -add_field(DCMolecularField *field) { - bool inserted = _moleculars_by_name.insert - (MolecularsByName::value_type(field->_name, field)).second; - - if (!inserted) { - return false; - } - - field->_number = get_num_inherited_moleculars(); - _molecular_fields.push_back(field); + field->_number = get_num_inherited_fields(); + _fields.push_back(field); return true; } diff --git a/direct/src/dcparse/dcClass.h b/direct/src/dcparse/dcClass.h index 4a79255ae9..624779a4e2 100644 --- a/direct/src/dcparse/dcClass.h +++ b/direct/src/dcparse/dcClass.h @@ -7,8 +7,7 @@ #define DCCLASS_H #include "dcbase.h" -#include "dcAtomicField.h" -#include "dcMolecularField.h" +#include "dcField.h" #include #include @@ -26,27 +25,19 @@ PUBLISHED: bool has_parent() const; DCClass *get_parent() const; - int get_num_atomics(); - DCAtomicField *get_atomic(int n); - DCAtomicField *get_atomic_by_name(const string &name); + int get_num_fields(); + DCField *get_field(int n); + DCField *get_field_by_name(const string &name); - int get_num_inherited_atomics(); - DCAtomicField *get_inherited_atomic(int n); - - int get_num_moleculars(); - DCMolecularField *get_molecular(int n); - DCMolecularField *get_molecular_by_name(const string &name); - - int get_num_inherited_moleculars(); - DCMolecularField *get_inherited_molecular(int n); + int get_num_inherited_fields(); + DCField *get_inherited_field(int n); public: DCClass(); ~DCClass(); void write(ostream &out, int indent_level = 0) const; - bool add_field(DCAtomicField *field); - bool add_field(DCMolecularField *field); + bool add_field(DCField *field); public: // These members define the primary interface to the distributed @@ -57,20 +48,14 @@ public: typedef vector Parents; Parents _parents; - typedef vector AtomicFields; - AtomicFields _atomic_fields; - - typedef vector MolecularFields; - MolecularFields _molecular_fields; + typedef vector Fields; + Fields _fields; public: // These members are built up during parsing for the convenience of // the parser. - typedef map AtomicsByName; - AtomicsByName _atomics_by_name; - - typedef map MolecularsByName; - MolecularsByName _moleculars_by_name; + typedef map FieldsByName; + FieldsByName _fields_by_name; }; #endif diff --git a/direct/src/dcparse/dcMolecularField.cxx b/direct/src/dcparse/dcMolecularField.cxx index 4674da603e..5c50f006d3 100644 --- a/direct/src/dcparse/dcMolecularField.cxx +++ b/direct/src/dcparse/dcMolecularField.cxx @@ -11,25 +11,15 @@ //////////////////////////////////////////////////////////////////// -// Function: DCMolecularField::get_number -// Access: Public -// Description: Returns a unique index number associated with this -// field. This is defined implicitly when the .dc -// file(s) are read. +// Function: DCMolecularField::as_molecular_field +// Access: Public, Virtual +// Description: Returns the same field pointer converted to a +// molecular field pointer, if this is in fact a +// molecular field; otherwise, returns NULL. //////////////////////////////////////////////////////////////////// -int DCMolecularField:: -get_number() const { - return _number; -} - -//////////////////////////////////////////////////////////////////// -// Function: DCMolecularField::get_name -// Access: Public -// Description: Returns the name of this field. -//////////////////////////////////////////////////////////////////// -string DCMolecularField:: -get_name() const { - return _name; +DCMolecularField *DCMolecularField:: +as_molecular_field() { + return this; } //////////////////////////////////////////////////////////////////// @@ -69,7 +59,7 @@ DCMolecularField() { //////////////////////////////////////////////////////////////////// // Function: DCMolecularField::write -// Access: Public +// Access: Public, Virtual // Description: Generates a parseable description of the object to // the indicated output stream. //////////////////////////////////////////////////////////////////// @@ -87,6 +77,6 @@ write(ostream &out, int indent_level) const { } } - out << "; // molecular " << _number << "\n"; + out << "; // field " << _number << "\n"; } diff --git a/direct/src/dcparse/dcMolecularField.h b/direct/src/dcparse/dcMolecularField.h index 8d4831467d..e7152a227c 100644 --- a/direct/src/dcparse/dcMolecularField.h +++ b/direct/src/dcparse/dcMolecularField.h @@ -7,6 +7,7 @@ #define DCMOLECULARFIELD_H #include "dcbase.h" +#include "dcField.h" #include @@ -19,24 +20,20 @@ class DCAtomicField; // of two or more related atomic fields, that will often // be treated as a unit. //////////////////////////////////////////////////////////////////// -class DCMolecularField { +class DCMolecularField : public DCField { PUBLISHED: - int get_number() const; - string get_name() const; + virtual DCMolecularField *as_molecular_field(); int get_num_atomics() const; DCAtomicField *get_atomic(int n) const; public: DCMolecularField(); - void write(ostream &out, int indent_level = 0) const; + virtual void write(ostream &out, int indent_level = 0) const; public: // These members define the primary interface to the molecular field // definition as read from the file. - int _number; - string _name; - typedef vector Fields; Fields _fields; }; diff --git a/direct/src/dcparse/dcParser.yxx b/direct/src/dcparse/dcParser.yxx index 4fe3a8d476..69a0260dfa 100644 --- a/direct/src/dcparse/dcParser.yxx +++ b/direct/src/dcparse/dcParser.yxx @@ -9,6 +9,7 @@ #include "dcFile.h" #include "dcClass.h" #include "dcAtomicField.h" +#include "dcMolecularField.h" // Because our token type contains objects of type string, which // require correct copy construction (and not simply memcpying), we @@ -139,7 +140,7 @@ atomic_field: current_atomic = new DCAtomicField; current_atomic->_name = $1; if (!current_class->add_field(current_atomic)) { - yyerror("Duplicate atomic field name: " + current_atomic->_name); + yyerror("Duplicate field name: " + current_atomic->_name); } } parameter_list ')' atomic_flags @@ -148,9 +149,15 @@ atomic_field: atomic_name: IDENTIFIER { - $$ = current_class->get_atomic_by_name($1); - if ($$ == (DCAtomicField *)NULL) { - yyerror("Unknown atomic field: " + $1); + DCField *field = current_class->get_field_by_name($1); + $$ = (DCAtomicField *)NULL; + if (field == (DCField *)NULL) { + yyerror("Unknown field: " + $1); + } else { + $$ = field->as_atomic_field(); + if ($$ == (DCAtomicField *)NULL) { + yyerror("Not an atomic field: " + $1); + } } } @@ -270,7 +277,7 @@ molecular_field: current_molecular = new DCMolecularField; current_molecular->_name = $1; if (!current_class->add_field(current_molecular)) { - yyerror("Duplicate molecular field name: " + current_molecular->_name); + yyerror("Duplicate field name: " + current_molecular->_name); } } molecular_atom_list @@ -287,6 +294,11 @@ molecular_atom_list: { if ($3 != (DCAtomicField *)NULL) { current_molecular->_fields.push_back($3); + if (current_molecular->_fields[0]->_flags != $3->_flags) { + yyerror("Mismatched flags in molecule between " + + current_molecular->_fields[0]->_name + " and " + + $3->_name); + } } } ; diff --git a/direct/src/dcparse/test.dc b/direct/src/dcparse/test.dc index baf86cced5..1a4d79a1df 100644 --- a/direct/src/dcparse/test.dc +++ b/direct/src/dcparse/test.dc @@ -14,7 +14,7 @@ dclass Movable { dclass Attitude : Movable { // methods are inherited from parent class. - set_attitude(int8); + set_attitude(int8) required broadcast ram; // This molecular field uses some inherited atomic fields. set_xyzhprattitude : set_xyz, set_hpr, set_attitude;