From abada90e3f84dc703b8ddc9efcbed8a946fadead Mon Sep 17 00:00:00 2001 From: Bernard Normier Date: Thu, 1 Feb 2007 17:09:49 +0000 Subject: Expanded tabs into spaces --- php/src/IcePHP/Marshal.cpp | 692 ++++++++++++++++++++++----------------------- 1 file changed, 346 insertions(+), 346 deletions(-) (limited to 'php/src/IcePHP/Marshal.cpp') diff --git a/php/src/IcePHP/Marshal.cpp b/php/src/IcePHP/Marshal.cpp index 7c29b94346f..b3501512285 100644 --- a/php/src/IcePHP/Marshal.cpp +++ b/php/src/IcePHP/Marshal.cpp @@ -390,7 +390,7 @@ IcePHP::Marshaler::createMarshaler(const Slice::TypePtr& type TSRMLS_DC) { string scoped = cl->scoped(); php_error_docref(NULL TSRMLS_CC, E_ERROR, "cannot use Slice %s %s because it has not been defined", - cl->isInterface() ? "interface" : "class", scoped.c_str()); + cl->isInterface() ? "interface" : "class", scoped.c_str()); return 0; } return new ObjectMarshaler(def TSRMLS_CC); @@ -560,7 +560,7 @@ IcePHP::PrimitiveMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Ob { if(!validate(zv TSRMLS_CC)) { - return false; + return false; } switch(_type->kind()) @@ -747,7 +747,7 @@ IcePHP::SequenceMarshaler::SequenceMarshaler(const Slice::SequencePtr& type TSRM Slice::BuiltinPtr b = Slice::BuiltinPtr::dynamicCast(type); if(b && b->kind() != Slice::Builtin::KindObject && b->kind() != Slice::Builtin::KindObjectProxy) { - _builtin = b; + _builtin = b; } _elementMarshaler = createMarshaler(type->type() TSRMLS_CC); } @@ -757,9 +757,9 @@ IcePHP::SequenceMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Obj { if(Z_TYPE_P(zv) != IS_ARRAY) { - string s = zendTypeToString(Z_TYPE_P(zv)); - php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected array value but received %s", s.c_str()); - return false; + string s = zendTypeToString(Z_TYPE_P(zv)); + php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected array value but received %s", s.c_str()); + return false; } HashTable* arr = Z_ARRVAL_P(zv); @@ -770,198 +770,198 @@ IcePHP::SequenceMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Obj if(_builtin) { - PrimitiveMarshalerPtr pm = PrimitiveMarshalerPtr::dynamicCast(_elementMarshaler); - assert(pm); - switch(_builtin->kind()) - { - case Slice::Builtin::KindBool: - { - Ice::BoolSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - seq[i++] = Z_BVAL_P(*val) ? true : false; - zend_hash_move_forward_ex(arr, &pos); - } - os->writeBoolSeq(seq); - break; - } - case Slice::Builtin::KindByte: - { - Ice::ByteSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - long l = Z_LVAL_P(*val); - assert(l >= 0 && l <= 255); - seq[i++] = static_cast(l); - zend_hash_move_forward_ex(arr, &pos); - } - os->writeByteSeq(seq); - break; - } - case Slice::Builtin::KindShort: - { - Ice::ShortSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - long l = Z_LVAL_P(*val); - assert(l >= SHRT_MIN && l <= SHRT_MAX); - seq[i++] = static_cast(l); - zend_hash_move_forward_ex(arr, &pos); - } - os->writeShortSeq(seq); - break; - } - case Slice::Builtin::KindInt: - { - Ice::IntSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - long l = Z_LVAL_P(*val); - assert(l >= INT_MIN && l <= INT_MAX); - seq[i++] = static_cast(l); - zend_hash_move_forward_ex(arr, &pos); - } - os->writeIntSeq(seq); - break; - } - case Slice::Builtin::KindLong: - { - Ice::LongSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - // - // The platform's 'long' type may not be 64 bits, so we also accept - // a string argument for this type. - // - assert(Z_TYPE_P(*val) == IS_LONG || Z_TYPE_P(*val) == IS_STRING); - Ice::Long l; - if(Z_TYPE_P(*val) == IS_LONG) - { - l = Z_LVAL_P(*val); - } - else - { - string sval(Z_STRVAL_P(*val), Z_STRLEN_P(*val)); - IceUtil::stringToInt64(sval, l); - } - seq[i++] = l; - zend_hash_move_forward_ex(arr, &pos); - } - os->writeLongSeq(seq); - break; - } - case Slice::Builtin::KindFloat: - { - Ice::FloatSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - double d = Z_DVAL_P(*val); - seq[i++] = static_cast(d); - zend_hash_move_forward_ex(arr, &pos); - } - os->writeFloatSeq(seq); - break; - } - case Slice::Builtin::KindDouble: - { - Ice::DoubleSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - double d = Z_DVAL_P(*val); - seq[i++] = d; - zend_hash_move_forward_ex(arr, &pos); - } - os->writeDoubleSeq(seq); - break; - } - case Slice::Builtin::KindString: - { - Ice::StringSeq seq(sz); - zval** val; - Ice::Int i = 0; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!pm->validate(*val TSRMLS_CC)) - { - return false; - } - string s; - if(Z_TYPE_P(*val) == IS_STRING) - { - s = string(Z_STRVAL_P(*val), Z_STRLEN_P(*val)); - } - else - { - assert(Z_TYPE_P(*val) == IS_NULL); - } - seq[i++] = s; - zend_hash_move_forward_ex(arr, &pos); - } - os->writeStringSeq(seq); - break; - } - - case Slice::Builtin::KindObject: - case Slice::Builtin::KindObjectProxy: - case Slice::Builtin::KindLocalObject: - assert(false); - } + PrimitiveMarshalerPtr pm = PrimitiveMarshalerPtr::dynamicCast(_elementMarshaler); + assert(pm); + switch(_builtin->kind()) + { + case Slice::Builtin::KindBool: + { + Ice::BoolSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + seq[i++] = Z_BVAL_P(*val) ? true : false; + zend_hash_move_forward_ex(arr, &pos); + } + os->writeBoolSeq(seq); + break; + } + case Slice::Builtin::KindByte: + { + Ice::ByteSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + long l = Z_LVAL_P(*val); + assert(l >= 0 && l <= 255); + seq[i++] = static_cast(l); + zend_hash_move_forward_ex(arr, &pos); + } + os->writeByteSeq(seq); + break; + } + case Slice::Builtin::KindShort: + { + Ice::ShortSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + long l = Z_LVAL_P(*val); + assert(l >= SHRT_MIN && l <= SHRT_MAX); + seq[i++] = static_cast(l); + zend_hash_move_forward_ex(arr, &pos); + } + os->writeShortSeq(seq); + break; + } + case Slice::Builtin::KindInt: + { + Ice::IntSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + long l = Z_LVAL_P(*val); + assert(l >= INT_MIN && l <= INT_MAX); + seq[i++] = static_cast(l); + zend_hash_move_forward_ex(arr, &pos); + } + os->writeIntSeq(seq); + break; + } + case Slice::Builtin::KindLong: + { + Ice::LongSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + // + // The platform's 'long' type may not be 64 bits, so we also accept + // a string argument for this type. + // + assert(Z_TYPE_P(*val) == IS_LONG || Z_TYPE_P(*val) == IS_STRING); + Ice::Long l; + if(Z_TYPE_P(*val) == IS_LONG) + { + l = Z_LVAL_P(*val); + } + else + { + string sval(Z_STRVAL_P(*val), Z_STRLEN_P(*val)); + IceUtil::stringToInt64(sval, l); + } + seq[i++] = l; + zend_hash_move_forward_ex(arr, &pos); + } + os->writeLongSeq(seq); + break; + } + case Slice::Builtin::KindFloat: + { + Ice::FloatSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + double d = Z_DVAL_P(*val); + seq[i++] = static_cast(d); + zend_hash_move_forward_ex(arr, &pos); + } + os->writeFloatSeq(seq); + break; + } + case Slice::Builtin::KindDouble: + { + Ice::DoubleSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + double d = Z_DVAL_P(*val); + seq[i++] = d; + zend_hash_move_forward_ex(arr, &pos); + } + os->writeDoubleSeq(seq); + break; + } + case Slice::Builtin::KindString: + { + Ice::StringSeq seq(sz); + zval** val; + Ice::Int i = 0; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!pm->validate(*val TSRMLS_CC)) + { + return false; + } + string s; + if(Z_TYPE_P(*val) == IS_STRING) + { + s = string(Z_STRVAL_P(*val), Z_STRLEN_P(*val)); + } + else + { + assert(Z_TYPE_P(*val) == IS_NULL); + } + seq[i++] = s; + zend_hash_move_forward_ex(arr, &pos); + } + os->writeStringSeq(seq); + break; + } + + case Slice::Builtin::KindObject: + case Slice::Builtin::KindObjectProxy: + case Slice::Builtin::KindLocalObject: + assert(false); + } } else { - os->writeSize(sz); + os->writeSize(sz); - zval** val; - while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) - { - if(!_elementMarshaler->marshal(*val, os, m TSRMLS_CC)) - { - return false; - } - zend_hash_move_forward_ex(arr, &pos); - } + zval** val; + while(zend_hash_get_current_data_ex(arr, (void**)&val, &pos) != FAILURE) + { + if(!_elementMarshaler->marshal(*val, os, m TSRMLS_CC)) + { + return false; + } + zend_hash_move_forward_ex(arr, &pos); + } } return true; @@ -974,156 +974,156 @@ IcePHP::SequenceMarshaler::unmarshal(zval* zv, const Ice::InputStreamPtr& is TSR if(_builtin) { - switch(_builtin->kind()) - { - case Slice::Builtin::KindBool: - { - pair pr; - IceUtil::ScopedArray arr(is->readBoolSeq(pr)); - Ice::Int i = 0; - for(const bool* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_BOOL(val, *p ? 1 : 0); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindByte: - { - pair pr; - is->readByteSeq(pr); - Ice::Int i = 0; - for(const Ice::Byte* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_LONG(val, *p & 0xff); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindShort: - { - pair pr; - IceUtil::ScopedArray arr(is->readShortSeq(pr)); - Ice::Int i = 0; - for(const Ice::Short* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_LONG(val, *p); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindInt: - { - pair pr; - IceUtil::ScopedArray arr(is->readIntSeq(pr)); - Ice::Int i = 0; - for(const Ice::Int* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_LONG(val, *p); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindLong: - { - pair pr; - IceUtil::ScopedArray arr(is->readLongSeq(pr)); - Ice::Int i = 0; - for(const Ice::Long* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - // - // The platform's 'long' type may not be 64 bits, so we store 64-bit - // values as a string. - // - if(sizeof(Ice::Long) > sizeof(long) && (*p < LONG_MIN || *p > LONG_MAX)) - { - char buf[64]; + switch(_builtin->kind()) + { + case Slice::Builtin::KindBool: + { + pair pr; + IceUtil::ScopedArray arr(is->readBoolSeq(pr)); + Ice::Int i = 0; + for(const bool* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_BOOL(val, *p ? 1 : 0); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindByte: + { + pair pr; + is->readByteSeq(pr); + Ice::Int i = 0; + for(const Ice::Byte* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_LONG(val, *p & 0xff); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindShort: + { + pair pr; + IceUtil::ScopedArray arr(is->readShortSeq(pr)); + Ice::Int i = 0; + for(const Ice::Short* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_LONG(val, *p); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindInt: + { + pair pr; + IceUtil::ScopedArray arr(is->readIntSeq(pr)); + Ice::Int i = 0; + for(const Ice::Int* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_LONG(val, *p); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindLong: + { + pair pr; + IceUtil::ScopedArray arr(is->readLongSeq(pr)); + Ice::Int i = 0; + for(const Ice::Long* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + // + // The platform's 'long' type may not be 64 bits, so we store 64-bit + // values as a string. + // + if(sizeof(Ice::Long) > sizeof(long) && (*p < LONG_MIN || *p > LONG_MAX)) + { + char buf[64]; #ifdef WIN32 - sprintf(buf, "%I64d", *p); + sprintf(buf, "%I64d", *p); #else - sprintf(buf, "%lld", *p); + sprintf(buf, "%lld", *p); #endif - ZVAL_STRING(val, buf, 1); - } - else - { - ZVAL_LONG(val, static_cast(*p)); - } - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindFloat: - { - pair pr; - IceUtil::ScopedArray arr(is->readFloatSeq(pr)); - Ice::Int i = 0; - for(const Ice::Float* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_DOUBLE(zv, *p); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindDouble: - { - pair pr; - IceUtil::ScopedArray arr(is->readDoubleSeq(pr)); - Ice::Int i = 0; - for(const Ice::Double* p = pr.first; p != pr.second; ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_DOUBLE(zv, *p); - add_index_zval(zv, i, val); - } - break; - } - case Slice::Builtin::KindString: - { - Ice::StringSeq seq = is->readStringSeq(); - Ice::Int i = 0; - for(Ice::StringSeq::iterator p = seq.begin(); p != seq.end(); ++p, ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - ZVAL_STRINGL(val, const_cast(p->c_str()), p->length(), 1); - add_index_zval(zv, i, val); - } - break; - } - - case Slice::Builtin::KindObject: - case Slice::Builtin::KindObjectProxy: - case Slice::Builtin::KindLocalObject: - assert(false); - } + ZVAL_STRING(val, buf, 1); + } + else + { + ZVAL_LONG(val, static_cast(*p)); + } + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindFloat: + { + pair pr; + IceUtil::ScopedArray arr(is->readFloatSeq(pr)); + Ice::Int i = 0; + for(const Ice::Float* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_DOUBLE(zv, *p); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindDouble: + { + pair pr; + IceUtil::ScopedArray arr(is->readDoubleSeq(pr)); + Ice::Int i = 0; + for(const Ice::Double* p = pr.first; p != pr.second; ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_DOUBLE(zv, *p); + add_index_zval(zv, i, val); + } + break; + } + case Slice::Builtin::KindString: + { + Ice::StringSeq seq = is->readStringSeq(); + Ice::Int i = 0; + for(Ice::StringSeq::iterator p = seq.begin(); p != seq.end(); ++p, ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + ZVAL_STRINGL(val, const_cast(p->c_str()), p->length(), 1); + add_index_zval(zv, i, val); + } + break; + } + + case Slice::Builtin::KindObject: + case Slice::Builtin::KindObjectProxy: + case Slice::Builtin::KindLocalObject: + assert(false); + } } else { - Ice::Int sz = is->readSize(); - for(Ice::Int i = 0; i < sz; ++i) - { - zval* val; - MAKE_STD_ZVAL(val); - if(!_elementMarshaler->unmarshal(val, is TSRMLS_CC)) - { - return false; - } - add_index_zval(zv, i, val); - } + Ice::Int sz = is->readSize(); + for(Ice::Int i = 0; i < sz; ++i) + { + zval* val; + MAKE_STD_ZVAL(val); + if(!_elementMarshaler->unmarshal(val, is TSRMLS_CC)) + { + return false; + } + add_index_zval(zv, i, val); + } } return true; @@ -1172,7 +1172,7 @@ IcePHP::ProxyMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Object { string s = def->scoped(); php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected a proxy of type %s but received %s", - scoped.c_str(), s.c_str()); + scoped.c_str(), s.c_str()); return false; } } @@ -1297,7 +1297,7 @@ IcePHP::StructMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Objec { string s = zendTypeToString(Z_TYPE_P(zv)); php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected struct value of type %s but received %s", _class->name, - s.c_str()); + s.c_str()); return false; } @@ -1308,7 +1308,7 @@ IcePHP::StructMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Objec if(ce != _class) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected struct value of type %s but received %s", _class->name, - ce->name); + ce->name); return false; } @@ -1371,7 +1371,7 @@ IcePHP::EnumMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, ObjectM { string s = zendTypeToString(Z_TYPE_P(zv)); php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected long value for enum %s but received %s", _class->name, - s.c_str()); + s.c_str()); return false; } @@ -2003,7 +2003,7 @@ IcePHP::ObjectReader::setValue(zend_class_entry* ce, const string& scoped, zval* { Ice::UnexpectedObjectException ex(__FILE__, __LINE__); ex.type = _type ? _type->scoped() : "::Ice::Object"; - ex.expectedType = scoped; + ex.expectedType = scoped; throw ex; } @@ -2052,7 +2052,7 @@ IcePHP::ObjectMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Objec { string s = zendTypeToString(Z_TYPE_P(zv)); php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected object value of type %s but received %s", - _class ? _class->name : "ice_object", s.c_str()); + _class ? _class->name : "ice_object", s.c_str()); return false; } @@ -2074,7 +2074,7 @@ IcePHP::ObjectMarshaler::marshal(zval* zv, const Ice::OutputStreamPtr& os, Objec if(parent == NULL) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected object value of type %s but received %s", _class->name, - ce->name); + ce->name); return false; } } @@ -2218,7 +2218,7 @@ IcePHP::PHPObjectFactory::create(const string& scoped) if(!checkClass(ce, base)) { php_error_docref(NULL TSRMLS_CC, E_ERROR, - "object returned by factory does not implement Ice_ObjectImpl"); + "object returned by factory does not implement Ice_ObjectImpl"); throw AbortMarshaling(); } -- cgit v1.2.3