Polaris: BinRep.h Source File

BinRep.h Go to the documentation of this file. /// /// /// file BinRep.h /// #ifndef _BIN_REP_H #define _BIN_REP_H /// /// \class BinRep /// \brief a class for representing the interchange format. /// \defgroup Polaris /// \ingroup Polaris /// Base /// \see BinRep.h /// \see BinRep.h /// \see BinRep.cc /// /// \endcode /// \section Overview Overview /// This classes is intended for representing the interchange format in /// a manner that allows easy manipulation. /// /// \endcode /// \section Description Description /// The interchange format is based upon Lists and Sets of interchange /// objects. Each object represents one element in the interchange /// format. This class is intented as a easy way to manipulate and /// examine the interchange format. The BinRep class is a recursive /// datastructure that allows one to arbitrarity nest the BinRep objects. /// These BinRep objects can be changed into standard Polaris Collection /// objects to be examined and mutated in standard ways. /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include "ClassNames.h" #include "Listable.h" #include "IntElem.h" #include "Collection/List.h" #include "Collection/Set.h" #include "Collection/Database.h" #include "String.h" #include "Boolean.h" /// class MemBuf; class BinPtr; #include "bin_str_def.h" class BinRep : public Listable { private: BINSTR_TYPE _fc; ///< The type of the object we are representing. int _len; ///< The size of the object. union BinRep_union { List<BinRep> *L; Set<BinRep> *S; Database<String,BinRep> *D; void *C; } _u; ///< A BinRep object can be any of the above types. Each node in the ///< obejct can be either a List, a Set, a Database or a memory buffer. protected: BinRep & _omega() const; ///< return a reference to an FT_OMEGA object. void _init(); ///< Set to the empty node. void _destroy(); ///< Erase the current node. void _parse(const void *binstr); ///< Parse a memory buffer, determine if it is the IEF or SETL format. void _parse(istream &ifs); ///< Parse an istream, determine if it is the IEF or SETL format. void _ief_parse(const void *bin_header, const void *bin_body); ///< Parse the memory buffers in IEF format. void _ief_parse(istream &ifs); ///< Parse an istream in IEF format. void _setl_parse(const void *binstr); ///< Parse the memory buffer in SETL format. void _setl_parse(istream &ifs); ///< Parse an istream in SETL format. void _ascii_format(String & str) const; ///< This method appends to str. ///< Note: This method adds double quotes to strings so that it can ///< be easily seen when substructures of a binstr are strings. ///< It also adds "(double)" on the front of double (float) values ///< for the same reason. Sets are formatted with "{...}", tuples ///< with "[...]". int _ief_length(Database<String,IntElem> *map) const; ///< Return the length in bytes of the current node in IEF format. ///< If map is non-null then use it to lookup dictionary objects to ///< compact the length. void _ief_format(BinPtr &p, Database<String,IntElem> *map) const; ///< This method appends to str. ///< Note: This method changes the BinRep into a flat representation ///< suitable for interchange with other compilers like KAP. int _setl_length() const; ///< Return the length in bytes of the current node in SETL. If map ///< is non-null then use it to lookup dictionary objects to compact ///< the length. void _setl_format(BinPtr &p) const; ///< This method appends to str. ///< Note: This method changes the BinRep into a flat representation ///< suitable for interchange with the SETL environment in Delta. public: BinRep(); ///< Create a NULL node. BinRep(const void *binstr); ///< Create a BinRep object from the memory buffer. inline BinRep( List<BinRep> *L ); ///< Create a BinRep object from a List. inline BinRep( Set<BinRep> *S ); ///< Create a BinRep object from a List. inline BinRep( String &s ); ///< Create a BinRep object from a string. inline BinRep( const char *s ); ///< Create a BinRep object from a string. inline BinRep( int x ); ///< Create a BinRep object from an integer. BinRep(const BinRep &br); ///< Copy constructor. virtual ~BinRep(); ///< Destroy the BinRep object. BinRep & operator = (const void *binstr); ///< Create a BinRep object from the memory buffer. BinRep & operator = (const BinRep &br); ///< Copy the BinRep br into the current object. void del(int i); ///< This operator overloading is for tuple object only. ///< Delete the ith element of the tuple. BinRep & operator[] (int i) const; ///< This operator overloading is for tuple object only. ///< It returns a BinRep which corresponds to the ith element ///< of the tuple (where i == 0 is the first element) BinRep * find_ref(const char *field) const; ///< Check to see if field is a member of this BinRep object, return 0 if not. void del(const char *field); ///< This operator overloading is for set and map objects only. ///< Delete the specifed field of the map. BinRep & operator[] (const char *field) const; ///< This operator overloading of the square brackets is for set and map ///< objects only, and is really only meant for maps (sets of 2-tuples, ///< where the first element of each tuple is used as a tag and the second ///< element is used as the value for that tag, and furthermore the same ///< element does not appear as a tag twice). ///< It searches through the map for a tag having a value equal to ///< 'field' and returns a BinRep corresponding to the value for ///< that tag. If no such tag is found, a BinRep corresponding ///< to OM (undefined type) is returned. void ins( BinRep *b ); ///< Insert the BinRep into the top-level structure. void ins( const BinRep &b ); ///< Insert a copy of the BinRep into the top-level structure. void ascii_format(String & str) const; ///< Note: This method adds double quotes to strings so that it can ///< be easily seen when substructures of a binstr are strings. ///< It also adds "(double)" on the front of double (float) values ///< for the same reason. Sets are formatted with "{...}", tuples ///< with "[...]". void ief_format(MemBuf &buf) const; ///< Note: This method changes the BinRep into a flat representation ///< suitable for interchange with other compilers like KAP. void setl_format(MemBuf &buf) const; ///< Note: This method changes the BinRep into a flat representation ///< suitable for interchange with the SETL environment in Delta. void read(istream &ifs); ///< Read the BinRep from the istream ifs. BinRep *clone() const; ///< Create a copy of the BinRep. virtual Listable *listable_clone() const; ///< Copy and return a pointer to any Listable item ///< (MUST be implemented correctly by subclasses ///< for List copy functions to work) virtual void print(ostream & o) const; ///< Print the current BinRep node and it's children. int structures_OK() const; ///< Check the structure of the data for errors or inconsistency ///< Return 0 and print error message if problems found, otherwise ///< return 1 without message. inline BINSTR_TYPE type() const; ///< Return the type of this node. Boolean is_omega() const; ///< Check to see if this node is an OM. Boolean is_boolean() const; ///< Check to see if this node is a Boolean. Boolean is_double() const; ///< Check to see if this node is a Real. Boolean is_integer() const; ///< Check to see if this node is an Integer. Boolean is_string() const; ///< Check to see if this node is a String. Boolean is_tuple() const; ///< Check to see if this node is a Tuple. Boolean is_set() const; ///< Check to see if this node is a Set. inline Boolean is_map() const; ///< Check to see if this node is a Map. ///< \note currently Map's are not fully supported so this function ///< defaults to False. Boolean to_boolean() const; ///< Returns the Boolean value of a BinRep. If is_boolean() is ///< not true, aborts with an error message. double to_double() const; ///< Returns the double value of a BinRep. If is_double() is ///< not true, aborts with an error message. int to_integer() const; ///< Returns the int value of a BinRep. If is_integer() is ///< not true, aborts with an error message. void to_string(String & str) const; ///< Note: Due to technical concerns and to avoid an unobvious pitfall ///< of the String class the to_string method does not return a String, ///< but rather sets 'str' to the string value of the BinRep. ///< If is_string() is not true, aborts with an error message. List<BinRep> & to_tuple() const; ///< Returns the List value of a BinRep. If is_tuple() is ///< not true, aborts with an error message. Set<BinRep> & to_set() const; ///< Returns the Set value of a BinRep. If is_set() is ///< not true, aborts with an error message. Database<String,BinRep> & to_map() const; ///< Returns the Map value of a BinRep. If is_map() is ///< not true, aborts with an error message. void put_tuple( List<BinRep> *L ); ///< Store a tuple into the current node. void put_set( Set<BinRep> *S ); ///< Store a set into the current node. void put_map( Database<String,BinRep> *D ); ///< Store a map into the current node. void put_omega(); ///< Store an OM into the current node. void put_integer( const int x ); ///< Store an Integer into the current node. void put_boolean( const Boolean b ); ///< Store a Boolean into the current node. void put_string( const String &s ); ///< Store an String into the current node. void put_string( const char *s ); ///< Store a C string (null terminated) into the current node. void put_string( const char *s, int length ); ///< Store an C string of length into the current node. void put_double( const double d ); ///< Store an Real into the current node. }; ///< Description: ///< Return the ASCII type name for a formcode. char *binstr_type_name( BINSTR_TYPE expected_type ); inline BINSTR_TYPE BinRep::type() const { return _fc; } inline Boolean BinRep::is_map() const { return False; } inline BinRep::BinRep( List<BinRep> *L ) { _init(); put_tuple( L ); } inline BinRep::BinRep( Set<BinRep> *S ) { _init(); put_set( S ); } inline BinRep::BinRep( String &s ) { _init(); put_string( s ); } inline BinRep::BinRep( const char *s ) { _init(); put_string( s ); } inline BinRep::BinRep( int x ) { _init(); put_integer( x ); } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:41 2005