static void php_bencode_decode_str(zval *return_value, char *str, size_t *pos, size_t *str_len) /* {{{ */
{
size_t len = 0;
smart_str buf = {0};
while (*pos < *str_len && str[*pos] != ':') {
smart_str_appendc(&buf, str[*pos]);
(*pos)++;
}
if (str[*pos] != ':') {
zend_error(E_WARNING, "Invaild bencoded-string, expected semicolon, stop at position %u.", *pos);
RETURN_NULL();
}
(*pos)++;
smart_str_0(&buf);
len = atoi(ZSTR_VAL(buf.s));
smart_str_free(&buf);
if (len > 0 && *pos + len - 1 < *str_len) {
size_t i;
for (i = 0; i < len; i++, (*pos)++) {
smart_str_appendc(&buf, str[*pos]);
}
smart_str_0(&buf);
RETVAL_STR(buf.s);
} else {
RETVAL_EMPTY_STRING();
}
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
php_json_encoder encoder;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
ZEND_PARSE_PARAMETERS_START(1, 3)
Z_PARAM_ZVAL_DEREF(parameter)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(options)
Z_PARAM_LONG(depth)
ZEND_PARSE_PARAMETERS_END();
php_json_encode_init(&encoder);
encoder.max_depth = (int)depth;
encoder.error_code = PHP_JSON_ERROR_NONE;
php_json_encode_zval(&buf, parameter, (int)options, &encoder);
JSON_G(error_code) = encoder.error_code;
if (encoder.error_code != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
RETURN_FALSE;
}
smart_str_0(&buf); /* copy? */
if (buf.s) {
RETURN_NEW_STR(buf.s);
}
RETURN_EMPTY_STRING();
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
php_json_encoder encoder;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|ll", ¶meter, &options, &depth) == FAILURE) {
return;
}
php_json_encode_init(&encoder);
encoder.max_depth = (int)depth;
encoder.error_code = PHP_JSON_ERROR_NONE;
php_json_encode_zval(&buf, parameter, (int)options, &encoder);
JSON_G(error_code) = encoder.error_code;
if (encoder.error_code != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
RETURN_FALSE;
}
smart_str_0(&buf); /* copy? */
if (buf.s) {
RETURN_NEW_STR(buf.s);
}
RETURN_EMPTY_STRING();
}
/* {{{ HELPER FUNCTIONS */
static void php_filter_encode_html(zval *value, const unsigned char *chars)
{
smart_str str = {0};
size_t len = Z_STRLEN_P(value);
unsigned char *s = (unsigned char *)Z_STRVAL_P(value);
unsigned char *e = s + len;
if (Z_STRLEN_P(value) == 0) {
return;
}
while (s < e) {
if (chars[*s]) {
smart_str_appendl(&str, "&#", 2);
smart_str_append_unsigned(&str, (zend_ulong)*s);
smart_str_appendc(&str, ';');
} else {
/* XXX: this needs to be optimized to work with blocks of 'safe' chars */
smart_str_appendc(&str, *s);
}
s++;
}
smart_str_0(&str);
zval_ptr_dtor(value);
ZVAL_NEW_STR(value, str.s);
}
static inline long
hs_response_recv(php_stream *stream, char *recv, size_t size TSRMLS_DC)
{
long ret;
#ifdef HS_DEBUG
long i;
smart_str debug = {0};
#endif
ret = php_stream_read(stream, recv, size);
if (ret <= 0) {
return -1;
}
recv[size] = '\0';
#ifdef HS_DEBUG
for (i = 0; i < ret; i++) {
if ((unsigned char)recv[i] == HS_CODE_NULL) {
smart_str_appendl_ex(&debug, "\\0", strlen("\\0"), 1);
} else {
smart_str_appendc(&debug, recv[i]);
}
}
smart_str_0(&debug);
php_printf("[handlersocket] (recv) %ld : \"%s\"", ret, debug.c);
smart_str_free(&debug);
#endif
return ret;
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|ll", ¶meter, &options, &depth) == FAILURE) {
return;
}
JSON_G(error_code) = PHP_JSON_ERROR_NONE;
JSON_G(encode_max_depth) = (int)depth;
php_json_encode(&buf, parameter, (int)options);
if (JSON_G(error_code) != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
ZVAL_FALSE(return_value);
} else {
smart_str_0(&buf); /* copy? */
ZVAL_NEW_STR(return_value, buf.s);
}
}
ONPHP_METHOD(ExtractPart, toDialectString)
{
zval *dialect, *what, *from, *whatString, *fromString;
smart_str string = {0};
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
what = ONPHP_READ_PROPERTY(getThis(), "what");
from = ONPHP_READ_PROPERTY(getThis(), "from");
ONPHP_CALL_METHOD_0(what, "tostring", &whatString);
ONPHP_CALL_METHOD_1_NORET(from, "todialectstring", &fromString, dialect);
if (EG(exception)) {
ZVAL_FREE(whatString);
return;
}
smart_str_appendl(&string, "EXTRACT(", 8);
onphp_append_zval_to_smart_string(&string, whatString);
smart_str_appendl(&string, " FROM ", 6);
onphp_append_zval_to_smart_string(&string, fromString);
smart_str_appendc(&string, ')');
smart_str_0(&string);
zval_ptr_dtor(&whatString);
zval_ptr_dtor(&fromString);
RETURN_STRINGL(string.c, string.len, 0);
}
static void php_bencode_decode_int(zval *return_value, char *str, size_t *pos, size_t *str_len) /* {{{ */
{
int len = 0;
double d;
smart_str buf = {0};
(*pos)++;
while (*pos < *str_len && str[*pos] != PHP_BENCODE_END_STRUCTURE) {
smart_str_appendc(&buf, str[*pos]);
(*pos)++;
len++;
}
smart_str_0(&buf);
if (str[*pos] != PHP_BENCODE_END_STRUCTURE) {
smart_str_free(&buf);
zend_error(E_WARNING, "Invaild bencoded-integer, expected 'e'.");
RETURN_NULL();
}
(*pos)++;
ZVAL_STRINGL(return_value, ZSTR_VAL(buf.s), len);
d = zend_strtod(ZSTR_VAL(buf.s), NULL);
if (d <= ZEND_LONG_MAX && d >= ZEND_LONG_MIN) {
convert_to_long(return_value);
}
smart_str_free(&buf);
}
ZEND_API zend_string *zend_print_zval_r_to_str(zval *expr, int indent) /* {{{ */
{
smart_str buf = {0};
zend_print_zval_r_to_buf(&buf, expr, indent);
smart_str_0(&buf);
return buf.s;
}
static int phalcon_cssmin_internal(zval *return_value, zval *style, const char **error) {
int i;
unsigned char c;
cssmin_parser parser;
smart_str minified = {0};
parser.tmp_state = 0;
parser.state = 1;
parser.last_state = 1;
parser.in_paren = 0;
parser.style = style;
parser.error = NULL;
parser.minified = &minified;
for (i = 0; i < Z_STRLEN_P(style); i++) {
parser.style_pointer = i + 1;
c = phalcon_cssmin_machine(&parser, Z_STRVAL_P(style)[i]);
if (c != 0) {
smart_str_appendc(parser.minified, c);
}
i = parser.style_pointer - 1;
}
smart_str_0(&minified);
if (minified.s) {
ZVAL_STRINGL(return_value, minified.s->val, minified.s->len);
} else {
ZVAL_EMPTY_STRING(return_value);
}
*error = parser.error;
return SUCCESS;
}
/**
* Writes the meta-data to files
*
* @param string $key
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Files, write){
zval **key, **data, *meta_data_dir, *virtual_key;
zval *path, *php_export, *status;
smart_str exp = { NULL, 0, 0 };
phalcon_fetch_params_ex(2, 0, &key, &data);
PHALCON_MM_GROW();
meta_data_dir = phalcon_fetch_nproperty_this(this_ptr, SL("_metaDataDir"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(virtual_key);
phalcon_prepare_virtual_path_ex(virtual_key, Z_STRVAL_PP(key), Z_STRLEN_PP(key), '_' TSRMLS_CC);
PHALCON_INIT_VAR(path);
PHALCON_CONCAT_VVS(path, meta_data_dir, virtual_key, ".php");
smart_str_appends(&exp, "<?php return ");
php_var_export_ex(data, 0, &exp TSRMLS_CC);
smart_str_appendc(&exp, ';');
smart_str_0(&exp);
PHALCON_INIT_VAR(php_export);
ZVAL_STRINGL(php_export, exp.c, exp.len, 0);
PHALCON_INIT_VAR(status);
phalcon_file_put_contents(status, path, php_export TSRMLS_CC);
if (PHALCON_IS_FALSE(status)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Meta-Data directory cannot be written");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Writes parsed annotations to files
*
* @param string $key
* @param Phalcon\Annotations\Reflection $data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){
zval *key, *data, annotations_dir = {}, virtual_key = {}, path = {}, php_export = {}, status = {};
smart_str exp = { 0 };
phalcon_fetch_params(0, 2, 0, &key, &data);
PHALCON_ENSURE_IS_STRING(key);
phalcon_return_property(&annotations_dir, getThis(), SL("_annotationsDir"));
/**
* Paths must be normalized before be used as keys
*/
phalcon_prepare_virtual_path_ex(&virtual_key, Z_STRVAL_P(key), Z_STRLEN_P(key), '_');
PHALCON_CONCAT_VVS(&path, &annotations_dir, &virtual_key, ".php");
smart_str_appends(&exp, "<?php return ");
php_var_export_ex(data, 0, &exp);
smart_str_appendc(&exp, ';');
smart_str_0(&exp);
ZVAL_STR(&php_export, exp.s);
phalcon_file_put_contents(&status, &path, &php_export);
if (PHALCON_IS_FALSE(&status)) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_annotations_exception_ce, "Annotations directory cannot be written");
return;
}
}
ZEND_METHOD(Vedis, msetnx)
{
zval **val, *members;
int key_len;
HashPosition pos;
size_t n;
VEDIS_PARAM(MSETNX, 6);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
&members) == FAILURE) {
return;
}
VEDIS_SELF(intern);
n = zend_hash_num_elements(HASH_OF(members));
if (n == 0) {
RETURN_FALSE;
}
VEDIS_ARGS_INIT(n * 2);
zend_hash_internal_pointer_reset_ex(HASH_OF(members), &pos);
while (zend_hash_get_current_data_ex(HASH_OF(members),
(void **)&val, &pos) == SUCCESS) {
char *str_key;
uint str_key_len;
long num_key;
int flags;
flags = zend_hash_get_current_key_ex(HASH_OF(members),
&str_key, &str_key_len,
&num_key, 0, &pos);
if (flags == HASH_KEY_NON_EXISTANT) {
break;
}
if (Z_TYPE_PP(val) != IS_STRING) {
convert_to_string(*val);
}
if (flags == HASH_KEY_IS_STRING) {
VEDIS_ARGS_STRING(str_key, str_key_len - 1);
} else {
smart_str buf = {0};
smart_str_append_long(&buf, num_key);
smart_str_0(&buf);
VEDIS_ARGS_STRING(buf.c, buf.len);
smart_str_free(&buf);
}
VEDIS_ARGS_STRING(Z_STRVAL_PP(val), Z_STRLEN_PP(val));
zend_hash_move_forward_ex(HASH_OF(members), &pos);
}
VEDIS_ARGS_EXEC(RETURN_FALSE);
VEDIS_RETURN_BOOL();
}
/**
* var_export returns php variables without using the PHP userland
*/
void phalcon_var_export_ex(zval *return_value, zval *var) {
smart_str buf = { 0 };
php_var_export_ex(var, 1, &buf);
smart_str_0(&buf);
ZVAL_STR(return_value, buf.s);
}
/** {{{ zend_string * yaf_route_simple_assemble(zval *info, zval *query)
*/
zend_string * yaf_route_simple_assemble(yaf_route_t *this_ptr, zval *info, zval *query) {
smart_str tvalue = {0};
zval *nmodule, *ncontroller, *naction;
smart_str_appendc(&tvalue, '?');
nmodule = zend_read_property(yaf_route_simple_ce,
this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_MODULE), 1, NULL);
ncontroller = zend_read_property(yaf_route_simple_ce,
this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_CONTROLLER), 1, NULL);
naction = zend_read_property(yaf_route_simple_ce,
this_ptr, ZEND_STRL(YAF_ROUTE_SIMPLE_VAR_NAME_ACTION), 1, NULL);
do {
zval *tmp;
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_MOUDLE_FORMAT))) != NULL) {
smart_str_appendl(&tvalue, Z_STRVAL_P(nmodule), Z_STRLEN_P(nmodule));
smart_str_appendc(&tvalue, '=');
smart_str_appendl(&tvalue, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_appendc(&tvalue, '&');
}
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_CONTROLLER_FORMAT))) == NULL) {
yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "You need to specify the controller by ':c'");
break;
}
smart_str_appendl(&tvalue, Z_STRVAL_P(ncontroller), Z_STRLEN_P(ncontroller));
smart_str_appendc(&tvalue, '=');
smart_str_appendl(&tvalue, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
smart_str_appendc(&tvalue, '&');
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_ACTION_FORMAT))) == NULL) {
yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "You need to specify the action by ':a'");
break;
}
smart_str_appendl(&tvalue, Z_STRVAL_P(naction), Z_STRLEN_P(naction));
smart_str_appendc(&tvalue, '=');
smart_str_appendl(&tvalue, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
if (query && IS_ARRAY == Z_TYPE_P(query)) {
zend_string *key;
ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(query), key, tmp) {
if (IS_STRING == Z_TYPE_P(tmp) && key) {
smart_str_appendc(&tvalue, '&');
smart_str_appendl(&tvalue, ZSTR_VAL(key), ZSTR_LEN(key));
smart_str_appendc(&tvalue, '=');
smart_str_appendl(&tvalue, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
}
} ZEND_HASH_FOREACH_END();
}
smart_str_0(&tvalue);
return tvalue.s;
} while (0);
ONPHP_METHOD(Joiner, toDialectString)
{
zval
*dialect,
*from = ONPHP_READ_PROPERTY(getThis(), "from"),
*table;
zend_class_entry **cep;
smart_str string = {0};
unsigned int i = 0, count = zend_hash_num_elements(Z_ARRVAL_P(from));
if (!count) {
RETURN_NULL();
} else {
smart_str_appendl(&string, " FROM ", 6);
}
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
ONPHP_FIND_FOREIGN_CLASS("SelectQuery", cep);
for (i = 0; i < count; ++i) {
zval *out;
ONPHP_ARRAY_GET(from, i, table);
if (i == 0) {
/* nop */
} else {
if (ONPHP_INSTANCEOF(from, FromTable)) {
zval *name;
ONPHP_CALL_METHOD_0(table, "gettable", &name);
if (instanceof_function(Z_OBJCE_P(table), *cep TSRMLS_CC)) {
smart_str_appendl(&string, ", ", 2);
} else {
smart_str_appendc(&string, ' ');
}
zval_ptr_dtor(&name);
} else {
smart_str_appendc(&string, ' ');
}
}
ONPHP_CALL_METHOD_1(table, "todialectstring", &out, dialect);
onphp_append_zval_to_smart_string(&string, out);
zval_ptr_dtor(&out);
}
smart_str_0(&string);
RETURN_STRINGL(string.c, string.len, 0);
}
void mic_time(smart_str *buf)
{
struct timeval now;
timerclear(&now);
gettimeofday(&now, NULL);
smart_str_append_long(buf,(long)time(NULL));
smart_str_appendc(buf,'.');
smart_str_append_long(buf,(long)now.tv_usec / 1000);
smart_str_0(buf);
}
ONPHP_METHOD(DBField, toDialectString)
{
smart_str string = {0};
zval *table, *field, *dialect, *cast, *quoted;
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
table = ONPHP_READ_PROPERTY(getThis(), "table");
field = ONPHP_READ_PROPERTY(getThis(), "field");
cast = ONPHP_READ_PROPERTY(getThis(), "cast");
// either null or instance of DialectString
if (Z_TYPE_P(table) == IS_OBJECT) {
zval *tmp;
ONPHP_CALL_METHOD_1(table, "todialectstring", &tmp, dialect);
onphp_append_zval_to_smart_string(&string, tmp);
zval_ptr_dtor(&tmp);
smart_str_appendc(&string, '.');
}
ONPHP_CALL_METHOD_1(dialect, "quotefield", "ed, field);
onphp_append_zval_to_smart_string(&string, quoted);
zval_ptr_dtor("ed);
smart_str_0(&string);
if (Z_STRLEN_P(cast)) {
zval *tmp, *out;
ALLOC_INIT_ZVAL(tmp);
ZVAL_STRINGL(tmp, string.c, string.len, 1);
ONPHP_CALL_METHOD_2_NORET(dialect, "tocasted", &out, tmp, cast);
ZVAL_FREE(tmp);
smart_str_free(&string);
if (EG(exception)) {
return;
}
RETURN_ZVAL(out, 1, 1);
}
RETURN_STRINGL(string.c, string.len, 0);
}
/** {{{ to_indexed
*/
static zval * to_indexed(zval * keys, char * query, int len) {
zval * sql = NULL;
char ch = 0;
int i = 0;
smart_str skey = {NULL, 0, 0};
smart_str ssql = {NULL, 0, 0};
for(i=0; i<len; i++) {
ch = *(query + i);
if (ch == ':') {
for (i++; i < len; i++) {
ch = *(query + i);
/* [a-zA-Z0-9_]+ */
if ((ch > 96 && ch < 123)
|| (ch > 64 && ch < 91)
|| (ch > 47 && ch < 58)
|| ch == 95
) {
smart_str_appendc(&skey, ch);
} else {
break;
}
}
smart_str_appendc(&ssql, '?');
smart_str_appendc(&ssql, ch);
smart_str_0(&skey);
if (ssql.len) {
add_next_index_stringl(keys, skey.c, skey.len, 1);
}
smart_str_free(&skey);
} else {
smart_str_appendc(&ssql, ch);
}
}
MAKE_STD_ZVAL(sql);
if (ssql.len) {
ZVAL_STRINGL(sql, ssql.c, ssql.len, 1);
}else{
ZVAL_STRINGL(sql, "", 0, 1);
}
smart_str_free(&skey);
smart_str_free(&ssql);
return sql;
}
/* {{{ proto mixed hstore_encode(array hstore)
Decodes the hStore representation into a PHP value */
static PHP_FUNCTION(hstore_encode)
{
zval *array, *value;
zend_ulong num_idx;
zend_string *str_idx;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {
return;
}
smart_str buf = {};
smart_str_alloc(&buf, 2048, 0);
zend_bool need_comma = 0;
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, value) {
if (need_comma) {
smart_str_appendl(&buf, ", ", 2);
} else {
need_comma = 1;
}
smart_str_appendc(&buf, '"');
if (str_idx) {
escape_string(&buf, str_idx);
} else {
smart_str_append_long(&buf, (long) num_idx);
}
smart_str_appendl(&buf, "\"=>", 3);
if (Z_TYPE_P(value) == IS_NULL) {
smart_str_appendl(&buf, "NULL", 4);
} else {
convert_to_string_ex(value);
smart_str_appendc(&buf, '"');
zend_string *str = zval_get_string(value);
escape_string(&buf, str);
zend_string_release(str);
smart_str_appendc(&buf, '"');
}
} ZEND_HASH_FOREACH_END();
smart_str_0(&buf); /* copy? */
ZVAL_NEW_STR(return_value, buf.s);
}
static zend_string *ast_version_info() {
smart_str str = {0};
size_t i;
smart_str_appends(&str, "Current version is ");
smart_str_append_long(&str, AST_CURRENT_VERSION);
smart_str_appends(&str, ". All versions (including experimental): {");
for (i = 0; i < versions_count; ++i) {
if (i != 0) smart_str_appends(&str, ", ");
smart_str_append_long(&str, versions[i]);
}
smart_str_appends(&str, "}");
smart_str_0(&str);
return str.s;
}
PHP_METHOD(TypeCollection, __toString)
{
cassandra_type *self;
smart_str string = PHP5TO7_SMART_STR_INIT;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
php_cassandra_type_string(self, &string TSRMLS_CC);
smart_str_0(&string);
PHP5TO7_RETVAL_STRING(PHP5TO7_SMART_STR_VAL(string));
smart_str_free(&string);
}
ZEND_API zend_string *zend_vstrpprintf(size_t max_len, const char *format, va_list ap) /* {{{ */
{
smart_str buf = {0};
zend_printf_to_smart_str(&buf, format, ap);
if (!buf.s) {
return ZSTR_EMPTY_ALLOC();
}
if (max_len && ZSTR_LEN(buf.s) > max_len) {
ZSTR_LEN(buf.s) = max_len;
}
smart_str_0(&buf);
return buf.s;
}
/* {{{ internalSubset string
readonly=yes
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-internalSubset
Since: DOM Level 2
*/
int dom_documenttype_internal_subset_read(dom_object *obj, zval *retval)
{
xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
xmlDtdPtr intsubset;
if (dtdptr == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
if (dtdptr->doc != NULL && ((intsubset = xmlGetIntSubset(dtdptr->doc)) != NULL)) {
smart_str ret_buf = {0};
xmlNodePtr cur = intsubset->children;
while (cur != NULL) {
xmlOutputBuffer *buff = xmlAllocOutputBuffer(NULL);
if (buff != NULL) {
xmlNodeDumpOutput (buff, NULL, cur, 0, 0, NULL);
xmlOutputBufferFlush(buff);
#ifdef LIBXML2_NEW_BUFFER
smart_str_appendl(&ret_buf, (const char *) xmlOutputBufferGetContent(buff), xmlOutputBufferGetSize(buff));
#else
smart_str_appendl(&ret_buf, (char *) buff->buffer->content, buff->buffer->use);
#endif
(void)xmlOutputBufferClose(buff);
}
cur = cur->next;
}
if (ret_buf.s) {
smart_str_0(&ret_buf);
ZVAL_NEW_STR(retval, ret_buf.s);
return SUCCESS;
}
}
ZVAL_NULL(retval);
return SUCCESS;
}
int php_ds_default_cast_object(zval *obj, zval *return_value, int type)
{
switch (type) {
case IS_STRING: {
smart_str buffer = {0};
smart_str_appendl(&buffer, "object(", 7);
smart_str_append (&buffer, Z_OBJCE_P(obj)->name);
smart_str_appendc(&buffer, ')');
smart_str_0(&buffer);
ZVAL_STR(return_value, buffer.s);
return SUCCESS;
}
}
return FAILURE;
}
int php_ds_pair_serialize(zval *object, unsigned char **buffer, size_t *length, zend_serialize_data *data)
{
smart_str buf = {0};
ds_pair_t *pair = Z_DS_PAIR_P(object);
php_serialize_data_t serialize_data = (php_serialize_data_t) data;
PHP_VAR_SERIALIZE_INIT(serialize_data);
php_var_serialize(&buf, &pair->key, &serialize_data);
php_var_serialize(&buf, &pair->value, &serialize_data);
smart_str_0(&buf);
SERIALIZE_SET_ZSTR(buf.s);
zend_string_release(buf.s);
PHP_VAR_SERIALIZE_DESTROY(serialize_data);
return SUCCESS;
}
zend_string *ds_join_zval_buffer(
zval *buffer,
zend_long size,
char *glue,
size_t len
) {
smart_str str = {0};
if (size <= 0) {
return ZSTR_EMPTY_ALLOC();
}
if (size == 1) {
return zval_get_string(buffer);
}
// Glue is optional, will use empty string by default if NULL
if (glue && len) {
zval *pos = buffer;
zval *end = buffer + size - 1; // Exclude last value
// Append each part and the glue right up to the last value.
do {
smart_str_appendz(&str, pos);
smart_str_appendl(&str, glue, len);
} while (++pos != end);
// Append last value
smart_str_appendz(&str, pos);
} else {
zval *pos = buffer;
zval *end = buffer + size;
// Append each part including the last, without glue.
do {
smart_str_appendz(&str, pos);
} while (++pos != end);
}
smart_str_0(&str);
return str.s;
}
/* ERRORS */
static void do_from_to_zval_err(struct err_s *err,
zend_llist *keys,
const char *what_conv,
const char *fmt,
va_list ap)
{
smart_str path = {0};
const char **node;
char *user_msg;
int user_msg_size;
zend_llist_position pos;
if (err->has_error) {
return;
}
for (node = zend_llist_get_first_ex(keys, &pos);
node != NULL;
node = zend_llist_get_next_ex(keys, &pos)) {
smart_str_appends(&path, *node);
smart_str_appends(&path, " > ");
}
if (path.s && path.s->len > 3) {
path.s->len -= 3;
}
smart_str_0(&path);
user_msg_size = vspprintf(&user_msg, 0, fmt, ap);
err->has_error = 1;
err->level = E_WARNING;
spprintf(&err->msg, 0, "error converting %s data (path: %s): %.*s",
what_conv,
path.s && *path.s->val != '\0' ? path.s->val : "unavailable",
user_msg_size, user_msg);
err->should_free = 1;
efree(user_msg);
smart_str_free(&path);
}
/* {{{ proto string SplDoublyLinkedList::serialize()
Serializes storage */
SPL_METHOD(SplDoublyLinkedList, serialize)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
smart_str buf = {0};
spl_ptr_llist_element *current = intern->llist->head, *next;
zval flags;
php_serialize_data_t var_hash;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
PHP_VAR_SERIALIZE_INIT(var_hash);
/* flags */
ZVAL_LONG(&flags, intern->flags);
php_var_serialize(&buf, &flags, &var_hash);
zval_ptr_dtor(&flags);
/* elements */
while (current) {
smart_str_appendc(&buf, ':');
next = current->next;
php_var_serialize(&buf, ¤t->data, &var_hash);
current = next;
}
smart_str_0(&buf);
/* done */
PHP_VAR_SERIALIZE_DESTROY(var_hash);
if (buf.s) {
RETURN_STR(buf.s);
} else {
RETURN_NULL();
}
} /* }}} */
ONPHP_METHOD(DBBinary, toDialectString)
{
zval *dialect, *value, *quoted;
smart_str string = {0};
ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);
ONPHP_CALL_METHOD_0(getThis(), "getvalue", &value);
ONPHP_CALL_METHOD_1(dialect, "quotebinary", "ed, value);
zval_ptr_dtor(&value);
smart_str_appendc(&string, '\'');
onphp_append_zval_to_smart_string(&string, quoted);
zval_ptr_dtor("ed);
smart_str_appendc(&string, '\'');
smart_str_0(&string);
RETURN_STRINGL(string.c, string.len, 0);
}
