Polaris: BinRep.cc Source File

BinRep.cc Go to the documentation of this file. /// #include "define.h" #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif #include <stdio.h> #include <memory.h> #include "BinRep.h" #include "BinPtr.h" #include "MemBuf.h" #include "debug.h" #include "String.h" #include "IntElem.h" #include "Collection/Iterator.h" #include "Collection/Mutator.h" #include "Collection/KeyIterator.h" #include "macros.h" /// Return the number of bytes needed to represent the value x. static int bytes_per_value( int x ) { if (x >= -128 && x <= 127) return 1; else if (x >= -32768 && x <= 32767) return 2; return 4; } inline BINSTR_TYPE select_type( int size, BINSTR_TYPE t1, BINSTR_TYPE t2, BINSTR_TYPE t3 ) { if (size == 1) return t1; else if (size == 2) return t2; return t3; } /// Create an uninitialized BinRep object. BinRep::BinRep() { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_REP, sizeof(BinRep), this); #endif _fc = _ILLEGAL_TYPES; _len = 0; } BinRep::BinRep(const BinRep &br) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_REP, sizeof(BinRep), this); #endif _fc = br._fc; _len = br._len; if (br.is_tuple()) _u.L = new List<BinRep>( *br._u.L ); else if (br.is_set()) _u.S = new Set<BinRep>( *br._u.S ); else if (br.is_map()) _u.D = new Database<String,BinRep>( *br._u.D ); else { _u.C = malloc(_len*sizeof(char)); memcpy( _u.C, br._u.C, _len ); } } BinRep & BinRep::operator = (const BinRep &br) { _fc = br._fc; _len = br._len; if (br.is_tuple()) _u.L = new List<BinRep>( *br._u.L ); else if (br.is_set()) _u.S = new Set<BinRep>( *br._u.S ); else if (br.is_map()) _u.D = new Database<String,BinRep>( *br._u.D ); else { _u.C = malloc(_len*sizeof(char)); memcpy( _u.C, br._u.C, _len ); } return (*this); } BinRep::BinRep(const void *binstr) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_REP, sizeof(BinRep), this); #endif _fc = _ILLEGAL_TYPES; _len = 0; _parse( binstr ); } BinRep::~BinRep() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(BIN_REP, this); #endif _destroy(); } BinRep & BinRep::_omega() const { static BinRep *om = 0; if (om == 0) { om = new BinRep; om->_fc = IEF_OMEGA; om->_len = 0; om->_u.C = 0; } return *om; } void BinRep::_parse( const void *binstr ) { _destroy(); char *s = (char *) binstr; if (*s == IEF_HEADER) _ief_parse( binstr, 0 ); else _setl_parse( binstr ); } void BinRep::_parse( istream & ifs ) { char ch; _destroy(); ifs.get( ch ); if (ifs.eof()) return; ifs.putback( ch ); if (ch == IEF_HEADER) _ief_parse( ifs ); else _setl_parse( ifs ); } static void aux_ief_parse( Database<int,BinRep> &dict, BinRep &br, BinPtr &p ) { binptr_1 form_code; p.fetch( form_code ); switch ( form_code ) { case IEF_OMEGA: br.put_omega(); break; case IEF_TRUE: br.put_boolean( True ); break; case IEF_FALSE: br.put_boolean( False ); break; case IEF_REAL: { double x; p.fetch( x ); br.put_double( x ); } break; case IEF_INTEGER_1: { binptr_1 x; p.fetch( x ); br.put_integer( x ); } break; case IEF_INTEGER_2: { binptr_2 x; p.fetch( x ); br.put_integer( x ); } break; case IEF_INTEGER_4: { binptr_4 x; p.fetch( x ); br.put_integer( x ); } break; case IEF_STRING_1: { binptr_1 size; p.fetch( size ); char *buffer = new char[ size+1 ]; p.fetch( buffer, size ); br.put_string( buffer, size ); delete [] buffer; } break; case IEF_STRING_2: { binptr_2 size; p.fetch( size ); char *buffer = new char[ size+1 ]; p.fetch( buffer, size ); br.put_string( buffer, size ); delete [] buffer; } break; case IEF_STRING_4: { binptr_4 size; p.fetch( size ); char *buffer = new char[ size+1 ]; p.fetch( buffer, size ); br.put_string( buffer, size ); delete [] buffer; } break; case IEF_TUPLE_1: { binptr_1 size; p.fetch( size ); List<BinRep> *L = new List<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); L->ins_last( b ); } br.put_tuple( L ); } break; case IEF_TUPLE_2: { binptr_2 size; p.fetch( size ); List<BinRep> *L = new List<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); L->ins_last( b ); } br.put_tuple( L ); } break; case IEF_TUPLE_4: { binptr_4 size; p.fetch( size ); List<BinRep> *L = new List<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); L->ins_last( b ); } br.put_tuple( L ); } break; case IEF_SET_1: case IEF_MAP_1: { binptr_1 size; p.fetch( size ); Set<BinRep> *S = new Set<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); S->ins( b ); } br.put_set( S ); } break; case IEF_SET_2: case IEF_MAP_2: { binptr_2 size; p.fetch( size ); Set<BinRep> *S = new Set<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); S->ins( b ); } br.put_set( S ); } break; case IEF_SET_4: case IEF_MAP_4: { binptr_4 size; p.fetch( size ); Set<BinRep> *S = new Set<BinRep>; for (int i = 0; i < size; ++i) { BinRep *b = new BinRep; aux_ief_parse( dict, *b, p ); S->ins( b ); } br.put_set( S ); } break; case IEF_DICT_1: { binptr_1 x; p.fetch( x ); BinRep *b = dict.find_ref( (int) x ); p_assert( b, "Error: unknown dictionary entry" ); br = *b; } break; case IEF_DICT_2: { binptr_2 x; p.fetch( x ); BinRep *b = dict.find_ref( (int) x ); p_assert( b, "Error: unknown dictionary entry" ); br = *b; } break; case IEF_DICT_4: { binptr_4 x; p.fetch( x ); BinRep *b = dict.find_ref( (int) x ); p_assert( b, "Error: unknown dictionary entry" ); br = *b; } break; } } void BinRep::_ief_parse( const void *bin_header, const void *bin_body ) { Database<int,BinRep> dict; BinPtr p( bin_header ); binptr_4 header_version, header_length; binptr_1 form_code; p.fetch( form_code ); p_assert( form_code == IEF_HEADER, "not the IEF_HEADER code" ); p.fetch( header_version ); p.fetch( header_length ); int count = 0; p.fetch( form_code ); switch ( form_code ) { case IEF_TUPLE_1: { binptr_1 x; p.fetch( x ); count = x; break; } case IEF_TUPLE_2: { binptr_2 x; p.fetch( x ); count = x; break; } case IEF_TUPLE_4: { binptr_4 x; p.fetch( x ); count = x; break; } } for (int i = 1; i <= count; ++i) { BinRep *br = new BinRep; aux_ief_parse( dict, *br, p ); dict.ins( i, br ); } if (bin_body != 0) p.reset( bin_body ); binptr_4 body_version, body_length; p.fetch( form_code ); p_assert( form_code == IEF_BODY, "not the IEF_BODY code" ); p.fetch( body_version ); p.fetch( body_length ); aux_ief_parse( dict, (*this), p ); } void BinRep::_ief_parse( istream &ifs ) { Database<int,BinRep> dict; BinPtr p( ifs ); binptr_4 header_version, header_length; binptr_1 form_code; p.fetch( form_code ); p_assert( form_code == IEF_HEADER, "not the IEF_HEADER code" ); p.fetch( header_version ); p.fetch( header_length ); int count = 0; p.fetch( form_code ); switch ( form_code ) { case IEF_TUPLE_1: { binptr_1 x; p.fetch( x ); count = x; break; } case IEF_TUPLE_2: { binptr_2 x; p.fetch( x ); count = x; break; } case IEF_TUPLE_4: { binptr_4 x; p.fetch( x ); count = x; break; } } for (int i = 1; i <= count; ++i) { BinRep *br = new BinRep; aux_ief_parse( dict, *br, p ); dict.ins( i, br ); } binptr_4 body_version, body_length; p.fetch( form_code ); p_assert( form_code == IEF_BODY, "not the IEF_BODY code" ); p.fetch( body_version ); p.fetch( body_length ); aux_ief_parse( dict, (*this), p ); } static void aux_setl_parse( BinRep &br, BinPtr &p ) { binptr_4 form_code; p.fetch( form_code ); switch ( form_code ) { case FT_ALT_OMEGA: { binptr_4 extra; p.fetch( extra ); br.put_omega(); } break; case FT_OMEGA: br.put_omega(); break; case FT_ATOM: { binptr_4 atom_value, pointer; p.fetch( atom_value ); p.fetch( pointer ); br.put_boolean( (atom_value != 0) ); } break; case FT_SHORT: { binptr_4 int_value; p.fetch( int_value ); br.put_integer( int_value ); } break; case FT_DOUBLE: { double real_value; p.fetch( real_value ); br.put_double( real_value ); } break; case FT_LONGINT: { binptr_4 long_length, digit; int long_value, sign, pos; p.fetch( long_length ); if (long_length >= 0) sign = 1; else { sign = -1; long_length = -long_length; } for (long_value = pos = 0; long_length > 0; --long_length) { p.fetch( digit ); long_value |= (digit << (pos++ * 15)); } long_value = sign * long_value; br.put_integer( long_value ); } break; case FT_STRING: { binptr_4 len; p.fetch( len ); char *buffer = new char[ len+1 ]; p.fetch( buffer, len ); br.put_string( buffer, len ); delete [] buffer; } break; case FT_TUPLE: { binptr_4 tuple_length; p.fetch( tuple_length ); List<BinRep> *L = new List<BinRep>; for (int i = 0; i < tuple_length; ++i) { BinRep *b = new BinRep; aux_setl_parse( *b, p ); L->ins_last( b ); } br.put_tuple( L ); } break; case FT_SET: { binptr_4 set_length; p.fetch( set_length ); Set<BinRep> *S = new Set<BinRep>; for (int i = 0; i < set_length; ++i) { BinRep *b = new BinRep; aux_setl_parse( *b, p ); S->ins( b ); } br.put_set( S ); } break; default: p_abort( "unknown form_code" ); break; } } void BinRep::_setl_parse( const void *binstr ) { BinPtr p( binstr ); aux_setl_parse( *this, p ); } void BinRep::_setl_parse( istream &ifs ) { BinPtr p( ifs ); aux_setl_parse( *this, p ); } void BinRep::_init() { _fc = _ILLEGAL_TYPES; _len = 0; } void BinRep::_destroy() { switch ( _fc ) { case _ILLEGAL_TYPES: /// ... nothing to do break; case FT_TUPLE: case IEF_TUPLE_1: case IEF_TUPLE_2: case IEF_TUPLE_4: delete _u.L; _u.L = 0; break; case FT_SET: case IEF_SET_1: case IEF_SET_2: case IEF_SET_4: delete _u.S; _u.S = 0; break; case IEF_MAP_1: case IEF_MAP_2: case IEF_MAP_4: p_abort( "not supported" ); delete _u.D; _u.D = 0; break; default: free(_u.C); _u.C = 0; break; } _fc = _ILLEGAL_TYPES; _len = 0; } BinRep & BinRep::operator = (const void *binstr) { _destroy(); _parse( binstr ); return (*this); } void BinRep::ascii_format(String & str) const { str = ""; _ascii_format( str ); } void BinRep::_ascii_format(String & str) const { if ( is_omega() ) str += "OM"; else if (is_boolean()) str += ( to_boolean() ? "TRUE" : "FALSE" ); else if (is_integer()){ char buffer[32]; sprintf( buffer, "%d", to_integer() ); str += buffer; } else if (is_double()) { char buffer[32]; sprintf( buffer, "%f", to_double() ); str += "(double)"; str += buffer; } else if (is_string()) { String s; to_string( s ); str += "\""; str += s; str += "\""; } else if (is_tuple()) { str += "["; Iterator<BinRep> iter = to_tuple(); if (iter.valid()) { iter.current()._ascii_format( str ); for (++iter; iter.valid(); ++iter) { str += ","; iter.current()._ascii_format( str ); } } str += "]"; } else if (is_set()) { str += "{"; Iterator<BinRep> iter = to_set(); if (iter.valid()) { iter.current()._ascii_format( str ); for (++iter; iter.valid(); ++iter) { str += ","; iter.current()._ascii_format( str ); } } str += "}"; } else if (is_map()) { str += "{"; KeyIterator<String,BinRep> iter = to_map(); if (iter.valid()) { str += "["; str += iter.current_key(); str += ","; iter.current_data()._ascii_format( str ); str += "]"; for (++iter; iter.valid(); ++iter) { str += ", ["; str += iter.current_key(); str += ","; iter.current_data()._ascii_format( str ); str += "]"; } } str += "}"; } } int BinRep::_setl_length() const { int size = sizeof( binptr_4 ); switch( _fc ) { case FT_OMEGA: case IEF_OMEGA: break; case FT_ATOM: case IEF_TRUE: case IEF_FALSE: size += 2 * sizeof( binptr_4 ); break; case FT_DOUBLE: case IEF_REAL: size += sizeof( binptr_8 ); break; case FT_LONGINT: case FT_SHORT: case IEF_INTEGER_1: case IEF_INTEGER_2: case IEF_INTEGER_4: { int x = to_integer(); if (bytes_per_value(x) <= 2) size += sizeof( binptr_4 ); else size += sizeof( binptr_4 ) + 3*sizeof( binptr_4 ); } break; case FT_STRING: case IEF_STRING_1: case IEF_STRING_2: case IEF_STRING_4: size += sizeof( binptr_4 ) + _len; break; case FT_TUPLE: case IEF_TUPLE_1: case IEF_TUPLE_2: case IEF_TUPLE_4: { size += sizeof( binptr_4 ); for (Iterator<BinRep> iter = to_tuple(); iter.valid(); ++iter) size += iter.current()._setl_length(); } break; case FT_SET: case IEF_SET_1: case IEF_SET_2: case IEF_SET_4: { size += sizeof( binptr_4 ); for (Iterator<BinRep> iter = to_set(); iter.valid(); ++iter) size += iter.current()._setl_length(); } break; case IEF_MAP_1: case IEF_MAP_2: case IEF_MAP_4: { p_abort( "not suppoted" ); size += sizeof( binptr_4 ); for (KeyIterator<String,BinRep> iter = to_map(); iter.valid(); ++iter) { size += iter.current_data()._setl_length(); } } break; default: p_abort( "unknown form code" ); break; } return size; } int BinRep::_ief_length( Database<String,IntElem> *map ) const { int size = sizeof( binptr_1 ); switch( _fc ) { case FT_OMEGA: case IEF_OMEGA: case FT_ATOM: case IEF_TRUE: case IEF_FALSE: break; case FT_DOUBLE: case IEF_REAL: size += sizeof( binptr_8 ); break; case FT_LONGINT: case FT_SHORT: case IEF_INTEGER_1: case IEF_INTEGER_2: case IEF_INTEGER_4: size += bytes_per_value( to_integer() ); break; case FT_STRING: case IEF_STRING_1: case IEF_STRING_2: case IEF_STRING_4: if (map == 0) size += bytes_per_value( _len ) + _len; else { String str; to_string( str ); IntElem *e; if ((e = map->find_ref(str)) == 0) { e = new IntElem( map->entries() + 1 ); map->ins( str, e ); } size += bytes_per_value( e->value() ); } break; case FT_TUPLE: case IEF_TUPLE_1: case IEF_TUPLE_2: case IEF_TUPLE_4: { size += bytes_per_value( to_tuple().entries() ); for (Iterator<BinRep> iter = to_tuple(); iter.valid(); ++iter) size += iter.current()._ief_length( map ); } break; case FT_SET: case IEF_SET_1: case IEF_SET_2: case IEF_SET_4: { size += bytes_per_value( to_set().entries() ); for (Iterator<BinRep> iter = to_set(); iter.valid(); ++iter) size += iter.current()._ief_length( map ); } break; case IEF_MAP_1: case IEF_MAP_2: case IEF_MAP_4: { p_abort( "not suppoted" ); size += bytes_per_value( to_map().entries() ); for (KeyIterator<String,BinRep> iter = to_map(); iter.valid(); ++iter) { size += iter.current_data()._ief_length( map ); } } break; default: p_abort( "unknown form code" ); break; } return size; } void BinRep::_ief_format( BinPtr &p, Database<String,IntElem> *map ) const { switch( _fc ) { case FT_OMEGA: case IEF_OMEGA: p.store( IEF_OMEGA, 1 ); break; case FT_ATOM: case IEF_TRUE: case IEF_FALSE: p.store( ( to_boolean() ? IEF_TRUE : IEF_FALSE ), 1 ); break; case FT_DOUBLE: case IEF_REAL: { double x = to_double(); p.store( IEF_REAL, 1 ); p.store( x ); } break; case FT_LONGINT: case FT_SHORT: case IEF_INTEGER_1: case IEF_INTEGER_2: case IEF_INTEGER_4: { int value = to_integer(); int size = bytes_per_value( value ); p.store( select_type(size, IEF_INTEGER_1, IEF_INTEGER_2, IEF_INTEGER_4 ), 1 ); p.store( value, size ); } break; case FT_STRING: case IEF_STRING_1: case IEF_STRING_2: case IEF_STRING_4: if (map == 0) { int size = bytes_per_value( _len ); p.store( select_type(size, IEF_STRING_1, IEF_STRING_2, IEF_STRING_4 ), 1 ); p.store( _len, size ); p.store( _u.C, _len ); } else { String str; to_string( str ); IntElem *e = map->find_ref(str); p_assert( e, "must call _ief_length() first" ); int size = bytes_per_value( e->value() ); p.store( select_type(size, IEF_DICT_1, IEF_DICT_2, IEF_DICT_4 ), 1 ); p.store( e->value(), size ); } break; case FT_TUPLE: case IEF_TUPLE_1: case IEF_TUPLE_2: case IEF_TUPLE_4: { List<BinRep> &L = to_tuple(); int size = bytes_per_value( L.entries() ); p.store( select_type(size, IEF_TUPLE_1, IEF_TUPLE_2, IEF_TUPLE_4 ), 1 ); p.store( L.entries(), size ); for (Iterator<BinRep> iter = L; iter.valid(); ++iter) iter.current()._ief_format( p, map ); } break; case FT_SET: case IEF_SET_1: case IEF_SET_2: case IEF_SET_4: { Set<BinRep> &S = to_set(); int size = bytes_per_value( S.entries() ); p.store( select_type(size, IEF_SET_1, IEF_SET_2, IEF_SET_4 ), 1 ); p.store( S.entries(), size ); for (Iterator<BinRep> iter = S; iter.valid(); ++iter) iter.current()._ief_format( p, map ); } break; case IEF_MAP_1: case IEF_MAP_2: case IEF_MAP_4: { p_abort( "not supported" ); Database<String, BinRep> &D = to_map(); int size = bytes_per_value( D.entries() ); p.store( select_type(size, IEF_MAP_1, IEF_MAP_2, IEF_MAP_4 ), 1 ); p.store( D.entries(), size ); for (KeyIterator<String,BinRep> iter = to_map(); iter.valid(); ++iter) { iter.current_data()._ief_format( p, map ); } } break; default: p_abort( "unknown form code" ); break; } } void BinRep::ief_format(MemBuf &buf) const { Database<String,IntElem> map; int body_version = 1; int body_length = _ief_length( &map ); List<BinRep> *dict = new List<BinRep>; dict->make_static_list( map.entries() ); for (KeyIterator<String,IntElem> iter = map; iter.valid(); ++iter) { BinRep *b = new BinRep; b->put_string( iter.current_key() ); dict->modify( iter.current_data().value() - 1, b ); } dict->unfix_size(); BinRep head; head.put_tuple( dict ); int header_version = 1; int header_length = head._ief_length( 0 ); buf.reset(); buf.append_empty( 2*sizeof(binptr_1) + 4*sizeof(binptr_4) + header_length + body_length ); BinPtr p( buf.data_ref() ); p.store( IEF_HEADER, 1 ); p.store( header_version ); p.store( header_length ); head._ief_format( p, 0 ); p.store( IEF_BODY, 1 ); p.store( body_version ); p.store( body_length ); _ief_format( p, &map ); } void BinRep::_setl_format( BinPtr &p ) const { switch( _fc ) { case FT_OMEGA: case IEF_OMEGA: p.store( (long) FT_OMEGA, 4 ); break; case FT_ATOM: case IEF_TRUE: case IEF_FALSE: { binptr_4 atom_value= (int) to_boolean(); binptr_4 pointer = 0x01234567; p.store( FT_ATOM, 4 ); p.store( atom_value ); p.store( pointer ); } break; case FT_DOUBLE: case IEF_REAL: { double x = to_double(); p.store( FT_DOUBLE, 4 ); p.store( x ); } break; case FT_LONGINT: case FT_SHORT: case IEF_INTEGER_1: case IEF_INTEGER_2: case IEF_INTEGER_4: { int value = to_integer(); int size = bytes_per_value( value ); if (size <= 2) { p.store( FT_SHORT, 4 ); p.store( value, 4 ); } else { const int max_packets = 3; binptr_4 buffer[ max_packets ]; int sign = 1, len = 0; if (value < 0) { sign = -1; value = -value; } do { const int mask = (1 << 15) - 1; /// ... mask out 1st 15 bits buffer[ len++ ] = (mask & value); value >>= 15; } while (value != 0); p_assert( len > 0 && len <= max_packets, "too many packets" ); sign = sign * len; p.store( FT_LONGINT, 4 ); p.store( sign ); for (int i = 0; i < len; ++i) p.store( buffer[i] ); } } break; case FT_STRING: case IEF_STRING_1: case IEF_STRING_2: case IEF_STRING_4: p.store( FT_STRING, 4 ); p.store( _len, 4 ); p.store( _u.C, _len ); break; case FT_TUPLE: case IEF_TUPLE_1: case IEF_TUPLE_2: case IEF_TUPLE_4: { List<BinRep> &L = to_tuple(); p.store( FT_TUPLE, 4 ); p.store( L.entries(), 4 ); for (Iterator<BinRep> iter = L; iter.valid(); ++iter) iter.current()._setl_format( p ); } break; case FT_SET: case IEF_SET_1: case IEF_SET_2: case IEF_SET_4: { Set<BinRep> &S = to_set(); p.store( FT_SET, 4 ); p.store( S.entries(), 4 ); for (Iterator<BinRep> iter = S; iter.valid(); ++iter) iter.current()._setl_format( p ); } break; case IEF_MAP_1: case IEF_MAP_2: case IEF_MAP_4: p_abort( "not supported" ); break; default: p_abort( "unknown form code" ); break; } } void BinRep::setl_format(MemBuf &buf) const { int length = _setl_length(); buf.reset(); buf.append_empty( sizeof(binptr_4) + length ); BinPtr p( buf.data_ref() ); p.store( length ); _setl_format( p ); } void BinRep::read( istream &ifs ) { char ch; /// ... If anything exists in this BinRep, remove it. _destroy(); ifs.get( ch ); if (ifs.eof()) return; ifs.putback( ch ); if (ch != IEF_HEADER) { int length = -1; ifs.read( (char *) &length, sizeof(length) ); if (length > 0) { p_assert( length < 9999999, "SETL binstr too long" ); _setl_parse( ifs ); ifs.get( ch ); if (! ifs.eof()) ifs.putback( ch ); } } else { p_assert( ch == IEF_HEADER, "not IEF_HEADER code" ); _ief_parse( ifs ); ifs.get( ch ); if (! ifs.eof()) ifs.putback( ch ); } } int BinRep::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. return 1; } Boolean BinRep::is_omega() const { return ( #if 0 type() == FT_ALT_OMEGA || type() == FT_OMEGA || #endif type() == IEF_OMEGA ); } Boolean BinRep::is_boolean() const { return ( #if 0 type() == FT_ATOM || #endif type() == IEF_TRUE || type() == IEF_FALSE ); } Boolean BinRep::is_double() const { return ( #if 0 type() == FT_DOUBLE || #endif type() == IEF_REAL ); } Boolean BinRep::is_integer() const { return ( #if 0 type() == FT_LONGINT || type() == FT_SHORT || #endif type() == IEF_INTEGER_1 || type() == IEF_INTEGER_2 || type() == IEF_INTEGER_4 ); } Boolean BinRep::is_string() const { return ( #if 0 type() == FT_STRING || #endif type() == IEF_STRING_1 || type() == IEF_STRING_2 || type() == IEF_STRING_4 ); } Boolean BinRep::is_tuple() const { return ( #if 0 type() == FT_TUPLE || #endif type() == IEF_TUPLE_1 || type() == IEF_TUPLE_2 || type() == IEF_TUPLE_4 ); } Boolean BinRep::is_set() const { return ( #if 0 type() == FT_SET || #endif #if 0 type() == IEF_MAP_1 || type() == IEF_MAP_2 || type() == IEF_MAP_4 || #endif type() == IEF_SET_1 || type() == IEF_SET_2 || type() == IEF_SET_4 ); } Boolean BinRep::to_boolean() const { p_assert( is_boolean(), "not a boolean" ); switch ( _fc ) { case IEF_TRUE: return True; case IEF_FALSE: return False; default: return False; } return False; } double BinRep::to_double() const { p_assert( is_double(), "not a double" ); BinPtr p( _u.C ); double value; p.fetch( value ); return value; } int BinRep::to_integer() const { p_assert( is_integer(), "not an integer" ); BinPtr p( _u.C ); switch ( _fc ) { case IEF_INTEGER_1: { binptr_1 value; p.fetch( value ); return value; } case IEF_INTEGER_2: { binptr_2 value; p.fetch( value ); return value; } case IEF_INTEGER_4: { binptr_4 value; p.fetch( value ); return value; } default: return 0; } return 0; } void BinRep::to_string(String & str) const { p_assert( is_string(), "not a string" ); String s( (char *) _u.C, _len ); str = s; } List<BinRep> & BinRep::to_tuple() const { p_assert( is_tuple(), "not a tuple" ); return *_u.L; } Set<BinRep> & BinRep::to_set() const { p_assert( is_set(), "not a set" ); return *_u.S; } Database<String, BinRep> & BinRep::to_map() const { p_assert( is_map(), "not a map" ); return *_u.D; } void BinRep::put_omega() { _destroy(); _fc = IEF_OMEGA; _len = 0; _u.C = 0; } void BinRep::put_tuple(List<BinRep> *L) { _destroy(); _fc = IEF_TUPLE_4; _len = 0; _u.L = L; } void BinRep::put_set(Set<BinRep> *S) { _destroy(); _fc = IEF_SET_4; _len = 0; _u.S = S; } void BinRep::put_map(Database<String,BinRep> *D) { p_abort( "not supported" ); _destroy(); _fc = IEF_MAP_4; _len = 0; _u.D = D; } void BinRep::put_integer(const int x) { _destroy(); switch (bytes_per_value(x)) { case 1: { binptr_1 *value = (binptr_1 *)malloc(sizeof(binptr_1)); _fc = IEF_INTEGER_1; _len = sizeof( *value ); *value = (char) x; _u.C = (void *) value; break; } case 2: { binptr_2 *value = (binptr_2 *)malloc(sizeof(binptr_2)); _fc = IEF_INTEGER_2; _len = sizeof( *value ); *value = (binptr_2) x; _u.C = (void *) value; break; } case 4: { binptr_4 *value = (binptr_4 *)malloc(sizeof(binptr_4)); _fc = IEF_INTEGER_4; _len = sizeof( *value ); *value = (int) x; _u.C = (void *) value; break; } } } void BinRep::put_boolean(const Boolean b) { _destroy(); _fc = (b ? IEF_TRUE : IEF_FALSE); _len = 0; _u.C = 0; } void BinRep::put_string(const char *s, int length) { _destroy(); char *buffer = (char *)malloc((length + 1) * sizeof(char)); BinPtr p( buffer ); p.store( s, length ); _fc = IEF_STRING_4; _len = length; _u.C = (void *) buffer; } void BinRep::put_string(const String & s) { const char *p = (const char *) s; put_string( p, s.len() ); } void BinRep::put_string(const char *s) { put_string( s, strlen(s) ); } void BinRep::put_double(const double d) { _destroy(); double *value = (double *)malloc(sizeof(double)); *value = d; _fc = IEF_REAL; _len = sizeof( *value ); _u.C = (void *) value; } Listable * BinRep::listable_clone() const { return new BinRep( *this ); } void BinRep::print(ostream & o) const { String str; ascii_format( str ); o << str; } BinRep & BinRep::operator[] (int i) const { p_assert( is_tuple(), "not a tuple" ); List<BinRep> &L = to_tuple(); if (i >= 0 && L.entries() > i) return L[i]; return _omega(); } BinRep & BinRep::operator[] (const char *field) const { BinRep *b = find_ref( field ); return ( (b != 0) ? *b : _omega() ); } void BinRep::del(int i) { p_assert( is_tuple(), "not a tuple" ); List<BinRep> &L = to_tuple(); if (i >= 0 && L.entries() > i) L.del(i); } void BinRep::del(const char *field) { p_assert( is_set() == True || is_map() == True, "not a set or map" ); if (is_set()) { for (Mutator<BinRep> iter = to_set(); iter.valid(); ++iter) { p_assert( iter.current().is_tuple(), "not a tuple" ); List<BinRep> &L = iter.current().to_tuple(); if (L.entries() == 2) { BinRep &key = L[0]; if (key.is_string()) { String key_string; key.to_string( key_string ); if (key_string == field) { iter.del(); return; } } } } } else if (is_map()) { Database<String,BinRep> &D = to_map(); String s = field; BinRep *b = D.find_ref( s ); if (b != 0) D.del( s ); } } void BinRep::ins( BinRep *b ) { if (is_tuple()) to_tuple().ins_last( b ); else if (is_set()) to_set().ins( b ); else { p_abort( "not a set or tuple" ); } } void BinRep::ins( const BinRep &b ) { if (is_tuple()) to_tuple().ins_last( new BinRep(b) ); else if (is_set()) to_set().ins( new BinRep(b) ); else { p_abort( "not a set or tuple" ); } } BinRep * BinRep::clone() const { return new BinRep( *this ); } BinRep * BinRep::find_ref(const char *field) const { p_assert( is_set() == True || is_map() == True, "not a set or map" ); if (is_set()) { for (Iterator<BinRep> iter = to_set(); iter.valid(); ++iter) { p_assert( iter.current().is_tuple(), "not a tuple" ); List<BinRep> &L = iter.current().to_tuple(); if (L.entries() == 2) { BinRep &key = L[0]; if (key.is_string()) { String key_string; key.to_string( key_string ); if (key_string == field) return &L[1]; } } } } else if (is_map()) { Database<String,BinRep> &D = to_map(); String s = field; BinRep *b = D.find_ref( s ); if (b != 0) return b; } return 0; } static char *type_name[] = { "FT_OMEGA", /// ... FT_OMEGA (0) "FT_ATOM", /// ... FT_ATOM (1) "FT_SHORT", /// ... FT_SHORT (2) "(Undefined)", /// ... (3) "(Undefined)", /// ... (4) "(Undefined)", /// ... (5) "(Undefined)", /// ... (6) "(Undefined)", /// ... (7) "(Undefined)", /// ... (8) "(Undefined)", /// ... (9) "FT_DOUBLE", /// ... FT_DOUBLE (10) "FT_LONGINT", /// ... FT_LONGINT (11) "FT_STRING", /// ... FT_STRING (12) "FT_TUPLE", /// ... FT_TUPLE (13) "(Undefined)", /// ... (14) "FT_SET" /// ... FT_SET (15) }; static char *ief_type_name[] = { "IEF_OMEGA", // = 'A', /// ... Omega "IEF_TRUE", // = 'B', /// ... True "IEF_FALSE", // = 'C', /// ... False "IEF_REAL", // = 'D', /// ... 8 byte IEEE double "IEF_INTEGER_1", // = 'E', /// ... 1 byte signed integer "IEF_INTEGER_2", // = 'F', /// ... 2 byte signed integer "IEF_INTEGER_4", // = 'G', /// ... 4 byte signed integer "IEF_STRING_1", // = 'H', /// ... 1 byte unsigned length, up to $2^{8}-1$ "IEF_STRING_2", // = 'I', /// ... 2 byte unsigned length, up to $2^{16}-1$ "IEF_STRING_4", // = 'J', /// ... 4 byte unsigned length, up to $2^{32}-1$ "IEF_TUPLE_1", // = 'K', /// ... 1 byte unsigned length, up to $2^{8}-1$ "IEF_TUPLE_2", // = 'L', /// ... 2 byte unsigned length, up to $2^{16}-1$ "IEF_TUPLE_4", // = 'M', /// ... 4 byte unsigned length, up to $2^{32}-1$ "IEF_SET_1", // = 'N', /// ... 1 byte unsigned length, up to $2^{8}-1$ "IEF_SET_2", // = 'O', /// ... 2 byte unsigned length, up to $2^{16}-1$ "IEF_SET_4", // = 'P', /// ... 4 byte unsigned length, up to $2^{32}-1$ "IEF_MAP_1", // = 'Q', /// ... 1 byte unsigned length, up to $2^{8}-1$ "IEF_MAP_2", // = 'R', /// ... 2 byte unsigned length, up to $2^{16}-1$ "IEF_MAP_4", // = 'S', /// ... 4 byte unsigned length, up to $2^{32}-1$ "IEF_DICT_1", // = 'T', /// ... 1 byte unsigned dictionary index "IEF_DICT_2", // = 'U', /// ... 2 byte unsigned dictionary index "IEF_DICT_4", // = 'V', /// ... 4 byte unsigned dictionary index }; char * binstr_type_name( BINSTR_TYPE expected_type ) { int index = (int) expected_type; if (index >= 0 && index <= 15) return type_name[index]; else if (index >= 'A' && index <= 'Z') return ief_type_name[index - 'A']; else if (index == '$') return "IEF_HEADER"; else if (index == '#') return "IEF_BODY"; return "(undefined error)"; }

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