From 52be1ef0d126f09ba943c7afcf367e7d9347f2fd Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Thu, 8 Nov 2012 22:58:28 +0000 Subject: tabconv: it's all spaces now. --- src/variable.cpp | 1542 +++++++++++++++++++++++++++--------------------------- 1 file changed, 771 insertions(+), 771 deletions(-) (limited to 'src/variable.cpp') diff --git a/src/variable.cpp b/src/variable.cpp index ffc41a6..bef0ca8 100644 --- a/src/variable.cpp +++ b/src/variable.cpp @@ -6,1036 +6,1036 @@ using Bu::sio; #include Variable::Variable() : - eType( typeNone ) + eType( typeNone ) { - memset( &uVal, 0, sizeof(uVal) ); + memset( &uVal, 0, sizeof(uVal) ); } Variable::Variable( Type t ) : - eType( t ) + eType( t ) { - memset( &uVal, 0, sizeof(uVal) ); - if( eType == typeString || eType == typeRef ) - { - uVal.sVal = new Bu::String; - } - else if( eType == typeList ) - { - uVal.lVal = new VarList; - } + memset( &uVal, 0, sizeof(uVal) ); + if( eType == typeString || eType == typeRef ) + { + uVal.sVal = new Bu::String; + } + else if( eType == typeList ) + { + uVal.lVal = new VarList; + } } Variable::Variable( int iVal ) : - eType( typeInt ) + eType( typeInt ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.iVal = iVal; + memset( &uVal, 0, sizeof(uVal) ); + uVal.iVal = iVal; } Variable::Variable( double fVal ) : - eType( typeFloat ) + eType( typeFloat ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.fVal = fVal; + memset( &uVal, 0, sizeof(uVal) ); + uVal.fVal = fVal; } Variable::Variable( bool bVal ) : - eType( typeBool ) + eType( typeBool ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.bVal = bVal; + memset( &uVal, 0, sizeof(uVal) ); + uVal.bVal = bVal; } Variable::Variable( const Bu::String &sVal ) : - eType( typeString ) + eType( typeString ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.sVal = new Bu::String( sVal ); + memset( &uVal, 0, sizeof(uVal) ); + uVal.sVal = new Bu::String( sVal ); } Variable::Variable( const char *sVal ) : - eType( typeString ) + eType( typeString ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.sVal = new Bu::String( sVal ); + memset( &uVal, 0, sizeof(uVal) ); + uVal.sVal = new Bu::String( sVal ); } Variable::Variable( const Variable &v ) : - eType( v.eType ) + eType( v.eType ) { - memset( &uVal, 0, sizeof(uVal) ); - if( eType == typeString || eType == typeRef ) - { - uVal.sVal = new Bu::String( *v.uVal.sVal ); - } - else if( eType == typeList ) - { - uVal.lVal = new VarList( *v.uVal.lVal ); - } - else - { - uVal = v.uVal; - } + memset( &uVal, 0, sizeof(uVal) ); + if( eType == typeString || eType == typeRef ) + { + uVal.sVal = new Bu::String( *v.uVal.sVal ); + } + else if( eType == typeList ) + { + uVal.lVal = new VarList( *v.uVal.lVal ); + } + else + { + uVal = v.uVal; + } } - + Variable::Variable( const class AstLeaf &l ) { - switch( l.getDataType() ) - { - case AstNode::typeDataInt: - eType = typeInt; - uVal.iVal = l.getIntValue(); - break; - - case AstNode::typeDataFloat: - eType = typeFloat; - uVal.fVal = l.getFloatValue(); - break; - - case AstNode::typeDataBool: - eType = typeBool; - uVal.bVal = l.getBoolValue(); - break; - - case AstNode::typeDataString: - eType = typeString; - uVal.sVal = new Bu::String( l.getStrValue() ); - break; - - case AstNode::typeDataNone: - eType = typeNone; - memset( &uVal, 0, sizeof(uVal) ); - break; - - default: - sio << "Unhandled type <>" << sio.nl << sio.nl; - break; - } + switch( l.getDataType() ) + { + case AstNode::typeDataInt: + eType = typeInt; + uVal.iVal = l.getIntValue(); + break; + + case AstNode::typeDataFloat: + eType = typeFloat; + uVal.fVal = l.getFloatValue(); + break; + + case AstNode::typeDataBool: + eType = typeBool; + uVal.bVal = l.getBoolValue(); + break; + + case AstNode::typeDataString: + eType = typeString; + uVal.sVal = new Bu::String( l.getStrValue() ); + break; + + case AstNode::typeDataNone: + eType = typeNone; + memset( &uVal, 0, sizeof(uVal) ); + break; + + default: + sio << "Unhandled type <>" << sio.nl << sio.nl; + break; + } } Variable::Variable( const StrList &lst ) { - if( lst.getSize() == 1 ) - { - eType = typeString; - uVal.sVal = new Bu::String( lst.first() ); - } - else - { - eType = typeList; - uVal.lVal = new VarList(); - for( StrList::const_iterator i = lst.begin(); i; i++ ) - { - uVal.lVal->append( Variable( *i ) ); - } - } + if( lst.getSize() == 1 ) + { + eType = typeString; + uVal.sVal = new Bu::String( lst.first() ); + } + else + { + eType = typeList; + uVal.lVal = new VarList(); + for( StrList::const_iterator i = lst.begin(); i; i++ ) + { + uVal.lVal->append( Variable( *i ) ); + } + } } Variable::Variable( const VarList &lst ) { - eType = typeList; - uVal.lVal = new VarList( lst ); + eType = typeList; + uVal.lVal = new VarList( lst ); } Variable::Variable( void *oVal ) : - eType( typeOpaque ) + eType( typeOpaque ) { - memset( &uVal, 0, sizeof(uVal) ); - uVal.oVal = oVal; + memset( &uVal, 0, sizeof(uVal) ); + uVal.oVal = oVal; } Variable::~Variable() { - if( eType == typeString || eType == typeRef ) - { - delete uVal.sVal; - } - else if( eType == typeList ) - { - delete uVal.lVal; - } + if( eType == typeString || eType == typeRef ) + { + delete uVal.sVal; + } + else if( eType == typeList ) + { + delete uVal.lVal; + } } Variable Variable::mkRef( const Bu::String &sVal ) { - Variable v( typeRef ); - (*v.uVal.sVal) = sVal; - return v; + Variable v( typeRef ); + (*v.uVal.sVal) = sVal; + return v; } Variable::Type Variable::getType() const { - return eType; + return eType; } int Variable::getInt() const { - if( eType != typeInt ) throw Bu::ExceptionBase("Wrong variable type."); - return uVal.iVal; + if( eType != typeInt ) throw Bu::ExceptionBase("Wrong variable type."); + return uVal.iVal; } double Variable::getFloat() const { - if( eType != typeFloat ) throw Bu::ExceptionBase("Wrong variable type."); - return uVal.fVal; + if( eType != typeFloat ) throw Bu::ExceptionBase("Wrong variable type."); + return uVal.fVal; } bool Variable::getBool() const { - if( eType != typeBool ) throw Bu::ExceptionBase("Wrong variable type."); - return uVal.bVal; + if( eType != typeBool ) throw Bu::ExceptionBase("Wrong variable type."); + return uVal.bVal; } const Bu::String &Variable::getString() const { - if( eType != typeString && eType != typeRef ) throw Bu::ExceptionBase("Wrong variable type."); - return *uVal.sVal; + if( eType != typeString && eType != typeRef ) throw Bu::ExceptionBase("Wrong variable type."); + return *uVal.sVal; } const VarList &Variable::getList() const { - if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); - return *uVal.lVal; + if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); + return *uVal.lVal; } const void *Variable::getOpaque() const { - if( eType != typeOpaque ) throw Bu::ExceptionBase("Wrong variable type."); - return uVal.oVal; + if( eType != typeOpaque ) throw Bu::ExceptionBase("Wrong variable type."); + return uVal.oVal; } int Variable::toInt() const { - switch( eType ) - { - case typeInt: - return uVal.iVal; + switch( eType ) + { + case typeInt: + return uVal.iVal; - case typeFloat: - return (int)uVal.fVal; + case typeFloat: + return (int)uVal.fVal; - case typeBool: - return (uVal.bVal)?(1):(0); + case typeBool: + return (uVal.bVal)?(1):(0); - case typeString: - case typeRef: - return strtol( uVal.sVal->getStr(), NULL, 0 ); + case typeString: + case typeRef: + return strtol( uVal.sVal->getStr(), NULL, 0 ); - default: - return 0; - } - return 0; + default: + return 0; + } + return 0; } double Variable::toFloat() const { - switch( eType ) - { - case typeInt: - return (double)uVal.iVal; + switch( eType ) + { + case typeInt: + return (double)uVal.iVal; - case typeFloat: - return uVal.fVal; + case typeFloat: + return uVal.fVal; - case typeBool: - return (uVal.bVal)?(1.0):(0.0); + case typeBool: + return (uVal.bVal)?(1.0):(0.0); - case typeString: - case typeRef: - return strtod( uVal.sVal->getStr(), NULL ); + case typeString: + case typeRef: + return strtod( uVal.sVal->getStr(), NULL ); - default: - return 0.0; - } - return 0.0; + default: + return 0.0; + } + return 0.0; } bool Variable::toBool() const { - switch( eType ) - { - case typeInt: - return uVal.iVal != 0; + switch( eType ) + { + case typeInt: + return uVal.iVal != 0; - case typeFloat: - return uVal.fVal != 0.0; + case typeFloat: + return uVal.fVal != 0.0; - case typeBool: - return uVal.bVal; + case typeBool: + return uVal.bVal; - case typeString: - case typeRef: - return (*uVal.sVal) == "true"; + case typeString: + case typeRef: + return (*uVal.sVal) == "true"; - case typeList: - return !(*uVal.lVal).isEmpty(); + case typeList: + return !(*uVal.lVal).isEmpty(); - default: - return false; - } - return false; + default: + return false; + } + return false; } Bu::String Variable::toString() const { - Bu::String sRet; - switch( eType ) - { - case typeNone: - // No type, no data, we return empty string - break; - - case typeInt: - sRet = Bu::String("%1").arg( uVal.iVal ); - break; - - case typeFloat: - sRet = Bu::String("%1").arg( uVal.fVal ); - break; - - case typeBool: - sRet = (uVal.bVal)?("true"):("false"); - break; - - case typeString: - case typeRef: - sRet = *uVal.sVal; - break; - - case typeList: - { - for( VarList::const_iterator i = uVal.lVal->begin(); i; i++ ) - { - if( i != uVal.lVal->begin() ) - sRet += " "; - sRet += (*i).toString(); - } - } - break; - - case typeVersion: - break; - - case typeOpaque: - sRet = Bu::String("").arg( uVal.oVal ); - break; - } - - return sRet; + Bu::String sRet; + switch( eType ) + { + case typeNone: + // No type, no data, we return empty string + break; + + case typeInt: + sRet = Bu::String("%1").arg( uVal.iVal ); + break; + + case typeFloat: + sRet = Bu::String("%1").arg( uVal.fVal ); + break; + + case typeBool: + sRet = (uVal.bVal)?("true"):("false"); + break; + + case typeString: + case typeRef: + sRet = *uVal.sVal; + break; + + case typeList: + { + for( VarList::const_iterator i = uVal.lVal->begin(); i; i++ ) + { + if( i != uVal.lVal->begin() ) + sRet += " "; + sRet += (*i).toString(); + } + } + break; + + case typeVersion: + break; + + case typeOpaque: + sRet = Bu::String("").arg( uVal.oVal ); + break; + } + + return sRet; } VarList Variable::toList() const { - if( eType == typeList ) - return *uVal.lVal; - return VarList( *this ); + if( eType == typeList ) + return *uVal.lVal; + return VarList( *this ); } Variable Variable::toType( Type eNewType ) const { - switch( eNewType ) - { - case typeNone: - return Variable(); + switch( eNewType ) + { + case typeNone: + return Variable(); - case typeBool: - return Variable( toBool() ); + case typeBool: + return Variable( toBool() ); - case typeInt: - return Variable( toInt() ); + case typeInt: + return Variable( toInt() ); - case typeFloat: - return Variable( toFloat() ); + case typeFloat: + return Variable( toFloat() ); - case typeVersion: - return Variable(); + case typeVersion: + return Variable(); - case typeString: - return Variable( toString() ); + case typeString: + return Variable( toString() ); - case typeList: - return Variable( toList() ); - - case typeRef: - return Variable::mkRef( toString() ); + case typeList: + return Variable( toList() ); + + case typeRef: + return Variable::mkRef( toString() ); - case typeOpaque: - throw Bu::ExceptionBase("Cannot convert opaque types."); - } - throw Bu::ExceptionBase("Unhandled case in Variable toType"); + case typeOpaque: + throw Bu::ExceptionBase("Cannot convert opaque types."); + } + throw Bu::ExceptionBase("Unhandled case in Variable toType"); } void Variable::append( const Variable &v ) { - if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); - - if( v.eType == typeList ) - { - uVal.lVal->append( *v.uVal.lVal ); - } - else - { - uVal.lVal->append( v ); - } + if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); + + if( v.eType == typeList ) + { + uVal.lVal->append( *v.uVal.lVal ); + } + else + { + uVal.lVal->append( v ); + } } VarList::iterator Variable::begin() { - if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); + if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); - return uVal.lVal->begin(); + return uVal.lVal->begin(); } VarList::const_iterator Variable::begin() const { - if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); - - return const_cast(uVal.lVal)->begin(); + if( eType != typeList ) throw Bu::ExceptionBase("Wrong variable type."); + + return const_cast(uVal.lVal)->begin(); } void Variable::doNegate() { - switch( eType ) - { - case typeNone: - break; - - case typeBool: - throw Bu::ExceptionBase("You cannot negate boolean values."); - - case typeInt: - uVal.iVal = -uVal.iVal; - break; - - case typeFloat: - uVal.fVal = -uVal.fVal; - break; - - case typeVersion: - throw Bu::ExceptionBase("You cannot negate version values."); - - case typeString: - throw Bu::ExceptionBase("You cannot negate string values."); - - case typeList: - throw Bu::ExceptionBase("You cannot negate list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot negate reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot negate opaque values."); - } + switch( eType ) + { + case typeNone: + break; + + case typeBool: + throw Bu::ExceptionBase("You cannot negate boolean values."); + + case typeInt: + uVal.iVal = -uVal.iVal; + break; + + case typeFloat: + uVal.fVal = -uVal.fVal; + break; + + case typeVersion: + throw Bu::ExceptionBase("You cannot negate version values."); + + case typeString: + throw Bu::ExceptionBase("You cannot negate string values."); + + case typeList: + throw Bu::ExceptionBase("You cannot negate list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot negate reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot negate opaque values."); + } } void Variable::doNot() { - bool bVal = !toBool(); - reset( typeBool ); - uVal.bVal = bVal; + bool bVal = !toBool(); + reset( typeBool ); + uVal.bVal = bVal; } const Variable &Variable::operator=( const Variable &rhs ) { - reset( rhs.eType ); - if( rhs.eType == typeString || rhs.eType == typeRef ) - { - uVal.sVal = new Bu::String( *rhs.uVal.sVal ); - } - else if( rhs.eType == typeList ) - { - uVal.lVal = new VarList( *rhs.uVal.lVal ); - } - else - { - uVal = rhs.uVal; - } - - return *this; + reset( rhs.eType ); + if( rhs.eType == typeString || rhs.eType == typeRef ) + { + uVal.sVal = new Bu::String( *rhs.uVal.sVal ); + } + else if( rhs.eType == typeList ) + { + uVal.lVal = new VarList( *rhs.uVal.lVal ); + } + else + { + uVal = rhs.uVal; + } + + return *this; } const Variable &Variable::operator=( const int &rhs ) { - reset( typeInt ); - uVal.iVal = rhs; + reset( typeInt ); + uVal.iVal = rhs; - return *this; + return *this; } const Variable &Variable::operator=( const double &rhs ) { - reset( typeFloat ); - uVal.fVal = rhs; + reset( typeFloat ); + uVal.fVal = rhs; - return *this; + return *this; } const Variable &Variable::operator=( const bool &rhs ) { - reset( typeBool ); - uVal.bVal = rhs; + reset( typeBool ); + uVal.bVal = rhs; - return *this; + return *this; } const Variable &Variable::operator=( const Bu::String &rhs ) { - reset( typeString ); - uVal.sVal = new Bu::String( rhs ); + reset( typeString ); + uVal.sVal = new Bu::String( rhs ); - return *this; + return *this; } const Variable &Variable::operator=( void *rhs ) { - reset( typeOpaque ); - uVal.oVal = rhs; + reset( typeOpaque ); + uVal.oVal = rhs; - return *this; + return *this; } const Variable &Variable::operator+=( const Variable &rhs ) { - switch( eType ) - { - case typeNone: - reset( rhs.eType ); - if( eType == typeString || eType == typeRef ) - { - uVal.sVal = new Bu::String( *rhs.uVal.sVal ); - } - else if( eType == typeList ) - { - uVal.lVal = new VarList( *rhs.uVal.lVal ); - } - else - { - uVal = rhs.uVal; - } - break; - - case typeInt: - uVal.iVal += rhs.getInt(); - break; - - case typeFloat: - uVal.fVal += rhs.getFloat(); - break; - - case typeBool: - throw Bu::ExceptionBase("Can't += with a boolean..."); - break; - - case typeString: - uVal.sVal->append(" "); - uVal.sVal->append( rhs.getString() ); - break; - - case typeList: - uVal.lVal->append( rhs.getList() ); - break; - - case typeVersion: - break; - - default: - break; - } - return *this; + switch( eType ) + { + case typeNone: + reset( rhs.eType ); + if( eType == typeString || eType == typeRef ) + { + uVal.sVal = new Bu::String( *rhs.uVal.sVal ); + } + else if( eType == typeList ) + { + uVal.lVal = new VarList( *rhs.uVal.lVal ); + } + else + { + uVal = rhs.uVal; + } + break; + + case typeInt: + uVal.iVal += rhs.getInt(); + break; + + case typeFloat: + uVal.fVal += rhs.getFloat(); + break; + + case typeBool: + throw Bu::ExceptionBase("Can't += with a boolean..."); + break; + + case typeString: + uVal.sVal->append(" "); + uVal.sVal->append( rhs.getString() ); + break; + + case typeList: + uVal.lVal->append( rhs.getList() ); + break; + + case typeVersion: + break; + + default: + break; + } + return *this; } const Variable &Variable::operator<<( const Variable &rhs ) { - switch( eType ) - { - case typeNone: - reset( rhs.eType ); - if( eType == typeString ) - { - uVal.sVal = new Bu::String( *rhs.uVal.sVal ); - } - else if( eType == typeList ) - { - uVal.lVal = new VarList( *rhs.uVal.lVal ); - } - else - { - uVal = rhs.uVal; - } - break; - - case typeString: - uVal.sVal->append( rhs.getString() ); - break; - - case typeList: - uVal.lVal->append( rhs.getList() ); - break; - - default: - throw Bu::ExceptionBase("Can't << with non-string or non-list."); - break; - } - return *this; + switch( eType ) + { + case typeNone: + reset( rhs.eType ); + if( eType == typeString ) + { + uVal.sVal = new Bu::String( *rhs.uVal.sVal ); + } + else if( eType == typeList ) + { + uVal.lVal = new VarList( *rhs.uVal.lVal ); + } + else + { + uVal = rhs.uVal; + } + break; + + case typeString: + uVal.sVal->append( rhs.getString() ); + break; + + case typeList: + uVal.lVal->append( rhs.getList() ); + break; + + default: + throw Bu::ExceptionBase("Can't << with non-string or non-list."); + break; + } + return *this; } bool Variable::operator==( const Variable &rhs ) const { - if( eType != rhs.eType ) - return false; - switch( eType ) - { - case typeNone: - return true; + if( eType != rhs.eType ) + return false; + switch( eType ) + { + case typeNone: + return true; - case typeInt: - return uVal.iVal == rhs.uVal.iVal; + case typeInt: + return uVal.iVal == rhs.uVal.iVal; - case typeFloat: - return uVal.fVal == rhs.uVal.fVal; + case typeFloat: + return uVal.fVal == rhs.uVal.fVal; - case typeBool: - return uVal.bVal == rhs.uVal.bVal; + case typeBool: + return uVal.bVal == rhs.uVal.bVal; - case typeString: - case typeRef: - return *uVal.sVal == *rhs.uVal.sVal; + case typeString: + case typeRef: + return *uVal.sVal == *rhs.uVal.sVal; - case typeList: - return *uVal.lVal == *rhs.uVal.lVal; + case typeList: + return *uVal.lVal == *rhs.uVal.lVal; - case typeVersion: - return false; + case typeVersion: + return false; - case typeOpaque: - return uVal.oVal == rhs.uVal.oVal; - } + case typeOpaque: + return uVal.oVal == rhs.uVal.oVal; + } - return false; + return false; } bool Variable::operator!=( const Variable &rhs ) const { - return !(*this == rhs); + return !(*this == rhs); } bool Variable::operator<( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return false; - - case typeBool: - throw Bu::ExceptionBase("You cannot < compare boolean values."); - - case typeInt: - return toInt() < rhs.toInt(); - - case typeFloat: - return toFloat() < rhs.toFloat(); - - case typeVersion: - return true; - - case typeString: - return toString() < rhs.toString(); - - case typeList: - throw Bu::ExceptionBase("You cannot < compare list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot < compare reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot < compare opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable < compare"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return false; + + case typeBool: + throw Bu::ExceptionBase("You cannot < compare boolean values."); + + case typeInt: + return toInt() < rhs.toInt(); + + case typeFloat: + return toFloat() < rhs.toFloat(); + + case typeVersion: + return true; + + case typeString: + return toString() < rhs.toString(); + + case typeList: + throw Bu::ExceptionBase("You cannot < compare list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot < compare reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot < compare opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable < compare"); } bool Variable::operator>( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return false; - - case typeBool: - throw Bu::ExceptionBase("You cannot > compare boolean values."); - - case typeInt: - return toInt() > rhs.toInt(); - - case typeFloat: - return toFloat() > rhs.toFloat(); - - case typeVersion: - return true; - - case typeString: - return toString() > rhs.toString(); - - case typeList: - throw Bu::ExceptionBase("You cannot > compare list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot > compare reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot > compare opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable > compare"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return false; + + case typeBool: + throw Bu::ExceptionBase("You cannot > compare boolean values."); + + case typeInt: + return toInt() > rhs.toInt(); + + case typeFloat: + return toFloat() > rhs.toFloat(); + + case typeVersion: + return true; + + case typeString: + return toString() > rhs.toString(); + + case typeList: + throw Bu::ExceptionBase("You cannot > compare list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot > compare reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot > compare opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable > compare"); } bool Variable::operator<=( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return false; - - case typeBool: - throw Bu::ExceptionBase("You cannot <= compare boolean values."); - - case typeInt: - return toInt() <= rhs.toInt(); - - case typeFloat: - return toFloat() <= rhs.toFloat(); - - case typeVersion: - return true; - - case typeString: - return toString() <= rhs.toString(); - - case typeList: - throw Bu::ExceptionBase("You cannot <= compare list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot <= compare reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot <= compare opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable <= compare"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return false; + + case typeBool: + throw Bu::ExceptionBase("You cannot <= compare boolean values."); + + case typeInt: + return toInt() <= rhs.toInt(); + + case typeFloat: + return toFloat() <= rhs.toFloat(); + + case typeVersion: + return true; + + case typeString: + return toString() <= rhs.toString(); + + case typeList: + throw Bu::ExceptionBase("You cannot <= compare list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot <= compare reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot <= compare opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable <= compare"); } bool Variable::operator>=( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return false; - - case typeBool: - throw Bu::ExceptionBase("You cannot >= compare boolean values."); - - case typeInt: - return toInt() >= rhs.toInt(); - - case typeFloat: - return toFloat() >= rhs.toFloat(); - - case typeVersion: - return true; - - case typeString: - return toString() >= rhs.toString(); - - case typeList: - throw Bu::ExceptionBase("You cannot >= compare list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot >= compare reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot >= compare opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable >= compare"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return false; + + case typeBool: + throw Bu::ExceptionBase("You cannot >= compare boolean values."); + + case typeInt: + return toInt() >= rhs.toInt(); + + case typeFloat: + return toFloat() >= rhs.toFloat(); + + case typeVersion: + return true; + + case typeString: + return toString() >= rhs.toString(); + + case typeList: + throw Bu::ExceptionBase("You cannot >= compare list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot >= compare reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot >= compare opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable >= compare"); } Variable Variable::operator+( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return Variable(); - - case typeBool: - throw Bu::ExceptionBase("You cannot add boolean values."); - - case typeInt: - return Variable( toInt() + rhs.toInt() ); - - case typeFloat: - return Variable( toFloat() + rhs.toFloat() ); - - case typeVersion: - throw Bu::ExceptionBase("You cannot add version values."); - - case typeString: - return Variable( toString() + rhs.toString() ); - - case typeList: - return Variable( toList() + rhs.toList() ); - - case typeRef: - throw Bu::ExceptionBase("You cannot add reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot add opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable add"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return Variable(); + + case typeBool: + throw Bu::ExceptionBase("You cannot add boolean values."); + + case typeInt: + return Variable( toInt() + rhs.toInt() ); + + case typeFloat: + return Variable( toFloat() + rhs.toFloat() ); + + case typeVersion: + throw Bu::ExceptionBase("You cannot add version values."); + + case typeString: + return Variable( toString() + rhs.toString() ); + + case typeList: + return Variable( toList() + rhs.toList() ); + + case typeRef: + throw Bu::ExceptionBase("You cannot add reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot add opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable add"); } Variable Variable::operator-( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return Variable(); - - case typeBool: - throw Bu::ExceptionBase("You cannot subtract boolean values."); - - case typeInt: - return Variable( toInt() - rhs.toInt() ); - - case typeFloat: - return Variable( toFloat() - rhs.toFloat() ); - - case typeVersion: - throw Bu::ExceptionBase("You cannot subtract version values."); - - case typeString: - throw Bu::ExceptionBase("You cannot subtract string values."); - - case typeList: - return Variable( toList() - rhs.toList() ); - - case typeRef: - throw Bu::ExceptionBase("You cannot subtract reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot subtract opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable subtract"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return Variable(); + + case typeBool: + throw Bu::ExceptionBase("You cannot subtract boolean values."); + + case typeInt: + return Variable( toInt() - rhs.toInt() ); + + case typeFloat: + return Variable( toFloat() - rhs.toFloat() ); + + case typeVersion: + throw Bu::ExceptionBase("You cannot subtract version values."); + + case typeString: + throw Bu::ExceptionBase("You cannot subtract string values."); + + case typeList: + return Variable( toList() - rhs.toList() ); + + case typeRef: + throw Bu::ExceptionBase("You cannot subtract reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot subtract opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable subtract"); } Variable Variable::operator*( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return Variable(); - - case typeBool: - throw Bu::ExceptionBase("You cannot multiply boolean values."); - - case typeInt: - return Variable( toInt() * rhs.toInt() ); - - case typeFloat: - return Variable( toFloat() * rhs.toFloat() ); - - case typeVersion: - throw Bu::ExceptionBase("You cannot multiply version values."); - - case typeString: - throw Bu::ExceptionBase("You cannot multiply string values."); - - case typeList: - throw Bu::ExceptionBase("You cannot multiply list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot multiply reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot multiply opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable multiply"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return Variable(); + + case typeBool: + throw Bu::ExceptionBase("You cannot multiply boolean values."); + + case typeInt: + return Variable( toInt() * rhs.toInt() ); + + case typeFloat: + return Variable( toFloat() * rhs.toFloat() ); + + case typeVersion: + throw Bu::ExceptionBase("You cannot multiply version values."); + + case typeString: + throw Bu::ExceptionBase("You cannot multiply string values."); + + case typeList: + throw Bu::ExceptionBase("You cannot multiply list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot multiply reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot multiply opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable multiply"); } Variable Variable::operator/( const Variable &rhs ) const { - Type eTop = Bu::buMax( eType, rhs.eType ); - switch( eTop ) - { - case typeNone: - return Variable(); - - case typeBool: - throw Bu::ExceptionBase("You cannot divide boolean values."); - - case typeInt: - return Variable( toInt() / rhs.toInt() ); - - case typeFloat: - return Variable( toFloat() / rhs.toFloat() ); - - case typeVersion: - throw Bu::ExceptionBase("You cannot divide version values."); - - case typeString: - throw Bu::ExceptionBase("You cannot divide string values."); - - case typeList: - throw Bu::ExceptionBase("You cannot divide list values."); - - case typeRef: - throw Bu::ExceptionBase("You cannot divide reference values."); - - case typeOpaque: - throw Bu::ExceptionBase("You cannot divide opaque values."); - } - throw Bu::ExceptionBase("Unhandled case in Variable divide"); + Type eTop = Bu::buMax( eType, rhs.eType ); + switch( eTop ) + { + case typeNone: + return Variable(); + + case typeBool: + throw Bu::ExceptionBase("You cannot divide boolean values."); + + case typeInt: + return Variable( toInt() / rhs.toInt() ); + + case typeFloat: + return Variable( toFloat() / rhs.toFloat() ); + + case typeVersion: + throw Bu::ExceptionBase("You cannot divide version values."); + + case typeString: + throw Bu::ExceptionBase("You cannot divide string values."); + + case typeList: + throw Bu::ExceptionBase("You cannot divide list values."); + + case typeRef: + throw Bu::ExceptionBase("You cannot divide reference values."); + + case typeOpaque: + throw Bu::ExceptionBase("You cannot divide opaque values."); + } + throw Bu::ExceptionBase("Unhandled case in Variable divide"); } void Variable::reset( Type eNewType ) { - if( eType == typeString || eType == typeRef ) - { - delete uVal.sVal; - } - else if( eType == typeList ) - { - delete uVal.lVal; - } - memset( &uVal, 0, sizeof(uVal) ); - - eType = eNewType; + if( eType == typeString || eType == typeRef ) + { + delete uVal.sVal; + } + else if( eType == typeList ) + { + delete uVal.lVal; + } + memset( &uVal, 0, sizeof(uVal) ); + + eType = eNewType; } Bu::Formatter &operator<<( Bu::Formatter &f, const Variable::Type &t ) { - switch( t ) - { - case Variable::typeNone: f << "*typeless*"; break; - case Variable::typeInt: f << "int"; break; - case Variable::typeFloat: f << "double"; break; - case Variable::typeBool: f << "bool"; break; - case Variable::typeString: f << "string"; break; - case Variable::typeList: f << "list"; break; - case Variable::typeVersion: f << "version"; break; - case Variable::typeRef: f << "ref"; break; - case Variable::typeOpaque: f << "opaque"; break; - } - return f; + switch( t ) + { + case Variable::typeNone: f << "*typeless*"; break; + case Variable::typeInt: f << "int"; break; + case Variable::typeFloat: f << "double"; break; + case Variable::typeBool: f << "bool"; break; + case Variable::typeString: f << "string"; break; + case Variable::typeList: f << "list"; break; + case Variable::typeVersion: f << "version"; break; + case Variable::typeRef: f << "ref"; break; + case Variable::typeOpaque: f << "opaque"; break; + } + return f; } Bu::Formatter &operator<<( Bu::Formatter &f, const Variable &v ) { - f << "Variable(" << v.getType() << ") = "; - switch( v.getType() ) - { - case Variable::typeNone: break; - case Variable::typeInt: f << v.getInt(); break; - case Variable::typeFloat: f << v.getFloat(); break; - case Variable::typeBool: f << v.getBool(); break; - case Variable::typeString: f << v.getString(); break; - case Variable::typeList: f << v.getList(); break; - case Variable::typeVersion:/*f << v.getVersion();*/ break; - case Variable::typeRef: f << v.getString(); break; - case Variable::typeOpaque: f << ""; - break; - } - - return f; + f << "Variable(" << v.getType() << ") = "; + switch( v.getType() ) + { + case Variable::typeNone: break; + case Variable::typeInt: f << v.getInt(); break; + case Variable::typeFloat: f << v.getFloat(); break; + case Variable::typeBool: f << v.getBool(); break; + case Variable::typeString: f << v.getString(); break; + case Variable::typeList: f << v.getList(); break; + case Variable::typeVersion:/*f << v.getVersion();*/ break; + case Variable::typeRef: f << v.getString(); break; + case Variable::typeOpaque: f << ""; + break; + } + + return f; } Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Variable &v ) { - ar << (int8_t)v.eType; - switch( v.eType ) - { - case Variable::typeNone: - break; + ar << (int8_t)v.eType; + switch( v.eType ) + { + case Variable::typeNone: + break; - case Variable::typeBool: - ar << v.uVal.bVal; - break; + case Variable::typeBool: + ar << v.uVal.bVal; + break; - case Variable::typeInt: - ar << v.uVal.iVal; - break; + case Variable::typeInt: + ar << v.uVal.iVal; + break; - case Variable::typeFloat: - ar << v.uVal.fVal; - break; + case Variable::typeFloat: + ar << v.uVal.fVal; + break; - case Variable::typeVersion: - break; + case Variable::typeVersion: + break; - case Variable::typeString: - ar << *v.uVal.sVal; - break; + case Variable::typeString: + ar << *v.uVal.sVal; + break; - case Variable::typeList: - ar << *v.uVal.lVal; - break; + case Variable::typeList: + ar << *v.uVal.lVal; + break; - case Variable::typeRef: - ar << *v.uVal.sVal; - break; + case Variable::typeRef: + ar << *v.uVal.sVal; + break; - case Variable::typeOpaque: - break; - } + case Variable::typeOpaque: + break; + } - return ar; + return ar; } Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Variable &v ) { - int8_t t; - ar >> t; - v.eType = (Variable::Type)t; - v.reset( v.eType ); - switch( v.eType ) - { - case Variable::typeNone: - break; - - case Variable::typeBool: - ar >> v.uVal.bVal; - break; - - case Variable::typeInt: - ar >> v.uVal.iVal; - break; - - case Variable::typeFloat: - ar >> v.uVal.fVal; - break; - - case Variable::typeVersion: - break; - - case Variable::typeString: - ar >> *v.uVal.sVal; - break; - - case Variable::typeList: - ar >> *v.uVal.lVal; - break; - - case Variable::typeRef: - ar >> *v.uVal.sVal; - break; - - case Variable::typeOpaque: - break; - } - - return ar; + int8_t t; + ar >> t; + v.eType = (Variable::Type)t; + v.reset( v.eType ); + switch( v.eType ) + { + case Variable::typeNone: + break; + + case Variable::typeBool: + ar >> v.uVal.bVal; + break; + + case Variable::typeInt: + ar >> v.uVal.iVal; + break; + + case Variable::typeFloat: + ar >> v.uVal.fVal; + break; + + case Variable::typeVersion: + break; + + case Variable::typeString: + ar >> *v.uVal.sVal; + break; + + case Variable::typeList: + ar >> *v.uVal.lVal; + break; + + case Variable::typeRef: + ar >> *v.uVal.sVal; + break; + + case Variable::typeOpaque: + break; + } + + return ar; } VarList operator-( const VarList &rBase, const VarList &rSub ) -- cgit v1.2.3