generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-03-19 13:02:13 +01:00
Code Issues Projects Releases Wiki Activity

Split msgpack-php repository.

Browse Source
This commit is contained in:
INADA Naoki 2012-08-20 22:04:44 +09:00
parent d642487f99
commit eae0532b8c
220 changed files with 0 additions and 44379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
php/CREDITS
View File

@ -1 +0,0 @@
msgpack

95
php/ChangeLog
View File

@ -1,95 +0,0 @@
msgpack extension changelog
Version 0.5.2
-------------
* Support PHP 5.4.x version.
Version 0.5.1
-------------
* Fixed include path for version check.
(Contributed by duedal)
Version 0.5.0
-------------
* Fix ZEND_DECLARE_MODULE_GLOBALS:
Moved ZEND_DECLARE_MODULE_GLOBALS from header to source file.
Added ZEND_EXTERN_MODULE_GLOBALS in source files to avoid undefined
_msgpack_globals message.
(Contributed by seporaitis)
* Add unpack of template converter:
Merge https://github.com/msgpack/msgpack/pull/58
Fixed memory leaks.
Fixed older version.
Fixed tests scripts.
Added msgpack_unpack function was implemented.
(Contributed by ivan)
Version 0.4.0
-------------
* Fix array pack.
* Fix test code.
* Add unpack of class object converter.
Version 0.3.4
-------------
* Support PHP 5.3.x version on Windows.
(note: NAN and Resource is failed)
Version 0.3.3
-------------
* Update msgpack header files.
* Fix unpack internal processing.
Version 0.3.2
-------------
* Version PHP 5 or newer.
Version 0.3.1
-------------
* Fix class MessagePackUnpacker.
Version 0.3.0
-------------
* Change msgpack_unpack.c (used template)
* Add php_only ini option (true / false)
* Change class MessagePack and MessagePackUnpacker __construct option.
* Add class MessagePack and MessagePackUnpacker setOption method.
Version 0.2.1
-------------
* Fix stream deserializer.
Version 0.2.0
-------------
* Add stream deserializer / class MessagePackUnpacker interface.
* Add alias functions.
* Add class MessagePack interface.
Version 0.1.5
-------------
* Add msgpack_pack.c
* Add msgpack_unpack.c
* Update msgpack.c
Version 0.1.4
-------------
* Change broken random data.
* Support PHP 5.2.x version.
Version 0.1.3
-------------
* Fix broken random data.
* Change arrays and objects.
Version 0.1.2
-------------
* Add Serializable class support.
* Fix arrays and objects reference.
Version 0.1.1
-------------
* Add session support.
Version 0.1.0
-------------
* Initial release.

0
php/EXPERIMENTAL
View File

26
php/LICENSE
View File

@ -1,26 +0,0 @@
Copyright (c) 2010, advect
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the advect nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

11
php/README
View File

@ -1,11 +0,0 @@
Description
-----------
This extension provide API for communicating with MessagePack serialization.
MessagePack is a binary-based efficient object serialization library.
It enables to exchange structured objects between many languages like JSON.
But unlike JSON, it is very fast and small.
Resources
---------
* [msgpack](http://msgpack.org/)

51
php/bench/bench.php
View File

@ -1,51 +0,0 @@
<?php
//ini_set('memory_limit' ,'128M');
$ary = array();
for($i=0; $i<pow(2, 10); $i++){
$ary = array_merge($ary, range(0, 1024));
}
echo count($ary);
function getSize($ary)
{
if (ini_get('mbstring.func_overload') & 2 && function_exists('mb_strlen')) {
$size = mb_strlen($ary, 'ASCII');
} else {
$size = strlen($ary);
}
return $size;
}
echo "fin" . $size . "\n";
echo "----\n";
echo "MessagePack\n";
$a = microtime(true);
$packed = msgpack_pack($ary);
$b = microtime(true);
echo ($b-$a) . "sec, " . getSize($packed) . "bytes\n";
$a = microtime(true);
$pack = msgpack_unpack($packed);
$b = microtime(true);
echo ($b-$a) . "sec\n";
echo "----\n";
echo "JSON\n";
$a = microtime(true);
$jsoned = json_encode($ary);
$b = microtime(true);
echo ($b-$a) . "sec, " . getSize($jsoned) . "bytes\n";
$a = microtime(true);
$json = json_decode($jsoned);
$b = microtime(true);
echo ($b-$a) . "sec\n";
?>

239
php/benchmark.php
View File

@ -1,239 +0,0 @@
<?php
$loop = 10000;
$retry = 10;
$value_display = false;
$types = array(
1, //integer
2, //float
3, //string
4, //array
5, //hash
6, //object
);
foreach ($types as $type)
{
switch ($type)
{
case 1:
//integer
$value = rand();
break;
case 2:
//float
$value = log(rand());
break;
case 3:
//string
$value = md5(rand());
break;
case 4:
//array
$value = array(md5(rand()),
md5(rand()),
md5(rand()),
md5(rand()),
md5(rand()));
break;
case 5:
//hash
$value = array(md5(rand()) => md5(rand()),
md5(rand()) => md5(rand()),
md5(rand()) => md5(rand()),
md5(rand()) => md5(rand()),
md5(rand()) => md5(rand()));
break;
case 6:
//object
$value = new stdClass;
$value->param1 = rand();
$value->param2 = md5(uniqid());
$value->param3 = array(md5(uniqid()));
$value->param4 = array(md5(uniqid()) => md5(uniqid()));
$value->param5 = null;
break;
default:
//null
$value = null;
}
if (!is_numeric($retry) || empty($retry))
{
$retry = 1;
}
$serialize_pack = 0;
$serialize_unpack = 0;
$serialize_size = 0;
$serialize_status = '*NG*';
$json_pack = 0;
$json_unpack = 0;
$json_size = 0;
$json_status = '*NG*';
$igbinary_pack = 0;
$igbinary_unpack = 0;
$igbinary_size = 0;
$igbinary_status = '*NG*';
$msgpack_pack = 0;
$msgpack_unpack = 0;
$msgpack_size = 0;
$msgpack_status = '*NG*';
for ($c = 0; $c < $retry; $c++)
{
//default (serialize)
$pack = null;
$unpack = null;
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$pack = serialize($value);
}
$end = microtime(true);
$serialize_pack += ($end - $start);
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$unpack = unserialize($pack);
}
$end = microtime(true);
$serialize_unpack += ($end - $start);
$serialize_size += strlen($pack);
if ($unpack === $value ||
(is_object($value) && $unpack == $value))
{
$serialize_status = 'OK';
}
//json
$pack = null;
$unpack = null;
$opt = false;
if (is_array($value))
{
$opt = true;
}
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$pack = json_encode($value);
}
$end = microtime(true);
$json_pack += ($end - $start);
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$unpack = json_decode($pack, $opt);
}
$end = microtime(true);
$json_unpack += ($end - $start);
$json_size += strlen($pack);
if ($unpack === $value ||
(is_object($value) && $unpack == $value) ||
(is_float($value) &&
number_format($value, 10, '.', '') ===
number_format($unpack, 10, '.', '')))
{
$json_status = 'OK';
}
//igbinary
if (extension_loaded('igbinary'))
{
$pack = null;
$unpack = null;
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$pack = igbinary_serialize($value);
}
$end = microtime(true);
$igbinary_pack += ($end - $start);
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$unpack = igbinary_unserialize($pack);
}
$end = microtime(true);
$igbinary_unpack += ($end - $start);
$igbinary_size += strlen($pack);
if ($unpack === $value ||
(is_object($value) && $unpack == $value))
{
$igbinary_status = 'OK';
}
}
//msgpack
$pack = null;
$unpack = null;
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$pack = msgpack_serialize($value);
}
$end = microtime(true);
$msgpack_pack += ($end - $start);
$start = microtime(true);
for ($i = 0; $i < $loop; $i++)
{
$unpack = msgpack_unserialize($pack);
}
$end = microtime(true);
$msgpack_unpack += ($end - $start);
$msgpack_size += strlen($pack);
if ($unpack === $value ||
(is_object($value) && $unpack == $value))
{
$msgpack_status = 'OK';
}
}
$serialize_pack /= $retry;
$serialize_unpack /= $retry;
$serialize_size /= $retry;
$json_pack /= $retry;
$json_unpack /= $retry;
$json_size /= $retry;
$igbinary_pack /= $retry;
$igbinary_unpack /= $retry;
$igbinary_size /= $retry;
$msgpack_pack /= $retry;
$msgpack_unpack /= $retry;
$msgpack_size /= $retry;
printf("[%-10s] %13s %13s %13s %13s\n",
gettype($value), 'default', 'json', 'igbinary', 'msgpack');
printf("status : %12s %12s %12s %12s\n",
$serialize_status, $json_status, $igbinary_status, $msgpack_status);
printf("serialize : %.4f (100%%) %.4f (%3d%%) %.4f (%3d%%) %.4f (%3d%%)\n",
$serialize_pack,
$json_pack, ($json_pack / $serialize_pack * 100),
$igbinary_pack, ($igbinary_pack / $serialize_pack * 100),
$msgpack_pack, ($msgpack_pack / $serialize_pack * 100));
printf("unserialize: %.4f (100%%) %.4f (%3d%%) %.4f (%3d%%) %.4f (%3d%%)\n",
$serialize_unpack,
$json_unpack, ($json_unpack / $serialize_unpack * 100),
$igbinary_unpack, ($igbinary_unpack / $serialize_unpack * 100),
$msgpack_unpack, ($msgpack_unpack / $serialize_unpack * 100));
printf("size : %6d (100%%) %6d (%3d%%) %6d (%3d%%) %6d (%3d%%)\n\n",
$serialize_size,
$json_size, ($json_size / $serialize_size * 100),
$igbinary_size, ($igbinary_size / $serialize_size * 100),
$msgpack_size, ($msgpack_size / $serialize_size * 100));
if ($value_display === true)
{
var_dump($value);
echo PHP_EOL;
}
}

33
php/config.m4
View File

@ -1,33 +0,0 @@
dnl config.m4 for extension msgpack
dnl Comments in this file start with the string 'dnl'.
dnl Remove where necessary. This file will not work
dnl without editing.
dnl Check PHP version:
AC_MSG_CHECKING(PHP version)
AC_TRY_COMPILE([#include "$phpincludedir/main/php_version.h"], [
#if PHP_MAJOR_VERSION < 5
#error this extension requires at least PHP version 5 or newer
#endif
],
[AC_MSG_RESULT(ok)],
[AC_MSG_ERROR([need at least PHP 5 or newer])])
dnl If your extension references something external, use with:
PHP_ARG_WITH(msgpack, for msgpack support,
Make sure that the comment is aligned:
[ --with-msgpack Include msgpack support])
if test "$PHP_MSGPACK" != "no"; then
PHP_NEW_EXTENSION(msgpack, msgpack.c msgpack_pack.c msgpack_unpack.c msgpack_class.c msgpack_convert.c, $ext_shared)
ifdef([PHP_INSTALL_HEADERS],
[
PHP_INSTALL_HEADERS([ext/msgpack], [php_msgpack.h])
], [
PHP_ADD_MAKEFILE_FRAGMENT
])
fi

9
php/config.w32
View File

@ -1,9 +0,0 @@
// $Id$
// vim:ft=javascript
ARG_ENABLE("msgpack", "for msgpack support", "yes");
if (PHP_MSGPACK != "no") {
EXTENSION("msgpack", "msgpack.c", PHP_MSGPACK_SHARED, "");
ADD_SOURCES(configure_module_dirname, "msgpack_pack.c msgpack_unpack.c msgpack_class.c msgpack_convert.c", "msgpack");
}

345
php/msgpack.c
View File

@ -1,345 +0,0 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "ext/standard/php_smart_str.h"
#include "ext/standard/php_incomplete_class.h"
#include "ext/standard/php_var.h"
#include "ext/session/php_session.h"
#include "php_msgpack.h"
#include "msgpack_pack.h"
#include "msgpack_unpack.h"
#include "msgpack_class.h"
#include "msgpack_convert.h"
#include "msgpack_errors.h"
#include "msgpack/version.h"
ZEND_DECLARE_MODULE_GLOBALS(msgpack)
static ZEND_FUNCTION(msgpack_serialize);
static ZEND_FUNCTION(msgpack_unserialize);
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_serialize, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unserialize, 0, 0, 1)
ZEND_ARG_INFO(0, str)
ZEND_ARG_INFO(0, object)
ZEND_END_ARG_INFO()
PHP_INI_BEGIN()
STD_PHP_INI_BOOLEAN(
"msgpack.error_display", "1", PHP_INI_ALL, OnUpdateBool,
error_display, zend_msgpack_globals, msgpack_globals)
STD_PHP_INI_BOOLEAN(
"msgpack.php_only", "1", PHP_INI_ALL, OnUpdateBool,
php_only, zend_msgpack_globals, msgpack_globals)
STD_PHP_INI_BOOLEAN(
"msgpack.illegal_key_insert", "0", PHP_INI_ALL, OnUpdateBool,
illegal_key_insert, zend_msgpack_globals, msgpack_globals)
PHP_INI_END()
PS_SERIALIZER_FUNCS(msgpack);
static const zend_function_entry msgpack_functions[] = {
ZEND_FE(msgpack_serialize, arginfo_msgpack_serialize)
ZEND_FE(msgpack_unserialize, arginfo_msgpack_unserialize)
ZEND_FALIAS(msgpack_pack, msgpack_serialize, arginfo_msgpack_serialize)
ZEND_FALIAS(msgpack_unpack, msgpack_unserialize, arginfo_msgpack_unserialize)
{NULL, NULL, NULL}
};
static void msgpack_init_globals(zend_msgpack_globals *msgpack_globals)
{
TSRMLS_FETCH();
if (PG(display_errors))
{
msgpack_globals->error_display = 1;
}
else
{
msgpack_globals->error_display = 0;
}
msgpack_globals->php_only = 1;
msgpack_globals->illegal_key_insert = 0;
}
static ZEND_MINIT_FUNCTION(msgpack)
{
ZEND_INIT_MODULE_GLOBALS(msgpack, msgpack_init_globals, NULL);
REGISTER_INI_ENTRIES();
#if HAVE_PHP_SESSION
php_session_register_serializer("msgpack",
PS_SERIALIZER_ENCODE_NAME(msgpack),
PS_SERIALIZER_DECODE_NAME(msgpack));
#endif
msgpack_init_class();
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 1)
REGISTER_LONG_CONSTANT(
"MESSAGEPACK_OPT_PHPONLY", MSGPACK_CLASS_OPT_PHPONLY,
CONST_CS | CONST_PERSISTENT);
#endif
return SUCCESS;
}
static ZEND_MSHUTDOWN_FUNCTION(msgpack)
{
UNREGISTER_INI_ENTRIES();
return SUCCESS;
}
static ZEND_MINFO_FUNCTION(msgpack)
{
php_info_print_table_start();
php_info_print_table_row(2, "MessagePack Support", "enabled");
#if HAVE_PHP_SESSION
php_info_print_table_row(2, "Session Support", "enabled" );
#endif
php_info_print_table_row(2, "extension Version", MSGPACK_EXTENSION_VERSION);
php_info_print_table_row(2, "header Version", MSGPACK_VERSION);
php_info_print_table_end();
DISPLAY_INI_ENTRIES();
}
zend_module_entry msgpack_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
"msgpack",
msgpack_functions,
ZEND_MINIT(msgpack),
ZEND_MSHUTDOWN(msgpack),
NULL,
NULL,
ZEND_MINFO(msgpack),
#if ZEND_MODULE_API_NO >= 20010901
MSGPACK_EXTENSION_VERSION,
#endif
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_MSGPACK
ZEND_GET_MODULE(msgpack)
#endif
PS_SERIALIZER_ENCODE_FUNC(msgpack)
{
smart_str buf = {0};
msgpack_serialize_data_t var_hash;
PHP_VAR_SERIALIZE_INIT(var_hash);
#if PHP_API_VERSION < 20100412
msgpack_serialize_zval(&buf, PS(http_session_vars), &var_hash TSRMLS_CC);
#else
msgpack_serialize_zval(&buf, PS(http_session_vars), var_hash TSRMLS_CC);
#endif
if (newlen)
{
*newlen = buf.len;
}
smart_str_0(&buf);
*newstr = buf.c;
PHP_VAR_SERIALIZE_DESTROY(var_hash);
return SUCCESS;
}
PS_SERIALIZER_DECODE_FUNC(msgpack)
{
int ret;
HashTable *tmp_hash;
HashPosition tmp_hash_pos;
char *key_str;
ulong key_long;
uint key_len;
zval *tmp;
zval **value;
size_t off = 0;
msgpack_unpack_t mp;
msgpack_unserialize_data_t var_hash;
ALLOC_INIT_ZVAL(tmp);
template_init(&mp);
msgpack_unserialize_var_init(&var_hash);
mp.user.retval = (zval *)tmp;
mp.user.var_hash = (msgpack_unserialize_data_t *)&var_hash;
ret = template_execute(&mp, (char *)val, (size_t)vallen, &off);
if (ret == MSGPACK_UNPACK_EXTRA_BYTES || ret == MSGPACK_UNPACK_SUCCESS)
{
msgpack_unserialize_var_destroy(&var_hash, 0);
tmp_hash = HASH_OF(tmp);
zend_hash_internal_pointer_reset_ex(tmp_hash, &tmp_hash_pos);
while (zend_hash_get_current_data_ex(
tmp_hash, (void *)&value, &tmp_hash_pos) == SUCCESS)
{
ret = zend_hash_get_current_key_ex(
tmp_hash, &key_str, &key_len, &key_long, 0, &tmp_hash_pos);
switch (ret)
{
case HASH_KEY_IS_LONG:
/* ??? */
break;
case HASH_KEY_IS_STRING:
php_set_session_var(
key_str, key_len - 1, *value, NULL TSRMLS_CC);
php_add_session_var(key_str, key_len - 1 TSRMLS_CC);
break;
}
zend_hash_move_forward_ex(tmp_hash, &tmp_hash_pos);
}
}
else
{
msgpack_unserialize_var_destroy(&var_hash, 1);
}
zval_ptr_dtor(&tmp);
return SUCCESS;
}
PHP_MSGPACK_API void php_msgpack_serialize(smart_str *buf, zval *val TSRMLS_DC)
{
msgpack_serialize_data_t var_hash;
PHP_VAR_SERIALIZE_INIT(var_hash);
#if PHP_API_VERSION < 20100412
msgpack_serialize_zval(buf, val, &var_hash TSRMLS_CC);
#else
msgpack_serialize_zval(buf, val, var_hash TSRMLS_CC);
#endif
PHP_VAR_SERIALIZE_DESTROY(var_hash);
}
PHP_MSGPACK_API void php_msgpack_unserialize(
zval *return_value, char *str, size_t str_len TSRMLS_DC)
{
int ret;
size_t off = 0;
msgpack_unpack_t mp;
msgpack_unserialize_data_t var_hash;
if (str_len <= 0)
{
RETURN_NULL();
}
template_init(&mp);
msgpack_unserialize_var_init(&var_hash);
mp.user.retval = (zval *)return_value;
mp.user.var_hash = (msgpack_unserialize_data_t *)&var_hash;
ret = template_execute(&mp, str, (size_t)str_len, &off);
switch (ret)
{
case MSGPACK_UNPACK_PARSE_ERROR:
msgpack_unserialize_var_destroy(&var_hash, 1);
MSGPACK_WARNING("[msgpack] (%s) Parse error", __FUNCTION__);
break;
case MSGPACK_UNPACK_CONTINUE:
msgpack_unserialize_var_destroy(&var_hash, 1);
MSGPACK_WARNING(
"[msgpack] (%s) Insufficient data for unserializing",
__FUNCTION__);
break;
case MSGPACK_UNPACK_EXTRA_BYTES:
case MSGPACK_UNPACK_SUCCESS:
msgpack_unserialize_var_destroy(&var_hash, 0);
if (off < (size_t)str_len)
{
MSGPACK_WARNING("[msgpack] (%s) Extra bytes", __FUNCTION__);
}
break;
default:
msgpack_unserialize_var_destroy(&var_hash, 0);
MSGPACK_WARNING("[msgpack] (%s) Unknown result", __FUNCTION__);
break;
}
}
static ZEND_FUNCTION(msgpack_serialize)
{
zval *parameter;
smart_str buf = {0};
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "z", &parameter) == FAILURE)
{
return;
}
php_msgpack_serialize(&buf, parameter TSRMLS_CC);
ZVAL_STRINGL(return_value, buf.c, buf.len, 1);
smart_str_free(&buf);
}
static ZEND_FUNCTION(msgpack_unserialize)
{
char *str;
int str_len;
zval *object = NULL;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "s|z",
&str, &str_len, &object) == FAILURE)
{
return;
}
if (!str_len)
{
RETURN_NULL();
}
if (object == NULL)
{
php_msgpack_unserialize(return_value, str, str_len TSRMLS_CC);
}
else
{
zval *zv;
ALLOC_INIT_ZVAL(zv);
php_msgpack_unserialize(zv, str, str_len TSRMLS_CC);
if (msgpack_convert_template(return_value, object, &zv) != SUCCESS)
{
RETURN_NULL();
}
}
}

21
php/msgpack.php
View File

@ -1,21 +0,0 @@
<?php
$br = (php_sapi_name() == "cli")? "":"<br>";
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$module = 'msgpack';
$functions = get_extension_funcs($module);
echo "Functions available in the test extension:$br\n";
foreach($functions as $func) {
echo $func."$br\n";
}
echo "$br\n";
$function = $module . '_serialize';
if (extension_loaded($module)) {
$str = $function($module);
} else {
$str = "Module $module is not compiled into PHP";
}
echo "$str\n";
?>

26
php/msgpack/pack_define.h
View File

@ -1,26 +0,0 @@
/*
* MessagePack unpacking routine template
*
* Copyright (C) 2008-2010 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MSGPACK_PACK_DEFINE_H__
#define MSGPACK_PACK_DEFINE_H__
#include "msgpack/sysdep.h"
#include <limits.h>
#include <string.h>
#endif /* msgpack/pack_define.h */

766
php/msgpack/pack_template.h
View File

@ -1,766 +0,0 @@
/*
* MessagePack packing routine template
*
* Copyright (C) 2008-2010 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__LITTLE_ENDIAN__)
#define TAKE8_8(d) ((uint8_t*)&d)[0]
#define TAKE8_16(d) ((uint8_t*)&d)[0]
#define TAKE8_32(d) ((uint8_t*)&d)[0]
#define TAKE8_64(d) ((uint8_t*)&d)[0]
#elif defined(__BIG_ENDIAN__)
#define TAKE8_8(d) ((uint8_t*)&d)[0]
#define TAKE8_16(d) ((uint8_t*)&d)[1]
#define TAKE8_32(d) ((uint8_t*)&d)[3]
#define TAKE8_64(d) ((uint8_t*)&d)[7]
#endif
#ifndef msgpack_pack_inline_func
#error msgpack_pack_inline_func template is not defined
#endif
#ifndef msgpack_pack_user
#error msgpack_pack_user type is not defined
#endif
#ifndef msgpack_pack_append_buffer
#error msgpack_pack_append_buffer callback is not defined
#endif
/*
* Integer
*/
#define msgpack_pack_real_uint8(x, d) \
do { \
if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
} else { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} while(0)
#define msgpack_pack_real_uint16(x, d) \
do { \
if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
} else if(d < (1<<8)) { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} else { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} \
} while(0)
#define msgpack_pack_real_uint32(x, d) \
do { \
if(d < (1<<8)) { \
if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
} else { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} else { \
if(d < (1<<16)) { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else { \
/* unsigned 32 */ \
unsigned char buf[5]; \
buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} \
} \
} while(0)
#define msgpack_pack_real_uint64(x, d) \
do { \
if(d < (1ULL<<8)) { \
if(d < (1ULL<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
} else { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} else { \
if(d < (1ULL<<16)) { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else if(d < (1ULL<<32)) { \
/* unsigned 32 */ \
unsigned char buf[5]; \
buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} else { \
/* unsigned 64 */ \
unsigned char buf[9]; \
buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
msgpack_pack_append_buffer(x, buf, 9); \
} \
} \
} while(0)
#define msgpack_pack_real_int8(x, d) \
do { \
if(d < -(1<<5)) { \
/* signed 8 */ \
unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} else { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
} \
} while(0)
#define msgpack_pack_real_int16(x, d) \
do { \
if(d < -(1<<5)) { \
if(d < -(1<<7)) { \
/* signed 16 */ \
unsigned char buf[3]; \
buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else { \
/* signed 8 */ \
unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} else if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
} else { \
if(d < (1<<8)) { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} else { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} \
} \
} while(0)
#define msgpack_pack_real_int32(x, d) \
do { \
if(d < -(1<<5)) { \
if(d < -(1<<15)) { \
/* signed 32 */ \
unsigned char buf[5]; \
buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} else if(d < -(1<<7)) { \
/* signed 16 */ \
unsigned char buf[3]; \
buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else { \
/* signed 8 */ \
unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} else if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
} else { \
if(d < (1<<8)) { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} else if(d < (1<<16)) { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else { \
/* unsigned 32 */ \
unsigned char buf[5]; \
buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} \
} \
} while(0)
#define msgpack_pack_real_int64(x, d) \
do { \
if(d < -(1LL<<5)) { \
if(d < -(1LL<<15)) { \
if(d < -(1LL<<31)) { \
/* signed 64 */ \
unsigned char buf[9]; \
buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
msgpack_pack_append_buffer(x, buf, 9); \
} else { \
/* signed 32 */ \
unsigned char buf[5]; \
buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} \
} else { \
if(d < -(1<<7)) { \
/* signed 16 */ \
unsigned char buf[3]; \
buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} else { \
/* signed 8 */ \
unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} \
} \
} else if(d < (1<<7)) { \
/* fixnum */ \
msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
} else { \
if(d < (1LL<<16)) { \
if(d < (1<<8)) { \
/* unsigned 8 */ \
unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
msgpack_pack_append_buffer(x, buf, 2); \
} else { \
/* unsigned 16 */ \
unsigned char buf[3]; \
buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
msgpack_pack_append_buffer(x, buf, 3); \
} \
} else { \
if(d < (1LL<<32)) { \
/* unsigned 32 */ \
unsigned char buf[5]; \
buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
msgpack_pack_append_buffer(x, buf, 5); \
} else { \
/* unsigned 64 */ \
unsigned char buf[9]; \
buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
msgpack_pack_append_buffer(x, buf, 9); \
} \
} \
} \
} while(0)
#ifdef msgpack_pack_inline_func_fixint
msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d)
{
unsigned char buf[2] = {0xcc, TAKE8_8(d)};
msgpack_pack_append_buffer(x, buf, 2);
}
msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d)
{
unsigned char buf[3];
buf[0] = 0xcd; _msgpack_store16(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 3);
}
msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d)
{
unsigned char buf[5];
buf[0] = 0xce; _msgpack_store32(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 5);
}
msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d)
{
unsigned char buf[9];
buf[0] = 0xcf; _msgpack_store64(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 9);
}
msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d)
{
unsigned char buf[2] = {0xd0, TAKE8_8(d)};
msgpack_pack_append_buffer(x, buf, 2);
}
msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d)
{
unsigned char buf[3];
buf[0] = 0xd1; _msgpack_store16(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 3);
}
msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d)
{
unsigned char buf[5];
buf[0] = 0xd2; _msgpack_store32(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 5);
}
msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d)
{
unsigned char buf[9];
buf[0] = 0xd3; _msgpack_store64(&buf[1], d);
msgpack_pack_append_buffer(x, buf, 9);
}
#undef msgpack_pack_inline_func_fixint
#endif
msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d)
{
msgpack_pack_real_uint8(x, d);
}
msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d)
{
msgpack_pack_real_uint16(x, d);
}
msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d)
{
msgpack_pack_real_uint32(x, d);
}
msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d)
{
msgpack_pack_real_uint64(x, d);
}
msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d)
{
msgpack_pack_real_int8(x, d);
}
msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d)
{
msgpack_pack_real_int16(x, d);
}
msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d)
{
msgpack_pack_real_int32(x, d);
}
msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
{
msgpack_pack_real_int64(x, d);
}
#ifdef msgpack_pack_inline_func_cint
msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
{
#if defined(SIZEOF_SHORT)
#if SIZEOF_SHORT == 2
msgpack_pack_real_int16(x, d);
#elif SIZEOF_SHORT == 4
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#elif defined(SHRT_MAX)
#if SHRT_MAX == 0x7fff
msgpack_pack_real_int16(x, d);
#elif SHRT_MAX == 0x7fffffff
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#else
if(sizeof(short) == 2) {
msgpack_pack_real_int16(x, d);
} else if(sizeof(short) == 4) {
msgpack_pack_real_int32(x, d);
} else {
msgpack_pack_real_int64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d)
{
#if defined(SIZEOF_INT)
#if SIZEOF_INT == 2
msgpack_pack_real_int16(x, d);
#elif SIZEOF_INT == 4
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#elif defined(INT_MAX)
#if INT_MAX == 0x7fff
msgpack_pack_real_int16(x, d);
#elif INT_MAX == 0x7fffffff
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#else
if(sizeof(int) == 2) {
msgpack_pack_real_int16(x, d);
} else if(sizeof(int) == 4) {
msgpack_pack_real_int32(x, d);
} else {
msgpack_pack_real_int64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d)
{
#if defined(SIZEOF_LONG)
#if SIZEOF_LONG == 2
msgpack_pack_real_int16(x, d);
#elif SIZEOF_LONG == 4
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#elif defined(LONG_MAX)
#if LONG_MAX == 0x7fffL
msgpack_pack_real_int16(x, d);
#elif LONG_MAX == 0x7fffffffL
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#else
if(sizeof(long) == 2) {
msgpack_pack_real_int16(x, d);
} else if(sizeof(long) == 4) {
msgpack_pack_real_int32(x, d);
} else {
msgpack_pack_real_int64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d)
{
#if defined(SIZEOF_LONG_LONG)
#if SIZEOF_LONG_LONG == 2
msgpack_pack_real_int16(x, d);
#elif SIZEOF_LONG_LONG == 4
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#elif defined(LLONG_MAX)
#if LLONG_MAX == 0x7fffL
msgpack_pack_real_int16(x, d);
#elif LLONG_MAX == 0x7fffffffL
msgpack_pack_real_int32(x, d);
#else
msgpack_pack_real_int64(x, d);
#endif
#else
if(sizeof(long long) == 2) {
msgpack_pack_real_int16(x, d);
} else if(sizeof(long long) == 4) {
msgpack_pack_real_int32(x, d);
} else {
msgpack_pack_real_int64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d)
{
#if defined(SIZEOF_SHORT)
#if SIZEOF_SHORT == 2
msgpack_pack_real_uint16(x, d);
#elif SIZEOF_SHORT == 4
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#elif defined(USHRT_MAX)
#if USHRT_MAX == 0xffffU
msgpack_pack_real_uint16(x, d);
#elif USHRT_MAX == 0xffffffffU
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#else
if(sizeof(unsigned short) == 2) {
msgpack_pack_real_uint16(x, d);
} else if(sizeof(unsigned short) == 4) {
msgpack_pack_real_uint32(x, d);
} else {
msgpack_pack_real_uint64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d)
{
#if defined(SIZEOF_INT)
#if SIZEOF_INT == 2
msgpack_pack_real_uint16(x, d);
#elif SIZEOF_INT == 4
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#elif defined(UINT_MAX)
#if UINT_MAX == 0xffffU
msgpack_pack_real_uint16(x, d);
#elif UINT_MAX == 0xffffffffU
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#else
if(sizeof(unsigned int) == 2) {
msgpack_pack_real_uint16(x, d);
} else if(sizeof(unsigned int) == 4) {
msgpack_pack_real_uint32(x, d);
} else {
msgpack_pack_real_uint64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d)
{
#if defined(SIZEOF_LONG)
#if SIZEOF_LONG == 2
msgpack_pack_real_uint16(x, d);
#elif SIZEOF_LONG == 4
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#elif defined(ULONG_MAX)
#if ULONG_MAX == 0xffffUL
msgpack_pack_real_uint16(x, d);
#elif ULONG_MAX == 0xffffffffUL
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#else
if(sizeof(unsigned long) == 2) {
msgpack_pack_real_uint16(x, d);
} else if(sizeof(unsigned long) == 4) {
msgpack_pack_real_uint32(x, d);
} else {
msgpack_pack_real_uint64(x, d);
}
#endif
}
msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d)
{
#if defined(SIZEOF_LONG_LONG)
#if SIZEOF_LONG_LONG == 2
msgpack_pack_real_uint16(x, d);
#elif SIZEOF_LONG_LONG == 4
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#elif defined(ULLONG_MAX)
#if ULLONG_MAX == 0xffffUL
msgpack_pack_real_uint16(x, d);
#elif ULLONG_MAX == 0xffffffffUL
msgpack_pack_real_uint32(x, d);
#else
msgpack_pack_real_uint64(x, d);
#endif
#else
if(sizeof(unsigned long long) == 2) {
msgpack_pack_real_uint16(x, d);
} else if(sizeof(unsigned long long) == 4) {
msgpack_pack_real_uint32(x, d);
} else {
msgpack_pack_real_uint64(x, d);
}
#endif
}
#undef msgpack_pack_inline_func_cint
#endif
/*
* Float
*/
msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
{
union { float f; uint32_t i; } mem;
unsigned char buf[5];
mem.f = d;
buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
msgpack_pack_append_buffer(x, buf, 5);
}
msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
{
union { double f; uint64_t i; } mem;
unsigned char buf[9];
mem.f = d;
buf[0] = 0xcb; _msgpack_store64(&buf[1], mem.i);
msgpack_pack_append_buffer(x, buf, 9);
}
/*
* Nil
*/
msgpack_pack_inline_func(_nil)(msgpack_pack_user x)
{
static const unsigned char d = 0xc0;
msgpack_pack_append_buffer(x, &d, 1);
}
/*
* Boolean
*/
msgpack_pack_inline_func(_true)(msgpack_pack_user x)
{
static const unsigned char d = 0xc3;
msgpack_pack_append_buffer(x, &d, 1);
}
msgpack_pack_inline_func(_false)(msgpack_pack_user x)
{
static const unsigned char d = 0xc2;
msgpack_pack_append_buffer(x, &d, 1);
}
/*
* Array
*/
msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
{
if(n < 16) {
unsigned char d = 0x90 | n;
msgpack_pack_append_buffer(x, &d, 1);
} else if(n < 65536) {
unsigned char buf[3];
buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
msgpack_pack_append_buffer(x, buf, 3);
} else {
unsigned char buf[5];
buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
msgpack_pack_append_buffer(x, buf, 5);
}
}
/*
* Map
*/
msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
{
if(n < 16) {
unsigned char d = 0x80 | n;
msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
} else if(n < 65536) {
unsigned char buf[3];
buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
msgpack_pack_append_buffer(x, buf, 3);
} else {
unsigned char buf[5];
buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
msgpack_pack_append_buffer(x, buf, 5);
}
}
/*
* Raw
*/
msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
{
if(l < 32) {
unsigned char d = 0xa0 | l;
msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
} else if(l < 65536) {
unsigned char buf[3];
buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
msgpack_pack_append_buffer(x, buf, 3);
} else {
unsigned char buf[5];
buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
msgpack_pack_append_buffer(x, buf, 5);
}
}
msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l)
{
msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
}
#undef msgpack_pack_inline_func
#undef msgpack_pack_user
#undef msgpack_pack_append_buffer
#undef TAKE8_8
#undef TAKE8_16
#undef TAKE8_32
#undef TAKE8_64
#undef msgpack_pack_real_uint8
#undef msgpack_pack_real_uint16
#undef msgpack_pack_real_uint32
#undef msgpack_pack_real_uint64
#undef msgpack_pack_real_int8
#undef msgpack_pack_real_int16
#undef msgpack_pack_real_int32
#undef msgpack_pack_real_int64

120
php/msgpack/sysdep.h
View File

@ -1,120 +0,0 @@
/*
* MessagePack system dependencies
*
* Copyright (C) 2008-2010 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MSGPACK_SYSDEP_H__
#define MSGPACK_SYSDEP_H__
#include <stdlib.h>
#include <stddef.h>
#if defined(_MSC_VER) && _MSC_VER < 1600
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#elif defined(_MSC_VER) // && _MSC_VER >= 1600
#include <stdint.h>
#else
#include <stdint.h>
#include <stdbool.h>
#endif
#ifdef _WIN32
typedef long _msgpack_atomic_counter_t;
#define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
#define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
#else
typedef unsigned int _msgpack_atomic_counter_t;
#define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
#define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1)
#endif
#ifdef _WIN32
#include <winsock2.h>
#ifdef __cplusplus
/* numeric_limits<T>::min,max */
#ifdef max
#undef max
#endif
#ifdef min
#undef min
#endif
#endif
#else
#include <arpa/inet.h> /* __BYTE_ORDER */
#endif
#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define __LITTLE_ENDIAN__
#elif __BYTE_ORDER == __BIG_ENDIAN
#define __BIG_ENDIAN__
#endif
#endif
#ifdef __LITTLE_ENDIAN__
#define _msgpack_be16(x) ntohs(x)
#define _msgpack_be32(x) ntohl(x)
#if defined(_byteswap_uint64) || _MSC_VER >= 1400
# define _msgpack_be64(x) (_byteswap_uint64(x))
#elif defined(bswap_64)
# define _msgpack_be64(x) bswap_64(x)
#elif defined(__DARWIN_OSSwapInt64)
# define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
#else
#define _msgpack_be64(x) \
( ((((uint64_t)x) << 56) & 0xff00000000000000ULL ) | \
((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
((((uint64_t)x) << 8) & 0x000000ff00000000ULL ) | \
((((uint64_t)x) >> 8) & 0x00000000ff000000ULL ) | \
((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
((((uint64_t)x) >> 56) & 0x00000000000000ffULL ) )
#endif
#else
#define _msgpack_be16(x) (x)
#define _msgpack_be32(x) (x)
#define _msgpack_be64(x) (x)
#endif
#define _msgpack_store16(to, num) \
do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0);
#define _msgpack_store32(to, num) \
do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0);
#define _msgpack_store64(to, num) \
do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0);
#define _msgpack_load16(cast, from) ((cast)_msgpack_be16(*(uint16_t*)from))
#define _msgpack_load32(cast, from) ((cast)_msgpack_be32(*(uint32_t*)from))
#define _msgpack_load64(cast, from) ((cast)_msgpack_be64(*(uint64_t*)from))
#endif /* msgpack/sysdep.h */

93
php/msgpack/unpack_define.h
View File

@ -1,93 +0,0 @@
/*
* MessagePack unpacking routine template
*
* Copyright (C) 2008-2010 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MSGPACK_UNPACK_DEFINE_H__
#define MSGPACK_UNPACK_DEFINE_H__
#include "msgpack/sysdep.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MSGPACK_EMBED_STACK_SIZE
#define MSGPACK_EMBED_STACK_SIZE 32
#endif
typedef enum {
CS_HEADER = 0x00, // nil
//CS_ = 0x01,
//CS_ = 0x02, // false
//CS_ = 0x03, // true
//CS_ = 0x04,
//CS_ = 0x05,
//CS_ = 0x06,
//CS_ = 0x07,
//CS_ = 0x08,
//CS_ = 0x09,
CS_FLOAT = 0x0a,
CS_DOUBLE = 0x0b,
CS_UINT_8 = 0x0c,
CS_UINT_16 = 0x0d,
CS_UINT_32 = 0x0e,
CS_UINT_64 = 0x0f,
CS_INT_8 = 0x10,
CS_INT_16 = 0x11,
CS_INT_32 = 0x12,
CS_INT_64 = 0x13,
//CS_ = 0x14,
//CS_ = 0x15,
//CS_BIG_INT_16 = 0x16,
//CS_BIG_INT_32 = 0x17,
//CS_BIG_FLOAT_16 = 0x18,
//CS_BIG_FLOAT_32 = 0x19,
CS_RAW_16 = 0x1a,
CS_RAW_32 = 0x1b,
CS_ARRAY_16 = 0x1c,
CS_ARRAY_32 = 0x1d,
CS_MAP_16 = 0x1e,
CS_MAP_32 = 0x1f,
//ACS_BIG_INT_VALUE,
//ACS_BIG_FLOAT_VALUE,
ACS_RAW_VALUE,
} msgpack_unpack_state;
typedef enum {
CT_ARRAY_ITEM,
CT_MAP_KEY,
CT_MAP_VALUE,
} msgpack_container_type;
#ifdef __cplusplus
}
#endif
#endif /* msgpack/unpack_define.h */

412
php/msgpack/unpack_template.h
View File

@ -1,412 +0,0 @@
/*
* MessagePack unpacking routine template
*
* Copyright (C) 2008-2010 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef msgpack_unpack_func
#error msgpack_unpack_func template is not defined
#endif
#ifndef msgpack_unpack_callback
#error msgpack_unpack_callback template is not defined
#endif
#ifndef msgpack_unpack_struct
#error msgpack_unpack_struct template is not defined
#endif
#ifndef msgpack_unpack_struct_decl
#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name)
#endif
#ifndef msgpack_unpack_object
#error msgpack_unpack_object type is not defined
#endif
#ifndef msgpack_unpack_user
#error msgpack_unpack_user type is not defined
#endif
#ifndef USE_CASE_RANGE
#if !defined(_MSC_VER)
#define USE_CASE_RANGE
#endif
#endif
msgpack_unpack_struct_decl(_stack) {
msgpack_unpack_object obj;
size_t count;
unsigned int ct;
msgpack_unpack_object map_key;
};
msgpack_unpack_struct_decl(_context) {
msgpack_unpack_user user;
unsigned int cs;
unsigned int trail;
unsigned int top;
/*
msgpack_unpack_struct(_stack)* stack;
unsigned int stack_size;
msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
*/
msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
};
msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
{
ctx->cs = CS_HEADER;
ctx->trail = 0;
ctx->top = 0;
/*
ctx->stack = ctx->embed_stack;
ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
*/
ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
}
/*
msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx)
{
if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
free(ctx->stack);
}
}
*/
msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
{
return (ctx)->stack[0].obj;
}
msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off)
{
#ifndef _MSC_VER
assert(len >= *off);
#endif
const unsigned char* p = (unsigned char*)data + *off;
const unsigned char* const pe = (unsigned char*)data + len;
const void* n = NULL;
unsigned int trail = ctx->trail;
unsigned int cs = ctx->cs;
unsigned int top = ctx->top;
int ret;
msgpack_unpack_struct(_stack)* stack = ctx->stack;
/*
unsigned int stack_size = ctx->stack_size;
*/
msgpack_unpack_user* user = &ctx->user;
msgpack_unpack_object obj;
msgpack_unpack_struct(_stack)* c = NULL;
#define push_simple_value(func) \
if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
goto _push
#define push_fixed_value(func, arg) \
if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
goto _push
#define push_variable_value(func, base, pos, len) \
if(msgpack_unpack_callback(func)(user, \
(const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
goto _push
#define again_fixed_trail(_cs, trail_len) \
trail = trail_len; \
cs = _cs; \
goto _fixed_trail_again
#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
trail = trail_len; \
if(trail == 0) { goto ifzero; } \
cs = _cs; \
goto _fixed_trail_again
#define start_container(func, count_, ct_) \
if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
if((count_) == 0) { obj = stack[top].obj; goto _push; } \
stack[top].ct = ct_; \
stack[top].count = count_; \
++top; \
/*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
/*printf("stack push %d\n", top);*/ \
/* FIXME \
if(top >= stack_size) { \
if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \
size_t nsize = csize * 2; \
msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \
if(tmp == NULL) { goto _failed; } \
memcpy(tmp, ctx->stack, csize); \
ctx->stack = stack = tmp; \
ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
} else { \
size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \
msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \
if(tmp == NULL) { goto _failed; } \
ctx->stack = stack = tmp; \
ctx->stack_size = stack_size = stack_size * 2; \
} \
} \
*/ \
goto _header_again
#define NEXT_CS(p) \
((unsigned int)*p & 0x1f)
#ifdef USE_CASE_RANGE
#define SWITCH_RANGE_BEGIN switch(*p) {
#define SWITCH_RANGE(FROM, TO) case FROM ... TO:
#define SWITCH_RANGE_DEFAULT default:
#define SWITCH_RANGE_END }
#else
#define SWITCH_RANGE_BEGIN { if(0) {
#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) {
#define SWITCH_RANGE_DEFAULT } else {
#define SWITCH_RANGE_END } }
#endif
if(p == pe) { goto _out; }
do {
switch(cs) {
case CS_HEADER:
SWITCH_RANGE_BEGIN
SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum
push_fixed_value(_uint8, *(uint8_t*)p);
SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum
push_fixed_value(_int8, *(int8_t*)p);
SWITCH_RANGE(0xc0, 0xdf) // Variable
switch(*p) {
case 0xc0: // nil
push_simple_value(_nil);
//case 0xc1: // string
// again_terminal_trail(NEXT_CS(p), p+1);
case 0xc2: // false
push_simple_value(_false);
case 0xc3: // true
push_simple_value(_true);
//case 0xc4:
//case 0xc5:
//case 0xc6:
//case 0xc7:
//case 0xc8:
//case 0xc9:
case 0xca: // float
case 0xcb: // double
case 0xcc: // unsigned int 8
case 0xcd: // unsigned int 16
case 0xce: // unsigned int 32
case 0xcf: // unsigned int 64
case 0xd0: // signed int 8
case 0xd1: // signed int 16
case 0xd2: // signed int 32
case 0xd3: // signed int 64
again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
//case 0xd4:
//case 0xd5:
//case 0xd6: // big integer 16
//case 0xd7: // big integer 32
//case 0xd8: // big float 16
//case 0xd9: // big float 32
case 0xda: // raw 16
case 0xdb: // raw 32
case 0xdc: // array 16
case 0xdd: // array 32
case 0xde: // map 16
case 0xdf: // map 32
again_fixed_trail(NEXT_CS(p), 2 << (((unsigned int)*p) & 0x01));
default:
goto _failed;
}
SWITCH_RANGE(0xa0, 0xbf) // FixRaw
again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
SWITCH_RANGE(0x90, 0x9f) // FixArray
start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
SWITCH_RANGE(0x80, 0x8f) // FixMap
start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
SWITCH_RANGE_DEFAULT
goto _failed;
SWITCH_RANGE_END
// end CS_HEADER
_fixed_trail_again:
++p;
default:
if((size_t)(pe - p) < trail) { goto _out; }
n = p; p += trail - 1;
switch(cs) {
//case CS_
//case CS_
case CS_FLOAT: {
union { uint32_t i; float f; } mem;
mem.i = _msgpack_load32(uint32_t,n);
push_fixed_value(_float, mem.f); }
case CS_DOUBLE: {
union { uint64_t i; double f; } mem;
mem.i = _msgpack_load64(uint64_t,n);
push_fixed_value(_double, mem.f); }
case CS_UINT_8:
push_fixed_value(_uint8, *(uint8_t*)n);
case CS_UINT_16:
push_fixed_value(_uint16, _msgpack_load16(uint16_t,n));
case CS_UINT_32:
push_fixed_value(_uint32, _msgpack_load32(uint32_t,n));
case CS_UINT_64:
push_fixed_value(_uint64, _msgpack_load64(uint64_t,n));
case CS_INT_8:
push_fixed_value(_int8, *(int8_t*)n);
case CS_INT_16:
push_fixed_value(_int16, _msgpack_load16(int16_t,n));
case CS_INT_32:
push_fixed_value(_int32, _msgpack_load32(int32_t,n));
case CS_INT_64:
push_fixed_value(_int64, _msgpack_load64(int64_t,n));
//case CS_
//case CS_
//case CS_BIG_INT_16:
// again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero);
//case CS_BIG_INT_32:
// again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero);
//case ACS_BIG_INT_VALUE:
//_big_int_zero:
// // FIXME
// push_variable_value(_big_int, data, n, trail);
//case CS_BIG_FLOAT_16:
// again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero);
//case CS_BIG_FLOAT_32:
// again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero);
//case ACS_BIG_FLOAT_VALUE:
//_big_float_zero:
// // FIXME
// push_variable_value(_big_float, data, n, trail);
case CS_RAW_16:
again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero);
case CS_RAW_32:
again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero);
case ACS_RAW_VALUE:
_raw_zero:
push_variable_value(_raw, data, n, trail);
case CS_ARRAY_16:
start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM);
case CS_ARRAY_32:
/* FIXME security guard */
start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM);
case CS_MAP_16:
start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY);
case CS_MAP_32:
/* FIXME security guard */
start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY);
default:
goto _failed;
}
}
_push:
if(top == 0) { goto _finish; }
c = &stack[top-1];
switch(c->ct) {
case CT_ARRAY_ITEM:
if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; }
if(--c->count == 0) {
obj = c->obj;
--top;
/*printf("stack pop %d\n", top);*/
goto _push;
}
goto _header_again;
case CT_MAP_KEY:
c->map_key = obj;
c->ct = CT_MAP_VALUE;
goto _header_again;
case CT_MAP_VALUE:
if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
if(--c->count == 0) {
obj = c->obj;
--top;
/*printf("stack pop %d\n", top);*/
goto _push;
}
c->ct = CT_MAP_KEY;
goto _header_again;
default:
goto _failed;
}
_header_again:
cs = CS_HEADER;
++p;
} while(p != pe);
goto _out;
_finish:
stack[0].obj = obj;
++p;
ret = 1;
/*printf("-- finish --\n"); */
goto _end;
_failed:
/*printf("** FAILED **\n"); */
ret = -1;
goto _end;
_out:
ret = 0;
goto _end;
_end:
ctx->cs = cs;
ctx->trail = trail;
ctx->top = top;
*off = p - (const unsigned char*)data;
return ret;
}
#undef msgpack_unpack_func
#undef msgpack_unpack_callback
#undef msgpack_unpack_struct
#undef msgpack_unpack_object
#undef msgpack_unpack_user
#undef push_simple_value
#undef push_fixed_value
#undef push_variable_value
#undef again_fixed_trail
#undef again_fixed_trail_if_zero
#undef start_container
#undef NEXT_CS

40
php/msgpack/version.h
View File

@ -1,40 +0,0 @@
/*
* MessagePack for C version information
*
* Copyright (C) 2008-2009 FURUHASHI Sadayuki
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MSGPACK_VERSION_H__
#define MSGPACK_VERSION_H__
#ifdef __cplusplus
extern "C" {
#endif
const char* msgpack_version(void);
int msgpack_version_major(void);
int msgpack_version_minor(void);
#define MSGPACK_VERSION "0.5.4"
#define MSGPACK_VERSION_MAJOR 0
#define MSGPACK_VERSION_MINOR 5
#ifdef __cplusplus
}
#endif
#endif /* msgpack/version.h */

687
php/msgpack_class.c
View File

@ -1,687 +0,0 @@
#include "php.h"
#include "php_msgpack.h"
#include "msgpack_pack.h"
#include "msgpack_unpack.h"
#include "msgpack_class.h"
#include "msgpack_convert.h"
#include "msgpack_errors.h"
typedef struct {
zend_object object;
long php_only;
} php_msgpack_base_t;
typedef struct {
zend_object object;
smart_str buffer;
zval *retval;
long offset;
msgpack_unpack_t mp;
msgpack_unserialize_data_t var_hash;
long php_only;
zend_bool finished;
int error;
} php_msgpack_unpacker_t;
#if ZEND_MODULE_API_NO >= 20060613
# define MSGPACK_METHOD_BASE(classname, name) zim_##classname##_##name
#else
# define MSGPACK_METHOD_BASE(classname, name) zif_##classname##_##name
#endif
#if ZEND_MODULE_API_NO >= 20090115
# define PUSH_PARAM(arg) zend_vm_stack_push(arg TSRMLS_CC)
# define POP_PARAM() (void)zend_vm_stack_pop(TSRMLS_C)
# define PUSH_EO_PARAM()
# define POP_EO_PARAM()
#else
# define PUSH_PARAM(arg) zend_ptr_stack_push(&EG(argument_stack), arg)
# define POP_PARAM() (void)zend_ptr_stack_pop(&EG(argument_stack))
# define PUSH_EO_PARAM() zend_ptr_stack_push(&EG(argument_stack), NULL)
# define POP_EO_PARAM() (void)zend_ptr_stack_pop(&EG(argument_stack))
#endif
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
#define MSGPACK_METHOD_HELPER(classname, name, retval, thisptr, num, param) \
PUSH_PARAM(param); PUSH_PARAM((void*)num); \
PUSH_EO_PARAM(); \
MSGPACK_METHOD_BASE(classname, name)(num, retval, NULL, thisptr, 0 TSRMLS_CC); \
POP_EO_PARAM(); \
POP_PARAM(); POP_PARAM();
#define MSGPACK_METHOD(classname, name, retval, thisptr) \
MSGPACK_METHOD_BASE(classname, name)(0, retval, NULL, thisptr, 0 TSRMLS_CC)
#else
#define MSGPACK_METHOD_HELPER(classname, name, retval, thisptr, num, param) \
PUSH_PARAM(param); PUSH_PARAM((void*)num); \
PUSH_EO_PARAM(); \
MSGPACK_METHOD_BASE(classname, name)(num, retval, thisptr, 0 TSRMLS_CC); \
POP_EO_PARAM(); \
POP_PARAM(); POP_PARAM();
#define MSGPACK_METHOD(classname, name, retval, thisptr) \
MSGPACK_METHOD_BASE(classname, name)(0, retval, thisptr, 0 TSRMLS_CC)
#endif
#define MSGPACK_METHOD1(classname, name, retval, thisptr, param1) \
MSGPACK_METHOD_HELPER(classname, name, retval, thisptr, 1, param1);
#define MSGPACK_BASE_OBJECT \
php_msgpack_base_t *base; \
base = (php_msgpack_base_t *)zend_object_store_get_object(getThis() TSRMLS_CC);
#define MSGPACK_UNPACKER_OBJECT \
php_msgpack_unpacker_t *unpacker; \
unpacker = (php_msgpack_unpacker_t *)zend_object_store_get_object(getThis() TSRMLS_CC);
/* MessagePack */
static zend_class_entry *msgpack_ce = NULL;
static ZEND_METHOD(msgpack, __construct);
static ZEND_METHOD(msgpack, setOption);
static ZEND_METHOD(msgpack, pack);
static ZEND_METHOD(msgpack, unpack);
static ZEND_METHOD(msgpack, unpacker);
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_base___construct, 0, 0, 0)
ZEND_ARG_INFO(0, opt)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_base_setOption, 0, 0, 2)
ZEND_ARG_INFO(0, option)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_base_pack, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_base_unpack, 0, 0, 1)
ZEND_ARG_INFO(0, str)
ZEND_ARG_INFO(0, object)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_base_unpacker, 0, 0, 0)
ZEND_END_ARG_INFO()
static const zend_function_entry msgpack_base_methods[] = {
ZEND_ME(msgpack, __construct,
arginfo_msgpack_base___construct, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack, setOption, arginfo_msgpack_base_setOption, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack, pack, arginfo_msgpack_base_pack, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack, unpack, arginfo_msgpack_base_unpack, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack, unpacker, arginfo_msgpack_base_unpacker, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* MessagePackUnpacker */
static zend_class_entry *msgpack_unpacker_ce = NULL;
static ZEND_METHOD(msgpack_unpacker, __construct);
static ZEND_METHOD(msgpack_unpacker, __destruct);
static ZEND_METHOD(msgpack_unpacker, setOption);
static ZEND_METHOD(msgpack_unpacker, feed);
static ZEND_METHOD(msgpack_unpacker, execute);
static ZEND_METHOD(msgpack_unpacker, data);
static ZEND_METHOD(msgpack_unpacker, reset);
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker___construct, 0, 0, 0)
ZEND_ARG_INFO(0, opt)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker___destruct, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker_setOption, 0, 0, 2)
ZEND_ARG_INFO(0, option)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker_feed, 0, 0, 1)
ZEND_ARG_INFO(0, str)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker_execute, 1, 0, 0)
ZEND_ARG_INFO(0, str)
ZEND_ARG_INFO(1, offset)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker_data, 0, 0, 0)
ZEND_ARG_INFO(0, object)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_msgpack_unpacker_reset, 0, 0, 0)
ZEND_END_ARG_INFO()
static const zend_function_entry msgpack_unpacker_methods[] = {
ZEND_ME(msgpack_unpacker, __construct,
arginfo_msgpack_unpacker___construct, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, __destruct,
arginfo_msgpack_unpacker___destruct, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, setOption,
arginfo_msgpack_unpacker_setOption, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, feed,
arginfo_msgpack_unpacker_feed, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, execute,
arginfo_msgpack_unpacker_execute, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, data,
arginfo_msgpack_unpacker_data, ZEND_ACC_PUBLIC)
ZEND_ME(msgpack_unpacker, reset,
arginfo_msgpack_unpacker_reset, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
static void php_msgpack_base_free(php_msgpack_base_t *base TSRMLS_DC)
{
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
zend_object_std_dtor(&base->object TSRMLS_CC);
#else
if (base->object.properties)
{
zend_hash_destroy(base->object.properties);
FREE_HASHTABLE(base->object.properties);
}
#endif
efree(base);
}
static zend_object_value php_msgpack_base_new(zend_class_entry *ce TSRMLS_DC)
{
zend_object_value retval;
php_msgpack_base_t *base;
#if PHP_API_VERSION < 20100412
zval *tmp;
#endif
base = emalloc(sizeof(php_msgpack_base_t));
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
zend_object_std_init(&base->object, ce TSRMLS_CC);
#else
ALLOC_HASHTABLE(base->object.properties);
zend_hash_init(base->object.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
base->object.ce = ce;
#endif
#if PHP_API_VERSION < 20100412
zend_hash_copy(
base->object.properties, &ce->default_properties,
(copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *));
#else
object_properties_init(&base->object, ce);
#endif
retval.handle = zend_objects_store_put(
base, (zend_objects_store_dtor_t)zend_objects_destroy_object,
(zend_objects_free_object_storage_t)php_msgpack_base_free,
NULL TSRMLS_CC);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
static void php_msgpack_unpacker_free(
php_msgpack_unpacker_t *unpacker TSRMLS_DC)
{
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
zend_object_std_dtor(&unpacker->object TSRMLS_CC);
#else
if (unpacker->object.properties)
{
zend_hash_destroy(unpacker->object.properties);
FREE_HASHTABLE(unpacker->object.properties);
}
#endif
efree(unpacker);
}
static zend_object_value php_msgpack_unpacker_new(
zend_class_entry *ce TSRMLS_DC)
{
zend_object_value retval;
php_msgpack_unpacker_t *unpacker;
#if PHP_API_VERSION < 20100412
zval *tmp;
#endif
unpacker = emalloc(sizeof(php_msgpack_unpacker_t));
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
zend_object_std_init(&unpacker->object, ce TSRMLS_CC);
#else
ALLOC_HASHTABLE(unpacker->object.properties);
zend_hash_init(unpacker->object.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
unpacker->object.ce = ce;
#endif
#if PHP_API_VERSION < 20100412
zend_hash_copy(
unpacker->object.properties, &ce->default_properties,
(copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *));
#else
object_properties_init(&unpacker->object, ce);
#endif
retval.handle = zend_objects_store_put(
unpacker, (zend_objects_store_dtor_t)zend_objects_destroy_object,
(zend_objects_free_object_storage_t)php_msgpack_unpacker_free,
NULL TSRMLS_CC);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
/* MessagePack */
static ZEND_METHOD(msgpack, __construct)
{
zend_bool php_only = MSGPACK_G(php_only);
MSGPACK_BASE_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "|b", &php_only) == FAILURE)
{
return;
}
base->php_only = php_only;
}
static ZEND_METHOD(msgpack, setOption)
{
long option;
zval *value;
MSGPACK_BASE_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "lz", &option, &value) == FAILURE)
{
return;
}
switch (option)
{
case MSGPACK_CLASS_OPT_PHPONLY:
convert_to_boolean(value);
base->php_only = Z_BVAL_P(value);
break;
default:
MSGPACK_WARNING("[msgpack] (MessagePack::setOption) "
"error setting msgpack option");
RETURN_FALSE;
break;
}
RETURN_TRUE;
}
static ZEND_METHOD(msgpack, pack)
{
zval *parameter;
smart_str buf = {0};
int php_only = MSGPACK_G(php_only);
MSGPACK_BASE_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "z", &parameter) == FAILURE)
{
return;
}
MSGPACK_G(php_only) = base->php_only;
php_msgpack_serialize(&buf, parameter TSRMLS_CC);
MSGPACK_G(php_only) = php_only;
ZVAL_STRINGL(return_value, buf.c, buf.len, 1);
smart_str_free(&buf);
}
static ZEND_METHOD(msgpack, unpack)
{
char *str;
int str_len;
zval *object = NULL;
int php_only = MSGPACK_G(php_only);
MSGPACK_BASE_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "s|z",
&str, &str_len, &object) == FAILURE)
{
return;
}
if (!str_len)
{
RETURN_NULL();
}
MSGPACK_G(php_only) = base->php_only;
if (object == NULL)
{
php_msgpack_unserialize(return_value, str, str_len TSRMLS_CC);
}
else
{
zval *zv;
ALLOC_INIT_ZVAL(zv);
php_msgpack_unserialize(zv, str, str_len TSRMLS_CC);
if (msgpack_convert_template(return_value, object, &zv) != SUCCESS)
{
RETURN_NULL();
}
}
MSGPACK_G(php_only) = php_only;
}
static ZEND_METHOD(msgpack, unpacker)
{
zval temp, *opt;
MSGPACK_BASE_OBJECT;
ALLOC_INIT_ZVAL(opt);
ZVAL_BOOL(opt, base->php_only);
object_init_ex(return_value, msgpack_unpacker_ce);
MSGPACK_METHOD1(msgpack_unpacker, __construct, &temp, return_value, opt);
zval_ptr_dtor(&opt);
}
/* MessagePackUnpacker */
static ZEND_METHOD(msgpack_unpacker, __construct)
{
zend_bool php_only = MSGPACK_G(php_only);
MSGPACK_UNPACKER_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "|b", &php_only) == FAILURE)
{
return;
}
unpacker->php_only = php_only;
unpacker->buffer.c = NULL;
unpacker->buffer.len = 0;
unpacker->buffer.a = 0;
unpacker->retval = NULL;
unpacker->offset = 0;
unpacker->finished = 0;
unpacker->error = 0;
template_init(&unpacker->mp);
msgpack_unserialize_var_init(&unpacker->var_hash);
(&unpacker->mp)->user.var_hash =
(msgpack_unserialize_data_t *)&unpacker->var_hash;
}
static ZEND_METHOD(msgpack_unpacker, __destruct)
{
MSGPACK_UNPACKER_OBJECT;
smart_str_free(&unpacker->buffer);
if (unpacker->retval != NULL)
{
zval_ptr_dtor(&unpacker->retval);
}
msgpack_unserialize_var_destroy(&unpacker->var_hash, unpacker->error);
}
static ZEND_METHOD(msgpack_unpacker, setOption)
{
long option;
zval *value;
MSGPACK_UNPACKER_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "lz", &option, &value) == FAILURE)
{
return;
}
switch (option)
{
case MSGPACK_CLASS_OPT_PHPONLY:
convert_to_boolean(value);
unpacker->php_only = Z_BVAL_P(value);
break;
default:
MSGPACK_WARNING("[msgpack] (MessagePackUnpacker::setOption) "
"error setting msgpack option");
RETURN_FALSE;
break;
}
RETURN_TRUE;
}
static ZEND_METHOD(msgpack_unpacker, feed)
{
char *str;
int str_len;
MSGPACK_UNPACKER_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE)
{
return;
}
if (!str_len)
{
RETURN_FALSE;
}
smart_str_appendl(&unpacker->buffer, str, str_len);
RETURN_TRUE;
}
static ZEND_METHOD(msgpack_unpacker, execute)
{
char *str = NULL, *data;
long str_len = 0;
zval *offset = NULL;
int ret;
size_t len, off;
int error_display = MSGPACK_G(error_display);
int php_only = MSGPACK_G(php_only);
MSGPACK_UNPACKER_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "|sz/",
&str, &str_len, &offset) == FAILURE)
{
return;
}
if (str != NULL)
{
data = (char *)str;
len = (size_t)str_len;
if (offset != NULL)
{
off = Z_LVAL_P(offset);
}
else
{
off = 0;
}
}
else
{
data = (char *)unpacker->buffer.c;
len = unpacker->buffer.len;
off = unpacker->offset;
}
if (unpacker->retval == NULL)
{
ALLOC_INIT_ZVAL(unpacker->retval);
}
else if (unpacker->finished)
{
zval_ptr_dtor(&unpacker->retval);
msgpack_unserialize_var_destroy(&unpacker->var_hash, unpacker->error);
unpacker->error = 0;
ALLOC_INIT_ZVAL(unpacker->retval);
template_init(&unpacker->mp);
msgpack_unserialize_var_init(&unpacker->var_hash);
(&unpacker->mp)->user.var_hash =
(msgpack_unserialize_data_t *)&unpacker->var_hash;
}
(&unpacker->mp)->user.retval = (zval *)unpacker->retval;
MSGPACK_G(error_display) = 0;
MSGPACK_G(php_only) = unpacker->php_only;
ret = template_execute(&unpacker->mp, data, len, &off);
MSGPACK_G(error_display) = error_display;
MSGPACK_G(php_only) = php_only;
if (str != NULL)
{
if (offset != NULL)
{
ZVAL_LONG(offset, off);
}
}
else
{
unpacker->offset = off;
}
switch (ret)
{
case MSGPACK_UNPACK_EXTRA_BYTES:
case MSGPACK_UNPACK_SUCCESS:
unpacker->finished = 1;
unpacker->error = 0;
RETURN_TRUE;
default:
unpacker->error = 1;
RETURN_FALSE;
}
}
static ZEND_METHOD(msgpack_unpacker, data)
{
zval *object = NULL;
MSGPACK_UNPACKER_OBJECT;
if (zend_parse_parameters(
ZEND_NUM_ARGS() TSRMLS_CC, "|z", &object) == FAILURE)
{
return;
}
if (unpacker->retval != NULL)
{
if (object == NULL)
{
ZVAL_ZVAL(return_value, unpacker->retval, 1, 0);
}
else
{
zval *zv;
ALLOC_INIT_ZVAL(zv);
ZVAL_ZVAL(zv, unpacker->retval, 1, 0);
if (msgpack_convert_object(return_value, object, &zv) != SUCCESS)
{
RETURN_NULL();
}
}
MSGPACK_METHOD(msgpack_unpacker, reset, NULL, getThis());
return;
}
RETURN_FALSE;
}
static ZEND_METHOD(msgpack_unpacker, reset)
{
smart_str buffer = {0};
MSGPACK_UNPACKER_OBJECT;
if (unpacker->buffer.len > unpacker->offset)
{
smart_str_appendl(&buffer, unpacker->buffer.c + unpacker->offset,
unpacker->buffer.len - unpacker->offset);
}
smart_str_free(&unpacker->buffer);
unpacker->buffer.c = NULL;
unpacker->buffer.len = 0;
unpacker->buffer.a = 0;
unpacker->offset = 0;
unpacker->finished = 0;
if (buffer.len > 0)
{
smart_str_appendl(&unpacker->buffer, buffer.c, buffer.len);
}
smart_str_free(&buffer);
if (unpacker->retval != NULL)
{
zval_ptr_dtor(&unpacker->retval);
unpacker->retval = NULL;
}
msgpack_unserialize_var_destroy(&unpacker->var_hash, unpacker->error);
unpacker->error = 0;
template_init(&unpacker->mp);
msgpack_unserialize_var_init(&unpacker->var_hash);
(&unpacker->mp)->user.var_hash =
(msgpack_unserialize_data_t *)&unpacker->var_hash;
}
void msgpack_init_class()
{
zend_class_entry ce;
TSRMLS_FETCH();
/* base */
INIT_CLASS_ENTRY(ce, "MessagePack", msgpack_base_methods);
msgpack_ce = zend_register_internal_class(&ce TSRMLS_CC);
msgpack_ce->create_object = php_msgpack_base_new;
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
zend_declare_class_constant_long(
msgpack_ce, ZEND_STRS("OPT_PHPONLY") - 1,
MSGPACK_CLASS_OPT_PHPONLY TSRMLS_CC);
#endif
/* unpacker */
INIT_CLASS_ENTRY(ce, "MessagePackUnpacker", msgpack_unpacker_methods);
msgpack_unpacker_ce = zend_register_internal_class(&ce TSRMLS_CC);
msgpack_unpacker_ce->create_object = php_msgpack_unpacker_new;
}

9
php/msgpack_class.h
View File

@ -1,9 +0,0 @@
#ifndef MSGPACK_CLASS_H
#define MSGPACK_CLASS_H
#define MSGPACK_CLASS_OPT_PHPONLY -1001
void msgpack_init_class();
#endif

794
php/msgpack_convert.c
View File

@ -1,794 +0,0 @@
#include "php.h"
#include "php_msgpack.h"
#include "msgpack_convert.h"
#include "msgpack_errors.h"
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 3)
# define Z_REFCOUNT_P(pz) ((pz)->refcount)
# define Z_SET_ISREF_P(pz) (pz)->is_ref = 1
# define Z_UNSET_ISREF_P(pz) (pz)->is_ref = 0
#endif
#define MSGPACK_CONVERT_COPY_ZVAL(_pz, _ppz) \
ALLOC_INIT_ZVAL(_pz); \
*(_pz) = **(_ppz); \
if (PZVAL_IS_REF(*(_ppz))) { \
if (Z_REFCOUNT_P(*(_ppz)) > 0) { \
zval_copy_ctor(_pz); \
} else { \
FREE_ZVAL(*(_ppz)); \
} \
INIT_PZVAL(_pz); \
Z_SET_ISREF_P(_pz); \
} else { \
zval_copy_ctor(_pz); \
INIT_PZVAL(_pz); \
}
#define MSGPACK_CONVERT_UPDATE_PROPERTY(_ht, _key, _key_len, _val, _var) \
if (zend_symtable_update( \
_ht, _key, _key_len, &_val, sizeof(_val), NULL) == SUCCESS) { \
zend_hash_add(_var, _key, _key_len, &_val, sizeof(_val), NULL); \
return SUCCESS; \
}
inline int msgpack_convert_long_to_properties(
HashTable *ht, HashTable **properties, HashPosition *prop_pos,
uint key_index, zval *val, HashTable *var)
{
TSRMLS_FETCH();
if (*properties != NULL)
{
char *prop_key;
uint prop_key_len;
ulong prop_key_index;
zval **data = NULL;
zval *tplval = NULL;
zval **dataval = NULL;
for (;; zend_hash_move_forward_ex(*properties, prop_pos))
{
if (zend_hash_get_current_key_ex(
*properties, &prop_key, &prop_key_len,
&prop_key_index, 0, prop_pos) == HASH_KEY_IS_STRING)
{
if (var == NULL ||
!zend_hash_exists(var, prop_key, prop_key_len))
{
if (zend_hash_find(
ht, prop_key, prop_key_len,
(void **)&data) == SUCCESS)
{
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
{
HashTable *dataht;
dataht = HASH_OF(val);
if (zend_hash_index_find(
dataht, prop_key_index,
(void **)dataval) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) "
"can't get data value by index",
__FUNCTION__);
return FAILURE;
}
ALLOC_INIT_ZVAL(tplval);
if (msgpack_convert_array(
tplval, *data, dataval) == SUCCESS)
{
zend_hash_move_forward_ex(
*properties, prop_pos);
return zend_symtable_update(
ht, prop_key, prop_key_len,
&tplval, sizeof(tplval), NULL);
}
// TODO: de we need to call dtor?
return FAILURE;
break;
}
case IS_OBJECT:
{
ALLOC_INIT_ZVAL(tplval);
if (msgpack_convert_object(
tplval, *data, &val) == SUCCESS)
{
zend_hash_move_forward_ex(
*properties, prop_pos);
return zend_symtable_update(
ht, prop_key, prop_key_len,
&tplval, sizeof(tplval), NULL);
}
// TODO: de we need to call dtor?
return FAILURE;
break;
}
default:
zend_hash_move_forward_ex(*properties, prop_pos);
return zend_symtable_update(
ht, prop_key, prop_key_len,
&val, sizeof(val), NULL);
break;
}
}
}
}
else
{
break;
}
}
*properties = NULL;
}
return zend_hash_index_update(ht, key_index, &val, sizeof(val), NULL);
}
inline int msgpack_convert_string_to_properties(
zval *object, char *key, uint key_len, zval *val, HashTable *var)
{
zval **data = NULL;
HashTable *ht;
zend_class_entry *ce;
char *prot_name, *priv_name;
int prop_name_len;
TSRMLS_FETCH();
ht = HASH_OF(object);
ce = zend_get_class_entry(object TSRMLS_CC);
/* private */
zend_mangle_property_name(
&priv_name, &prop_name_len, ce->name, ce->name_length, key, key_len, 1);
if (zend_hash_find(
ht, priv_name, prop_name_len, (void **)&data) == SUCCESS)
{
MSGPACK_CONVERT_UPDATE_PROPERTY(ht, priv_name, prop_name_len, val, var);
}
/* protected */
zend_mangle_property_name(
&prot_name, &prop_name_len, "*", 1, key, key_len, 1);
if (zend_hash_find(
ht, prot_name, prop_name_len, (void **)&data) == SUCCESS)
{
MSGPACK_CONVERT_UPDATE_PROPERTY(ht, prot_name, prop_name_len, val, var);
}
/* public */
MSGPACK_CONVERT_UPDATE_PROPERTY(ht, key, key_len, val, var);
return FAILURE;
}
int msgpack_convert_array(zval *return_value, zval *tpl, zval **value)
{
TSRMLS_FETCH();
if (Z_TYPE_P(tpl) == IS_ARRAY)
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data, **arydata;
HashPosition pos, valpos;
HashTable *ht, *htval;
int num;
ht = HASH_OF(tpl);
// TODO: maybe need to release memory?
array_init(return_value);
num = zend_hash_num_elements(ht);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) template array length is 0",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
/* string */
if (ht->nNumOfElements != ht->nNextFreeElement)
{
htval = HASH_OF(*value);
if (!htval)
{
MSGPACK_WARNING(
"[msgpack] (%s) input data is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(ht, &pos),
zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
if (key_type == HASH_KEY_IS_STRING)
{
int (*convert_function)(zval *, zval *, zval **) = NULL;
zval **dataval, *val;
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
// case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&dataval, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
MSGPACK_CONVERT_COPY_ZVAL(val, dataval);
if (convert_function)
{
zval *rv;
ALLOC_INIT_ZVAL(rv);
if (convert_function(rv, *data, &val) != SUCCESS)
{
zval_ptr_dtor(&val);
return FAILURE;
}
add_assoc_zval_ex(return_value, key, key_len, rv);
}
else
{
add_assoc_zval_ex(return_value, key, key_len, val);
}
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
else
{
/* index */
int (*convert_function)(zval *, zval *, zval **) = NULL;
if (Z_TYPE_PP(value) != IS_ARRAY)
{
MSGPACK_WARNING(
"[msgpack] (%s) unserialized data must be array.",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
MSGPACK_WARNING(
"[msgpack] (%s) first element in template array is empty",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) invalid template: empty array?",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
htval = HASH_OF(*value);
num = zend_hash_num_elements(htval);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) array length is 0 in unserialized data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
htval, &key, &key_len, &key_index, 0, &valpos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&arydata, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get next data in indexed array",
__FUNCTION__);
continue;
}
switch (key_type)
{
case HASH_KEY_IS_LONG:
{
zval *aryval, *rv;
ALLOC_INIT_ZVAL(rv);
MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata);
if (convert_function)
{
if (convert_function(rv, *data, &aryval) != SUCCESS)
{
zval_ptr_dtor(&aryval);
MSGPACK_WARNING(
"[msgpack] (%s) "
"convert failure in HASH_KEY_IS_LONG "
"in indexed array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
add_next_index_zval(return_value, rv);
}
else
{
add_next_index_zval(return_value, aryval);
}
break;
}
case HASH_KEY_IS_STRING:
MSGPACK_WARNING(
"[msgpack] (%s) key is string",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
default:
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
}
else
{
// shouldn't reach
MSGPACK_WARNING(
"[msgpack] (%s) template is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
// shouldn't reach
zval_ptr_dtor(value);
return FAILURE;
}
int msgpack_convert_object(zval *return_value, zval *tpl, zval **value)
{
zend_class_entry *ce, **pce;
TSRMLS_FETCH();
switch (Z_TYPE_P(tpl))
{
case IS_STRING:
if (zend_lookup_class(
Z_STRVAL_P(tpl), Z_STRLEN_P(tpl),
&pce TSRMLS_CC) != SUCCESS)
{
MSGPACK_ERROR("[msgpack] (%s) Class '%s' not found",
__FUNCTION__, Z_STRVAL_P(tpl));
return FAILURE;
}
ce = *pce;
break;
case IS_OBJECT:
ce = zend_get_class_entry(tpl TSRMLS_CC);
break;
default:
MSGPACK_ERROR("[msgpack] (%s) object type is unsupported",
__FUNCTION__);
return FAILURE;
}
if (Z_TYPE_PP(value) == IS_OBJECT)
{
zend_class_entry *vce;
vce = zend_get_class_entry(*value TSRMLS_CC);
if (strcmp(ce->name, vce->name) == 0)
{
*return_value = **value;
zval_copy_ctor(return_value);
zval_ptr_dtor(value);
return SUCCESS;
}
}
object_init_ex(return_value, ce);
/* Run the constructor if there is one */
if (ce->constructor
&& (ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC))
{
zval *retval_ptr = NULL;
zval ***params = NULL;
int num_args = 0;
zend_fcall_info fci;
zend_fcall_info_cache fcc;
#if ZEND_MODULE_API_NO >= 20090626
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
fci.function_name = NULL;
fci.symbol_table = NULL;
fci.object_ptr = return_value;
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = num_args;
fci.params = params;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(return_value);
fcc.object_ptr = return_value;
#else
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
fci.function_name = NULL;
fci.symbol_table = NULL;
fci.object_pp = &return_value;
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = num_args;
fci.params = params;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.object_pp = &return_value;
#endif
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE)
{
if (params)
{
efree(params);
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
MSGPACK_WARNING(
"[msgpack] (%s) Invocation of %s's constructor failed",
__FUNCTION__, ce->name);
return FAILURE;
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
if (params)
{
efree(params);
}
}
switch (Z_TYPE_PP(value))
{
case IS_ARRAY:
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data;
HashPosition pos;
HashTable *ht, *ret;
HashTable *var = NULL;
int num;
ht = HASH_OF(*value);
ret = HASH_OF(return_value);
num = zend_hash_num_elements(ht);
if (num <= 0)
{
zval_ptr_dtor(value);
break;
}
/* string - php_only mode? */
if (ht->nNumOfElements != ht->nNextFreeElement
|| ht->nNumOfElements != ret->nNumOfElements)
{
HashTable *properties = NULL;
HashPosition prop_pos;
ALLOC_HASHTABLE(var);
zend_hash_init(var, num, NULL, NULL, 0);
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
if (key_type == HASH_KEY_IS_STRING)
{
zval *val;
MSGPACK_CONVERT_COPY_ZVAL(val, data);
if (msgpack_convert_string_to_properties(
return_value, key, key_len, val, var) != SUCCESS)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) "
"illegal offset type, skip this decoding",
__FUNCTION__);
}
}
}
/* index */
properties = Z_OBJ_HT_P(return_value)->get_properties(
return_value TSRMLS_CC);
if (HASH_OF(tpl))
{
properties = HASH_OF(tpl);
}
zend_hash_internal_pointer_reset_ex(properties, &prop_pos);
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
switch (key_type)
{
case HASH_KEY_IS_LONG:
{
zval *val;
MSGPACK_CONVERT_COPY_ZVAL(val, data);
if (msgpack_convert_long_to_properties(
ret, &properties, &prop_pos,
key_index, val, var) != SUCCESS)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) "
"illegal offset type, skip this decoding",
__FUNCTION__);
}
break;
}
case HASH_KEY_IS_STRING:
break;
default:
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
break;
}
}
zend_hash_destroy(var);
FREE_HASHTABLE(var);
}
else
{
HashPosition valpos;
int (*convert_function)(zval *, zval *, zval **) = NULL;
zval **arydata, *aryval;
/* index */
zend_hash_internal_pointer_reset_ex(ret, &pos);
zend_hash_internal_pointer_reset_ex(ht, &valpos);
for (;; zend_hash_move_forward_ex(ret, &pos),
zend_hash_move_forward_ex(ht, &valpos))
{
key_type = zend_hash_get_current_key_ex(
ret, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ret, (void *)&data, &pos) != SUCCESS)
{
continue;
}
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
//case IS_STRING: -- may have default values of
// class members, so it's not wise to allow
convert_function = msgpack_convert_object;
break;
default:
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&arydata, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get data value by index",
__FUNCTION__);
return FAILURE;
}
MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata);
if (convert_function)
{
zval *rv;
ALLOC_INIT_ZVAL(rv);
if (convert_function(rv, *data, &aryval) != SUCCESS)
{
zval_ptr_dtor(&aryval);
MSGPACK_WARNING(
"[msgpack] (%s) "
"convert failure in convert_object",
__FUNCTION__);
return FAILURE;
}
zend_symtable_update(
ret, key, key_len, &rv, sizeof(rv), NULL);
}
else
{
zend_symtable_update(
ret, key, key_len, &aryval, sizeof(aryval), NULL);
}
}
}
zval_ptr_dtor(value);
break;
}
default:
{
HashTable *properties = NULL;
HashPosition prop_pos;
properties = Z_OBJ_HT_P(return_value)->get_properties(
return_value TSRMLS_CC);
zend_hash_internal_pointer_reset_ex(properties, &prop_pos);
if (msgpack_convert_long_to_properties(
HASH_OF(return_value), &properties, &prop_pos,
0, *value, NULL) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) illegal offset type, skip this decoding",
__FUNCTION__);
}
break;
}
}
return SUCCESS;
}
int msgpack_convert_template(zval *return_value, zval *tpl, zval **value)
{
TSRMLS_FETCH();
switch (Z_TYPE_P(tpl))
{
case IS_ARRAY:
return msgpack_convert_array(return_value, tpl, value);
break;
case IS_STRING:
case IS_OBJECT:
return msgpack_convert_object(return_value, tpl, value);
break;
default:
MSGPACK_ERROR("[msgpack] (%s) Template type is unsupported",
__FUNCTION__);
return FAILURE;
}
// shouldn't reach
return FAILURE;
}

9
php/msgpack_convert.h
View File

@ -1,9 +0,0 @@
#ifndef MSGPACK_CONVERT_H
#define MSGPACK_CONVERT_H
int msgpack_convert_object(zval *return_value, zval *object, zval **value);
int msgpack_convert_array(zval *return_value, zval *tpl, zval **value);
int msgpack_convert_template(zval *return_value, zval *tpl, zval **value);
#endif

17
php/msgpack_errors.h
View File

@ -1,17 +0,0 @@
#ifndef MSGPACK_ERRORS_H
#define MSGPACK_ERRORS_H
#define MSGPACK_NOTICE(...) \
if (MSGPACK_G(error_display)) { \
zend_error(E_NOTICE, __VA_ARGS__); \
}
#define MSGPACK_WARNING(...) \
if (MSGPACK_G(error_display)) { \
zend_error(E_WARNING, __VA_ARGS__); \
}
#define MSGPACK_ERROR(...) zend_error(E_ERROR, __VA_ARGS__)
#endif

604
php/msgpack_pack.c
View File

@ -1,604 +0,0 @@
#include "php.h"
#include "php_ini.h"
#include "ext/standard/php_smart_str.h"
#include "ext/standard/php_incomplete_class.h"
#include "ext/standard/php_var.h"
#include "php_msgpack.h"
#include "msgpack_pack.h"
#include "msgpack_errors.h"
#include "msgpack/pack_define.h"
#define msgpack_pack_user smart_str*
#define msgpack_pack_inline_func(name) \
static inline void msgpack_pack ## name
#define msgpack_pack_inline_func_cint(name) \
static inline void msgpack_pack ## name
#define msgpack_pack_append_buffer(user, buf, len) \
smart_str_appendl(user, (const void*)buf, len)
#include "msgpack/pack_template.h"
#if ZEND_MODULE_API_NO < 20090626
# define Z_ISREF_P(pz) PZVAL_IS_REF(pz)
#endif
inline static int msgpack_var_add(
HashTable *var_hash, zval *var, void *var_old TSRMLS_DC)
{
ulong var_no;
char id[32], *p;
int len;
if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry)
{
p = smart_str_print_long(
id + sizeof(id) - 1,
(((size_t)Z_OBJCE_P(var) << 5)
| ((size_t)Z_OBJCE_P(var) >> (sizeof(long) * 8 - 5)))
+ (long)Z_OBJ_HANDLE_P(var));
len = id + sizeof(id) - 1 - p;
}
else if (Z_TYPE_P(var) == IS_ARRAY)
{
p = smart_str_print_long(id + sizeof(id) - 1, (long)var);
len = id + sizeof(id) - 1 - p;
}
else
{
return FAILURE;
}
if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS)
{
if (!Z_ISREF_P(var))
{
var_no = -1;
zend_hash_next_index_insert(
var_hash, &var_no, sizeof(var_no), NULL);
}
return FAILURE;
}
var_no = zend_hash_num_elements(var_hash) + 1;
zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL);
return SUCCESS;
}
inline static void msgpack_serialize_string(
smart_str *buf, char *str, size_t len)
{
msgpack_pack_raw(buf, len);
msgpack_pack_raw_body(buf, str, len);
}
inline static void msgpack_serialize_class(
smart_str *buf, zval *val, zval *retval_ptr, HashTable *var_hash,
char *class_name, zend_uint name_len, zend_bool incomplete_class TSRMLS_DC)
{
int count;
HashTable *ht = HASH_OF(retval_ptr);
count = zend_hash_num_elements(ht);
if (incomplete_class)
{
--count;
}
if (count > 0)
{
char *key;
zval **data, **name;
ulong key_index;
HashPosition pos;
int n;
zval nval, *nvalp;
msgpack_pack_map(buf, count + 1);
msgpack_pack_nil(buf);
msgpack_serialize_string(buf, class_name, name_len);
ZVAL_NULL(&nval);
nvalp = &nval;
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
n = zend_hash_get_current_key_ex(
ht, &key, NULL, &key_index, 0, &pos);
if (n == HASH_KEY_NON_EXISTANT)
{
break;
}
if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0)
{
continue;
}
zend_hash_get_current_data_ex(ht, (void **)&name, &pos);
if (Z_TYPE_PP(name) != IS_STRING)
{
MSGPACK_NOTICE(
"[msgpack] (%s) __sleep should return an array only "
"containing the names of instance-variables to serialize",
__FUNCTION__);
continue;
}
if (zend_hash_find(
Z_OBJPROP_P(val), Z_STRVAL_PP(name),
Z_STRLEN_PP(name) + 1, (void *)&data) == SUCCESS)
{
msgpack_serialize_string(
buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
msgpack_serialize_zval(buf, *data, var_hash TSRMLS_CC);
}
else
{
zend_class_entry *ce;
ce = zend_get_class_entry(val TSRMLS_CC);
if (ce)
{
char *prot_name, *priv_name;
int prop_name_length;
do
{
zend_mangle_property_name(
&priv_name, &prop_name_length, ce->name,
ce->name_length, Z_STRVAL_PP(name),
Z_STRLEN_PP(name),
ce->type & ZEND_INTERNAL_CLASS);
if (zend_hash_find(
Z_OBJPROP_P(val), priv_name,
prop_name_length + 1,
(void *)&data) == SUCCESS)
{
msgpack_serialize_string(
buf, priv_name, prop_name_length);
pefree(priv_name,
ce->type & ZEND_INTERNAL_CLASS);
msgpack_serialize_zval(
buf, *data, var_hash TSRMLS_CC);
break;
}
pefree(priv_name,
ce->type & ZEND_INTERNAL_CLASS);
zend_mangle_property_name(
&prot_name, &prop_name_length, "*", 1,
Z_STRVAL_PP(name), Z_STRLEN_PP(name),
ce->type & ZEND_INTERNAL_CLASS);
if (zend_hash_find(
Z_OBJPROP_P(val), prot_name,
prop_name_length + 1,
(void *)&data) == SUCCESS)
{
msgpack_serialize_string(
buf, prot_name, prop_name_length);
pefree(prot_name,
ce->type & ZEND_INTERNAL_CLASS);
msgpack_serialize_zval(
buf, *data, var_hash TSRMLS_CC);
break;
}
pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
MSGPACK_NOTICE(
"[msgpack] (%s) \"%s\" returned as member "
"variable from __sleep() but does not exist",
__FUNCTION__, Z_STRVAL_PP(name));
msgpack_serialize_string(
buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
msgpack_serialize_zval(
buf, nvalp, var_hash TSRMLS_CC);
}
while (0);
}
else
{
msgpack_serialize_string(
buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
msgpack_serialize_zval(buf, nvalp, var_hash TSRMLS_CC);
}
}
}
}
}
inline static void msgpack_serialize_array(
smart_str *buf, zval *val, HashTable *var_hash, zend_bool object,
char* class_name, zend_uint name_len, zend_bool incomplete_class TSRMLS_DC)
{
HashTable *ht;
size_t n;
zend_bool hash = 1;
if (object)
{
ht = Z_OBJPROP_P(val);
}
else
{
ht = HASH_OF(val);
}
if (ht)
{
n = zend_hash_num_elements(ht);
}
else
{
n = 0;
}
if (n > 0 && incomplete_class)
{
--n;
}
if (object)
{
if (n == 0)
{
msgpack_pack_map(buf, n);
}
else
{
if (MSGPACK_G(php_only))
{
if (Z_ISREF_P(val))
{
msgpack_pack_map(buf, n + 2);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_REFERENCE);
}
else
{
msgpack_pack_map(buf, n + 1);
}
msgpack_pack_nil(buf);
msgpack_serialize_string(buf, class_name, name_len);
}
else
{
msgpack_pack_array(buf, n);
hash = 0;
}
}
}
else if (n == 0)
{
hash = 0;
msgpack_pack_array(buf, n);
}
else if (Z_ISREF_P(val) && MSGPACK_G(php_only))
{
msgpack_pack_map(buf, n + 1);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_REFERENCE);
}
else if (ht->nNumOfElements == ht->nNextFreeElement)
{
hash = 0;
msgpack_pack_array(buf, n);
}
else
{
msgpack_pack_map(buf, n);
}
if (n > 0)
{
if (object || hash)
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data;
HashPosition pos;
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0)
{
continue;
}
if (hash)
{
switch (key_type)
{
case HASH_KEY_IS_LONG:
msgpack_pack_long(buf, key_index);
break;
case HASH_KEY_IS_STRING:
msgpack_serialize_string(buf, key, key_len - 1);
break;
default:
msgpack_serialize_string(buf, "", sizeof(""));
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
break;
}
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS ||
!data || data == &val ||
(Z_TYPE_PP(data) == IS_ARRAY &&
Z_ARRVAL_PP(data)->nApplyCount > 1))
{
msgpack_pack_nil(buf);
}
else
{
if (Z_TYPE_PP(data) == IS_ARRAY)
{
Z_ARRVAL_PP(data)->nApplyCount++;
}
msgpack_serialize_zval(buf, *data, var_hash TSRMLS_CC);
if (Z_TYPE_PP(data) == IS_ARRAY)
{
Z_ARRVAL_PP(data)->nApplyCount--;
}
}
}
}
else
{
zval **data;
uint i;
for (i = 0; i < n; i++)
{
if (zend_hash_index_find(ht, i, (void *)&data) != SUCCESS ||
!data || data == &val ||
(Z_TYPE_PP(data) == IS_ARRAY &&
Z_ARRVAL_PP(data)->nApplyCount > 1))
{
msgpack_pack_nil(buf);
}
else
{
if (Z_TYPE_PP(data) == IS_ARRAY)
{
Z_ARRVAL_PP(data)->nApplyCount++;
}
msgpack_serialize_zval(buf, *data, var_hash TSRMLS_CC);
if (Z_TYPE_PP(data) == IS_ARRAY)
{
Z_ARRVAL_PP(data)->nApplyCount--;
}
}
}
}
}
}
inline static void msgpack_serialize_object(
smart_str *buf, zval *val, HashTable *var_hash,
char* class_name, zend_uint name_len, zend_bool incomplete_class TSRMLS_DC)
{
zval *retval_ptr = NULL;
zval fname;
int res;
zend_class_entry *ce = NULL;
if (Z_OBJ_HT_P(val)->get_class_entry)
{
ce = Z_OBJCE_P(val);
}
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
if (ce && ce->serialize != NULL)
{
unsigned char *serialized_data = NULL;
zend_uint serialized_length;
if (ce->serialize(
val, &serialized_data, &serialized_length,
(zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS &&
!EG(exception))
{
/* has custom handler */
msgpack_pack_map(buf, 2);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_CUSTOM_OBJECT);
msgpack_serialize_string(buf, (char *)ce->name, ce->name_length);
msgpack_pack_raw(buf, serialized_length);
msgpack_pack_raw_body(buf, serialized_data, serialized_length);
}
else
{
msgpack_pack_nil(buf);
}
if (serialized_data)
{
efree(serialized_data);
}
return;
}
#endif
if (ce && ce != PHP_IC_ENTRY &&
zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep")))
{
INIT_PZVAL(&fname);
ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
res = call_user_function_ex(CG(function_table), &val, &fname,
&retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
if (res == SUCCESS && !EG(exception))
{
if (retval_ptr)
{
if (HASH_OF(retval_ptr))
{
msgpack_serialize_class(
buf, val, retval_ptr, var_hash,
class_name, name_len, incomplete_class TSRMLS_CC);
}
else
{
MSGPACK_NOTICE(
"[msgpack] (%s) __sleep should return an array only "
"containing the names of instance-variables "
"to serialize", __FUNCTION__);
msgpack_pack_nil(buf);
}
zval_ptr_dtor(&retval_ptr);
}
return;
}
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
msgpack_serialize_array(
buf, val, var_hash, 1,
class_name, name_len, incomplete_class TSRMLS_CC);
}
void msgpack_serialize_zval(
smart_str *buf, zval *val, HashTable *var_hash TSRMLS_DC)
{
ulong *var_already;
if (MSGPACK_G(php_only) &&
var_hash &&
msgpack_var_add(
var_hash, val, (void *)&var_already TSRMLS_CC) == FAILURE)
{
if (Z_ISREF_P(val))
{
if (Z_TYPE_P(val) == IS_ARRAY)
{
msgpack_pack_map(buf, 2);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_RECURSIVE);
msgpack_pack_long(buf, 0);
msgpack_pack_long(buf, *var_already);
return;
}
else if (Z_TYPE_P(val) == IS_OBJECT)
{
msgpack_pack_map(buf, 2);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE);
msgpack_pack_long(buf, 0);
msgpack_pack_long(buf, *var_already);
return;
}
}
else if (Z_TYPE_P(val) == IS_OBJECT)
{
msgpack_pack_map(buf, 2);
msgpack_pack_nil(buf);
msgpack_pack_long(buf, MSGPACK_SERIALIZE_TYPE_OBJECT);
msgpack_pack_long(buf, 0);
msgpack_pack_long(buf, *var_already);
return;
}
}
switch (Z_TYPE_P(val))
{
case IS_NULL:
msgpack_pack_nil(buf);
break;
case IS_BOOL:
if (Z_BVAL_P(val))
{
msgpack_pack_true(buf);
}
else
{
msgpack_pack_false(buf);
}
break;
case IS_LONG:
msgpack_pack_long(buf, Z_LVAL_P(val));
break;
case IS_DOUBLE:
{
double dbl = Z_DVAL_P(val);
msgpack_pack_double(buf, dbl);
}
break;
case IS_STRING:
msgpack_serialize_string(
buf, Z_STRVAL_P(val), Z_STRLEN_P(val));
break;
case IS_ARRAY:
msgpack_serialize_array(
buf, val, var_hash, 0, NULL, 0, 0 TSRMLS_CC);
break;
case IS_OBJECT:
{
PHP_CLASS_ATTRIBUTES;
PHP_SET_CLASS_ATTRIBUTES(val);
msgpack_serialize_object(
buf, val, var_hash, class_name, name_len,
incomplete_class TSRMLS_CC);
PHP_CLEANUP_CLASS_ATTRIBUTES();
}
break;
default:
MSGPACK_WARNING(
"[msgpack] (%s) type is unsupported, encoded as null",
__FUNCTION__);
msgpack_pack_nil(buf);
break;
}
return;
}

26
php/msgpack_pack.h
View File

@ -1,26 +0,0 @@
#ifndef MSGPACK_PACK_H
#define MSGPACK_PACK_H
#include "ext/standard/php_var.h"
#if PHP_API_VERSION < 20100412
#define msgpack_serialize_data_t HashTable
#else
typedef HashTable* msgpack_serialize_data_t;
#endif
enum msgpack_serialize_type
{
MSGPACK_SERIALIZE_TYPE_NONE = 0,
MSGPACK_SERIALIZE_TYPE_REFERENCE = 1,
MSGPACK_SERIALIZE_TYPE_RECURSIVE,
MSGPACK_SERIALIZE_TYPE_CUSTOM_OBJECT,
MSGPACK_SERIALIZE_TYPE_OBJECT,
MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE,
};
void msgpack_serialize_zval(
smart_str *buf, zval *val, HashTable *var_hash TSRMLS_DC);
#endif

760
php/msgpack_unpack.c
View File

@ -1,760 +0,0 @@
#include "php.h"
#include "php_ini.h"
#include "ext/standard/php_incomplete_class.h"
#include "php_msgpack.h"
#include "msgpack_pack.h"
#include "msgpack_unpack.h"
#include "msgpack_errors.h"
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION < 3)
# define Z_ADDREF_PP(ppz) ZVAL_ADDREF(*(ppz))
# define Z_SET_ISREF_PP(ppz) (*(ppz))->is_ref = 1
# define Z_UNSET_ISREF_PP(ppz) (*(ppz))->is_ref = 0
#endif
#define VAR_ENTRIES_MAX 1024
typedef struct
{
zval *data[VAR_ENTRIES_MAX];
long used_slots;
void *next;
} var_entries;
#define MSGPACK_UNSERIALIZE_ALLOC_STACK(_unpack) \
if (_unpack->deps <= 0) { \
*obj = _unpack->retval; \
msgpack_stack_push(_unpack->var_hash, obj, 0); \
} else { \
ALLOC_INIT_ZVAL(*obj); \
msgpack_stack_push(_unpack->var_hash, obj, 1); \
}
#define MSGPACK_UNSERIALIZE_ALLOC_VALUE(_unpack) \
if (_unpack->deps <= 0) { \
*obj = _unpack->retval; \
msgpack_var_push(_unpack->var_hash, obj); \
} else { \
ALLOC_INIT_ZVAL(*obj); \
msgpack_var_push(_unpack->var_hash, obj); \
}
#define MSGPACK_UNSERIALIZE_FINISH_ITEM(_unpack, _count) \
msgpack_stack_pop(_unpack->var_hash, _count); \
_unpack->stack[_unpack->deps-1]--; \
if (_unpack->stack[_unpack->deps-1] == 0) { \
_unpack->deps--; \
}
#define MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(_unpack, _key, _val) \
zval_ptr_dtor(&_key); \
zval_ptr_dtor(&_val); \
MSGPACK_UNSERIALIZE_FINISH_ITEM(_unpack, 2);
inline static void msgpack_var_push(
msgpack_unserialize_data_t *var_hashx, zval **rval)
{
var_entries *var_hash, *prev = NULL;
if (!var_hashx)
{
return;
}
var_hash = var_hashx->first;
while (var_hash && var_hash->used_slots == VAR_ENTRIES_MAX)
{
prev = var_hash;
var_hash = var_hash->next;
}
if (!var_hash)
{
var_hash = emalloc(sizeof(var_entries));
var_hash->used_slots = 0;
var_hash->next = 0;
if (!var_hashx->first)
{
var_hashx->first = var_hash;
}
else
{
prev->next = var_hash;
}
}
var_hash->data[var_hash->used_slots++] = *rval;
}
inline static int msgpack_var_access(
msgpack_unserialize_data_t *var_hashx, long id, zval ***store)
{
var_entries *var_hash = var_hashx->first;
while (id >= VAR_ENTRIES_MAX &&
var_hash && var_hash->used_slots == VAR_ENTRIES_MAX)
{
var_hash = var_hash->next;
id -= VAR_ENTRIES_MAX;
}
if (!var_hash)
{
return !SUCCESS;
}
if (id < 0 || id >= var_hash->used_slots)
{
return !SUCCESS;
}
*store = &var_hash->data[id];
return SUCCESS;
}
inline static void msgpack_stack_push(
msgpack_unserialize_data_t *var_hashx, zval **rval, zend_bool save)
{
var_entries *var_hash, *prev = NULL;
if (!var_hashx)
{
return;
}
var_hash = var_hashx->first_dtor;
while (var_hash && var_hash->used_slots == VAR_ENTRIES_MAX)
{
prev = var_hash;
var_hash = var_hash->next;
}
if (!var_hash)
{
var_hash = emalloc(sizeof(var_entries));
var_hash->used_slots = 0;
var_hash->next = 0;
if (!var_hashx->first_dtor)
{
var_hashx->first_dtor = var_hash;
}
else
{
prev->next = var_hash;
}
}
if (save)
{
var_hash->data[var_hash->used_slots++] = *rval;
}
else
{
var_hash->data[var_hash->used_slots++] = NULL;
}
}
inline static void msgpack_stack_pop(
msgpack_unserialize_data_t *var_hashx, long count)
{
long i;
var_entries *var_hash = var_hashx->first_dtor;
while (var_hash && var_hash->used_slots == VAR_ENTRIES_MAX)
{
var_hash = var_hash->next;
}
if (!var_hash || count <= 0)
{
return;
}
for (i = count; i > 0; i--)
{
var_hash->used_slots--;
if (var_hash->used_slots < 0)
{
var_hash->used_slots = 0;
var_hash->data[var_hash->used_slots] = NULL;
break;
}
else
{
var_hash->data[var_hash->used_slots] = NULL;
}
}
}
inline static zend_class_entry* msgpack_unserialize_class(
zval **container, char *class_name, size_t name_len)
{
zend_class_entry *ce, **pce;
zend_bool incomplete_class = 0;
zval *user_func, *retval_ptr, **args[1], *arg_func_name;
TSRMLS_FETCH();
do
{
/* Try to find class directly */
if (zend_lookup_class(class_name, name_len, &pce TSRMLS_CC) == SUCCESS)
{
ce = *pce;
break;
}
/* Check for unserialize callback */
if ((PG(unserialize_callback_func) == NULL) ||
(PG(unserialize_callback_func)[0] == '\0'))
{
incomplete_class = 1;
ce = PHP_IC_ENTRY;
break;
}
/* Call unserialize callback */
ALLOC_INIT_ZVAL(user_func);
ZVAL_STRING(user_func, PG(unserialize_callback_func), 1);
args[0] = &arg_func_name;
ALLOC_INIT_ZVAL(arg_func_name);
ZVAL_STRING(arg_func_name, class_name, 1);
if (call_user_function_ex(
CG(function_table), NULL, user_func, &retval_ptr,
1, args, 0, NULL TSRMLS_CC) != SUCCESS)
{
MSGPACK_WARNING("[msgpack] (%s) defined (%s) but not found",
__FUNCTION__, class_name);
incomplete_class = 1;
ce = PHP_IC_ENTRY;
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
break;
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
/* The callback function may have defined the class */
if (zend_lookup_class(class_name, name_len, &pce TSRMLS_CC) == SUCCESS)
{
ce = *pce;
}
else
{
MSGPACK_WARNING("[msgpack] (%s) Function %s() hasn't defined "
"the class it was called for",
__FUNCTION__, class_name);
incomplete_class = 1;
ce = PHP_IC_ENTRY;
}
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&arg_func_name);
}
while(0);
if (EG(exception))
{
MSGPACK_WARNING("[msgpack] (%s) Exception error", __FUNCTION__);
return NULL;
}
object_init_ex(*container, ce);
/* store incomplete class name */
if (incomplete_class)
{
php_store_class_name(*container, class_name, name_len);
}
return ce;
}
void msgpack_unserialize_var_init(msgpack_unserialize_data_t *var_hashx)
{
var_hashx->first = 0;
var_hashx->first_dtor = 0;
}
void msgpack_unserialize_var_destroy(
msgpack_unserialize_data_t *var_hashx, zend_bool err)
{
void *next;
long i;
var_entries *var_hash = var_hashx->first;
while (var_hash)
{
if (err)
{
for (i = var_hash->used_slots - 1; i > 0; i--)
{
if (var_hash->data[i])
{
zval_ptr_dtor(&var_hash->data[i]);
}
}
}
next = var_hash->next;
efree(var_hash);
var_hash = next;
}
var_hash = var_hashx->first_dtor;
while (var_hash)
{
for (i = var_hash->used_slots - 1; i >= 0; i--)
{
if (var_hash->data[i])
{
zval_ptr_dtor(&var_hash->data[i]);
}
}
next = var_hash->next;
efree(var_hash);
var_hash = next;
}
}
void msgpack_unserialize_init(msgpack_unserialize_data *unpack)
{
unpack->deps = 0;
unpack->type = MSGPACK_SERIALIZE_TYPE_NONE;
}
int msgpack_unserialize_uint8(
msgpack_unserialize_data *unpack, uint8_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_uint16(
msgpack_unserialize_data *unpack, uint16_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_uint32(
msgpack_unserialize_data *unpack, uint32_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_uint64(
msgpack_unserialize_data *unpack, uint64_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_int8(
msgpack_unserialize_data *unpack, int8_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_int16(
msgpack_unserialize_data *unpack, int16_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_int32(
msgpack_unserialize_data *unpack, int32_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_int64(
msgpack_unserialize_data *unpack, int64_t data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_LONG(*obj, data);
return 0;
}
int msgpack_unserialize_float(
msgpack_unserialize_data *unpack, float data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_DOUBLE(*obj, data);
return 0;
}
int msgpack_unserialize_double(
msgpack_unserialize_data *unpack, double data, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_DOUBLE(*obj, data);
return 0;
}
int msgpack_unserialize_nil(msgpack_unserialize_data *unpack, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_NULL(*obj);
return 0;
}
int msgpack_unserialize_true(msgpack_unserialize_data *unpack, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_BOOL(*obj, 1);
return 0;
}
int msgpack_unserialize_false(msgpack_unserialize_data *unpack, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
ZVAL_BOOL(*obj, 0);
return 0;
}
int msgpack_unserialize_raw(
msgpack_unserialize_data *unpack, const char* base,
const char* data, unsigned int len, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_STACK(unpack);
if (len == 0)
{
ZVAL_STRINGL(*obj, "", 0, 1);
}
else
{
ZVAL_STRINGL(*obj, data, len, 1);
}
return 0;
}
int msgpack_unserialize_array(
msgpack_unserialize_data *unpack, unsigned int count, zval **obj)
{
MSGPACK_UNSERIALIZE_ALLOC_VALUE(unpack);
array_init(*obj);
unpack->stack[unpack->deps++] = count;
return 0;
}
int msgpack_unserialize_array_item(
msgpack_unserialize_data *unpack, zval **container, zval *obj)
{
add_next_index_zval(*container, obj);
MSGPACK_UNSERIALIZE_FINISH_ITEM(unpack, 1);
return 0;
}
int msgpack_unserialize_map(
msgpack_unserialize_data *unpack, unsigned int count, zval **obj)
{
TSRMLS_FETCH();
MSGPACK_UNSERIALIZE_ALLOC_VALUE(unpack);
unpack->stack[unpack->deps++] = count;
unpack->type = MSGPACK_SERIALIZE_TYPE_NONE;
if (count == 0)
{
if (MSGPACK_G(php_only))
{
object_init(*obj);
}
else
{
array_init(*obj);
}
}
return 0;
}
int msgpack_unserialize_map_item(
msgpack_unserialize_data *unpack, zval **container, zval *key, zval *val)
{
long deps;
TSRMLS_FETCH();
if (MSGPACK_G(php_only))
{
zend_class_entry *ce;
if (Z_TYPE_P(key) == IS_NULL)
{
unpack->type = MSGPACK_SERIALIZE_TYPE_NONE;
if (Z_TYPE_P(val) == IS_LONG)
{
switch (Z_LVAL_P(val))
{
case MSGPACK_SERIALIZE_TYPE_REFERENCE:
Z_SET_ISREF_PP(container);
break;
case MSGPACK_SERIALIZE_TYPE_RECURSIVE:
unpack->type = MSGPACK_SERIALIZE_TYPE_RECURSIVE;
break;
case MSGPACK_SERIALIZE_TYPE_CUSTOM_OBJECT:
unpack->type = MSGPACK_SERIALIZE_TYPE_CUSTOM_OBJECT;
break;
case MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE:
unpack->type = MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE;
break;
case MSGPACK_SERIALIZE_TYPE_OBJECT:
unpack->type = MSGPACK_SERIALIZE_TYPE_OBJECT;
break;
default:
break;
}
}
else if (Z_TYPE_P(val) == IS_STRING)
{
ce = msgpack_unserialize_class(
container, Z_STRVAL_P(val), Z_STRLEN_P(val));
if (ce == NULL)
{
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
}
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
else
{
switch (unpack->type)
{
case MSGPACK_SERIALIZE_TYPE_CUSTOM_OBJECT:
unpack->type = MSGPACK_SERIALIZE_TYPE_NONE;
ce = msgpack_unserialize_class(
container, Z_STRVAL_P(key), Z_STRLEN_P(key));
if (ce == NULL)
{
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 0)
/* implementing Serializable */
if (ce->unserialize == NULL)
{
MSGPACK_WARNING(
"[msgpack] (%s) Class %s has no unserializer",
__FUNCTION__, ce->name);
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
ce->unserialize(
container, ce,
(const unsigned char *)Z_STRVAL_P(val),
Z_STRLEN_P(val) + 1, NULL TSRMLS_CC);
#endif
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
case MSGPACK_SERIALIZE_TYPE_RECURSIVE:
case MSGPACK_SERIALIZE_TYPE_OBJECT:
case MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE:
{
zval **rval;
int type = unpack->type;
unpack->type = MSGPACK_SERIALIZE_TYPE_NONE;
if (msgpack_var_access(
unpack->var_hash,
Z_LVAL_P(val) - 1, &rval) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) Invalid references value: %ld",
__FUNCTION__, Z_LVAL_P(val) - 1);
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
if (container != NULL)
{
zval_ptr_dtor(container);
}
*container = *rval;
Z_ADDREF_PP(container);
if (type == MSGPACK_SERIALIZE_TYPE_OBJECT)
{
Z_UNSET_ISREF_PP(container);
}
else if (type == MSGPACK_SERIALIZE_TYPE_OBJECT_REFERENCE)
{
Z_SET_ISREF_PP(container);
}
MSGPACK_UNSERIALIZE_FINISH_MAP_ITEM(unpack, key, val);
return 0;
}
}
}
}
if (Z_TYPE_PP(container) != IS_ARRAY && Z_TYPE_PP(container) != IS_OBJECT)
{
array_init(*container);
}
switch (Z_TYPE_P(key))
{
case IS_LONG:
if (zend_hash_index_update(
HASH_OF(*container), Z_LVAL_P(key), &val,
sizeof(val), NULL) == FAILURE)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) illegal offset type, skip this decoding",
__FUNCTION__);
}
zval_ptr_dtor(&key);
break;
case IS_STRING:
if (zend_symtable_update(
HASH_OF(*container), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1,
&val, sizeof(val), NULL) == FAILURE)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) illegal offset type, skip this decoding",
__FUNCTION__);
}
zval_ptr_dtor(&key);
break;
default:
MSGPACK_WARNING("[msgpack] (%s) illegal key type", __FUNCTION__);
if (MSGPACK_G(illegal_key_insert))
{
if (zend_hash_next_index_insert(
HASH_OF(*container), &key, sizeof(key), NULL) == FAILURE)
{
zval_ptr_dtor(&val);
}
if (zend_hash_next_index_insert(
HASH_OF(*container), &val, sizeof(val), NULL) == FAILURE)
{
zval_ptr_dtor(&val);
}
}
else
{
convert_to_string(key);
if (zend_symtable_update(
HASH_OF(*container),
Z_STRVAL_P(key), Z_STRLEN_P(key) + 1,
&val, sizeof(val), NULL) == FAILURE)
{
zval_ptr_dtor(&val);
}
zval_ptr_dtor(&key);
}
break;
}
msgpack_stack_pop(unpack->var_hash, 2);
deps = unpack->deps - 1;
unpack->stack[deps]--;
if (unpack->stack[deps] == 0)
{
unpack->deps--;
/* wakeup */
if (MSGPACK_G(php_only) &&
Z_TYPE_PP(container) == IS_OBJECT &&
Z_OBJCE_PP(container) != PHP_IC_ENTRY &&
zend_hash_exists(
&Z_OBJCE_PP(container)->function_table,
"__wakeup", sizeof("__wakeup")))
{
zval f, *h = NULL;
INIT_PZVAL(&f);
ZVAL_STRINGL(&f, "__wakeup", sizeof("__wakeup") - 1, 0);
call_user_function_ex(
CG(function_table), container, &f, &h, 0, 0, 1, NULL TSRMLS_CC);
if (h)
{
zval_ptr_dtor(&h);
}
}
}
return 0;
}

132
php/msgpack_unpack.h
View File

@ -1,132 +0,0 @@
#ifndef MSGPACK_UNPACK_H
#define MSGPACK_UNPACK_H
#include "ext/standard/php_var.h"
#define MSGPACK_EMBED_STACK_SIZE 1024
#include "msgpack/unpack_define.h"
typedef enum
{
MSGPACK_UNPACK_SUCCESS = 2,
MSGPACK_UNPACK_EXTRA_BYTES = 1,
MSGPACK_UNPACK_CONTINUE = 0,
MSGPACK_UNPACK_PARSE_ERROR = -1,
} msgpack_unpack_return;
typedef struct php_unserialize_data msgpack_unserialize_data_t;
typedef struct {
zval *retval;
long deps;
msgpack_unserialize_data_t *var_hash;
long stack[MSGPACK_EMBED_STACK_SIZE];
int type;
} msgpack_unserialize_data;
void msgpack_unserialize_var_init(msgpack_unserialize_data_t *var_hashx);
void msgpack_unserialize_var_destroy(
msgpack_unserialize_data_t *var_hashx, zend_bool err);
void msgpack_unserialize_init(msgpack_unserialize_data *unpack);
int msgpack_unserialize_uint8(
msgpack_unserialize_data *unpack, uint8_t data, zval **obj);
int msgpack_unserialize_uint16(
msgpack_unserialize_data *unpack, uint16_t data, zval **obj);
int msgpack_unserialize_uint32(
msgpack_unserialize_data *unpack, uint32_t data, zval **obj);
int msgpack_unserialize_uint64(
msgpack_unserialize_data *unpack, uint64_t data, zval **obj);
int msgpack_unserialize_int8(
msgpack_unserialize_data *unpack, int8_t data, zval **obj);
int msgpack_unserialize_int16(
msgpack_unserialize_data *unpack, int16_t data, zval **obj);
int msgpack_unserialize_int32(
msgpack_unserialize_data *unpack, int32_t data, zval **obj);
int msgpack_unserialize_int64(
msgpack_unserialize_data *unpack, int64_t data, zval **obj);
int msgpack_unserialize_float(
msgpack_unserialize_data *unpack, float data, zval **obj);
int msgpack_unserialize_double(
msgpack_unserialize_data *unpack, double data, zval **obj);
int msgpack_unserialize_nil(msgpack_unserialize_data *unpack, zval **obj);
int msgpack_unserialize_true(msgpack_unserialize_data *unpack, zval **obj);
int msgpack_unserialize_false(msgpack_unserialize_data *unpack, zval **obj);
int msgpack_unserialize_raw(
msgpack_unserialize_data *unpack, const char* base, const char* data,
unsigned int len, zval **obj);
int msgpack_unserialize_array(
msgpack_unserialize_data *unpack, unsigned int count, zval **obj);
int msgpack_unserialize_array_item(
msgpack_unserialize_data *unpack, zval **container, zval *obj);
int msgpack_unserialize_map(
msgpack_unserialize_data *unpack, unsigned int count, zval **obj);
int msgpack_unserialize_map_item(
msgpack_unserialize_data *unpack, zval **container, zval *key, zval *val);
/* template functions */
#define msgpack_unpack_struct(name) struct template ## name
#define msgpack_unpack_func(ret, name) ret template ## name
#define msgpack_unpack_callback(name) template_callback ## name
#define msgpack_unpack_object zval*
#define unpack_user msgpack_unserialize_data
#define msgpack_unpack_user msgpack_unserialize_data
struct template_context;
typedef struct template_context msgpack_unpack_t;
static void template_init(msgpack_unpack_t* unpack);
static msgpack_unpack_object template_data(msgpack_unpack_t* unpack);
static int template_execute(
msgpack_unpack_t* unpack, const char* data, size_t len, size_t* off);
static inline msgpack_unpack_object template_callback_root(unpack_user* user)
{
msgpack_unserialize_init(user);
return NULL;
}
#define template_callback_uint8(user, data, obj) \
msgpack_unserialize_uint8(user, data, obj)
#define template_callback_uint16(user, data, obj) \
msgpack_unserialize_uint16(user, data, obj)
#define template_callback_uint32(user, data, obj) \
msgpack_unserialize_uint32(user, data, obj)
#define template_callback_uint64(user, data, obj) \
msgpack_unserialize_uint64(user, data, obj)
#define template_callback_int8(user, data, obj) \
msgpack_unserialize_int8(user, data, obj)
#define template_callback_int16(user, data, obj) \
msgpack_unserialize_int16(user, data, obj)
#define template_callback_int32(user, data, obj) \
msgpack_unserialize_int32(user, data, obj)
#define template_callback_int64(user, data, obj) \
msgpack_unserialize_int64(user, data, obj)
#define template_callback_float(user, data, obj) \
msgpack_unserialize_float(user, data, obj)
#define template_callback_double(user, data, obj) \
msgpack_unserialize_double(user, data, obj)
#define template_callback_nil(user, obj) \
msgpack_unserialize_nil(user, obj)
#define template_callback_true(user, obj) \
msgpack_unserialize_true(user, obj)
#define template_callback_false(user, obj) \
msgpack_unserialize_false(user, obj)
#define template_callback_raw(user, base, data, len, obj) \
msgpack_unserialize_raw(user, base, data, len, obj)
#define template_callback_array(user, count, obj) \
msgpack_unserialize_array(user, count, obj)
#define template_callback_array_item(user, container, obj) \
msgpack_unserialize_array_item(user, container, obj)
#define template_callback_map(user, count, obj) \
msgpack_unserialize_map(user, count, obj)
#define template_callback_map_item(user, container, key, val) \
msgpack_unserialize_map_item(user, container, key, val)
#include "msgpack/unpack_template.h"
#endif

255
php/package.xml
View File

@ -1,255 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<package version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0 http://pear.php.net/dtd/tasks-1.0.xsd http://pear.php.net/dtd/package-2.0 http://pear.php.net/dtd/package-2.0.xsd">
<name>msgpack</name>
<channel>pecl.php.net</channel>
<summary>PHP extension for interfacing with MessagePack</summary>
<description>This extension provide API for communicating with MessagePack serialization.</description>
<lead>
<name>Advect</name>
<user>advect</user>
<email>advect@gmail.com</email>
<active>yes</active>
</lead>
<date>2011-07-27</date>
<time>12:39:33</time>
<version>
<release>0.5.0</release>
<api>0.5.0</api>
</version>
<stability>
<release>beta</release>
<api>beta</api>
</stability>
<license filesource="LICENSE">New BSD</license>
<notes>Initial release.</notes>
<contents>
<dir name="/">
<file md5sum="12b9d8867e5fde4af426c134283e2082" name="LICENSE" role="doc" />
<file md5sum="8daeb22744f11b57da9d0966608e2fc1" name="README" role="doc" />
<file md5sum="c40d516627022a54003ac2b74a82688a" name="CREDITS" role="doc" />
<file md5sum="4175fc9f98d3c3755abc4ed9f8340f98" name="ChangeLog" role="doc" />
<file md5sum="d41d8cd98f00b204e9800998ecf8427e" name="EXPERIMENTAL" role="doc" />
<file md5sum="6747376fed353e6bd2490c5c4b3a096c" name="config.m4" role="src" />
<file md5sum="195040cca1f961b6356d296e60a532ce" name="config.w32" role="src" />
<file md5sum="8eadc10d9a8345f3ffa9614348cdb939" name="msgpack.php" role="src" />
<file md5sum="a8f42021390a4c9f8ad1690a7543262e" name="msgpack.c" role="src" />
<file md5sum="c6cdb4c0a9e44f2259fdbd3be79d0b6b" name="msgpack_class.c" role="src" />
<file md5sum="b8eadd32c3eafb67645bb4ffe16f687c" name="msgpack_class.h" role="src" />
<file md5sum="7b9adaae675371038f8774a1eb3b831b" name="msgpack_convert.c" role="src" />
<file md5sum="36e55e18e2a3c53f2929558fb6cdd7ed" name="msgpack_convert.h" role="src" />
<file md5sum="7d25383ea3cff751ca993c98b1b5e57e" name="msgpack_errors.h" role="src" />
<file md5sum="ffaeb53d003a0961bcb6837545815877" name="msgpack_pack.c" role="src" />
<file md5sum="06f85a181c2070272c0ecd0dc3161161" name="msgpack_pack.h" role="src" />
<file md5sum="d341e1a3b400b45f844a94ecd5198248" name="msgpack_unpack.c" role="src" />
<file md5sum="1a31c49f353c8deec86affd1564909d1" name="msgpack_unpack.h" role="src" />
<file md5sum="7a558da9034ccda806990aff0b212c90" name="php_msgpack.h" role="src" />
<file md5sum="82079e9a298ecdda2122757ddfbf576e" name="msgpack/pack_define.h" role="src" />
<file md5sum="af3f5ca341be55d866fe151c45186d22" name="msgpack/pack_template.h" role="src" />
<file md5sum="09510085da29090ea0f3919c2e708f46" name="msgpack/unpack_define.h" role="src" />
<file md5sum="61cd2025a8357329430154bd3e568be9" name="msgpack/unpack_template.h" role="src" />
<file md5sum="5eea4af1097495efab534b174c16d939" name="msgpack/sysdep.h" role="src" />
<file md5sum="2e346ebe243e8b770ed01f56d9f886ba" name="msgpack/version.h" role="src" />
<file md5sum="237eda031928a5546bdb92a34815830f" name="tests/001.phpt" role="test" />
<file md5sum="11d3a17e404ec4938eff1d0b0e724e5f" name="tests/002.phpt" role="test" />
<file md5sum="1006ba0ae8b22e3d090a200f3eefea82" name="tests/003.phpt" role="test" />
<file md5sum="21c14487ba126c00d5d42d2dd03c76c3" name="tests/004.phpt" role="test" />
<file md5sum="99b8bb5df5c98b6e27541245b39bb13f" name="tests/005.phpt" role="test" />
<file md5sum="e0488f07f26c74d1c918634c39555d6e" name="tests/006.phpt" role="test" />
<file md5sum="b64692d608852aeb2482d2dd05634426" name="tests/007.phpt" role="test" />
<file md5sum="211dd4d1d52a660b8d598b298cc05df9" name="tests/008.phpt" role="test" />
<file md5sum="645c378bd5bc693ab99b1d340e09b250" name="tests/009.phpt" role="test" />
<file md5sum="952e140db05c0e59aec3b2a1ba5894a2" name="tests/009b.phpt" role="test" />
<file md5sum="ddb421cd083baaca3ce3a5263f731dcd" name="tests/010.phpt" role="test" />
<file md5sum="5d5ecd404959caea3ee96c48e6765669" name="tests/012.phpt" role="test" />
<file md5sum="049a4b38ad7fa71228d0092171bf9ef2" name="tests/012c.phpt" role="test" />
<file md5sum="462898206b0ccd49b0055c96b78a2282" name="tests/013.phpt" role="test" />
<file md5sum="690e24be70da60cc9becad0027e762d5" name="tests/014.phpt" role="test" />
<file md5sum="266edf8fd821d58adcfebef1d9beb045" name="tests/015.phpt" role="test" />
<file md5sum="beb07e05272c62ec81dad284fa5b36ce" name="tests/015b.phpt" role="test" />
<file md5sum="abc8ed11d14cf131b8d40be510c36e6b" name="tests/015d.phpt" role="test" />
<file md5sum="28356690ba2a5f85c3b6fbfd745a6f96" name="tests/015e.phpt" role="test" />
<file md5sum="d2d6872cb086b769017af3cfaf5e0f52" name="tests/015f.phpt" role="test" />
<file md5sum="fb152ceb5208b0298684eba0a33f992b" name="tests/016.phpt" role="test" />
<file md5sum="4133eed2d1416ae3eb581daf4d08d309" name="tests/016c.phpt" role="test" />
<file md5sum="c143aa78b84c8d7a7189d754592613e0" name="tests/017.phpt" role="test" />
<file md5sum="527491d7441baa77188026e21a0af80b" name="tests/018.phpt" role="test" />
<file md5sum="375d39f1da5efb3067c326a636fa1d88" name="tests/019.phpt" role="test" />
<file md5sum="3d9e08a86a9c1f53af0a86cce5c42d6d" name="tests/020.phpt" role="test" />
<file md5sum="af470d224342fa2f24212e73a1aca1ca" name="tests/021.phpt" role="test" />
<file md5sum="23a30dd1eca67eaaf5b640d2153c8c5f" name="tests/022.phpt" role="test" />
<file md5sum="7fad3357febe18a1db8abca7c50614d1" name="tests/023.phpt" role="test" />
<file md5sum="d0ba1b06180c264b4f75c56c0eac4458" name="tests/024.phpt" role="test" />
<file md5sum="9e336d2611dfb39e235268f242b99755" name="tests/024b.phpt" role="test" />
<file md5sum="28c1eb029e8dfd71a4dfd4e7dede019e" name="tests/024c.phpt" role="test" />
<file md5sum="c48c256fc9a61eda85149df4da56a116" name="tests/025.phpt" role="test" />
<file md5sum="3a034382e2e40ea9adcfbb1443e22a87" name="tests/025c.phpt" role="test" />
<file md5sum="ee2fb07b3c06aacb1286d6274c75300c" name="tests/026.phpt" role="test" />
<file md5sum="e623ea72bed886b3667c1773ba5b64dc" name="tests/026b.phpt" role="test" />
<file md5sum="7128b56e93a8de75dda938b4fab661fd" name="tests/026d.phpt" role="test" />
<file md5sum="282e770306a16651c6157942c65be644" name="tests/027.phpt" role="test" />
<file md5sum="c8eadc5b775edb2451b895f89ec1fc41" name="tests/027d.phpt" role="test" />
<file md5sum="59e5a4d0f21579c1e9867e764340eb24" name="tests/028.phpt" role="test" />
<file md5sum="831e1e3e3d74ff6090966f91d8715c7b" name="tests/028b.phpt" role="test" />
<file md5sum="c93199e139706ed79f77b8fe99b5c57d" name="tests/028c.phpt" role="test" />
<file md5sum="19d5993e30880056145dae4ac140961a" name="tests/028d.phpt" role="test" />
<file md5sum="f380a42cf429a8fb72c50f9d38228109" name="tests/029.phpt" role="test" />
<file md5sum="7de90bedec2c170da12144bb3399dfe5" name="tests/030.phpt" role="test" />
<file md5sum="3f37b5f1f4da46a1afeafea516d56490" name="tests/031.phpt" role="test" />
<file md5sum="170dfcb82fd1e097fffc6b57a7e9764a" name="tests/032.phpt" role="test" />
<file md5sum="0e96b2ebf8c37c1c4c13de4d2d5dae95" name="tests/033.phpt" role="test" />
<file md5sum="c36550e0f68d0aa1174247bfb37c13f0" name="tests/034.phpt" role="test" />
<file md5sum="661553a8ccd9b83c95772dd9ad68d82b" name="tests/035.phpt" role="test" />
<file md5sum="3914d56c32ca243221c8eecc767b3056" name="tests/040.phpt" role="test" />
<file md5sum="8b49472a24bf5fbe9e90276b5f4b076a" name="tests/040b.phpt" role="test" />
<file md5sum="f15fd3c44f570deb4e918b0e04ceb735" name="tests/040c.phpt" role="test" />
<file md5sum="d760724f22120bf81776b564c3bb69ab" name="tests/040d.phpt" role="test" />
<file md5sum="011672f35987ed8e52b7c9afde98bb8d" name="tests/041.phpt" role="test" />
<file md5sum="1073706e82b72a1c845d09273d95b256" name="tests/042.phpt" role="test" />
<file md5sum="57478f4e95bd000bf73a8331e9e19cba" name="tests/050.phpt" role="test" />
<file md5sum="6ee4b49e6e82289e7ea7bf2e37a14212" name="tests/060.phpt" role="test" />
<file md5sum="4b5a8bd201c8b27bbf392f42586a98ca" name="tests/060b.phpt" role="test" />
<file md5sum="e245df195174210507fe6e3f02b97144" name="tests/060c.phpt" role="test" />
<file md5sum="8ac3126adb9ec49eac7f495f5354bc23" name="tests/061.phpt" role="test" />
<file md5sum="9b9f2721cbdd656b5e7936173cf9d160" name="tests/061b.phpt" role="test" />
<file md5sum="da9e32144da2aea8c5f498078d2e81a1" name="tests/061c.phpt" role="test" />
<file md5sum="187689f3d1d8fe3636ea7d6188e7e559" name="tests/062.phpt" role="test" />
<file md5sum="9c91266595d01080b813fb2a056fca82" name="tests/063.phpt" role="test" />
<file md5sum="9d05c3bfd49ad9c7cf00b9b056552c69" name="tests/064.phpt" role="test" />
<file md5sum="8db3eeb829880716d4630b6e448877f5" name="tests/064b.phpt" role="test" />
<file md5sum="0019c5df7135bcb1fa5f7d38a99cd099" name="tests/064c.phpt" role="test" />
<file md5sum="1bdbd6f93abb361a0c093d3783ee11ff" name="tests/065.phpt" role="test" />
<file md5sum="0dc03b9cac5f95a786a1719a7555bf1c" name="tests/065b.phpt" role="test" />
<file md5sum="3c2403702f5d31067fcb4d0c53dfb068" name="tests/065c.phpt" role="test" />
<file md5sum="bad0c2dee56d9f7a8dd0161ed863915e" name="tests/066.phpt" role="test" />
<file md5sum="d15e923a2bca68f5fb7e285da725c248" name="tests/067.phpt" role="test" />
<file md5sum="4057b290693f84ae1bd3053a1ebc25dd" name="tests/070.phpt" role="test" />
<file md5sum="395a04ef87a3a63953a42e1434bda80c" name="tests/070b.phpt" role="test" />
<file md5sum="0741ce324457decc95792fbcee70e930" name="tests/070c.phpt" role="test" />
<file md5sum="addf9d7eddd6a2e84be4af03a98416c3" name="tests/071.phpt" role="test" />
<file md5sum="3f752a3b8d579fe1e91de06e80d57197" name="tests/071b.phpt" role="test" />
<file md5sum="6a97b56ff05b21d8266a5ea37fcea081" name="tests/071c.phpt" role="test" />
<file md5sum="95117434072c89c609672e6f0a569b2b" name="tests/072.phpt" role="test" />
<file md5sum="4feabcf2792e2a80b261ee8a89a2b3e8" name="tests/072b.phpt" role="test" />
<file md5sum="33f62f9b3d7e5cae66e0c7b264a9dd68" name="tests/072c.phpt" role="test" />
<file md5sum="fe1d3229f9d3695ff587365de703dc0c" name="tests/073.phpt" role="test" />
<file md5sum="d3010d8a4f03966e64a48f10bc6868b4" name="tests/073b.phpt" role="test" />
<file md5sum="c774bc1bb903ee9e1a0f53f29dcfc512" name="tests/073c.phpt" role="test" />
<file md5sum="48ca6ddb000967871b553496707f6cbe" name="tests/080.phpt" role="test" />
<file md5sum="e2dd4e560717fa7b0718d7370ec1afb8" name="tests/081.phpt" role="test" />
<file md5sum="bdbdb5ac59480f15e311d60289cfc1a7" name="tests/082.phpt" role="test" />
<file md5sum="6d16ffffa5eaa04f8acca8b67e759f9c" name="tests/083.phpt" role="test" />
<file md5sum="4005e6303740cc7cb8cdf5bee6d05103" name="tests/084.phpt" role="test" />
<file md5sum="367f2bb3fd016a2ac55e4d0a5e0c9cec" name="tests/085.phpt" role="test" />
<file md5sum="658b1c4aa59ee2aa405febae768035fd" name="tests/086.phpt" role="test" />
<file md5sum="731e2f603e62c378b14160ae077839bd" name="tests/087.phpt" role="test" />
<file md5sum="5745832846722e08916b7dfc0489df15" name="tests/088.phpt" role="test" />
<file md5sum="5aafee8947d22e1c0de89f925bdf1649" name="tests/089.phpt" role="test" />
<file md5sum="5c12abf7868b4f96fd8819c6682063cd" name="tests/090.phpt" role="test" />
<file md5sum="a9895d6af644edff26d1e600a5801b84" name="tests/090b.phpt" role="test" />
<file md5sum="34e37d556a05faeed61317d0e9e01152" name="tests/091.phpt" role="test" />
<file md5sum="7d33c2ac3290f26daa587d9a34de80cb" name="tests/091b.phpt" role="test" />
<file md5sum="fa889c2093d7909fbebf7f7be0b9eaa2" name="tests/092.phpt" role="test" />
<file md5sum="086fb77d14a4b26fc7ff64b43559d49d" name="tests/092b.phpt" role="test" />
<file md5sum="f53e4a7ea728c85bd4e31b996bf4a50f" name="tests/093.phpt" role="test" />
<file md5sum="4f27b69cdabe232e2403e6bb4559f418" name="tests/093b.phpt" role="test" />
<file md5sum="3e81bb754a5e014713652b682e149cbd" name="tests/094.phpt" role="test" />
<file md5sum="36c0ca7322f400ea1624207f98b643c7" name="tests/094b.phpt" role="test" />
<file md5sum="927d3b859769b6d20db8c7eb5bebd351" name="tests/095.phpt" role="test" />
<file md5sum="33a3e473833d19b8b0c7d6a559d53592" name="tests/095b.phpt" role="test" />
<file md5sum="43a6f327f064e9533f8c09871566d7bc" name="tests/096.phpt" role="test" />
<file md5sum="9b7c2604bfcd99a16c26c6be98c866a8" name="tests/096b.phpt" role="test" />
<file md5sum="878f9a8345f63406d11bc44ed90350ed" name="tests/097.phpt" role="test" />
<file md5sum="e39b692da05e7362e388e0c80d419463" name="tests/097b.phpt" role="test" />
<file md5sum="734e3a9c37ffb28d352f85e2638ed6d1" name="tests/098.phpt" role="test" />
<file md5sum="2777634b35f4143ab903a855c19446fe" name="tests/098b.phpt" role="test" />
<file md5sum="1a18b4403a7c3f2b2a37259a4c03f5fa" name="tests/099.phpt" role="test" />
<file md5sum="31da8c01336bb819472a405a85f66477" name="tests/099b.phpt" role="test" />
<file md5sum="4bc4def03d39ae7029bfaef612cf2a18" name="tests/100.phpt" role="test" />
<file md5sum="515144778f3e998c4c88fcd5c2ac6f2f" name="tests/100b.phpt" role="test" />
<file md5sum="9efe9f1d907ac42a27970d3fe5c210e8" name="tests/101.phpt" role="test" />
<file md5sum="44fab12e51da9df02ab98f8dfbf3a2b4" name="tests/101b.phpt" role="test" />
<file md5sum="8a4eaae887f17ea08816bf24fa63c8fc" name="tests/102.phpt" role="test" />
<file md5sum="025d7ce0533df77af4e6621386fd4a0b" name="tests/102b.phpt" role="test" />
<file md5sum="cd76b1b0cd4d8905ed896dbac07df670" name="tests/103.phpt" role="test" />
<file md5sum="76bab9f004e10e76761c34b2338f9fee" name="tests/103b.phpt" role="test" />
<file md5sum="fe34de5b1e1613b0009b1151c9a2fb77" name="tests/104.phpt" role="test" />
<file md5sum="8ba365211992593daa3e5ace200b9698" name="tests/104b.phpt" role="test" />
<file md5sum="d4daa384c1824805165df0595cda598e" name="tests/105.phpt" role="test" />
<file md5sum="3d4d3da8b195686aabdef2c142955a50" name="tests/105b.phpt" role="test" />
<file md5sum="766a6fbfbd479c3612dc62435fa28172" name="tests/106.phpt" role="test" />
<file md5sum="1f9709dbd7deb6cd06eb96000822743d" name="tests/106b.phpt" role="test" />
<file md5sum="daa8775eb9dd7d96cd007aaf05ccd5fc" name="tests/107.phpt" role="test" />
<file md5sum="a5485997dc85a18f2571b1d96db24361" name="tests/107b.phpt" role="test" />
<file md5sum="fff04218d82653f79ef06a12db7eb688" name="tests/108.phpt" role="test" />
<file md5sum="242a8aa45a44e8b263c2dd0584a18d5f" name="tests/108b.phpt" role="test" />
<file md5sum="0da5a36396ec076a4259f4aa72702472" name="tests/109.phpt" role="test" />
<file md5sum="774a4a16a2ddee39595f479c8e7da374" name="tests/109b.phpt" role="test" />
<file md5sum="d44f963b68a26483d4bc95e1c1718c59" name="tests/110.phpt" role="test" />
<file md5sum="19fad685bf703baf889ece8fd031c548" name="tests/110b.phpt" role="test" />
<file md5sum="b5e79a4fdec999701eeed6e4ffedbaaf" name="tests/111.phpt" role="test" />
<file md5sum="aa326ce98233bf0aaf085a28b67ac9c6" name="tests/111b.phpt" role="test" />
<file md5sum="2d9d876a7771eb149e8751fb2764413e" name="tests/112.phpt" role="test" />
<file md5sum="9211056b9b3b664b409b3c9940b56453" name="tests/112b.phpt" role="test" />
<file md5sum="9961fad01da15f452e55e7ddd2fa2c40" name="tests/113.phpt" role="test" />
<file md5sum="ee7367c5c40cee3b8cc6a0f4b2f92c77" name="tests/113b.phpt" role="test" />
<file md5sum="889ae1fe8a8bf73da35d9f86e772f008" name="tests/114.phpt" role="test" />
<file md5sum="2e67b53bda5406182f7af545b66d2686" name="tests/114b.phpt" role="test" />
<file md5sum="0c352ddf3fe25db4c68f42f814ebbf91" name="tests/115.phpt" role="test" />
<file md5sum="7b81b4a35afaeffd707037a052f96660" name="tests/115b.phpt" role="test" />
<file md5sum="d1ce1f246f03ad9148a9a1ac4e9e8e40" name="tests/116.phpt" role="test" />
<file md5sum="a9b477ef90ffb043cd1e6ce3bffc56e8" name="tests/116b.phpt" role="test" />
<file md5sum="22ad9a50e059cb3460df3913323d0c98" name="tests/117.phpt" role="test" />
<file md5sum="4bee2fee7d418a03d0a2161d6851195b" name="tests/117b.phpt" role="test" />
<file md5sum="33b2f3109657045f97ddf56e8483a888" name="tests/118.phpt" role="test" />
<file md5sum="507c2900acf9b17506d8f886abc3f251" name="tests/118b.phpt" role="test" />
<file md5sum="063c815822c304354350d2ee2f3298f2" name="tests/119.phpt" role="test" />
<file md5sum="66d6b04af099daccc61e1b423e163159" name="tests/119b.phpt" role="test" />
<file md5sum="14e128915526b618110b7a69ee4f8350" name="tests/120.phpt" role="test" />
<file md5sum="b78062023ccf2774270987d5b06c4567" name="tests/120b.phpt" role="test" />
<file md5sum="39d997975c5fcb15f74ff0254cf7353e" name="tests/121.phpt" role="test" />
<file md5sum="021777d95203bd66f10ccb9764ba5d77" name="tests/121b.phpt" role="test" />
<file md5sum="88e32faca9d5d03b9450ca13788fe606" name="tests/122.phpt" role="test" />
<file md5sum="1933f5c66b5bf594740e98bb95b32ccb" name="tests/122b.phpt" role="test" />
<file md5sum="dfcba4317c824c19bfbe514bfe6cff45" name="tests/123.phpt" role="test" />
<file md5sum="7301229f2c4f0f0a8f6bca198495f7d4" name="tests/123b.phpt" role="test" />
<file md5sum="88d215f411a38ba06165759af9af9d74" name="tests/124.phpt" role="test" />
<file md5sum="a39c8f196277f3b387c3472664ee07aa" name="tests/124b.phpt" role="test" />
<file md5sum="e1f352ff75fefaf50d79c8fb19129051" name="tests/125.phpt" role="test" />
<file md5sum="dbe6cc43d405455fefe247f66c76195c" name="tests/125b.phpt" role="test" />
<file md5sum="5d7580cac61f98a12d52dc3bc621e565" name="tests/126.phpt" role="test" />
<file md5sum="000ba52afda50731ad6a5cf0afc16f70" name="tests/126b.phpt" role="test" />
<file md5sum="9c64222d9e74d89f2c01487b780e84c0" name="tests/127.phpt" role="test" />
<file md5sum="cb616c53b3ffdc20bea4b12d3e2c1d8c" name="tests/127b.phpt" role="test" />
<file md5sum="7591a640110855713549d6957d8394cf" name="tests/128.phpt" role="test" />
<file md5sum="f579ce8a1b8d7280fd45522268f46821" name="tests/128b.phpt" role="test" />
<file md5sum="15e6419d723c7c58494681d6c81e562f" name="tests/129.phpt" role="test" />
<file md5sum="759048ff6222150cdc74451ea136f992" name="tests/129b.phpt" role="test" />
<file md5sum="23f98cfe4c3ba459396c62801e04af04" name="tests/130.phpt" role="test" />
<file md5sum="d047c8603e7be5069ab578d009c799eb" name="tests/130b.phpt" role="test" />
<file md5sum="604111af2502d05fb3e59d45067f2003" name="tests/131.phpt" role="test" />
<file md5sum="54b91353b7be6c078dc13c368117a4b6" name="tests/131b.phpt" role="test" />
<file md5sum="f96c33aea681d7aa38f2bb671279173e" name="tests/132.phpt" role="test" />
<file md5sum="a3127fd73df54a33a4a67dded67248ca" name="tests/132b.phpt" role="test" />
<file md5sum="8b20b5ac3eedfe710b41ff0c39e73709" name="tests/133.phpt" role="test" />
<file md5sum="2c78697358f2baa98d2cf07e25783002" name="tests/133b.phpt" role="test" />
<file md5sum="1b99d02a41791e5cf6481d3e32635e75" name="tests/134.phpt" role="test" />
<file md5sum="ebe1916f9ef3b784baa7543252f13a5f" name="tests/134b.phpt" role="test" />
<file md5sum="ae5088b921e06924d0ea9af308b92d3d" name="tests/135.phpt" role="test" />
<file md5sum="bddb8caa6a0ebb0d200b0aa8f7f1bc2c" name="tests/135b.phpt" role="test" />
<file md5sum="78f1d56b752d8ce366d4b1ab9bb2b6d3" name="tests/136.phpt" role="test" />
<file md5sum="11e31f9cc6f60546b85dfd292240af89" name="tests/136b.phpt" role="test" />
</dir>
</contents>
<dependencies>
<required>
<php>
<min>5.0.0</min>
</php>
<pearinstaller>
<min>1.4.3</min>
</pearinstaller>
</required>
</dependencies>
<providesextension>msgpack</providesextension>
<extsrcrelease />
</package>

58
php/php-msgpack.spec
View File

@ -1,58 +0,0 @@
%define php_apiver %((echo 0; php -i 2>/dev/null | sed -n 's/^PHP API => //p') | tail -1)
%{!?php_extdir: %{expand: %%define php_extdir %(php-config --extension-dir)}}
Summary: PHP extension for interfacing with MessagePack
Name: php-msgpack
Version: 0.5.0
Release: 1%{?dist}
Source: php-msgpack-%{version}.tar.gz
License: New BSD License
Group: Development/Libraries
Packager: advect <advect@gmail.com>
Provides: php-pecl-msgpack
BuildRoot: %{_tmppath}/%{name}-%{version}-root
BuildRequires: php-devel
%if 0%{?php_zend_api}
Requires: php(zend-abi) = %{php_zend_api}
Requires: php(api) = %{php_core_api}
%else
Requires: php-api = %{php_apiver}
%endif
%description
PHP extension for interfacing with MessagePack.
%prep
%setup -q -n php-msgpack
%build
phpize
%configure
%{__make}
%install
%makeinstall INSTALL_ROOT=%{buildroot}
%{__install} -d %{buildroot}%{_sysconfdir}/php.d
%{__cat} > %{buildroot}%{_sysconfdir}/php.d/msgpack.ini <<EOF
; Enable msgpack extension module
extension=msgpack.so
EOF
%check
export NO_INTERACTION=1 REPORT_EXIT_STATUS=1
%{__make} test
unset NO_INTERACTION REPORT_EXIT_STATUS
if [ -n "`find tests -name \*.diff -type f -print`" ]; then
exit 1
fi
%clean
%{__rm} -rf %{buildroot}
%files
%attr(-, root, root)
%{_includedir}/php/ext/msgpack/php_msgpack.h
%{php_extdir}/msgpack.so
%config(noreplace) %{_sysconfdir}/php.d/msgpack.ini

43
php/php_msgpack.h
View File

@ -1,43 +0,0 @@
#ifndef PHP_MSGPACK_H
#define PHP_MSGPACK_H
#define MSGPACK_EXTENSION_VERSION "0.5.2"
#include "ext/standard/php_smart_str.h"
extern zend_module_entry msgpack_module_entry;
#define phpext_msgpack_ptr &msgpack_module_entry
#ifdef PHP_WIN32
# define PHP_MSGPACK_API __declspec(dllexport)
#elif defined(__GNUC__) && __GNUC__ >= 4
# define PHP_MSGPACK_API __attribute__ ((visibility("default")))
#else
# define PHP_MSGPACK_API
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
ZEND_BEGIN_MODULE_GLOBALS(msgpack)
zend_bool error_display;
zend_bool php_only;
zend_bool illegal_key_insert;
ZEND_END_MODULE_GLOBALS(msgpack)
ZEND_EXTERN_MODULE_GLOBALS(msgpack)
#ifdef ZTS
#define MSGPACK_G(v) TSRMG(msgpack_globals_id, zend_msgpack_globals *, v)
#else
#define MSGPACK_G(v) (msgpack_globals.v)
#endif
PHP_MSGPACK_API void php_msgpack_serialize(
smart_str *buf, zval *val TSRMLS_DC);
PHP_MSGPACK_API void php_msgpack_unserialize(
zval *return_value, char *str, size_t str_len TSRMLS_DC);
#endif /* PHP_MSGPACK_H */

19
php/test_normal.php
View File

@ -1,19 +0,0 @@
<?php
//$data = array(array(null=>1), array("takei"=>"hide"), 3);
//$data = array("more"=>10, "test", null);
//$data = array();
$data = array(0=>1,1=>2,2=>3);
var_dump($data);
// serialize
$msg = msgpack_pack($data);
// hexadecimal
$str = unpack('H*', $msg);
var_dump("0x".$str[1]);
// deserialize
$ret = msgpack_unpack($msg);
var_dump($ret);
?>

31
php/test_streaming.php
View File

@ -1,31 +0,0 @@
<?php
// serialized data
$msgs = array(pack("C*", 0x93, 0x01, 0x02, 0x03, 0x92), pack("C*", 0x03, 0x09, 0x04));
// streaming deserialize
$unpacker = new MessagePackUnpacker();
$buffer = "";
$nread = 0;
foreach($msgs as $msg){
$buffer = $buffer . $msg;
while(true){
if($unpacker->execute($buffer, $nread)){
$msg = $unpacker->data();
var_dump($msg);
$unpacker->reset();
$buffer = substr($buffer, $nread);
$nread = 0;
if(!empty($buffer)){
continue;
}
}
break;
}
}
?>

10
php/tests/001.phpt
View File

@ -1,10 +0,0 @@
--TEST--
Check for msgpack presence
--SKIPIF--
<?php if (!extension_loaded("msgpack")) print "skip"; ?>
--FILE--
<?php
echo "msgpack extension is available";
?>
--EXPECT--
msgpack extension is available

26
php/tests/002.phpt
View File

@ -1,26 +0,0 @@
--TEST--
Check for null serialisation
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('null', null);
?>
--EXPECT--
null
c0
NULL
OK

31
php/tests/003.phpt
View File

@ -1,31 +0,0 @@
--TEST--
Check for bool serialisation
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('bool true', true);
test('bool false', false);
?>
--EXPECT--
bool true
c3
bool(true)
OK
bool false
c2
bool(false)
OK

56
php/tests/004.phpt
View File

@ -1,56 +0,0 @@
--TEST--
Check for integer serialisation
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
?>
--EXPECT--
zero: 0
00
int(0)
OK
small: 1
01
int(1)
OK
small: -1
ff
int(-1)
OK
medium: 1000
cd03e8
int(1000)
OK
medium: -1000
d1fc18
int(-1000)
OK
large: 100000
ce000186a0
int(100000)
OK
large: -100000
d2fffe7960
int(-100000)
OK

26
php/tests/005.phpt
View File

@ -1,26 +0,0 @@
--TEST--
Check for double serialisation
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('double: 123.456', 123.456);
?>
--EXPECT--
double: 123.456
cb405edd2f1a9fbe77
float(123.456)
OK

31
php/tests/006.phpt
View File

@ -1,31 +0,0 @@
--TEST--
Check for simple string serialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('empty: ""', "");
test('string: "foobar"', "foobar");
?>
--EXPECT--
empty: ""
a0
string(0) ""
OK
string: "foobar"
a6666f6f626172
string(6) "foobar"
OK

72
php/tests/007.phpt
View File

@ -1,72 +0,0 @@
--TEST--
Check for simple array serialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('empty array:', array());
test('array(1, 2, 3)', array(1, 2, 3));
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)));
?>
--EXPECT--
empty array:
90
array(0) {
}
OK
array(1, 2, 3)
93010203
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(array(1, 2, 3), arr...
93930102039304050693070809
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK

61
php/tests/008.phpt
View File

@ -1,61 +0,0 @@
--TEST--
Check for array+string serialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"));
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2));
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"));
test('array("" => "empty")', array("" => "empty"));
?>
--EXPECT--
array("foo", "foo", "foo")
93a3666f6fa3666f6fa3666f6f
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array("one" => 1, "two" => 2))
82a36f6e6501a374776f02
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array("kek" => "lol", "lol" => "kek")
82a36b656ba36c6f6ca36c6f6ca36b656b
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array("" => "empty")
81a0a5656d707479
array(1) {
[""]=>
string(5) "empty"
}
OK

103
php/tests/009.phpt
View File

@ -1,103 +0,0 @@
--TEST--
Check for reference serialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
var_dump($a);
var_dump(msgpack_unserialize(msgpack_serialize($a)));
--EXPECT--
array($a, $a)
9291a3666f6f91a3666f6f
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(&$a, &$a)
9282c00100a3666f6f82c0020002
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
cyclic
9182c0010082c0010082c0020002
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}

121
php/tests/009b.phpt
View File

@ -1,121 +0,0 @@
--TEST--
Check for reference serialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
var_dump($a);
var_dump(msgpack_unserialize(msgpack_serialize($a)));
--EXPECT--
array($a, $a)
9291a3666f6f91a3666f6f
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(&$a, &$a)
9282c00100a3666f6f82c0020002
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
cyclic
9182c0010082c0010082c0020002
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}

49
php/tests/010.phpt
View File

@ -1,49 +0,0 @@
--TEST--
Array test
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
?>
--EXPECT--
array
82a16182a162a163a164a165a16681a167a168
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK

52
php/tests/012.phpt
View File

@ -1,52 +0,0 @@
--TEST--
Object test
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
$o = new Obj(1, 2, 3);
test('object', $o, false);
?>
--EXPECTF--
object
84c0a34f626aa16101a4002a006202a6004f626a006303
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK

52
php/tests/012c.phpt
View File

@ -1,52 +0,0 @@
--TEST--
Object test
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
$o = new Obj(1, 2, 3);
test('object', $o, false);
?>
--EXPECTF--
object
84c0a34f626aa16101a4002a006202a6004f626a006303
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
OK

54
php/tests/013.phpt
View File

@ -1,54 +0,0 @@
--TEST--
Object-Array test
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
}
$o = array(new Obj(1, 2), new Obj(3, 4));
test('object', $o, false);
?>
--EXPECTF--
object
9283c0a34f626aa16101a1620283c0a34f626aa16103a16204
array(2) {
[0]=>
object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
[1]=>
object(Obj)#%d (2) {
["a"]=>
int(3)
["b"]=>
int(4)
}
}
OK

54
php/tests/014.phpt
View File

@ -1,54 +0,0 @@
--TEST--
Object-Reference test
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
}
$o = new Obj(1, 2);
$a = array(&$o, &$o);
test('object', $a, false);
?>
--EXPECTF--
object
9284c001c0a34f626aa16101a1620282c0050002
array(2) {
[0]=>
&object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
[1]=>
&object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
}
OK

62
php/tests/015.phpt
View File

@ -1,62 +0,0 @@
--TEST--
Check for serialization handler
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
return pack('H*', '81a3666f6f01');
}
function write($id, $data) {
global $output;
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
echo ++$_SESSION['foo'], PHP_EOL;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
2
82c001a3666f6f02
array(1) {
["foo"]=>
int(2)
}

62
php/tests/015b.phpt
View File

@ -1,62 +0,0 @@
--TEST--
Check for serialization handler, ini-directive
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--INI--
session.serialize_handler=msgpack
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
return pack('H*', '81a3666f6f01');
}
function write($id, $data) {
global $output;
$output .= bin2hex($data) . PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
echo ++$_SESSION['foo'], PHP_EOL;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
2
82c001a3666f6f02
array(1) {
["foo"]=>
int(2)
}

62
php/tests/015d.phpt
View File

@ -1,62 +0,0 @@
--TEST--
Check for serialization handler
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.2 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
return pack('H*', '81a3666f6f01');
}
function write($id, $data) {
global $output;
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
echo ++$_SESSION['foo'], PHP_EOL;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
2
81a3666f6f02
array(1) {
["foo"]=>
int(2)
}

65
php/tests/015e.phpt
View File

@ -1,65 +0,0 @@
--TEST--
Check for serialization handler, broken
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(0);
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
//broken data
return pack('H*', '81a36');
}
function write($id, $data) {
global $output;
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
echo ++$_SESSION['foo'], PHP_EOL;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
1
82c001a3666f6f01
array(1) {
["foo"]=>
int(1)
}

65
php/tests/015f.phpt
View File

@ -1,65 +0,0 @@
--TEST--
Check for serialization handler, broken
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.2 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(0);
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
//broken data
return pack('H*', '81a36');
}
function write($id, $data) {
global $output;
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
echo ++$_SESSION['foo'], PHP_EOL;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
1
81a3666f6f01
array(1) {
["foo"]=>
int(1)
}

64
php/tests/016.phpt
View File

@ -1,64 +0,0 @@
--TEST--
Object test, __sleep
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
var $d;
function __construct($a, $b, $c, $d) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->d = $d;
}
function __sleep() {
return array('a', 'b', 'c');
}
# function __wakeup() {
# $this->d = $this->a + $this->b + $this->c;
# }
}
$o = new Obj(1, 2, 3, 4);
test('object', $o, true);
?>
--EXPECTF--
object
84c0a34f626aa16101a4002a006202a6004f626a006303
object(Obj)#%d (4) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
["d"]=>
NULL
}
OK

64
php/tests/016c.phpt
View File

@ -1,64 +0,0 @@
--TEST--
Object test, __sleep
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
var $d;
function __construct($a, $b, $c, $d) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->d = $d;
}
function __sleep() {
return array('a', 'b', 'c');
}
# function __wakeup() {
# $this->d = $this->a + $this->b + $this->c;
# }
}
$o = new Obj(1, 2, 3, 4);
test('object', $o, true);
?>
--EXPECTF--
object
84c0a34f626aa16101a4002a006202a6004f626a006303
object(Obj)#%d (4) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
["d"]=>
NULL
}
OK

48
php/tests/017.phpt
View File

@ -1,48 +0,0 @@
--TEST--
Object test, __wakeup
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized->b == 3 ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
function __wakeup() {
$this->b = $this->a * 3;
}
}
$o = new Obj(1, 2);
test('object', $o, false);
?>
--EXPECTF--
object
83c0a34f626aa16101a16202
object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(3)
}
OK

84
php/tests/018.phpt
View File

@ -1,84 +0,0 @@
--TEST--
Object test, __sleep error cases
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(0);
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
function __sleep() {
return array('c');
}
# function __wakeup() {
# $this->b = $this->a * 3;
# }
}
class Opj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
function __sleep() {
return array(1);
}
# function __wakeup() {
#
# }
}
$o = new Obj(1, 2);
$p = new Opj(1, 2);
test('nonexisting', $o, true);
test('wrong', $p, true);
?>
--EXPECTF--
nonexisting
82c0a34f626aa163c0
object(Obj)#%d (3) {
["a"]=>
NULL
["b"]=>
NULL
["c"]=>
NULL
}
OK
wrong
82c0a34f706a
object(Opj)#%d (2) {
["a"]=>
NULL
["b"]=>
NULL
}
OK

43
php/tests/019.phpt
View File

@ -1,43 +0,0 @@
--TEST--
Object test, __autoload
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = pack('H*', $variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized->b == 2 ? 'OK' : 'ERROR', PHP_EOL;
}
function __autoload($classname) {
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
}
}
test('autoload', '83c0a34f626aa16101a16202', false);
?>
--EXPECTF--
autoload
83c0a34f626aa16101a16202
object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
OK

31
php/tests/020.phpt
View File

@ -1,31 +0,0 @@
--TEST--
Object test, incomplete class
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = pack('H*', $variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
}
test('incom', '83c0a34f626aa16101a16202', false);
?>
--EXPECTF--
incom
83c0a34f626aa16101a16202
object(__PHP_Incomplete_Class)#%d (3) {
["__PHP_Incomplete_Class_Name"]=>
string(3) "Obj"
["a"]=>
int(1)
["b"]=>
int(2)
}

56
php/tests/021.phpt
View File

@ -1,56 +0,0 @@
--TEST--
Object Serializable interface
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.1.0') < 0) {
echo "skip tests in PHP 5.1 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj implements Serializable {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
public function serialize() {
return pack('NN', $this->a, $this->b);
}
public function unserialize($serialized) {
$tmp = unpack('N*', $serialized);
$this->__construct($tmp[1], $tmp[2]);
}
}
$o = new Obj(1, 2);
test('object', $o, false);
?>
--EXPECTF--
object
82c003a34f626aa80000000100000002
object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
OK

45
php/tests/022.phpt
View File

@ -1,45 +0,0 @@
--TEST--
Object test, unserialize_callback_func
--SKIPIF--
--INI--
unserialize_callback_func=autoload
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = pack('H*', $variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized->b == 2 ? 'OK' : 'ERROR', PHP_EOL;
}
function autoload($classname) {
class Obj {
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
}
}
test('autoload', '83c0a34f626aa16101a16202', false);
?>
--EXPECTF--
autoload
83c0a34f626aa16101a16202
object(Obj)#%d (2) {
["a"]=>
int(1)
["b"]=>
int(2)
}
OK

45
php/tests/023.phpt
View File

@ -1,45 +0,0 @@
--TEST--
Resource
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(0);
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized === null ? 'OK' : 'FAIL', PHP_EOL;
}
if (function_exists('curl_init')) {
$test = 'curl';
$res = curl_init('http://php.net/');
} else {
$test = 'dir';
$res = opendir('/tmp');
}
test('resource', $res, false);
switch ($test) {
case 'curl':
curl_close($res);
break;
default:
closedir($res);
break;
}
?>
--EXPECT--
resource
c0
NULL
OK

167
php/tests/024.phpt
View File

@ -1,167 +0,0 @@
--TEST--
Recursive objects
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
class Obj2 {
public $aa;
protected $bb;
private $cc;
private $obj;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->obj = new Obj($a, $b, $c);
}
}
class Obj3 {
private $objs;
function __construct($a, $b, $c) {
$this->objs = array();
for ($i = $a; $i < $c; $i += $b) {
$this->objs[] = new Obj($a, $i, $c);
}
}
}
class Obj4 {
private $a;
private $obj;
function __construct($a) {
$this->a = $a;
}
public function set($obj) {
$this->obj = $obj;
}
}
$o2 = new Obj2(1, 2, 3);
test('objectrec', $o2, false);
$o3 = new Obj3(0, 1, 4);
test('objectrecarr', $o3, false);
$o4 = new Obj4(100);
$o4->set($o4);
test('objectselfrec', $o4, true);
?>
--EXPECTF--
objectrec
88c0a44f626a32a26161c0a5002a006262c0a8004f626a32006363c0a9004f626a32006f626a84c0a34f626aa16101a4002a006202a6004f626a006303a16101a16202a16303
object(Obj2)#%d (7) {
["aa"]=>
NULL
[%r"?bb"?:protected"?%r]=>
NULL
[%r"?cc"?:("Obj2":)?private"?%r]=>
NULL
[%r"?obj"?:("Obj2":)?private"?%r]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
["a"]=>
int(1)
["b"]=>
int(2)
["c"]=>
int(3)
}
OK
objectrecarr
82c0a44f626a33aa004f626a33006f626a739484c0a34f626aa16100a4002a006200a6004f626a00630484c0a34f626aa16100a4002a006201a6004f626a00630484c0a34f626aa16100a4002a006202a6004f626a00630484c0a34f626aa16100a4002a006203a6004f626a006304
object(Obj3)#%d (1) {
[%r"?objs"?:("Obj3":)?private"?%r]=>
array(4) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(0)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(1)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[2]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[3]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(3)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
}
}
OK
objectselfrec
83c0a44f626a34a7004f626a34006164a9004f626a34006f626a82c0040001
object(Obj4)#%d (2) {
[%r"?a"?:("Obj4":)?private"?%r]=>
int(100)
[%r"?obj"?:("Obj4":)?private"?%r]=>
*RECURSION*
}
OK

175
php/tests/024b.phpt
View File

@ -1,175 +0,0 @@
--TEST--
Recursive objects
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
class Obj2 {
public $aa;
protected $bb;
private $cc;
private $obj;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->obj = new Obj($a, $b, $c);
}
}
class Obj3 {
private $objs;
function __construct($a, $b, $c) {
$this->objs = array();
for ($i = $a; $i < $c; $i += $b) {
$this->objs[] = new Obj($a, $i, $c);
}
}
}
class Obj4 {
private $a;
private $obj;
function __construct($a) {
$this->a = $a;
}
public function set($obj) {
$this->obj = $obj;
}
}
$o2 = new Obj2(1, 2, 3);
test('objectrec', $o2, false);
$o3 = new Obj3(0, 1, 4);
test('objectrecarr', $o3, false);
$o4 = new Obj4(100);
$o4->set($o4);
test('objectselfrec', $o4, true);
?>
--EXPECTF--
objectrec
88c0a44f626a32a26161c0a5002a006262c0a8004f626a32006363c0a9004f626a32006f626a84c0a34f626aa16101a4002a006202a6004f626a006303a16101a16202a16303
object(Obj2)#%d (7) {
["aa"]=>
NULL
[%r"?bb"?:protected"?%r]=>
NULL
[%r"?cc"?:("Obj2":)?private"?%r]=>
NULL
[%r"?obj"?:("Obj2":)?private"?%r]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
["a"]=>
int(1)
["b"]=>
int(2)
["c"]=>
int(3)
}
OK
objectrecarr
82c0a44f626a33aa004f626a33006f626a739484c0a34f626aa16100a4002a006200a6004f626a00630484c0a34f626aa16100a4002a006201a6004f626a00630484c0a34f626aa16100a4002a006202a6004f626a00630484c0a34f626aa16100a4002a006203a6004f626a006304
object(Obj3)#%d (1) {
[%r"?objs"?:("Obj3":)?private"?%r]=>
array(4) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(0)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(1)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[2]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
[3]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
[%r"?b"?:protected"?%r]=>
int(3)
[%r"?c"?:("Obj":)?private"?%r]=>
int(4)
}
}
}
OK
objectselfrec
83c0a44f626a34a7004f626a34006164a9004f626a34006f626a82c0040001
object(Obj4)#%d (2) {
[%r"?a"?:("Obj4":)?private"?%r]=>
int(100)
[%r"?obj"?:("Obj4":)?private"?%r]=>
object(Obj4)#%d (2) {
[%r"?a"?:("Obj4":)?private"?%r]=>
int(100)
[%r"?obj"?:("Obj4":)?private"?%r]=>
*RECURSION*
}
}
OK

170
php/tests/024c.phpt
View File

@ -1,170 +0,0 @@
--TEST--
Recursive objects
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
class Obj2 {
public $aa;
protected $bb;
private $cc;
private $obj;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->obj = new Obj($a, $b, $c);
}
}
class Obj3 {
private $objs;
function __construct($a, $b, $c) {
$this->objs = array();
for ($i = $a; $i < $c; $i += $b) {
$this->objs[] = new Obj($a, $i, $c);
}
}
}
class Obj4 {
private $a;
private $obj;
function __construct($a) {
$this->a = $a;
}
public function set($obj) {
$this->obj = $obj;
}
}
$o2 = new Obj2(1, 2, 3);
test('objectrec', $o2, false);
$o3 = new Obj3(0, 1, 4);
test('objectrecarr', $o3, false);
$o4 = new Obj4(100);
$o4->set($o4);
test('objectselfrec', $o4, true);
?>
--EXPECTF--
objectrec
88c0a44f626a32a26161c0a5002a006262c0a8004f626a32006363c0a9004f626a32006f626a84c0a34f626aa16101a4002a006202a6004f626a006303a16101a16202a16303
object(Obj2)#%d (7) {
["aa"]=>
NULL
["bb:protected"]=>
NULL
["cc:private"]=>
NULL
["obj:private"]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
["a"]=>
int(1)
["b"]=>
int(2)
["c"]=>
int(3)
}
OK
objectrecarr
82c0a44f626a33aa004f626a33006f626a739484c0a34f626aa16100a4002a006200a6004f626a00630484c0a34f626aa16100a4002a006201a6004f626a00630484c0a34f626aa16100a4002a006202a6004f626a00630484c0a34f626aa16100a4002a006203a6004f626a006304
object(Obj3)#%d (1) {
["objs:private"]=>
array(4) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
["b:protected"]=>
int(0)
["c:private"]=>
int(4)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
["b:protected"]=>
int(1)
["c:private"]=>
int(4)
}
[2]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
["b:protected"]=>
int(2)
["c:private"]=>
int(4)
}
[3]=>
object(Obj)#%d (3) {
["a"]=>
int(0)
["b:protected"]=>
int(3)
["c:private"]=>
int(4)
}
}
}
OK
objectselfrec
83c0a44f626a34a7004f626a34006164a9004f626a34006f626a82c0040001
object(Obj4)#%d (2) {
["a:private"]=>
int(100)
["obj:private"]=>
object(Obj4)#%d (2) {
["a:private"]=>
int(100)
["obj:private"]=>
*RECURSION*
}
}
OK

123
php/tests/025.phpt
View File

@ -1,123 +0,0 @@
--TEST--
Object test, array of objects with __sleep
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
var_dump($variable);
var_dump($unserialized);
}
class Obj {
public $a;
protected $b;
private $c;
var $d;
function __construct($a, $b, $c, $d) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->d = $d;
}
function __sleep() {
return array('a', 'b', 'c');
}
# function __wakeup() {
# $this->d = $this->a + $this->b + $this->c;
# }
}
$array = array(
new Obj("aa", "bb", "cc", "dd"),
new Obj("ee", "ff", "gg", "hh"),
new Obj(1, 2, 3, 4),
);
test('array', $array, true);
?>
--EXPECTF--
array(3) {
[0]=>
object(Obj)#1 (4) {
["a"]=>
string(2) "aa"
[%r"?b"?:protected"?%r]=>
string(2) "bb"
[%r"?c"?:("Obj":)?private"?%r]=>
string(2) "cc"
["d"]=>
string(2) "dd"
}
[1]=>
object(Obj)#2 (4) {
["a"]=>
string(2) "ee"
[%r"?b"?:protected"?%r]=>
string(2) "ff"
[%r"?c"?:("Obj":)?private"?%r]=>
string(2) "gg"
["d"]=>
string(2) "hh"
}
[2]=>
object(Obj)#3 (4) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
["d"]=>
int(4)
}
}
array(3) {
[0]=>
object(Obj)#4 (4) {
["a"]=>
string(2) "aa"
[%r"?b"?:protected"?%r]=>
string(2) "bb"
[%r"?c"?:("Obj":)?private"?%r]=>
string(2) "cc"
["d"]=>
NULL
}
[1]=>
object(Obj)#5 (4) {
["a"]=>
string(2) "ee"
[%r"?b"?:protected"?%r]=>
string(2) "ff"
[%r"?c"?:("Obj":)?private"?%r]=>
string(2) "gg"
["d"]=>
NULL
}
[2]=>
object(Obj)#6 (4) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
["d"]=>
NULL
}
}

123
php/tests/025c.phpt
View File

@ -1,123 +0,0 @@
--TEST--
Object test, array of objects with __sleep
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
var_dump($variable);
var_dump($unserialized);
}
class Obj {
public $a;
protected $b;
private $c;
var $d;
function __construct($a, $b, $c, $d) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
$this->d = $d;
}
function __sleep() {
return array('a', 'b', 'c');
}
# function __wakeup() {
# $this->d = $this->a + $this->b + $this->c;
# }
}
$array = array(
new Obj("aa", "bb", "cc", "dd"),
new Obj("ee", "ff", "gg", "hh"),
new Obj(1, 2, 3, 4),
);
test('array', $array, true);
?>
--EXPECTF--
array(3) {
[0]=>
object(Obj)#1 (4) {
["a"]=>
string(2) "aa"
["b:protected"]=>
string(2) "bb"
["c:private"]=>
string(2) "cc"
["d"]=>
string(2) "dd"
}
[1]=>
object(Obj)#2 (4) {
["a"]=>
string(2) "ee"
["b:protected"]=>
string(2) "ff"
["c:private"]=>
string(2) "gg"
["d"]=>
string(2) "hh"
}
[2]=>
object(Obj)#3 (4) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
["d"]=>
int(4)
}
}
array(3) {
[0]=>
object(Obj)#4 (4) {
["a"]=>
string(2) "aa"
["b:protected"]=>
string(2) "bb"
["c:private"]=>
string(2) "cc"
["d"]=>
NULL
}
[1]=>
object(Obj)#5 (4) {
["a"]=>
string(2) "ee"
["b:protected"]=>
string(2) "ff"
["c:private"]=>
string(2) "gg"
["d"]=>
NULL
}
[2]=>
object(Obj)#6 (4) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
["d"]=>
NULL
}
}

109
php/tests/026.phpt
View File

@ -1,109 +0,0 @@
--TEST--
Cyclic array test
--INI--
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
);
$a['f'] = &$a;
test('array', $a, true);
$a = array("foo" => &$b);
$b = array(1, 2, $a);
var_dump($a);
var_dump($k = msgpack_unserialize(msgpack_serialize($a)));
$k["foo"][1] = "b";
var_dump($k);
?>
--EXPECT--
array
82a16182a162a163a164a165a16683c001a16182a162a163a164a165a16682c0020003
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
&array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
*RECURSION*
}
}
OK
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
*RECURSION*
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
string(1) "b"
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}

152
php/tests/026b.phpt
View File

@ -1,152 +0,0 @@
--TEST--
Cyclic array test
--INI--
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.1.0') < 0) {
echo "skip tests in PHP 5.1 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
);
$a['f'] = &$a;
test('array', $a, true);
$a = array("foo" => &$b);
$b = array(1, 2, $a);
var_dump($a);
var_dump($k = msgpack_unserialize(msgpack_serialize($a)));
$k["foo"][1] = "b";
var_dump($k);
?>
--EXPECT--
array
82a16182a162a163a164a165a16683c001a16182a162a163a164a165a16682c0020003
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
&array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
&array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
*RECURSION*
}
}
}
OK
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
*RECURSION*
}
}
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
string(1) "b"
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
string(1) "b"
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}
}
}

147
php/tests/026d.phpt
View File

@ -1,147 +0,0 @@
--TEST--
Cyclic array test
--INI--
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.1.0') >= 0) {
echo "skip tests in PHP 5.0 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
echo bin2hex($serialized), PHP_EOL;
var_dump($unserialized);
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
);
$a['f'] = &$a;
test('array', $a, true);
$a = array("foo" => &$b);
$b = array(1, 2, $a);
var_dump($a);
var_dump($k = msgpack_unserialize(msgpack_serialize($a)));
$k["foo"][1] = "b";
var_dump($k);
?>
--EXPECT--
array
82a16182a162a163a164a165a16682a16182a162a163a164a165a16682a16182a162a163a164a165a166c0
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
NULL
}
}
}
OK
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
*RECURSION*
}
}
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}
}
}
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
string(1) "b"
[2]=>
array(1) {
["foo"]=>
&array(3) {
[0]=>
int(1)
[1]=>
string(1) "b"
[2]=>
array(1) {
["foo"]=>
*RECURSION*
}
}
}
}
}

77
php/tests/027.phpt
View File

@ -1,77 +0,0 @@
--TEST--
Check for serialization handler
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
return pack('H*', '81a3666f6f01');
}
function write($id, $data) {
global $output;
$output .= "wrote: ";
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
class Foo {
}
class Bar {
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
$db_object = new Foo();
$session_object = new Bar();
$v = session_start();
var_dump($v);
$_SESSION['test'] = "foobar";
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
bool(true)
read
wrote: 83c001a3666f6f01a474657374a6666f6f626172
array(2) {
["foo"]=>
int(1)
["test"]=>
string(6) "foobar"
}

77
php/tests/027d.phpt
View File

@ -1,77 +0,0 @@
--TEST--
Check for serialization handler
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.2 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
return pack('H*', '81a3666f6f01');
}
function write($id, $data) {
global $output;
$output .= "wrote: ";
$output .= bin2hex($data). PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
class Foo {
}
class Bar {
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
$db_object = new Foo();
$session_object = new Bar();
$v = session_start();
var_dump($v);
$_SESSION['test'] = "foobar";
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECT--
bool(true)
read
wrote: 82a3666f6f01a474657374a6666f6f626172
array(2) {
["foo"]=>
int(1)
["test"]=>
string(6) "foobar"
}

169
php/tests/028.phpt
View File

@ -1,169 +0,0 @@
--TEST--
Serialize object into session, full set
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
class Foo {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
private $d1;
protected $d2;
public $d3;
public function __construct($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
class Bar {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
public $d1;
private $d2;
protected $d3;
public function __construct() {
}
public function set($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$session = array('old' => $b);
return msgpack_serialize($session);
}
function write($id, $data) {
global $output;
$output .= "write: ";
$output .= bin2hex($data) . PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
$_SESSION['test'] = "foobar";
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$_SESSION['new'] = $a;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECTF--
read
write: 84c001a36f6c6484c0a3466f6fa700466f6f00643184c0a3426172a2643182c0040002a70042617200643282c0040002a5002a00643382c0040002a5002a00643282c0040003a2643382c0040003a474657374a6666f6f626172a36e657784c0a3426172a2643184c0a3466f6fa700466f6f00643182c0040009a5002a00643282c0040009a2643382c0040009a70042617200643282c004000aa5002a00643382c004000a
array(3) {
["old"]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
["test"]=>
string(6) "foobar"
["new"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}

676
php/tests/028b.phpt
View File

@ -1,676 +0,0 @@
--TEST--
Serialize object into session, full set
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
class Foo {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
private $d1;
protected $d2;
public $d3;
public function __construct($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
class Bar {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
public $d1;
private $d2;
protected $d3;
public function __construct() {
}
public function set($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$session = array('old' => $b);
return msgpack_serialize($session);
}
function write($id, $data) {
global $output;
$output .= "write: ";
$output .= bin2hex($data) . PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
$_SESSION['test'] = "foobar";
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$_SESSION['new'] = $a;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECTF--
read
write: 84c001a36f6c6484c0a3466f6fa700466f6f00643184c0a3426172a2643182c0040002a70042617200643282c0040002a5002a00643382c0040002a5002a00643282c0040003a2643382c0040003a474657374a6666f6f626172a36e657784c0a3426172a2643184c0a3466f6fa700466f6f00643182c0040009a5002a00643282c0040009a2643382c0040009a70042617200643282c004000aa5002a00643382c004000a
array(3) {
["old"]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#3 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
[%r"?d2"?:("Bar":)?private"?%r]=>
*RECURSION*
[%r"?d3"?:protected"?%r]=>
*RECURSION*
}
}
}
}
["test"]=>
string(6) "foobar"
["new"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
[%r"?d2"?:protected"?%r]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d2"?:("Bar":)?private"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
[%r"?d3"?:protected"?%r]=>
object(Foo)#6 (3) {
[%r"?d1"?:("Foo":)?private"?%r]=>
*RECURSION*
[%r"?d2"?:protected"?%r]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
}
}

672
php/tests/028c.phpt
View File

@ -1,672 +0,0 @@
--TEST--
Serialize object into session, full set
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.1.0') < 0 ||
version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
class Foo {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
private $d1;
protected $d2;
public $d3;
public function __construct($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
class Bar {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
public $d1;
private $d2;
protected $d3;
public function __construct() {
}
public function set($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$session = array('old' => $b);
return msgpack_serialize($session);
}
function write($id, $data) {
global $output;
$output .= "write: ";
$output .= bin2hex($data) . PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
$_SESSION['test'] = "foobar";
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$_SESSION['new'] = $a;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECTF--
read
write: 83a36f6c6484c0a3466f6fa700466f6f00643184c0a3426172a2643182c0040002a70042617200643282c0040002a5002a00643382c0040002a5002a00643282c0040003a2643382c0040003a474657374a6666f6f626172a36e657784c0a3426172a2643184c0a3466f6fa700466f6f00643182c0040009a5002a00643282c0040009a2643382c0040009a70042617200643282c004000aa5002a00643382c004000a
array(3) {
["old"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
}
["test"]=>
string(6) "foobar"
["new"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
}
}

671
php/tests/028d.phpt
View File

@ -1,671 +0,0 @@
--TEST--
Serialize object into session, full set
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.1.0') >= 0) {
echo "skip tests in PHP 5.0 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
class Foo {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
private $d1;
protected $d2;
public $d3;
public function __construct($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
class Bar {
private static $s1 = array();
protected static $s2 = array();
public static $s3 = array();
public $d1;
private $d2;
protected $d3;
public function __construct() {
}
public function set($foo) {
$this->d1 = $foo;
$this->d2 = $foo;
$this->d3 = $foo;
}
}
$output = '';
function open($path, $name) {
return true;
}
function close() {
return true;
}
function read($id) {
global $output;
$output .= "read" . PHP_EOL;
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$session = array('old' => $b);
return msgpack_serialize($session);
}
function write($id, $data) {
global $output;
$output .= "write: ";
$output .= bin2hex($data) . PHP_EOL;
return true;
}
function destroy($id) {
return true;
}
function gc($time) {
return true;
}
ini_set('session.serialize_handler', 'msgpack');
session_set_save_handler('open', 'close', 'read', 'write', 'destroy', 'gc');
session_start();
$_SESSION['test'] = "foobar";
$a = new Bar();
$b = new Foo($a);
$a->set($b);
$_SESSION['new'] = $a;
session_write_close();
echo $output;
var_dump($_SESSION);
?>
--EXPECTF--
read
write: 83a36f6c6484c0a3466f6fa700466f6f00643184c0a3426172a2643182c0040002a70042617200643282c0040002a5002a00643382c0040002a5002a00643282c0040003a2643382c0040003a474657374a6666f6f626172a36e657784c0a3426172a2643184c0a3466f6fa700466f6f00643182c0040009a5002a00643282c0040009a2643382c0040009a70042617200643282c004000aa5002a00643382c004000a
array(3) {
["old"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d2:private"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
["d3:protected"]=>
object(Foo)#3 (3) {
["d1:private"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d2:protected"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
["d3"]=>
object(Bar)#4 (3) {
["d1"]=>
*RECURSION*
["d2:private"]=>
*RECURSION*
["d3:protected"]=>
*RECURSION*
}
}
}
}
["test"]=>
string(6) "foobar"
["new"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d2:protected"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
["d3"]=>
object(Bar)#5 (3) {
["d1"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d2:private"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
["d3:protected"]=>
object(Foo)#6 (3) {
["d1:private"]=>
*RECURSION*
["d2:protected"]=>
*RECURSION*
["d3"]=>
*RECURSION*
}
}
}
}
}

48
php/tests/029.phpt
View File

@ -1,48 +0,0 @@
--TEST--
Msgpack module info
--SKIPIF--
<?php if (!extension_loaded("msgpack")) print "skip"; ?>
--FILE--
<?php
ob_start();
phpinfo(INFO_MODULES);
$str = ob_get_clean();
$array = explode("\n", $str);
$section = false;
$blank = 0;
foreach ($array as $key => $val)
{
if (strcmp($val, 'msgpack') == 0 || $section)
{
$section = true;
}
else
{
continue;
}
if (empty($val))
{
$blank++;
if ($blank == 3)
{
$section = false;
}
}
echo $val, PHP_EOL;
}
--EXPECTF--
msgpack
MessagePack Support => enabled
Session Support => enabled
extension Version => %s
header Version => %s
Directive => Local Value => Master Value
msgpack.error_display => On => On
msgpack.illegal_key_insert => Off => Off
msgpack.php_only => On => On

230
php/tests/030.phpt
View File

@ -1,230 +0,0 @@
--TEST--
Unserialize invalid data
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$datas = array(
87817,
-1,
array(1,2,3,"testing" => 10, "foo"),
true,
false,
0.187182,
"dakjdh98389\000",
null,
(object)array(1,2,3),
);
error_reporting(0);
foreach ($datas as $data) {
$str = msgpack_serialize($data);
$len = strlen($str);
// truncated
for ($i = 0; $i < $len - 1; $i++) {
$v = msgpack_unserialize(substr($str, 0, $i));
if (is_object($data) || is_array($data)) {
if ($v !== null && $v !== false && $v != $data) {
echo "output at $i:\n";
var_dump($v);
}
} else if ($v !== null && $v == $data) {
continue;
} else if ($v !== null && $v !== $data) {
echo "output at $i:\n";
var_dump($v);
echo "vs.\n";
var_dump($data);
}
}
// padded
$str .= "98398afa\000y21_ ";
$v = msgpack_unserialize($str);
if ($v !== $data && !(is_object($data) && $v == $data)) {
echo "padded should get original\n";
var_dump($v);
echo "vs.\n";
var_dump($data);
}
}
?>
--EXPECTF--
output at 3:
array(1) {
[0]=>
int(1)
}
output at 4:
array(1) {
[0]=>
int(1)
}
output at 5:
array(2) {
[0]=>
int(1)
[1]=>
int(2)
}
output at 6:
array(2) {
[0]=>
int(1)
[1]=>
int(2)
}
output at 7:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 8:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 9:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 10:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 11:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 12:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 13:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 14:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 15:
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
output at 16:
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["testing"]=>
int(10)
}
output at 17:
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["testing"]=>
int(10)
}
output at 18:
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["testing"]=>
int(10)
}
output at 19:
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["testing"]=>
int(10)
}
output at 11:
object(stdClass)#2 (0) {
}
output at 12:
object(stdClass)#3 (0) {
}
output at 13:
object(stdClass)#2 (1) {
[0]=>
int(1)
}
output at 14:
object(stdClass)#3 (1) {
[0]=>
int(1)
}
output at 15:
object(stdClass)#2 (2) {
[0]=>
int(1)
[1]=>
int(2)
}

94
php/tests/031.phpt
View File

@ -1,94 +0,0 @@
--TEST--
Object Serializable interface throws exceptions
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.1.0') < 0) {
echo "skip tests in PHP 5.1 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
var_dump($unserialized);
}
class Obj implements Serializable {
private static $count = 1;
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
public function serialize() {
$c = self::$count++;
echo "call serialize, ", ($this->a ? "throw" : "no throw"), PHP_EOL;
if ($this->a) {
throw new Exception("exception in serialize $c");
}
return pack('NN', $this->a, $this->b);
}
public function unserialize($serialized) {
$tmp = unpack('N*', $serialized);
$this->__construct($tmp[1], $tmp[2]);
$c = self::$count++;
echo "call unserialize, ", ($this->b ? "throw" : "no throw"), PHP_EOL;
if ($this->b) {
throw new Exception("exception in unserialize $c");
}
}
}
$a = new Obj(1, 0);
$a = new Obj(0, 0);
$b = new Obj(0, 0);
$c = new Obj(1, 0);
$d = new Obj(0, 1);
echo "a, a, c", PHP_EOL;
try {
test(array($a, $a, $c));
} catch (Exception $e) {
if (version_compare(phpversion(), "5.3.0", ">=")) {
if ($e->getPrevious()) {
$e = $e->getPrevious();
}
}
echo $e->getMessage(), PHP_EOL;
}
echo "b, b, d", PHP_EOL;
try {
test(array($b, $b, $d));
} catch (Exception $e) {
if (version_compare(phpversion(), "5.3.0", ">=")) {
if ($e->getPrevious()) {
$e = $e->getPrevious();
}
}
echo $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
a, a, c
call serialize, no throw
call serialize, throw
exception in serialize 2
b, b, d
call serialize, no throw
call serialize, no throw
call unserialize, no throw
call unserialize, throw
exception in unserialize 6

76
php/tests/032.phpt
View File

@ -1,76 +0,0 @@
--TEST--
Object test, __sleep and __wakeup exceptions
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(0);
function test($variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
var_dump($unserialized);
}
class Obj {
private static $count = 0;
var $a;
var $b;
function __construct($a, $b) {
$this->a = $a;
$this->b = $b;
}
function __sleep() {
$c = self::$count++;
if ($this->a) {
throw new Exception("exception in __sleep $c");
}
return array('a', 'b');
}
function __wakeup() {
$c = self::$count++;
if ($this->b) {
throw new Exception("exception in __wakeup $c");
}
$this->b = $this->a * 3;
}
}
$a = new Obj(1, 0);
$b = new Obj(0, 1);
$c = new Obj(0, 0);
try {
test($a);
} catch (Exception $e) {
echo $e->getMessage(), PHP_EOL;
}
try {
test($b);
} catch (Exception $e) {
echo $e->getMessage(), PHP_EOL;
}
try {
test($c);
} catch (Exception $e) {
echo $e->getMessage(), PHP_EOL;
}
?>
--EXPECTF--
exception in __sleep 0
exception in __wakeup 2
object(Obj)#%d (2) {
["a"]=>
int(0)
["b"]=>
int(0)
}

55
php/tests/033.phpt
View File

@ -1,55 +0,0 @@
--TEST--
Object test, cyclic references
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
class Foo {
public $parent;
public $children;
public function __construct() {
$this->parent = null;
$this->children = array();
}
public function addChild(Foo $obj) {
$this->children[] = $obj;
$obj->setParent($this);
}
public function setParent(Foo $obj) {
$this->parent = $obj;
}
}
$obj1 = new Foo();
for ($i = 0; $i < 10; $i++) {
$obj = new Foo();
$obj1->addChild($obj);
}
$o = msgpack_unserialize(msgpack_serialize($obj1->children));
foreach ($obj1->children as $k => $v) {
$obj_v = $v;
$o_v = $o[$k];
echo gettype($obj_v), " ", gettype($o_v), PHP_EOL;
}
?>
--EXPECT--
object object
object object
object object
object object
object object
object object
object object
object object
object object
object object

41
php/tests/034.phpt
View File

@ -1,41 +0,0 @@
--TEST--
Unserialize invalid random data
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$datas = array(
87817,
-1,
array(1,2,3,"testing" => 10, "foo"),
true,
false,
0.187182,
"dakjdh98389\000",
null,
(object)array(1,2,3),
);
error_reporting(0);
foreach ($datas as $data)
{
$str = msgpack_serialize($data);
$len = strlen($str);
for ($j = 0; $j < 200; $j++)
{
for ($i = 0; $i < $len - 1; $i++)
{
$sub = substr($str, 0, $i);
$sub .= mcrypt_create_iv(30, MCRYPT_DEV_URANDOM);
$php_errormsg = null;
$v = msgpack_unserialize($sub);
}
}
}
--EXPECT--

34
php/tests/035.phpt
View File

@ -1,34 +0,0 @@
--TEST--
Profiling perf test.
--SKIPIF--
<?php
if (!extension_loaded("msgpack") || !extension_loaded("mcrypt")) {
echo "skip";
}
?>
--FILE--
<?php
$data_array = array();
for ($i = 0; $i < 5000; $i++) {
$data_array[mcrypt_create_iv(10, MCRYPT_DEV_URANDOM)] = mcrypt_create_iv(10, MCRYPT_DEV_URANDOM);
}
$time_start = microtime(true);
for ($i = 0; $i < 4000; $i++) {
$s = msgpack_serialize($data_array);
$array = msgpack_unserialize($s);
unset($array);
unset($s);
}
$time_end = microtime(true);
if ($time_end <= $time_start) {
echo "Strange, $i iterations ran in infinite speed: $time_end <= $time_start", PHP_EOL;
} else {
$speed = $i / ($time_end - $time_start);
printf("%d iterations took %f seconds: %d/s (%s)\n",
$i, $time_end - $time_start, $speed, ($speed > 400 ? "GOOD" : "BAD"));
}
?>
--EXPECTF--
%d iterations took %f seconds: %d/s (GOOD)

43
php/tests/040.phpt
View File

@ -1,43 +0,0 @@
--TEST--
broken random data test
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(E_ERROR | E_PARSE);
function test() {
$serialized = msgpack_serialize(null);
$serialized = substr($serialized, 0, -1);
$length = mt_rand(1, 255);
for ($i = 0; $i < $length; ++$i) {
$serialized .= chr(mt_rand(0, 255));
}
// if returned null everything is OK
if (($unserialized = msgpack_unserialize($serialized)) === null) {
return true;
}
// whole data is read?
if ($serialized !== msgpack_serialize($unserialized)) {
return true;
}
echo bin2hex($serialized), "\n";
var_dump($unserialized);
return false;
}
mt_srand(0x4c05b583);
for ($i = 0; $i < 100; ++$i) {
if (!test()) break;
}
?>
--EXPECT--

44
php/tests/040b.phpt
View File

@ -1,44 +0,0 @@
--TEST--
broken random data test : MessagePack class
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(E_ERROR | E_PARSE);
function test() {
$serialized = msgpack_serialize(null);
$serialized = substr($serialized, 0, -1);
$length = mt_rand(1, 255);
for ($i = 0; $i < $length; ++$i) {
$serialized .= chr(mt_rand(0, 255));
}
// if returned null everything is OK
$msgpack = new MessagePack();
if (($unserialized = $msgpack->unpack($serialized)) === null) {
return true;
}
// whole data is read?
if ($serialized !== msgpack_serialize($unserialized)) {
return true;
}
echo bin2hex($serialized), "\n";
var_dump($unserialized);
return false;
}
mt_srand(0x4c05b583);
for ($i = 0; $i < 100; ++$i) {
if (!test()) break;
}
?>
--EXPECT--

53
php/tests/040c.phpt
View File

@ -1,53 +0,0 @@
--TEST--
broken random data test : MessagePackUnpacker::feed
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(E_ERROR | E_PARSE);
function test() {
$serialized = msgpack_serialize(null);
$serialized = substr($serialized, 0, -1);
$length = mt_rand(1, 255);
for ($i = 0; $i < $length; ++$i) {
$serialized .= chr(mt_rand(0, 255));
}
// if returned null everything is OK
$unpacker = new MessagePackUnpacker();
$unpacker->feed($serialized);
if ($unpacker->execute())
{
if (($unserialized = $unpacker->data()) === null) {
return true;
}
$unpacker->reset();
}
else
{
return true;
}
// whole data is read?
if ($serialized !== msgpack_serialize($unserialized)) {
return true;
}
echo bin2hex($serialized), "\n";
var_dump($unserialized);
return false;
}
mt_srand(0x4c05b583);
for ($i = 0; $i < 100; ++$i) {
if (!test()) break;
}
?>
--EXPECT--

52
php/tests/040d.phpt
View File

@ -1,52 +0,0 @@
--TEST--
broken random data test : MessagePackUnpacker::execute
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
error_reporting(E_ERROR | E_PARSE);
function test() {
$serialized = msgpack_serialize(null);
$serialized = substr($serialized, 0, -1);
$length = mt_rand(1, 255);
for ($i = 0; $i < $length; ++$i) {
$serialized .= chr(mt_rand(0, 255));
}
// if returned null everything is OK
$unpacker = new MessagePackUnpacker();
if ($unpacker->execute($serialized, $offset))
{
if (($unserialized = $unpacker->data()) === null) {
return true;
}
$unpacker->reset();
}
else
{
return true;
}
// whole data is read?
if ($serialized !== msgpack_serialize($unserialized)) {
return true;
}
echo bin2hex($serialized), "\n";
var_dump($unserialized);
return false;
}
mt_srand(0x4c05b583);
for ($i = 0; $i < 100; ++$i) {
if (!test()) break;
}
?>
--EXPECT--

47
php/tests/041.phpt
View File

@ -1,47 +0,0 @@
--TEST--
Check for double NaN, Inf, -Inf, 0, and -0
--FILE--
<?php
function test($type, $variable) {
$serialized = msgpack_serialize($variable);
$unserialized = msgpack_unserialize($serialized);
echo $type, PHP_EOL;
var_dump($variable);
var_dump($unserialized);
echo bin2hex($serialized), PHP_EOL;
echo PHP_EOL;
}
test('double NaN:', NAN);
test('double Inf:', INF);
test('double -Inf:', -INF);
test('double 0.0:', 0.0);
test('double -0.0:', -0.0);
--EXPECTF--
double NaN:
float(NAN)
float(NAN)
cb7ff8000000000000
double Inf:
float(INF)
float(INF)
cb7ff0000000000000
double -Inf:
float(-INF)
float(-INF)
cbfff0000000000000
double 0.0:
float(0)
float(0)
cb0000000000000000
double -0.0:
float(0)
float(0)
cb0000000000000000

40
php/tests/042.phpt
View File

@ -1,40 +0,0 @@
--TEST--
Closure
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.3.0') < 0) {
echo "skip closures only for PHP 5.3.0 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$closure = function ($x) {
return $x + 1;
};
class Foo implements Serializable {
public function serialize() {
echo "Should not be run.\n";
}
public function unserialize($str) {
echo "Should not be run.\n";
}
}
$array = array($closure, new Foo());
try {
$ser = msgpack_serialize($array);
echo "Serialized closure.\n";
$unser = msgpack_unserialize($ser);
echo "Unserialized closure.\n";
var_dump($unser);
} catch (Exception $e) {
echo "Got exception.\n";
}
--EXPECT--
Got exception.

111
php/tests/050.phpt
View File

@ -1,111 +0,0 @@
--TEST--
Check for array unserialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable) {
$unserialized = msgpack_unserialize(pack('H*', $variable));
echo $type, PHP_EOL;
echo $variable, PHP_EOL;
var_dump($unserialized);
}
test('empty array:', '90');
test('array(1, 2, 3)', '93010203');
test('array(array(1, 2, 3), arr...', '93930102039304050693070809');
test('array("foo", "FOO", "Foo")', '93a3666f6fa3464f4fa3466f6f');
test('array(1, 123.45, true, ...', '9701cb405edccccccccccdc3c293010293090807c0a3666f6f');
?>
--EXPECT--
empty array:
90
array(0) {
}
array(1, 2, 3)
93010203
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
array(array(1, 2, 3), arr...
93930102039304050693070809
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
array("foo", "FOO", "Foo")
93a3666f6fa3464f4fa3466f6f
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "FOO"
[2]=>
string(3) "Foo"
}
array(1, 123.45, true, ...
9701cb405edccccccccccdc3c293010293090807c0a3666f6f
array(7) {
[0]=>
int(1)
[1]=>
float(123.45)
[2]=>
bool(true)
[3]=>
bool(false)
[4]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
array(3) {
[0]=>
int(9)
[1]=>
int(8)
[2]=>
int(7)
}
}
[5]=>
NULL
[6]=>
string(3) "foo"
}

315
php/tests/060.phpt
View File

@ -1,315 +0,0 @@
--TEST--
Check for buffered streaming unserialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

324
php/tests/060b.phpt
View File

@ -1,324 +0,0 @@
--TEST--
Check for buffered streaming unserialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

319
php/tests/060c.phpt
View File

@ -1,319 +0,0 @@
--TEST--
Check for buffered streaming unserialization
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
["b:protected"]=>
int(5)
["c:private"]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
}
OK

320
php/tests/061.phpt
View File

@ -1,320 +0,0 @@
--TEST--
Check for unbuffered streaming unserialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
$str = "";
$offset = 0;
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str .= substr($serialized, $i, $len);
if ($unpacker->execute($str, $offset))
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
$str = "";
$offset = 0;
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array: empty', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

329
php/tests/061b.phpt
View File

@ -1,329 +0,0 @@
--TEST--
Check for unbuffered streaming unserialization
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
$str = "";
$offset = 0;
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str .= substr($serialized, $i, $len);
if ($unpacker->execute($str, $offset))
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
$str = "";
$offset = 0;
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array: empty', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

324
php/tests/061c.phpt
View File

@ -1,324 +0,0 @@
--TEST--
Check for unbuffered streaming unserialization
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
$unpacker = new MessagePackUnpacker();
$length = strlen($serialized);
$str = "";
$offset = 0;
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str .= substr($serialized, $i, $len);
if ($unpacker->execute($str, $offset))
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
$str = "";
$offset = 0;
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array: empty', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
["b:protected"]=>
int(5)
["c:private"]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
}
OK

64
php/tests/062.phpt
View File

@ -1,64 +0,0 @@
--TEST--
Extra bytes buffered streaming unserialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$unpacker = new MessagePackUnpacker();
foreach ($variable as $var)
{
$serialized = pack('H*', $var);
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
while (true) {
if ($unpacker->execute()) {
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
} else {
break;
}
}
$i += $len;
}
}
}
test('array(1, 2, 3)', array('9301020392'));
test('array(1, 2, 3), array(3, 9), 4', array('9301020392', '030904'));
--EXPECTF--
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
array(2) {
[0]=>
int(3)
[1]=>
int(9)
}
int(4)

68
php/tests/063.phpt
View File

@ -1,68 +0,0 @@
--TEST--
Extra bytes unbuffered streaming unserialization
--SKIPIF--
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
function test($type, $variable, $test = null) {
$unpacker = new MessagePackUnpacker();
$str = "";
$offset = 0;
foreach ($variable as $var)
{
$serialized = pack('H*', $var);
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str .= substr($serialized, $i, $len);
while (true) {
if ($unpacker->execute($str, $offset)) {
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
$str = substr($str, $offset);
$offset = 0;
} else {
break;
}
}
$i += $len;
}
}
}
test('array(1, 2, 3)', array('9301020392'));
test('array(1, 2, 3), array(3, 9), 4', array('9301020392', '030904'));
--EXPECTF--
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
array(2) {
[0]=>
int(3)
[1]=>
int(9)
}
int(4)

317
php/tests/064.phpt
View File

@ -1,317 +0,0 @@
--TEST--
Check for buffered streaming unserialization (single)
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$unpacker = new MessagePackUnpacker();
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
global $unpacker;
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

326
php/tests/064b.phpt
View File

@ -1,326 +0,0 @@
--TEST--
Check for buffered streaming unserialization (single)
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.3.0') < 0 &&
version_compare(PHP_VERSION, '5.2.14') >= 0) ||
(version_compare(PHP_VERSION, '5.3.3') >= 0)) {
echo "skip tests in PHP 5.2.13/5.3.2 or older";
}
if (version_compare(PHP_VERSION, '5.2.0') < 0) {
echo "skip tests in PHP 5.2 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$unpacker = new MessagePackUnpacker();
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
global $unpacker;
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

321
php/tests/064c.phpt
View File

@ -1,321 +0,0 @@
--TEST--
Check for buffered streaming unserialization (single)
--SKIPIF--
<?php
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
echo "skip tests in PHP 5.1 or older";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$unpacker = new MessagePackUnpacker();
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
global $unpacker;
$length = strlen($serialized);
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str = substr($serialized, $i, $len);
$unpacker->feed($str);
if ($unpacker->execute())
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
["b:protected"]=>
int(5)
["c:private"]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
["b:protected"]=>
int(2)
["c:private"]=>
int(3)
}
}
OK

322
php/tests/065.phpt
View File

@ -1,322 +0,0 @@
--TEST--
Check for unbuffered streaming unserialization (single)
--SKIPIF--
<?php
if ((version_compare(PHP_VERSION, '5.2.13') <= 0) ||
(version_compare(PHP_VERSION, '5.3.0') >= 0 &&
version_compare(PHP_VERSION, '5.3.2') <= 0)) {
echo "skip tests in PHP 5.2.14/5.3.3 or newer";
}
--FILE--
<?php
if(!extension_loaded('msgpack')) {
dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$unpacker = new MessagePackUnpacker();
function test($type, $variable, $test = null) {
$serialized = msgpack_serialize($variable);
global $unpacker;
$length = strlen($serialized);
$str = "";
$offset = 0;
for ($i = 0; $i < $length;) {
$len = rand(1, 10);
$str .= substr($serialized, $i, $len);
if ($unpacker->execute($str, $offset))
{
$unserialized = $unpacker->data();
var_dump($unserialized);
$unpacker->reset();
$str = "";
$offset = 0;
}
$i += $len;
}
if (!is_bool($test))
{
echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}
else
{
echo $test || $unserialized == $variable ? 'OK' : 'ERROR', PHP_EOL;
}
}
test('null', null);
test('bool: true', true);
test('bool: false', false);
test('zero: 0', 0);
test('small: 1', 1);
test('small: -1', -1);
test('medium: 1000', 1000);
test('medium: -1000', -1000);
test('large: 100000', 100000);
test('large: -100000', -100000);
test('double: 123.456', 123.456);
test('empty: ""', "");
test('string: "foobar"', "foobar");
test('array: empty', array(), false);
test('array(1, 2, 3)', array(1, 2, 3), false);
test('array(array(1, 2, 3), arr...', array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), false);
test('array("foo", "foo", "foo")', array("foo", "foo", "foo"), false);
test('array("one" => 1, "two" => 2))', array("one" => 1, "two" => 2), false);
test('array("kek" => "lol", "lol" => "kek")', array("kek" => "lol", "lol" => "kek"), false);
test('array("" => "empty")', array("" => "empty"), false);
$a = array('foo');
test('array($a, $a)', array($a, $a), false);
test('array(&$a, &$a)', array(&$a, &$a), false);
$a = array(null);
$b = array(&$a);
$a[0] = &$b;
test('cyclic', $a, true);
$a = array(
'a' => array(
'b' => 'c',
'd' => 'e'
),
'f' => array(
'g' => 'h'
)
);
test('array', $a, false);
class Obj {
public $a;
protected $b;
private $c;
function __construct($a, $b, $c) {
$this->a = $a;
$this->b = $b;
$this->c = $c;
}
}
test('object', new Obj(1, 2, 3), false);
test('object', array(new Obj(1, 2, 3), new Obj(4, 5, 6)), false);
$o = new Obj(1, 2, 3);
test('object', array(&$o, &$o), false);
--EXPECTF--
NULL
OK
bool(true)
OK
bool(false)
OK
int(0)
OK
int(1)
OK
int(-1)
OK
int(1000)
OK
int(-1000)
OK
int(100000)
OK
int(-100000)
OK
float(123.456)
OK
string(0) ""
OK
string(6) "foobar"
OK
array(0) {
}
OK
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
OK
array(3) {
[0]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
[1]=>
array(3) {
[0]=>
int(4)
[1]=>
int(5)
[2]=>
int(6)
}
[2]=>
array(3) {
[0]=>
int(7)
[1]=>
int(8)
[2]=>
int(9)
}
}
OK
array(3) {
[0]=>
string(3) "foo"
[1]=>
string(3) "foo"
[2]=>
string(3) "foo"
}
OK
array(2) {
["one"]=>
int(1)
["two"]=>
int(2)
}
OK
array(2) {
["kek"]=>
string(3) "lol"
["lol"]=>
string(3) "kek"
}
OK
array(1) {
[""]=>
string(5) "empty"
}
OK
array(2) {
[0]=>
array(1) {
[0]=>
string(3) "foo"
}
[1]=>
array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(2) {
[0]=>
&array(1) {
[0]=>
string(3) "foo"
}
[1]=>
&array(1) {
[0]=>
string(3) "foo"
}
}
OK
array(1) {
[0]=>
&array(1) {
[0]=>
&array(1) {
[0]=>
*RECURSION*
}
}
}
OK
array(2) {
["a"]=>
array(2) {
["b"]=>
string(1) "c"
["d"]=>
string(1) "e"
}
["f"]=>
array(1) {
["g"]=>
string(1) "h"
}
}
OK
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
OK
array(2) {
[0]=>
object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
object(Obj)#%d (3) {
["a"]=>
int(4)
[%r"?b"?:protected"?%r]=>
int(5)
[%r"?c"?:("Obj":)?private"?%r]=>
int(6)
}
}
OK
array(2) {
[0]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
[1]=>
&object(Obj)#%d (3) {
["a"]=>
int(1)
[%r"?b"?:protected"?%r]=>
int(2)
[%r"?c"?:("Obj":)?private"?%r]=>
int(3)
}
}
OK

Some files were not shown because too many files have changed in this diff Show More