}
case IS_BOOL:
if (Z_LVAL_P(expr)) {
- // TODO: ??? use interned string
+ // TODO: use interned string ???
ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
} else {
TSRMLS_FETCH();
break;
case IS_ARRAY:
zend_error(E_NOTICE, "Array to string conversion");
- // TODO: ??? use interned string
+ // TODO: use interned string ???
ZVAL_NEW_STR(expr_copy, STR_INIT("Array", sizeof("Array") - 1, 0));
break;
case IS_OBJECT:
ZEND_API void free_string_zval(zval *zv);
END_EXTERN_C()
-/* FIXME: Check if we can save if (ptr) too */
-
-//???#define STR_FREE(ptr) if (ptr) { str_efree(ptr); }
-//???#define STR_FREE_REL(ptr) if (ptr) { str_efree_rel(ptr); }
-
/* output support */
#define ZEND_WRITE(str, str_len) zend_write((str), (str_len))
#define ZEND_WRITE_EX(str, str_len) write_func((str), (str_len))
} \
} while (0)
-//??? this macro should be used to get argument value passed by referebce
-//??? unfortunately it's not always work as expected
-#if 0
-#define ZVAL_DEREF_REF(z) do { \
- ZEND_ASSERT(Z_ISREF_P(z)); \
- (z) = Z_REFVAL_P(z); \
- } while (0)
-#else
-#define ZVAL_DEREF_REF(z) \
- ZVAL_DEREF(z)
-#endif
-
#define ZVAL_DUP_DEREF(z, v) \
do { \
zval *__z1 = (z); \
efree(ref); \
} while (0)
-// TODO: invalud ???
-#define INIT_PZVAL_COPY(z, v) \
- do { \
- ZVAL_COPY_VALUE(z, v); \
- Z_SET_REFCOUNT_P(z, 1); \
- Z_UNSET_ISREF_P(z); \
- } while (0)
-
#define SEPARATE_ZVAL(zv) do { \
zval *_zv = (zv); \
if (Z_REFCOUNTED_P(_zv)) { \
} \
} while (0)
-
-// TODO: remove ???
-#define COPY_PZVAL_TO_ZVAL(zv, pzv) \
- ZVAL_COPY_VALUE(&(zv), (pzv)); \
- if (Z_OPT_REFCOUNTED_P(pzv)) { \
- if (Z_REFCOUNT_P(pzv)>1) { \
- zval_copy_ctor(&(zv)); \
- Z_DELREF_P((pzv)); \
- } \
- } \
-
-// TODO: remove ???
-#define REPLACE_ZVAL_VALUE(ppzv_dest, pzv_src, copy) { \
- int is_ref, refcount; \
- \
- SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest); \
- is_ref = Z_ISREF_PP(ppzv_dest); \
- refcount = Z_REFCOUNT_PP(ppzv_dest); \
- zval_dtor(*ppzv_dest); \
- ZVAL_COPY_VALUE(*ppzv_dest, pzv_src); \
- if (copy) { \
- zval_opt_copy_ctor(*ppzv_dest); \
- } \
- Z_SET_ISREF_TO_PP(ppzv_dest, is_ref); \
- Z_SET_REFCOUNT_PP(ppzv_dest, refcount); \
-}
-
#define SEPARATE_ARG_IF_REF(varptr) do { \
zval *_varptr = (varptr); \
if (Z_ISREF_P(_varptr)) { \
int i;
if (class_type->default_properties_count) {
-//??? object->properties_table = emalloc(sizeof(zval*) * class_type->default_properties_count);
for (i = 0; i < class_type->default_properties_count; i++) {
#if ZTS
ZVAL_DUP(&object->properties_table[i], &class_type->default_properties_table[i]);
}
/* }}} */
-ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate) /* {{{ */
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str) /* {{{ */
{
zval *ret, tmp;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
return ret ? SUCCESS : FAILURE;
}
/* }}} */
-ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length) /* {{{ */
{
zval *ret, tmp;
-//??? ZVAL_STRINGL(tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
return ret ? SUCCESS : FAILURE;
}
/* }}} */
-ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int duplicate) /* {{{ */
+ZEND_API int add_index_string(zval *arg, ulong index, const char *str) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
}
/* }}} */
-ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRINGL(tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
-
return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
}
/* }}} */
}
/* }}} */
-ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate) /* {{{ */
+ZEND_API int add_next_index_string(zval *arg, const char *str) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRING(&tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
}
/* }}} */
-ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRINGL(&tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
}
}
/* }}} */
-ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate) /* {{{ */
+ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str) /* {{{ */
{
zval tmp, *ret;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
return ret;
}
/* }}} */
-ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length) /* {{{ */
{
zval tmp, *ret;
-//??? ZVAL_STRING(tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
return ret;
{
zval tmp;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STR(&tmp, str);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
}
/* }}} */
-ZEND_API zval *add_get_index_string(zval *arg, ulong index, const char *str, int duplicate) /* {{{ */
+ZEND_API zval *add_get_index_string(zval *arg, ulong index, const char *str) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
}
/* }}} */
-ZEND_API zval *add_get_index_stringl(zval *arg, ulong index, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API zval *add_get_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */
{
zval tmp;
-//??? ZVAL_STRINGL(tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
}
}
/* }}} */
-ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC) /* {{{ */
+ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC) /* {{{ */
{
zval tmp;
zval z_key;
-//??? ZVAL_STRING(tmp, str, duplicate);
ZVAL_STRING(&tmp, str);
ZVAL_STRINGL(&z_key, key, key_len);
Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
}
/* }}} */
-ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate TSRMLS_DC) /* {{{ */
+ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length TSRMLS_DC) /* {{{ */
{
zval tmp;
zval z_key;
-//??? ZVAL_STRINGL(tmp, str, length, duplicate);
ZVAL_STRINGL(&tmp, str, length);
ZVAL_STRINGL(&z_key, key, key_len);
Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r);
ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
ZEND_API int add_assoc_str_ex(zval *arg, const char *key, uint key_len, zend_string *str);
-ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
-ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str);
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length);
ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key), __r)
#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
#define add_assoc_str(__arg, __key, __str) add_assoc_str_ex(__arg, __key, strlen(__key), __str)
-#define add_assoc_string(__arg, __key, __str, __duplicate) add_assoc_string_ex(__arg, __key, strlen(__key), __str, __duplicate)
-#define add_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length, __duplicate)
+#define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
+#define add_assoc_stringl(__arg, __key, __str, __length) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
/* unset() functions are only suported for legacy modules and null() functions should be used */
ZEND_API int add_index_resource(zval *arg, ulong idx, zend_resource *r);
ZEND_API int add_index_double(zval *arg, ulong idx, double d);
ZEND_API int add_index_str(zval *arg, ulong idx, zend_string *str);
-ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
-ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
+ZEND_API int add_index_string(zval *arg, ulong idx, const char *str);
+ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length);
ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
ZEND_API int add_next_index_long(zval *arg, long n);
ZEND_API int add_next_index_resource(zval *arg, zend_resource *r);
ZEND_API int add_next_index_double(zval *arg, double d);
ZEND_API int add_next_index_str(zval *arg, zend_string *str);
-ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
-ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
+ZEND_API int add_next_index_string(zval *arg, const char *str);
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length);
ZEND_API int add_next_index_zval(zval *arg, zval *value);
-ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate);
-ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate);
+ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str);
+ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length);
-#define add_get_assoc_string(__arg, __key, __str, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key), __str, __duplicate)
-#define add_get_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length, __duplicate)
+#define add_get_assoc_string(__arg, __key, __str) add_get_assoc_string_ex(__arg, __key, strlen(__key), __str)
+#define add_get_assoc_stringl(__arg, __key, __str, __length) add_get_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
ZEND_API zval *add_get_index_long(zval *arg, ulong idx, long l);
ZEND_API zval *add_get_index_double(zval *arg, ulong idx, double d);
ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str);
-ZEND_API zval *add_get_index_string(zval *arg, ulong idx, const char *str, int duplicate);
-ZEND_API zval *add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
+ZEND_API zval *add_get_index_string(zval *arg, ulong idx, const char *str);
+ZEND_API zval *add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length);
ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC);
ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r TSRMLS_DC);
ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
-ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
-ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate TSRMLS_DC);
+ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC);
+ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length TSRMLS_DC);
ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n TSRMLS_CC)
#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b TSRMLS_CC)
#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r TSRMLS_CC)
#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d TSRMLS_CC)
-#define add_property_string(__arg, __key, __str, __duplicate) add_property_string_ex(__arg, __key, strlen(__key), __str, __duplicate TSRMLS_CC)
-#define add_property_stringl(__arg, __key, __str, __length, __duplicate) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length, __duplicate TSRMLS_CC)
+#define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str TSRMLS_CC)
+#define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length TSRMLS_CC)
#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value TSRMLS_CC)
END_EXTERN_C()
#if ZEND_DEBUG
-#define CHECK_ZVAL_STRING(z) \
- if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
-#define CHECK_ZVAL_STRING_REL(z) \
- if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", Z_STRVAL_P(z) ZEND_FILE_LINE_RELAY_CC); }
+#define CHECK_ZVAL_STRING(str) \
+ if ((str)->val[(str)->len] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", (str)->val); }
+#define CHECK_ZVAL_STRING_REL(str) \
+ if ((str)->val[(str)->len] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", (str)->val ZEND_FILE_LINE_RELAY_CC); }
#else
#define CHECK_ZVAL_STRING(z)
#define CHECK_ZVAL_STRING_REL(z)
#define RETURN_ZVAL_FAST(z) { RETVAL_ZVAL_FAST(z); return; }
-#define SET_VAR_STRING(n, v) { \
- { \
- zval *var; \
- ALLOC_ZVAL(var); \
- ZVAL_STRING(var, v, 0); \
- ZEND_SET_GLOBAL_VAR(n, var); \
- } \
- }
-
-#define SET_VAR_STRINGL(n, v, l) { \
- { \
- zval *var; \
- ALLOC_ZVAL(var); \
- ZVAL_STRINGL(var, v, l, 0); \
- ZEND_SET_GLOBAL_VAR(n, var); \
- } \
- }
-
-#define SET_VAR_LONG(n, v) { \
- { \
- zval *var; \
- ALLOC_ZVAL(var); \
- ZVAL_LONG(var, v); \
- ZEND_SET_GLOBAL_VAR(n, var); \
- } \
- }
-
-#define SET_VAR_DOUBLE(n, v) { \
- { \
- zval *var; \
- ALLOC_ZVAL(var); \
- ZVAL_DOUBLE(var, v); \
- ZEND_SET_GLOBAL_VAR(n, var); \
- } \
- }
-
-
-#define ZEND_SET_SYMBOL(symtable, name, var) \
- { \
- char *_name = (name); \
- \
- ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name), var, 1, 0); \
- }
-
-#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref) \
- { \
- zval *orig_var; \
- \
- if ((orig_var = zend_hash_str_find(symtable, (name), (name_length))) != NULL \
- && Z_ISREF_P(orig_var)) { \
- if (Z_REFCOUNTED_P(var)) { \
- Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(orig_var)); \
- if (_refcount) { \
- Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1); \
- } \
- } \
- zval_dtor(orig_var); \
- ZVAL_COPY_VALUE(orig_var, var); \
- /*???FREE_ZVAL(var);*/ \
- } else { \
- /*???Z_SET_ISREF_TO_P(var, _is_ref);*/ \
- if (_refcount && Z_REFCOUNTED_P(var)) { \
- Z_SET_REFCOUNT_P(var, _refcount); \
- } \
- zend_hash_str_update(symtable, (name), (name_length), var); \
- } \
- }
-
-
-#define ZEND_SET_GLOBAL_VAR(name, var) \
- ZEND_SET_SYMBOL(&EG(symbol_table).ht, name, var)
-
-#define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref) \
- ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table).ht, name, name_length, var, _refcount, _is_ref)
-
-#define ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask) \
-{ \
- char *_name = (name); \
- int namelen = strlen(_name); \
- zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC); \
-}
-
#define HASH_OF(p) (Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p) TSRMLS_CC) : NULL)))
#define ZVAL_IS_NULL(z) (Z_TYPE_P(z) == IS_NULL)
#define ZVAL_IS_UNDEF(z) (Z_TYPE_P(z) == IS_UNDEF)
#define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
#define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
-//???#define safe_estrdup(ptr) ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
-//???#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
-
ZEND_API int zend_set_memory_limit(size_t memory_limit TSRMLS_DC);
ZEND_API void start_memory_manager(TSRMLS_D);
return;
}
- ZVAL_DEREF_REF(array);
+ ZVAL_DEREF(array);
target_hash = HASH_OF(array);
if (!target_hash) {
zend_error(E_WARNING,"Variable passed to each() is not an array or object");
/* add value elements */
if (Z_ISREF_P(entry)) {
ZVAL_DUP(&tmp, Z_REFVAL_P(entry));
-//??? if (Z_REFCOUNTED(tmp)) Z_SET_REFCOUNT(tmp, 0);
entry = &tmp;
}
zend_hash_index_update(Z_ARRVAL_P(return_value), 1, entry);
{
zval *name_array = (zval *)arg;
zend_module_entry *module = (zend_module_entry*)Z_PTR_P(item);
- add_next_index_string(name_array, module->name, 1);
+ add_next_index_string(name_array, module->name);
return 0;
}
static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC)
{
zval *name_array = (zval *)arg;
- add_next_index_string(name_array, ext->name, 1);
+ add_next_index_string(name_array, ext->name);
return 0;
}
if (build_filename_arg && include_filename) {
array_init(&arg_array);
- add_next_index_string(&arg_array, (char*)include_filename, 1);
+ add_next_index_string(&arg_array, (char*)include_filename);
}
call_type = NULL;
}
if (skip->op_array) {
filename = skip->op_array->filename->val;
lineno = skip->opline->lineno;
- add_assoc_string_ex(&stack_frame, "file", sizeof("file")-1, (char*)filename, 1);
+ add_assoc_string_ex(&stack_frame, "file", sizeof("file")-1, (char*)filename);
add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, lineno);
/* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
NULL);
if (function_name) {
- add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name, 1);
+ add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name);
if (ptr->object) {
if (ptr->function_state.function->common.scope) {
Z_ADDREF(object);
}
- add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "->", 1);
+ add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "->");
} else if (ptr->function_state.function->common.scope) {
add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(ptr->function_state.function->common.scope->name));
- add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "::", 1);
+ add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "::");
}
if ((options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0 &&
if we have called include in the frame above - this is the file we have included.
*/
- add_next_index_string(&arg_array, (char*)include_filename, 1);
+ add_next_index_string(&arg_array, (char*)include_filename);
add_assoc_zval_ex(&stack_frame, "args", sizeof("args")-1, &arg_array);
}
- add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name, 1);
+ add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name);
}
add_next_index_zval(return_value, &stack_frame);
}
info_len = zend_spprintf(&info, 0, "%s",
i >= required ? "<optional>" : "<required>");
-//??? TODO: avoid reallocation
- add_assoc_stringl_ex(&val, name, name_len, info, info_len, 1);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl_ex(&val, name, name_len, info, info_len);
efree(info);
efree(name);
arg_info++;
static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
{
-//??? return (zend_uint)(zend_uintptr_t)EX_VAR_NUM_2(0, (op_array->T)++);
return (zend_uint)op_array->T++;
}
/* }}} */
}
}
ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
-//??? Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2);
-//??? Z_SET_ISREF(CONSTANT_EX(op_array, literal_position));
op_array->literals[literal_position].cache_slot = -1;
}
/* }}} */
}
CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
-//??? cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC);
cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
cur_arg_info->type_hint = 0;
if (IS_INTERNED(Z_STR(class_type->u.constant))) {
Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
}
-//???: for now we have to copy it :(
+// TODO: for now we have to copy it ???
#if 1
cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
SET_NODE(opline->op1, function_name);
SET_UNUSED(opline->op2);
opline->op2.num = CG(context).nested_calls;
-//??? CALCULATE_LITERAL_HASH(opline->op1.constant);
GET_CACHE_SLOT(opline->op1.constant);
} else {
opline->opcode = ZEND_DO_FCALL_BY_NAME;
int use_copy;
ZVAL_DUP(&zv, precv->op2.zv);
-//??? INIT_PZVAL(zv);
zval_update_constant_ex(&zv, (void*)1, fptr->common.scope TSRMLS_CC);
if (Z_TYPE(zv) == IS_BOOL) {
if (Z_LVAL(zv)) {
Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
}
zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC);
-//??? efree(Z_STRVAL(var_name->u.constant));
STR_RELEASE(Z_STR(var_name->u.constant));
}
/* }}} */
break;
}
if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
-//??? CALCULATE_LITERAL_HASH(opline_ptr->op2.constant);
GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
}
GET_NODE(result, opline_ptr->result);
SET_NODE(opline.op1, object);
SET_NODE(opline.op2, property);
if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-//??? CALCULATE_LITERAL_HASH(opline.op2.constant);
GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
}
GET_NODE(result, opline.result);
result->op_type = IS_CONST;
result->u.constant = c->value;
zval_copy_ctor(&result->u.constant);
-//??? INIT_PZVAL(&result->u.constant);
return 1;
}
return 0;
}
zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
*result = *constant_container;
-//???
Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
if (IS_INTERNED(Z_STR(result->u.constant))) {
Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
SET_NODE(opline->op1, constant_container);
}
SET_NODE(opline->op2, constant_name);
-//??? CALCULATE_LITERAL_HASH(opline->op2.constant);
if (opline->op1_type == IS_CONST) {
GET_CACHE_SLOT(opline->op2.constant);
} else {
}
*result = *constant_name;
-//???
Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
if (IS_INTERNED(Z_STR(result->u.constant))) {
Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
opline->result.var = get_temporary_variable(CG(active_op_array));
opline->result_type = IS_VAR;
LITERAL_STR(opline->op1, STR_INIT("shell_exec", sizeof("shell_exec")-1, 0));
-//??? CALCULATE_LITERAL_HASH(opline->op1.constant);
opline->op1_type = IS_CONST;
GET_CACHE_SLOT(opline->op1.constant);
opline->extended_value = 1;
if (numeric) {
zval_dtor(&CONSTANT(opline->op2.constant));
ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
- } else {
-//??? CALCULATE_LITERAL_HASH(opline->op2.constant);
}
}
} else {
if (numeric) {
zval_dtor(&CONSTANT(opline->op2.constant));
ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
- } else {
-//??? CALCULATE_LITERAL_HASH(opline->op2.constant);
}
}
} else {
if (offset) {
switch (Z_TYPE(offset->u.constant)) {
case IS_CONSTANT:
-//??? /* Ugly hack to denote that this value has a constant index */
Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT;
if (Z_CONST_FLAGS(offset->u.constant) & IS_CONSTANT_UNQUALIFIED) {
Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT_UNQUALIFIED;
}
-//??? Z_TYPE(element) |= IS_CONSTANT_INDEX;
-//??? Z_STRVAL(offset->u.constant) = erealloc(Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3);
-//??? Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+1] = Z_TYPE(offset->u.constant);
-//??? Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+2] = 0;
zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STR(offset->u.constant), &element);
zval_dtor(&offset->u.constant);
break;
case IS_CONSTANT_AST: {
-//??? /* Another ugly hack to store the data about the AST in the array */
zend_string *key;
-//??? int len = sizeof(zend_ast *);
-//??? Z_TYPE(element) |= IS_CONSTANT_INDEX;
key = STR_INIT((char*)&Z_AST(offset->u.constant), sizeof(zend_ast*), 0);
GC_FLAGS(key) |= IS_STR_AST;
-//??? key[len] = Z_TYPE(offset->u.constant);
-//??? key[len + 1] = 0;
zend_symtable_update(Z_ARRVAL(result->u.constant), key, &element);
STR_RELEASE(key);
break;
opline->result_type = IS_VAR;
opline->result.var = get_temporary_variable(CG(active_op_array));
SET_NODE(opline->op1, varname);
-//??? if (opline->op1_type == IS_CONST) {
-//??? CALCULATE_LITERAL_HASH(opline->op1.constant);
-//??? }
SET_UNUSED(opline->op2);
opline->extended_value = ZEND_FETCH_STATIC;
GET_NODE(&result, opline->result);
value.op_type = IS_CONST;
ZVAL_NULL(&value.u.constant);
Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
-//??? Z_SET_REFCOUNT_P(&value.u.constant, 1);
-//??? Z_UNSET_ISREF_P(&value.u.constant);
-
zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC);
}
/* }}} */
opline->result_type = IS_VAR;
opline->result.var = get_temporary_variable(CG(active_op_array));
SET_NODE(opline->op1, varname);
-//??? if (opline->op1_type == IS_CONST) {
-//??? CALCULATE_LITERAL_HASH(opline->op1.constant);
-//??? }
SET_UNUSED(opline->op2);
opline->extended_value = fetch_type;
GET_NODE(&result, opline->result);
}
again:
-//???
Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
switch (retval) {
break;
}
-//??? INIT_PZVAL(&zendlval->u.constant);
zendlval->op_type = IS_CONST;
return retval;
}
}
} else {
result->op_type = IS_CONST;
-//??? Z_TYPE(result->u.constant) = IS_STRING;
-//??? Z_STRVAL(result->u.constant) = NULL;
-//??? Z_STRLEN(result->u.constant) = 0;
ZVAL_EMPTY_STRING(&result->u.constant);
}
/* prefix = result */
name = &tmp;
p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
if (p) {
-//??? ZVAL_STRING(name, p+1, 1);
ZVAL_STRING(name, p+1);
} else {
ZVAL_ZVAL(name, &ns, 1, 0);
name = &tmp;
p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
if (p) {
-//??? ZVAL_STRING(name, p+1, 1);
ZVAL_STRING(name, p+1);
} else {
ZVAL_ZVAL(name, &ns, 1, 0);
{
if (ast->kind == ZEND_CONST) {
ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val);
-//???
efree(ast);
} else if (zend_ast_is_ct_constant(ast)) {
zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
typedef struct _zend_arg_info {
- const char *name;
+ const char *name; // TODO: convert into zend_string ???
zend_uint name_len;
- const char *class_name;
+ const char *class_name; // TODO: convert into zend_string ???
zend_uint class_name_len;
-//??? zend_string *name;
-//??? zend_string *class_name;
zend_uchar type_hint;
zend_uchar pass_by_reference;
zend_bool allow_null;
zval old_error_reporting;
zend_bool nested;
zval *return_value;
-//???
+ // TODO: simplify call sequence and remove current_* and call_* ???
zend_class_entry *current_scope;
zend_class_entry *current_called_scope;
zend_object *current_this;
#endif
if (!(c->flags & CONST_CS)) {
-//??? /* keep in mind that c->name_len already contains the '\0' */
lowercase_name = STR_ALLOC(c->name->len, c->flags & CONST_PERSISTENT);
zend_str_tolower_copy(lowercase_name->val, c->name->val, c->name->len);
lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
/* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
if (c->name->val[0] == '\0' && c->name->len > sizeof("\0__COMPILER_HALT_OFFSET__")-1
&& memcmp(name->val, "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
-//??? name++;
}
zend_error(E_NOTICE,"Constant %s already defined", name->val);
STR_RELEASE(c->name);
class_name = zend_get_object_classname(Z_OBJ_P(arg) TSRMLS_CC);
TRACE_APPEND_STRL(class_name->val, class_name->len);
-//??? if(!dup) {
-//??? efree((char*)class_name);
-//??? }
-
TRACE_APPEND_STR("), ");
break;
}
* the result in uncaught exception handlers without memleaks. */
zend_update_property_string(default_exception_ce, getThis(), "string", sizeof("string")-1, str TSRMLS_CC);
-//??? RETURN_STRINGL(str, len, 0);
+ // TODO: avoid reallocation ???
RETVAL_STRINGL(str, len);
efree(str);
}
}
Z_DELREF_P(object);
} else {
-#endif
zend_error(E_WARNING, "Creating default object from empty value");
-//??? }
+ }
+#else
+ zend_error(E_WARNING, "Creating default object from empty value");
+#endif
zval_dtor(object);
object_init(object);
} else {
return variable_ptr;
} else {
if (Z_REFCOUNT_P(value) == 1) {
-//??? auto dereferencing
ZVAL_UNREF(value);
ZVAL_COPY(variable_ptr, value);
} else {
} else if (is_ref != value) {
assign_ref:
if (Z_REFCOUNT_P(value) == 1) {
-//??? auto dereferencing
ZVAL_UNREF(value);
ZVAL_COPY(variable_ptr, value);
} else {
#include "zend_operators.h"
#include "zend_variables.h"
-//???typedef union _temp_variable {
-//??? zval tmp_var;
-//??? struct {
-//??? zval **ptr_ptr;
-//??? zval *ptr;
-//??? zend_bool fcall_returned_reference;
-//??? } var;
-//??? struct {
-//??? zval **ptr_ptr; /* shared with var.ptr_ptr */
-//??? zval *str;
-//??? zend_uint offset;
-//??? } str_offset;
-//??? struct {
-//??? zval **ptr_ptr; /* shared with var.ptr_ptr */
-//??? zval *ptr; /* shared with var.ptr */
-//??? HashPointer fe_pos;
-//??? } fe;
-//??? zend_class_entry *class_entry;
-//???} temp_variable;
-
BEGIN_EXTERN_C()
struct _zend_fcall_info;
ZEND_API extern void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
_zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_CC);
} else {
-//??? if (Z_REFCOUNT_P(zval_ptr) == 1 && Z_ISREF_P(zval_ptr)) {
- /* convert reference to regular value */
-//??? zend_reference *ref = Z_REF_P(zval_ptr);
-//??? ZVAL_COPY_VALUE(zval_ptr, &ref->val);
-//??? efree_rel(ref);
-//??? }
GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
}
}
Z_DELREF_P(zval_ptr);
if (Z_REFCOUNT_P(zval_ptr) == 0) {
_zval_internal_dtor_for_ptr(zval_ptr ZEND_FILE_LINE_CC);
-//??? } else if (Z_REFCOUNT_P(zval_ptr) == 1) {
-//??? if (Z_ISREF_P(zval_ptr)) {
-//??? zend_reference *ref = Z_REF_P(zval_ptr);
-//??? ZVAL_COPY_VALUE(zval_ptr, Z_REFVAL_P(zval_ptr));
-//??? efree(ref);
-//??? }
}
}
}
#include "../TSRM/tsrm_strtok_r.h"
-#define IS_VISITED_CONSTANT 0x080 //??? IS_CONSTANT_INDEX
+#define IS_VISITED_CONSTANT 0x080
#define IS_CONSTANT_VISITED(p) (Z_TYPE_P(p) & IS_VISITED_CONSTANT)
#define Z_REAL_TYPE_P(p) (Z_TYPE_P(p) & ~IS_VISITED_CONSTANT)
#define MARK_CONSTANT_VISITED(p) Z_TYPE_INFO_P(p) |= IS_VISITED_CONSTANT
static void zval_deep_copy(zval *p)
{
- zval value;
-
- ZVAL_DUP(&value, p);
-//??? Z_TYPE(value) &= ~IS_CONSTANT_INDEX;
-//??? zval_copy_ctor(&value);
-//??? Z_TYPE(value) = Z_TYPE_P(p);
- ZVAL_COPY_VALUE(p, &value);
+//??? zval value;
+//???
+//??? ZVAL_DUP(&value, p);
+//??? ZVAL_COPY_VALUE(p, &value);
+ zval_copy_ctor(p);
}
ZEND_API int zval_update_constant_ex(zval *p, void *arg, zend_class_entry *scope TSRMLS_DC) /* {{{ */
CG(interactive) = orig_interactive;
if (Z_TYPE(local_retval) != IS_UNDEF) {
if (retval_ptr) {
- COPY_PZVAL_TO_ZVAL(*retval_ptr, &local_retval);
+ ZVAL_COPY_VALUE(retval_ptr, &local_retval);
} else {
zval_ptr_dtor(&local_retval);
}
{
HANDLE_BLOCK_INTERRUPTIONS();
ht->flags |= HASH_FLAG_PACKED;
-//??? pefree(ht->arHash, ht->flags & HASH_FLAG_PERSISTENT);
ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket));
ht->arHash = (zend_uint*)&uninitialized_bucket;
HANDLE_UNBLOCK_INTERRUPTIONS();
if (setTargetPointer && source->nInternalPointer == idx) {
target->nInternalPointer = INVALID_IDX;
}
-//???
+ /* INDIRECT element may point to UNDEF-ined slots */
data = &p->val;
if (Z_TYPE_P(data) == IS_INDIRECT) {
data = Z_INDIRECT_P(data);
} else {
if (renumber) {
ht->flags |= HASH_FLAG_PACKED;
-//??? pefree(ht->arHash, ht->flags & HASH_FLAG_PERSISTENT);
ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket));
ht->arHash = (zend_uint*)&uninitialized_bucket;
} else {
struct _zend_ini_entry {
int module_number;
int modifiable;
- char *name;
+ char *name; // TODO: convert into zend_string ???
uint name_length;
ZEND_INI_MH((*on_modify));
void *mh_arg1;
void *mh_arg2;
void *mh_arg3;
- char *value;
+ char *value; // TODO: convert into zend_string ???
uint value_length;
- char *orig_value;
+ char *orig_value; // TODO: convert into zend_string ???
uint orig_value_length;
int orig_modifiable;
int modified;
ZEND_API void zend_register_iterator_wrapper(TSRMLS_D)
{
INIT_CLASS_ENTRY(zend_iterator_class_entry, "__iterator_wrapper", NULL);
-//??? STR_RELEASE(zend_iterator_class_entry.name);
-//??? zend_iterator_class_entry.name = STR_INIT("__iterator_wrapper", sizeof("__iterator_wrapper")-1, 0);
}
static void iter_wrapper_dtor(zend_object *object TSRMLS_DC)
}
/* }}} */
-//???
-#if 0
-ZEND_API zend_object *zend_objects_store_clone_obj(zval *zobject TSRMLS_DC)
-{
- zend_object *obj, *new_object;
-//??? struct _store_object *obj;
-//??? zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-
-//??? obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
-//??? if (obj->clone == NULL) {
-//??? zend_error(E_CORE_ERROR, "Trying to clone uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
-//??? }
-
- obj = Z_OBJ_P(zobject);
- new_object = obj->handlers->clone_obj(obj TSRMLS_CC);
- obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
- retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
- retval.handlers = Z_OBJ_HT_P(zobject);
- EG(objects_store).object_buckets[handle].bucket.obj.handlers = retval.handlers;
-
- return retval;
-}
-#endif
-
/* zend_object_store_set_object:
* It is ONLY valid to call this function from within the constructor of an
* overloaded object. Its purpose is to set the object pointer for the object
}
if (op_array->arg_info) {
for (i=0; i<op_array->num_args; i++) {
-//??? str_efree(op_array->arg_info[i].name);
efree((char*)op_array->arg_info[i].name);
if (op_array->arg_info[i].class_name) {
-//??? str_efree(op_array->arg_info[i].class_name);
efree((char*)op_array->arg_info[i].class_name);
}
}
(op) = &(holder); \
break; \
case IS_RESOURCE: \
- /* ??? delete old resource ??? */ \
ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op)); \
(op) = &(holder); \
break; \
ZVAL_LONG(&(holder), Z_LVAL_P(op)); \
break; \
case IS_RESOURCE: \
- /* ??? delete old resource ??? */ \
ZVAL_LONG(&holder, Z_RES_HANDLE_P(op)); \
break; \
default: \
ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
{
-//??? double dval;
-//??? switch (Z_TYPE_P(op)) {
-//??? case IS_DOUBLE: {
-//??? TSRMLS_FETCH();
-//??? dval = Z_DVAL_P(op);
-//??? Z_STRLEN_P(op) = zend_spprintf((char**)&Z_STRVAL_P(op), 0, "%.*H", (int) EG(precision), dval);
-//??? /* %H already handles removing trailing zeros from the fractional part, yay */
-//??? break;
-//??? }
-//??? default:
- _convert_to_string(op ZEND_FILE_LINE_CC);
-//??? }
-//??? Z_TYPE_P(op) = IS_STRING;
+ _convert_to_string(op ZEND_FILE_LINE_CC);
}
/* }}} */
break;
}
default:
- //??? op is set to be IS_STRING below.
zval_dtor(op);
ZVAL_BOOL(op, 0);
break;
ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2));
break;
case IS_STRING:
-// TODO: interned strings ???
- ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
- && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
+ if (Z_STR_P(op1) == Z_STR_P(op2)) {
+ ZVAL_BOOL(result, 1);
+ } else {
+ ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
+ && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
+ }
break;
case IS_ARRAY:
ZVAL_BOOL(result, Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
{
#ifndef ZTS
zend_hash_destroy(&CG(interned_strings));
-//??? free(CG(interned_strings).arData);
-//??? free(CG(interned_strings).arHash);
#else
free(CG(empty_string));
#endif
}
GC_REFCOUNT(str) = 1;
-// str->gc.u.v.type = IS_INTERNED_STRING;
GC_FLAGS(str) |= IS_STR_INTERNED;
-//??? if (CG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength) >=
-//??? CG(interned_strings_end)) {
-//??? /* no memory */
-//??? return arKey;
-//??? }
-
-//??? info = (zend_string_info*) CG(interned_strings_top);
-//??? CG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(sizeof(zend_string_info) + nKeyLength);
-
-//??? memcpy((char*)(info+1), arKey, nKeyLength);
-//??? if (free_src) {
-//??? efree((void *)arKey);
-//??? }
-//??? info->nKeyLength = nKeyLength;
-//??? info->h = h;
-
if (CG(interned_strings).nNumUsed >= CG(interned_strings).nTableSize) {
if ((CG(interned_strings).nTableSize << 1) > 0) { /* Let's double the table size */
Bucket *d = (Bucket *) perealloc_recoverable(CG(interned_strings).arData, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket), CG(interned_strings).flags & HASH_FLAG_PERSISTENT);
struct _zend_object {
zend_refcounted gc;
- zend_uint handle; //??? may be removed?
+ zend_uint handle; // TODO: may be removed ???
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
struct _zend_resource {
zend_refcounted gc;
- long handle; //??? may be removed?
+ long handle; // TODO: may be removed ???
int type;
void *ptr;
};
return pz->u1.v.type;
}
-//???
-#if 0
-# define Z_TYPE(zval) (zval).u1.v.type
-#else
-# define Z_TYPE(zval) zval_get_type(&(zval))
-#endif
+/* we should never set just Z_TYPE, we should set Z_TYPE_INFO */
+#define Z_TYPE(zval) zval_get_type(&(zval))
#define Z_TYPE_P(zval_p) Z_TYPE(*(zval_p))
#define Z_TYPE_FLAGS(zval) (zval).u1.v.type_flags
case IS_STRING:
case IS_CONSTANT: {
zend_string *str = (zend_string*)p;
-//??? CHECK_ZVAL_STRING_REL(zvalue);
+ CHECK_ZVAL_STRING_REL(str);
STR_RELEASE(str);
break;
}
case IS_STRING:
case IS_CONSTANT: {
zend_string *str = (zend_string*)p;
-//??? CHECK_ZVAL_STRING_REL(zvalue);
+ CHECK_ZVAL_STRING_REL(str);
STR_FREE(str);
break;
}
switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
- CHECK_ZVAL_STRING_REL(zvalue);
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
STR_RELEASE(Z_STR_P(zvalue));
break;
case IS_ARRAY:
switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
case IS_CONSTANT:
- CHECK_ZVAL_STRING_REL(zvalue);
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
STR_FREE(Z_STR_P(zvalue));
break;
case IS_ARRAY:
ZEND_API void zval_add_ref(zval *p)
{
if (Z_REFCOUNTED_P(p)) {
-//???: autoconversion from reverence to ordinal value
if (Z_ISREF_P(p) && Z_REFCOUNT_P(p) == 1) {
ZVAL_DUP(p, Z_REFVAL_P(p));
} else {
switch (Z_TYPE_P(zvalue)) {
case IS_CONSTANT:
case IS_STRING:
- CHECK_ZVAL_STRING_REL(zvalue);
+ CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
Z_STR_P(zvalue) = STR_DUP(Z_STR_P(zvalue), 0);
break;
case IS_ARRAY:
#endif
ZEND_API void zval_add_ref(zval *p);
-//??? previously references become regular values when refcount became 1
ZEND_API void zval_add_ref_unref(zval *p);
END_EXTERN_C()
array_init(return_value);
add_assoc_long (return_value, "errno", errnum);
- add_assoc_string(return_value, "errstr", (char*)errstr, 1);
+ add_assoc_string(return_value, "errstr", (char*)errstr);
break;
}
}
array_init(smonths);
for (i = 1; i <= calendar->num_months; i++) {
- add_index_string(months, i, calendar->month_name_long[i], 1);
- add_index_string(smonths, i, calendar->month_name_short[i], 1);
+ add_index_string(months, i, calendar->month_name_long[i]);
+ add_index_string(smonths, i, calendar->month_name_short[i]);
}
add_assoc_zval(*ret, "months", months);
add_assoc_zval(*ret, "abbrevmonths", smonths);
add_assoc_long(*ret, "maxdaysinmonth", calendar->max_days_in_month);
- add_assoc_string(*ret, "calname", calendar->name, 1);
- add_assoc_string(*ret, "calsymbol", calendar->symbol, 1);
+ add_assoc_string(*ret, "calname", calendar->name);
+ add_assoc_string(*ret, "calsymbol", calendar->symbol);
}
calendar->from_jd(jd, &year, &month, &day);
snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
- add_assoc_string(return_value, "date", date, 1);
+ add_assoc_string(return_value, "date", date);
add_assoc_long(return_value, "month", month);
add_assoc_long(return_value, "day", day);
/* day of week */
dow = DayOfWeek(jd);
add_assoc_long(return_value, "dow", dow);
- add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow], 1);
- add_assoc_string(return_value, "dayname", DayNameLong[dow], 1);
+ add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow]);
+ add_assoc_string(return_value, "dayname", DayNameLong[dow]);
/* month name */
if(cal == CAL_JEWISH) {
/* special case for Jewish calendar */
- add_assoc_string(return_value, "abbrevmonth", JEWISH_MONTH_NAME(year)[month], 1);
- add_assoc_string(return_value, "monthname", JEWISH_MONTH_NAME(year)[month], 1);
+ add_assoc_string(return_value, "abbrevmonth", JEWISH_MONTH_NAME(year)[month]);
+ add_assoc_string(return_value, "monthname", JEWISH_MONTH_NAME(year)[month]);
} else {
- add_assoc_string(return_value, "abbrevmonth", calendar->month_name_short[month], 1);
- add_assoc_string(return_value, "monthname", calendar->month_name_long[month], 1);
+ add_assoc_string(return_value, "abbrevmonth", calendar->month_name_short[month]);
+ add_assoc_string(return_value, "monthname", calendar->month_name_long[month]);
}
}
/* }}} */
#define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s), (long) v);
#define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s), (double) v);
-#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s), (char *) (v ? v : ""), 1);
+#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s), (char *) (v ? v : ""));
#define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s), (zval *) v);
#if defined(PHP_WIN32) || defined(__GNUC__)
array_init(protocol_list);
while (*p != NULL) {
- add_next_index_string(protocol_list, *p, 1);
+ add_next_index_string(protocol_list, *p);
p++;
}
CAAZ("protocols", protocol_list);
if(tmp) {
*tmp = '\0';
val = tmp+1;
- add_assoc_string(hash, key, val, 1);
+ add_assoc_string(hash, key, val);
}
s = split+2;
} while(split);
split_certinfo(&slist->data[len+1], hash);
add_assoc_zval(certhash, s, hash);
} else {
- add_assoc_string(certhash, s, &slist->data[len+1], 1);
+ add_assoc_string(certhash, s, &slist->data[len+1]);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not extract hash key from certificate info");
array_init(return_value);
if (curl_easy_getinfo(ch->cp, option, &slist) == CURLE_OK) {
while (slist) {
- add_next_index_string(return_value, slist->data, 1);
+ add_next_index_string(return_value, slist->data);
slist = slist->next;
}
curl_slist_free_all(slist);
add_assoc_long(return_value, "mon", ts->m);
add_assoc_long(return_value, "year", ts->y);
add_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d));
- add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d), 1);
- add_assoc_string(return_value, "month", mon_full_names[ts->m - 1], 1);
+ add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d));
+ add_assoc_string(return_value, "month", mon_full_names[ts->m - 1]);
add_index_long(return_value, 0, timestamp);
timelib_time_dtor(ts);
add_assoc_long(z, "warning_count", error->warning_count);
array_init(&element);
for (i = 0; i < error->warning_count; i++) {
- add_index_string(&element, error->warning_messages[i].position, error->warning_messages[i].message, 1);
+ add_index_string(&element, error->warning_messages[i].position, error->warning_messages[i].message);
}
add_assoc_zval(z, "warnings", &element);
add_assoc_long(z, "error_count", error->error_count);
array_init(&element);
for (i = 0; i < error->error_count; i++) {
- add_index_string(&element, error->error_messages[i].position, error->error_messages[i].message, 1);
+ add_index_string(&element, error->error_messages[i].position, error->error_messages[i].message);
}
add_assoc_zval(z, "errors", &element);
} /* }}} */
break;
case TIMELIB_ZONETYPE_ID:
if (parsed_time->tz_abbr) {
- add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1);
+ add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr);
}
if (parsed_time->tz_info) {
- add_assoc_string(return_value, "tz_id", parsed_time->tz_info->name, 1);
+ add_assoc_string(return_value, "tz_id", parsed_time->tz_info->name);
}
break;
case TIMELIB_ZONETYPE_ABBR:
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z);
add_assoc_bool(return_value, "is_dst", parsed_time->dst);
- add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1);
+ add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr);
break;
}
}
add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, timestamp_begin, 0 TSRMLS_CC)); \
add_assoc_long(&element, "offset", tzobj->tzi.tz->type[0].offset); \
add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[0].isdst); \
- add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx], 1); \
+ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx]); \
add_next_index_zval(return_value, &element);
#define add(i,ts) \
add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, ts, 0 TSRMLS_CC)); \
add_assoc_long(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \
add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \
- add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx], 1); \
+ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx]); \
add_next_index_zval(return_value, &element);
#define add_last() add(tzobj->tzi.tz->timecnt - 1, timestamp_begin)
}
array_init(return_value);
- add_assoc_string(return_value, "country_code", tzobj->tzi.tz->location.country_code, 1);
+ add_assoc_string(return_value, "country_code", tzobj->tzi.tz->location.country_code);
add_assoc_double(return_value, "latitude", tzobj->tzi.tz->location.latitude);
add_assoc_double(return_value, "longitude", tzobj->tzi.tz->location.longitude);
- add_assoc_string(return_value, "comments", tzobj->tzi.tz->location.comments, 1);
+ add_assoc_string(return_value, "comments", tzobj->tzi.tz->location.comments);
}
/* }}} */
for (i = 0; i < item_count; ++i) {
if (what == PHP_DATE_TIMEZONE_PER_COUNTRY) {
if (tzdb->data[table[i].pos + 5] == option[0] && tzdb->data[table[i].pos + 6] == option[1]) {
- add_next_index_string(return_value, table[i].id, 1);
+ add_next_index_string(return_value, table[i].id);
}
} else if (what == PHP_DATE_TIMEZONE_GROUP_ALL_W_BC || (check_id_allowed(table[i].id, what) && (tzdb->data[table[i].pos + 4] == '\1'))) {
- add_next_index_string(return_value, table[i].id, 1);
+ add_next_index_string(return_value, table[i].id);
}
};
}
add_assoc_bool(&element, "dst", entry->type);
add_assoc_long(&element, "offset", entry->gmtoffset);
if (entry->full_tz_name) {
- add_assoc_string(&element, "timezone_id", entry->full_tz_name, 1);
+ add_assoc_string(&element, "timezone_id", entry->full_tz_name);
} else {
add_assoc_null(&element, "timezone_id");
}
}
array_init(return_value);
if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
- add_next_index_stringl(return_value, key+1, name - (key + 1), 1);
- add_next_index_stringl(return_value, name+1, key_len - (name - key + 1), 1);
+ add_next_index_stringl(return_value, key+1, name - (key + 1));
+ add_next_index_stringl(return_value, name+1, key_len - (name - key + 1));
} else {
- add_next_index_stringl(return_value, "", 0, 1);
- add_next_index_stringl(return_value, key, key_len, 1);
+ add_next_index_stringl(return_value, "", 0);
+ add_next_index_stringl(return_value, key, key_len);
}
}
/* }}} */
for(hptr = handler; hptr->name; hptr++) {
if (full_info) {
- add_assoc_string(return_value, hptr->name, hptr->info(hptr, NULL TSRMLS_CC), 0);
+ // TODO: avoid reallocation ???
+ char *str = hptr->info(hptr, NULL TSRMLS_CC);
+ add_assoc_string(return_value, hptr->name, str);
+ efree(str);
} else {
- add_next_index_string(return_value, hptr->name, 1);
+ add_next_index_string(return_value, hptr->name);
}
}
}
}
if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
info = (dba_info *)(le->ptr);
- add_index_string(return_value, i, info->path, 1);
+ add_index_string(return_value, i, info->path);
}
}
}
MAKE_STD_ZVAL(tmp_array);
array_init(tmp_array);
- add_assoc_string(tmp_array, "name", (char *)name, 1);
- add_assoc_string(tmp_array, "desc", (char *)desc, 1);
- add_assoc_string(tmp_array, "file", (char *)file, 1);
+ add_assoc_string(tmp_array, "name", (char *)name);
+ add_assoc_string(tmp_array, "desc", (char *)desc);
+ add_assoc_string(tmp_array, "file", (char *)file);
if (Z_TYPE_P(zdesc)!=IS_ARRAY) {
array_init(zdesc);
{
zval *zdesc = (zval *) ud;
array_init(zdesc);
- add_assoc_string(zdesc, "lang", (char *)lang, 1);
- add_assoc_string(zdesc, "name", (char *)name, 1);
- add_assoc_string(zdesc, "desc", (char *)desc, 1);
- add_assoc_string(zdesc, "file", (char *)file, 1);
+ add_assoc_string(zdesc, "lang", (char *)lang);
+ add_assoc_string(zdesc, "name", (char *)name);
+ add_assoc_string(zdesc, "desc", (char *)desc);
+ add_assoc_string(zdesc, "file", (char *)file);
}
/* }}} */
MAKE_STD_ZVAL(tmp_array);
array_init(tmp_array);
- add_assoc_string(tmp_array, "lang_tag", (char *)lang_tag, 1);
- add_assoc_string(tmp_array, "provider_name", (char *)provider_name, 1);
- add_assoc_string(tmp_array, "provider_desc", (char *)provider_desc, 1);
- add_assoc_string(tmp_array, "provider_file", (char *)provider_file, 1);
+ add_assoc_string(tmp_array, "lang_tag", (char *)lang_tag);
+ add_assoc_string(tmp_array, "provider_name", (char *)provider_name);
+ add_assoc_string(tmp_array, "provider_desc", (char *)provider_desc);
+ add_assoc_string(tmp_array, "provider_file", (char *)provider_file);
if (Z_TYPE_P(zdesc) != IS_ARRAY) {
array_init(zdesc);
if (suggs && n_sugg) {
int i;
for (i = 0; i < n_sugg; i++) {
- add_next_index_string(sugg, suggs[i], 1);
+ add_next_index_string(sugg, suggs[i]);
}
enchant_dict_free_suggestions(pdict->pdict, suggs);
}
array_init(return_value);
for (i = 0; i < n_sugg; i++) {
- add_next_index_string(return_value, suggs[i], 1);
+ add_next_index_string(return_value, suggs[i]);
}
enchant_dict_free_suggestions(pdict->pdict, suggs);
match_len = 1;
if (array) {
- ZVAL_DEREF_REF(array);
+ ZVAL_DEREF(array);
}
if (array && err != REG_NOMATCH) {
start = subs[i].rm_so;
end = subs[i].rm_eo;
if (start != -1 && end > 0 && start < string_len && end < string_len && start < end) {
- add_index_stringl(array, i, string+start, end-start, 1);
+ add_index_stringl(array, i, string+start, end-start);
} else {
add_index_bool(array, i, 0);
}
while ((count == -1 || count > 1) && !(err = regexec(&re, strp, 1, subs, 0))) {
if (subs[0].rm_so == 0 && subs[0].rm_eo) {
/* match is at start of string, return empty string */
- add_next_index_stringl(return_value, "", 0, 1);
+ add_next_index_stringl(return_value, "", 0);
/* skip ahead the length of the regex match */
strp += subs[0].rm_eo;
} else if (subs[0].rm_so == 0 && subs[0].rm_eo == 0) {
size = subs[0].rm_so;
/* add it to the array */
- add_next_index_stringl(return_value, strp, size, 1);
+ add_next_index_stringl(return_value, strp, size);
/* point at our new starting point */
strp = strp + subs[0].rm_eo;
/* otherwise we just have one last element to add to the array */
size = endp - strp;
- add_next_index_stringl(return_value, strp, size, 1);
+ add_next_index_stringl(return_value, strp, size);
regfree(&re);
}
case TAG_FMT_SBYTE:
case TAG_FMT_UNDEFINED:
if (!info_value->s) {
- add_assoc_stringl(tmpi, name, "", 0, 1);
+ add_assoc_stringl(tmpi, name, "", 0);
} else {
- add_assoc_stringl(tmpi, name, info_value->s, info_data->length, 1);
+ add_assoc_stringl(tmpi, name, info_value->s, info_data->length);
}
break;
val = "";
}
if (section_index==SECTION_COMMENT) {
- add_index_string(tmpi, idx++, val, 1);
+ add_index_string(tmpi, idx++, val);
} else {
- add_assoc_string(tmpi, name, val, 1);
+ add_assoc_string(tmpi, name, val);
}
break;
case TAG_FMT_URATIONAL:
snprintf(buffer, sizeof(buffer), "%i/%i", info_value->ur.num, info_value->ur.den);
if (l==1) {
- add_assoc_string(tmpi, name, buffer, 1);
+ add_assoc_string(tmpi, name, buffer);
} else {
- add_index_string(array, ap, buffer, 1);
+ add_index_string(array, ap, buffer);
}
break;
case TAG_FMT_SRATIONAL:
snprintf(buffer, sizeof(buffer), "%i/%i", info_value->sr.num, info_value->sr.den);
if (l==1) {
- add_assoc_string(tmpi, name, buffer, 1);
+ add_assoc_string(tmpi, name, buffer);
} else {
- add_index_string(array, ap, buffer, 1);
+ add_index_string(array, ap, buffer);
}
break;
if (status == SUCCESS && retval_ptr != NULL) {
if (retval_ptr != value) {
zval_dtor(value);
- COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
+ ZVAL_COPY_VALUE(value, retval_ptr);
+//??? COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
} else {
zval_ptr_dtor(&retval_ptr);
}
array_init(return_value);
for (i = 0; i < size; ++i) {
- add_next_index_string(return_value, (char *)filter_list[i].name, 1);
+ add_next_index_string(return_value, (char *)filter_list[i].name);
}
}
/* }}} */
}
array_init(return_value);
while (ftp_readline(ftp)) {
- add_next_index_string(return_value, ftp->inbuf, 1);
+ add_next_index_string(return_value, ftp->inbuf);
if (isdigit(ftp->inbuf[0]) && isdigit(ftp->inbuf[1]) && isdigit(ftp->inbuf[2]) && ftp->inbuf[3] == ' ') {
return;
}
array_init(return_value);
for (ptr = nlist; *ptr; ptr++) {
- add_next_index_string(return_value, *ptr, 1);
+ add_next_index_string(return_value, *ptr);
}
efree(nlist);
}
array_init(return_value);
for (ptr = llist; *ptr; ptr++) {
- add_next_index_string(return_value, *ptr, 1);
+ add_next_index_string(return_value, *ptr);
}
efree(llist);
}
array_init(return_value);
- add_assoc_string(return_value, "GD Version", PHP_GD_VERSION_STRING, 1);
+ add_assoc_string(return_value, "GD Version", PHP_GD_VERSION_STRING);
#ifdef ENABLE_GD_TTF
add_assoc_bool(return_value, "FreeType Support", 1);
#if HAVE_LIBFREETYPE
- add_assoc_string(return_value, "FreeType Linkage", "with freetype", 1);
+ add_assoc_string(return_value, "FreeType Linkage", "with freetype");
#else
- add_assoc_string(return_value, "FreeType Linkage", "with unknown library", 1);
+ add_assoc_string(return_value, "FreeType Linkage", "with unknown library");
#endif
#else
add_assoc_bool(return_value, "FreeType Support", 0);
for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
(type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, &str_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTENT;
zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
- add_next_index_stringl(return_value, str, str_len-1, 1);
+ add_next_index_stringl(return_value, str, str_len-1);
}
}
/* }}} */
elem = &new_elem;
}
- add_next_index_stringl(*elem, header_value, header_value_len, 1);
+ add_next_index_stringl(*elem, header_value, header_value_len);
} else {
- add_assoc_stringl_ex(return_value, header_name, header_name_len, header_value, header_value_len, 1);
+ add_assoc_stringl_ex(return_value, header_name, header_name_len, header_value, header_value_len);
}
}
encoded_str_len -= next_pos - encoded_str;
if (!strcasecmp("all", type)) {
array_init(return_value);
- add_assoc_string(return_value, "input_encoding", ICONVG(input_encoding), 1);
- add_assoc_string(return_value, "output_encoding", ICONVG(output_encoding), 1);
- add_assoc_string(return_value, "internal_encoding", ICONVG(internal_encoding), 1);
+ add_assoc_string(return_value, "input_encoding", ICONVG(input_encoding));
+ add_assoc_string(return_value, "output_encoding", ICONVG(output_encoding));
+ add_assoc_string(return_value, "internal_encoding", ICONVG(internal_encoding));
} else if (!strcasecmp("input_encoding", type)) {
RETVAL_STRING(ICONVG(input_encoding), 1);
} else if (!strcasecmp("output_encoding", type)) {
/* walk through the ACLLIST */
for(; alist; alist = alist->next) {
- add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights), 1);
+ add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights));
}
}
/* }}} */
}
mail_fetchsubject(t = tmp + strlen(tmp), imap_le_struct->imap_stream, msgno, (long)25);
snprintf(t += strlen(t), sizeof(tmp) - strlen(tmp), " (%ld chars)", cache->rfc822_size);
- add_next_index_string(return_value, tmp, 1);
+ add_next_index_string(return_value, tmp);
}
}
/* }}} */
array_init(return_value);
cur=IMAPG(imap_folders);
while (cur != NIL) {
- add_next_index_string(return_value, cur->LTEXT, 1);
+ add_next_index_string(return_value, cur->LTEXT);
cur=cur->next;
}
mail_free_stringlist (&IMAPG(imap_folders));
while (cur != NIL) {
MAKE_STD_ZVAL(mboxob);
object_init(mboxob);
- add_property_string(mboxob, "name", cur->LTEXT, 1);
+ add_property_string(mboxob, "name", cur->LTEXT);
add_property_long(mboxob, "attributes", cur->attributes);
#ifdef IMAP41
delim[0] = (char)cur->delimiter;
delim[1] = 0;
- add_property_string(mboxob, "delimiter", delim, 1);
+ add_property_string(mboxob, "delimiter", delim);
#else
- add_property_string(mboxob, "delimiter", cur->delimiter, 1);
+ add_property_string(mboxob, "delimiter", cur->delimiter);
#endif
add_next_index_object(return_value, mboxob TSRMLS_CC);
cur=cur->next;
array_init(return_value);
cur=IMAPG(imap_folders);
while (cur != NIL) {
- add_next_index_string(return_value, cur->LTEXT, 1);
+ add_next_index_string(return_value, cur->LTEXT);
cur=cur->next;
}
mail_free_stringlist (&IMAPG(imap_folders));
if (imap_le_struct->imap_stream && imap_le_struct->imap_stream->mailbox) {
rfc822_date(date);
object_init(return_value);
- add_property_string(return_value, "Date", date, 1);
- add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
- add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
+ add_property_string(return_value, "Date", date);
+ add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name);
+ add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox);
add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
} else {
/* now run through properties that are only going to be returned
from a server, not text headers */
- add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ", 1);
- add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U", 1);
- add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ", 1);
- add_property_string(return_value, "Answered", cache->answered ? "A" : " ", 1);
- add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ", 1);
- add_property_string(return_value, "Draft", cache->draft ? "X" : " ", 1);
+ add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ");
+ add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U");
+ add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ");
+ add_property_string(return_value, "Answered", cache->answered ? "A" : " ");
+ add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ");
+ add_property_string(return_value, "Draft", cache->draft ? "X" : " ");
snprintf(dummy, sizeof(dummy), "%4ld", cache->msgno);
- add_property_string(return_value, "Msgno", dummy, 1);
+ add_property_string(return_value, "Msgno", dummy);
mail_date(dummy, cache);
- add_property_string(return_value, "MailDate", dummy, 1);
+ add_property_string(return_value, "MailDate", dummy);
snprintf(dummy, sizeof(dummy), "%ld", cache->rfc822_size);
- add_property_string(return_value, "Size", dummy, 1);
+ add_property_string(return_value, "Size", dummy);
add_property_long(return_value, "udate", mail_longdate(cache));
if (en->from && fromlength) {
fulladdress[0] = 0x00;
mail_fetchfrom(fulladdress, imap_le_struct->imap_stream, msgno, fromlength);
- add_property_string(return_value, "fetchfrom", fulladdress, 1);
+ add_property_string(return_value, "fetchfrom", fulladdress);
}
if (en->subject && subjectlength) {
fulladdress[0] = 0x00;
mail_fetchsubject(fulladdress, imap_le_struct->imap_stream, msgno, subjectlength);
- add_property_string(return_value, "fetchsubject", fulladdress, 1);
+ add_property_string(return_value, "fetchsubject", fulladdress);
}
}
/* }}} */
array_init(return_value);
cur=IMAPG(imap_sfolders);
while (cur != NIL) {
- add_next_index_string(return_value, cur->LTEXT, 1);
+ add_next_index_string(return_value, cur->LTEXT);
cur=cur->next;
}
mail_free_stringlist (&IMAPG(imap_sfolders));
while (cur != NIL) {
MAKE_STD_ZVAL(mboxob);
object_init(mboxob);
- add_property_string(mboxob, "name", cur->LTEXT, 1);
+ add_property_string(mboxob, "name", cur->LTEXT);
add_property_long(mboxob, "attributes", cur->attributes);
#ifdef IMAP41
delim[0] = (char)cur->delimiter;
delim[1] = 0;
- add_property_string(mboxob, "delimiter", delim, 1);
+ add_property_string(mboxob, "delimiter", delim);
#else
- add_property_string(mboxob, "delimiter", cur->delimiter, 1);
+ add_property_string(mboxob, "delimiter", cur->delimiter);
#endif
add_next_index_object(return_value, mboxob TSRMLS_CC);
cur=cur->next;
add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
add_property_long(return_value, "Size", msize);
rfc822_date(date);
- add_property_string(return_value, "Date", date, 1);
- add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
- add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
+ add_property_string(return_value, "Date", date);
+ add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name);
+ add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox);
add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
}
/* }}} */
MAKE_STD_ZVAL(tovals);
object_init(tovals);
if (addresstmp->mailbox) {
- add_property_string(tovals, "mailbox", addresstmp->mailbox, 1);
+ add_property_string(tovals, "mailbox", addresstmp->mailbox);
}
if (addresstmp->host) {
- add_property_string(tovals, "host", addresstmp->host, 1);
+ add_property_string(tovals, "host", addresstmp->host);
}
if (addresstmp->personal) {
- add_property_string(tovals, "personal", addresstmp->personal, 1);
+ add_property_string(tovals, "personal", addresstmp->personal);
}
if (addresstmp->adl) {
- add_property_string(tovals, "adl", addresstmp->adl, 1);
+ add_property_string(tovals, "adl", addresstmp->adl);
}
add_next_index_object(return_value, tovals TSRMLS_CC);
} while ((addresstmp = addresstmp->next));
if (body->subtype) {
add_property_long(return_value, "ifsubtype", 1);
- add_property_string(return_value, "subtype", body->subtype, 1);
+ add_property_string(return_value, "subtype", body->subtype);
} else {
add_property_long(return_value, "ifsubtype", 0);
}
if (body->description) {
add_property_long(return_value, "ifdescription", 1);
- add_property_string(return_value, "description", body->description, 1);
+ add_property_string(return_value, "description", body->description);
} else {
add_property_long(return_value, "ifdescription", 0);
}
if (body->id) {
add_property_long(return_value, "ifid", 1);
- add_property_string(return_value, "id", body->id, 1);
+ add_property_string(return_value, "id", body->id);
} else {
add_property_long(return_value, "ifid", 0);
}
#ifdef IMAP41
if (body->disposition.type) {
add_property_long(return_value, "ifdisposition", 1);
- add_property_string(return_value, "disposition", body->disposition.type, 1);
+ add_property_string(return_value, "disposition", body->disposition.type);
} else {
add_property_long(return_value, "ifdisposition", 0);
}
do {
MAKE_STD_ZVAL(dparam);
object_init(dparam);
- add_property_string(dparam, "attribute", dpar->attribute, 1);
- add_property_string(dparam, "value", dpar->value, 1);
+ add_property_string(dparam, "attribute", dpar->attribute);
+ add_property_string(dparam, "value", dpar->value);
add_next_index_object(dparametres, dparam TSRMLS_CC);
} while ((dpar = dpar->next));
add_assoc_object(return_value, "dparameters", dparametres TSRMLS_CC);
MAKE_STD_ZVAL(param);
object_init(param);
if (par->attribute) {
- add_property_string(param, "attribute", par->attribute, 1);
+ add_property_string(param, "attribute", par->attribute);
}
if (par->value) {
- add_property_string(param, "value", par->value, 1);
+ add_property_string(param, "value", par->value);
}
add_next_index_object(parametres, param TSRMLS_CC);
MAKE_STD_ZVAL(myoverview);
object_init(myoverview);
if (env->subject) {
- add_property_string(myoverview, "subject", env->subject, 1);
+ add_property_string(myoverview, "subject", env->subject);
}
if (env->from) {
env->from->next=NULL;
address =_php_rfc822_write_address(env->from TSRMLS_CC);
if (address) {
- add_property_string(myoverview, "from", address, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myoverview, "from", address);
+ efree(address);
}
}
if (env->to) {
env->to->next = NULL;
address = _php_rfc822_write_address(env->to TSRMLS_CC);
if (address) {
- add_property_string(myoverview, "to", address, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myoverview, "to", address);
+ efree(address);
}
}
if (env->date) {
- add_property_string(myoverview, "date", env->date, 1);
+ add_property_string(myoverview, "date", env->date);
}
if (env->message_id) {
- add_property_string(myoverview, "message_id", env->message_id, 1);
+ add_property_string(myoverview, "message_id", env->message_id);
}
if (env->references) {
- add_property_string(myoverview, "references", env->references, 1);
+ add_property_string(myoverview, "references", env->references);
}
if (env->in_reply_to) {
- add_property_string(myoverview, "in_reply_to", env->in_reply_to, 1);
+ add_property_string(myoverview, "in_reply_to", env->in_reply_to);
}
add_property_long(myoverview, "size", elt->rfc822_size);
add_property_long(myoverview, "uid", mail_uid(imap_le_struct->imap_stream, i));
cur = IMAPG(imap_alertstack);
while (cur != NIL) {
- add_next_index_string(return_value, cur->LTEXT, 1);
+ add_next_index_string(return_value, cur->LTEXT);
cur = cur->next;
}
mail_free_stringlist(&IMAPG(imap_alertstack));
cur = IMAPG(imap_errorstack);
while (cur != NIL) {
- add_next_index_string(return_value, cur->LTEXT, 1);
+ add_next_index_string(return_value, cur->LTEXT);
cur = cur->next;
}
mail_free_errorlist(&IMAPG(imap_errorstack));
text[charset_token - offset] = 0x00;
MAKE_STD_ZVAL(myobject);
object_init(myobject);
- add_property_string(myobject, "charset", "default", 1);
- add_property_string(myobject, "text", text, 1);
+ add_property_string(myobject, "charset", "default");
+ add_property_string(myobject, "text", text);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
}
if ((encoding_token = (long)php_memnstr(&string[charset_token+2], "?", 1, string+end))) { /* Find token for encoding */
}
MAKE_STD_ZVAL(myobject);
object_init(myobject);
- add_property_string(myobject, "charset", charset, 1);
- add_property_string(myobject, "text", decode, 1);
+ add_property_string(myobject, "charset", charset);
+ add_property_string(myobject, "text", decode);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
/* only free decode if it was allocated by rfc822_qprint or rfc822_base64 */
text[end - charset_token] = 0x00;
MAKE_STD_ZVAL(myobject);
object_init(myobject);
- add_property_string(myobject, "charset", "default", 1);
- add_property_string(myobject, "text", text, 1);
+ add_property_string(myobject, "charset", "default");
+ add_property_string(myobject, "text", text);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
offset = end; /* We have reached the end of the string. */
do {
MAKE_STD_ZVAL(tmpvals);
object_init(tmpvals);
- if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal, 1);
- if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl, 1);
- if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox, 1);
- if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host, 1);
+ if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal);
+ if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl);
+ if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox);
+ if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host);
add_next_index_object(paddress, tmpvals TSRMLS_CC);
} while ((addresstmp = addresstmp->next));
return fulladdress;
object_init(myzvalue);
- if (en->remail) add_property_string(myzvalue, "remail", en->remail, 1);
- if (en->date) add_property_string(myzvalue, "date", en->date, 1);
- if (en->date) add_property_string(myzvalue, "Date", en->date, 1);
- if (en->subject) add_property_string(myzvalue, "subject", en->subject, 1);
- if (en->subject) add_property_string(myzvalue, "Subject", en->subject, 1);
- if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to, 1);
- if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id, 1);
- if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups, 1);
- if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to, 1);
- if (en->references) add_property_string(myzvalue, "references", en->references, 1);
+ if (en->remail) add_property_string(myzvalue, "remail", en->remail);
+ if (en->date) add_property_string(myzvalue, "date", en->date);
+ if (en->date) add_property_string(myzvalue, "Date", en->date);
+ if (en->subject) add_property_string(myzvalue, "subject", en->subject);
+ if (en->subject) add_property_string(myzvalue, "Subject", en->subject);
+ if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to);
+ if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id);
+ if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups);
+ if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to);
+ if (en->references) add_property_string(myzvalue, "references", en->references);
if (en->to) {
MAKE_STD_ZVAL(paddress);
array_init(paddress);
fulladdress = _php_imap_parse_address(en->to, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "toaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "toaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "to", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->from, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "fromaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "fromaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "from", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->cc, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "ccaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "ccaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "cc", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->bcc, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "bccaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "bccaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "bcc", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->reply_to, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "reply_toaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "reply_toaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "reply_to", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->sender, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "senderaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "senderaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "sender", paddress TSRMLS_CC);
}
array_init(paddress);
fulladdress = _php_imap_parse_address(en->return_path, paddress TSRMLS_CC);
if (fulladdress) {
- add_property_string(myzvalue, "return_pathaddress", fulladdress, 0);
+ // TODO: avoid reallocation ???
+ add_property_string(myzvalue, "return_pathaddress", fulladdress);
+ efree(fulladdress);
}
add_assoc_object(myzvalue, "return_path", paddress TSRMLS_CC);
}
if (body->subtype) {
add_property_long(arg, "ifsubtype", 1);
- add_property_string(arg, "subtype", body->subtype, 1);
+ add_property_string(arg, "subtype", body->subtype);
} else {
add_property_long(arg, "ifsubtype", 0);
}
if (body->description) {
add_property_long(arg, "ifdescription", 1);
- add_property_string(arg, "description", body->description, 1);
+ add_property_string(arg, "description", body->description);
} else {
add_property_long(arg, "ifdescription", 0);
}
if (body->id) {
add_property_long(arg, "ifid", 1);
- add_property_string(arg, "id", body->id, 1);
+ add_property_string(arg, "id", body->id);
} else {
add_property_long(arg, "ifid", 0);
}
#ifdef IMAP41
if (body->disposition.type) {
add_property_long(arg, "ifdisposition", 1);
- add_property_string(arg, "disposition", body->disposition.type, 1);
+ add_property_string(arg, "disposition", body->disposition.type);
} else {
add_property_long(arg, "ifdisposition", 0);
}
do {
MAKE_STD_ZVAL(dparam);
object_init(dparam);
- add_property_string(dparam, "attribute", dpar->attribute, 1);
- add_property_string(dparam, "value", dpar->value, 1);
+ add_property_string(dparam, "attribute", dpar->attribute);
+ add_property_string(dparam, "value", dpar->value);
add_next_index_object(dparametres, dparam TSRMLS_CC);
} while ((dpar = dpar->next));
add_assoc_object(arg, "dparameters", dparametres TSRMLS_CC);
MAKE_STD_ZVAL(param);
object_init(param);
if (par->attribute) {
- add_property_string(param, "attribute", par->attribute, 1);
+ add_property_string(param, "attribute", par->attribute);
}
if (par->value) {
- add_property_string(param, "value", par->value, 1);
+ add_property_string(param, "value", par->value);
}
add_next_index_object(parametres, param TSRMLS_CC);
array_init(return_value);
- add_index_stringl(return_value, 0, var->sqlname, var->sqlname_length, 1);
- add_assoc_stringl(return_value, "name", var->sqlname, var->sqlname_length, 1);
+ add_index_stringl(return_value, 0, var->sqlname, var->sqlname_length);
+ add_assoc_stringl(return_value, "name", var->sqlname, var->sqlname_length);
- add_index_stringl(return_value, 1, var->aliasname, var->aliasname_length, 1);
- add_assoc_stringl(return_value, "alias", var->aliasname, var->aliasname_length, 1);
+ add_index_stringl(return_value, 1, var->aliasname, var->aliasname_length);
+ add_assoc_stringl(return_value, "alias", var->aliasname, var->aliasname_length);
- add_index_stringl(return_value, 2, var->relname, var->relname_length, 1);
- add_assoc_stringl(return_value, "relation", var->relname, var->relname_length, 1);
+ add_index_stringl(return_value, 2, var->relname, var->relname_length);
+ add_assoc_stringl(return_value, "relation", var->relname, var->relname_length);
len = slprintf(buf, 16, "%d", var->sqllen);
- add_index_stringl(return_value, 3, buf, len, 1);
- add_assoc_stringl(return_value, "length", buf, len, 1);
+ add_index_stringl(return_value, 3, buf, len);
+ add_assoc_stringl(return_value, "length", buf, len);
if (var->sqlscale < 0) {
unsigned short precision = 0;
break;
}
len = slprintf(buf, 16, "NUMERIC(%d,%d)", precision, -var->sqlscale);
- add_index_stringl(return_value, 4, s, len, 1);
- add_assoc_stringl(return_value, "type", s, len, 1);
+ add_index_stringl(return_value, 4, s, len);
+ add_assoc_stringl(return_value, "type", s, len);
} else {
switch (var->sqltype & ~1) {
case SQL_TEXT:
s = "QUAD";
break;
}
- add_index_string(return_value, 4, s, 1);
- add_assoc_string(return_value, "type", s, 1);
+ add_index_string(return_value, 4, s);
+ add_assoc_string(return_value, "type", s);
}
}
/* }}} */
case isc_spb_dbname:
len = isc_vax_integer(result,2);
- add_next_index_stringl(return_value, result +2, len, 1);
+ add_next_index_stringl(return_value, result +2, len);
result += len+2;
}
} while (*result != isc_info_flag_end);
add_next_index_zval(return_value, user);
len = isc_vax_integer(result,2);
- add_assoc_stringl(user, "user_name", result +2, len, 1);
+ add_assoc_stringl(user, "user_name", result +2, len);
result += len+2;
break;
case isc_spb_sec_firstname:
len = isc_vax_integer(result,2);
- add_assoc_stringl(user, "first_name", result +2, len, 1);
+ add_assoc_stringl(user, "first_name", result +2, len);
result += len+2;
break;
case isc_spb_sec_middlename:
len = isc_vax_integer(result,2);
- add_assoc_stringl(user, "middle_name", result +2, len, 1);
+ add_assoc_stringl(user, "middle_name", result +2, len);
result += len+2;
break;
case isc_spb_sec_lastname:
len = isc_vax_integer(result,2);
- add_assoc_stringl(user, "last_name", result +2, len, 1);
+ add_assoc_stringl(user, "last_name", result +2, len);
result += len+2;
break;
}
add_assoc_string_ex(&zv, "type", sizeof("type"),
- const_cast<char*>(typeid(*biter).name()), 1);
+ const_cast<char*>(typeid(*biter).name()));
return Z_ARRVAL(zv);
}
add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 1);
add_assoc_string_ex(&zv, "type", sizeof("type"),
- const_cast<char*>(cal->getType()), 1);
+ const_cast<char*>(cal->getType()));
{
zval ztz = zval_used_for_init,
Locale locale = cal->getLocale(ULOC_VALID_LOCALE, uec);
if (U_SUCCESS(uec)) {
add_assoc_string_ex(&zv, "locale", sizeof("locale"),
- const_cast<char*>(locale.getName()), 1);
+ const_cast<char*>(locale.getName()));
} else {
add_assoc_string_ex(&zv, "locale", sizeof("locale"),
- const_cast<char*>(u_errorName(uec)), 1);
+ const_cast<char*>(u_errorName(uec)));
}
}
if (U_SUCCESS(uec)) {
add_assoc_long(zfields, name, (long)res);
} else {
- add_assoc_string(zfields, name, const_cast<char*>(u_errorName(uec)), 1);
+ add_assoc_string(zfields, name, const_cast<char*>(u_errorName(uec)));
}
}
array_init(return_value);
for (int i = 0; i < count; i++) {
Locale locale = availLocales[i];
- add_next_index_string(return_value, locale.getName(), 1);
+ add_next_index_string(return_value, locale.getName());
}
}
array_init(&caller);
Z_ADDREF_P(zobj);
add_index_zval(&caller, 0, zobj);
- add_index_string(&caller, 1, callback_name, 1);
+ add_index_string(&caller, 1, callback_name);
if (zend_fcall_info_init(&caller, 0, finfo, fcache, NULL, &errstr TSRMLS_CC) == FAILURE) {
php_converter_throw_failure(objval, U_INTERNAL_PROGRAM_ERROR TSRMLS_CC, "Error setting converter callback: %s", errstr);
}
array_init(return_value);
for(i = 0; i < count; i++) {
const char *name = ucnv_getAvailableName(i);
- add_next_index_string(return_value, name, 1);
+ add_next_index_string(return_value, name);
}
}
/* }}} */
zval_dtor(return_value);
RETURN_NULL();
}
- add_next_index_string(return_value, alias, 1);
+ add_next_index_string(return_value, alias);
}
}
/* }}} */
zval_dtor(return_value);
RETURN_NULL();
}
- add_next_index_string(return_value, name, 1);
+ add_next_index_string(return_value, name);
}
}
/* }}} */
RETURN_FALSE;
}
- add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len);
+ efree(kw_value);
} /* end of while */
} /* end of if e!=NULL */
}
cur_key_name = (char*)ecalloc( 25, 25);
sprintf( cur_key_name , "%s%d", key_name , cnt++);
- add_assoc_string( hash_arr, cur_key_name , token ,TRUE );
+ add_assoc_string( hash_arr, cur_key_name , token);
/* tokenize on the "_" or "-" and stop at singleton if any */
while( (token = php_strtok_r(NULL , DELIMITER , &last_ptr)) && (strlen(token)>1) ){
sprintf( cur_key_name , "%s%d", key_name , cnt++);
- add_assoc_string( hash_arr, cur_key_name , token , TRUE );
+ add_assoc_string( hash_arr, cur_key_name , token);
}
/*
if( strcmp(key_name, LOC_PRIVATE_TAG) == 0 ){
}
} else {
if( result == 1 ){
- add_assoc_string( hash_arr, key_name , key_value , TRUE );
+ add_assoc_string( hash_arr, key_name , key_value);
cur_result = 1;
}
}
grOffset = findOffset( LOC_GRANDFATHERED , loc_name );
if( grOffset >= 0 ){
- add_assoc_string( return_value , LOC_GRANDFATHERED_LANG_TAG , estrdup(loc_name) ,FALSE );
+ add_assoc_string( return_value , LOC_GRANDFATHERED_LANG_TAG , loc_name);
}
else{
/* Not grandfathered */
if( result > 0 && variant){
/* Tokenize on the "_" or "-" */
token = php_strtok_r( variant , DELIMITER , &saved_ptr);
- add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
+ add_next_index_stringl( return_value, token , strlen(token));
/* tokenize on the "_" or "-" and stop at singleton if any */
while( (token = php_strtok_r(NULL , DELIMITER, &saved_ptr)) && (strlen(token)>1) ){
- add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
+ add_next_index_stringl( return_value, token , strlen(token));
}
}
if( variant ){
array_init( return_value );
while ((entry = uenum_next( icuenum, &entry_len, &icuerror ))) {
- add_next_index_stringl( return_value, (char *) entry, entry_len, 1 );
+ add_next_index_stringl( return_value, (char *) entry, entry_len);
}
uenum_close( icuenum );
}
if (U_FAILURE(uec)) {
return Z_ARRVAL(zv);
}
- add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len);
+ efree(str);
int32_t rawOffset, dstOffset;
UDate now = Calendar::getNow();
}
else
{
- add_next_index_stringl( return_value, el_char, el_len, 0 );
+ // TODO: avoid reallocation ???
+ add_next_index_stringl( return_value, el_char, el_len);
+ efree(el_char);
}
}
uenum_close( en );
array_init(tmp2);
add_assoc_long(tmp2, "count", num_values);
for (i = 0; i < num_values; i++) {
- add_index_stringl(tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+ add_index_stringl(tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
}
ldap_value_free_len(ldap_value);
attr_len = strlen(attribute);
zend_hash_update(Z_ARRVAL_P(tmp1), php_strtolower(attribute, attr_len), attr_len+1, (void *) &tmp2, sizeof(zval *), NULL);
- add_index_string(tmp1, num_attrib, attribute, 1);
+ add_index_string(tmp1, num_attrib, attribute);
num_attrib++;
#if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
add_assoc_long(tmp1, "count", num_attrib);
dn = ldap_get_dn(ldap, ldap_result_entry);
- add_assoc_string(tmp1, "dn", dn, 1);
+ add_assoc_string(tmp1, "dn", dn);
#if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
ldap_memfree(dn);
#else
array_init(tmp);
add_assoc_long(tmp, "count", num_values);
for (i = 0; i < num_values; i++) {
- add_index_stringl(tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+ add_index_stringl(tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
}
ldap_value_free_len(ldap_value);
zend_hash_update(Z_ARRVAL_P(return_value), attribute, strlen(attribute)+1, (void *) &tmp, sizeof(zval *), NULL);
- add_index_string(return_value, num_attrib, attribute, 1);
+ add_index_string(return_value, num_attrib, attribute);
num_attrib++;
#if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
array_init(return_value);
for (i=0; i<num_values; i++) {
- add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len, 1);
+ add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len);
}
add_assoc_long(return_value, "count", num_values);
add_assoc_long(return_value, "count", count);
for (i = 0; i<count; i++) {
- add_index_string(return_value, i, ldap_value[i], 1);
+ add_index_string(return_value, i, ldap_value[i]);
}
ldap_value_free(ldap_value);
if (lreferrals != NULL) {
refp = lreferrals;
while (*refp) {
- add_next_index_string(referrals, *refp, 1);
+ add_next_index_string(referrals, *refp);
refp++;
}
ldap_value_free(lreferrals);
if (lreferrals != NULL) {
refp = lreferrals;
while (*refp) {
- add_next_index_string(referrals, *refp, 1);
+ add_next_index_string(referrals, *refp);
refp++;
}
ldap_value_free(lreferrals);
/* return a PHP control object */
array_init(return_value);
- add_assoc_string(return_value, "oid", ctrl.ldctl_oid, 1);
+ add_assoc_string(return_value, "oid", ctrl.ldctl_oid);
if (ctrl.ldctl_value.bv_len) {
- add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len, 1);
+ add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len);
}
if (ctrl.ldctl_iscritical) {
add_assoc_bool(return_value, "iscritical", ctrl.ldctl_iscritical);
add_assoc_null_ex(ctxzv, #memb, sizeof(#memb) - 1); \
} else { \
add_assoc_string_ex(ctxzv, #memb, sizeof(#memb - 1), \
- (char *)context->memb, 1); \
+ (char *)context->memb); \
}
ADD_NULL_OR_STRING_KEY(directory)
add_property_long(return_value, "code", error->code);
add_property_long(return_value, "column", error->int2);
if (error->message) {
- add_property_string(return_value, "message", error->message, 1);
+ add_property_string(return_value, "message", error->message);
} else {
- add_property_stringl(return_value, "message", "", 0, 1);
+ add_property_stringl(return_value, "message", "", 0);
}
if (error->file) {
- add_property_string(return_value, "file", error->file, 1);
+ add_property_string(return_value, "file", error->file);
} else {
- add_property_stringl(return_value, "file", "", 0, 1);
+ add_property_stringl(return_value, "file", "", 0);
}
add_property_long(return_value, "line", error->line);
} else {
add_property_long(&z_error, "code", error->code);
add_property_long(&z_error, "column", error->int2);
if (error->message) {
- add_property_string(&z_error, "message", error->message, 1);
+ add_property_string(&z_error, "message", error->message);
} else {
- add_property_stringl(&z_error, "message", "", 0, 1);
+ add_property_stringl(&z_error, "message", "", 0);
}
if (error->file) {
- add_property_string(&z_error, "file", error->file, 1);
+ add_property_string(&z_error, "file", error->file);
} else {
- add_property_stringl(&z_error, "file", "", 0, 1);
+ add_property_stringl(&z_error, "file", "", 0);
}
add_property_long(&z_error, "line", error->line);
add_next_index_zval(return_value, &z_error);
size_t i;
array_init(return_value);
for (i = 0; i < n; i++) {
- add_next_index_string(return_value, (*entry)->name, 1);
+ add_next_index_string(return_value, (*entry)->name);
entry++;
}
retname = 0;
const mbfl_encoding **entry = MBSTRG(current_detect_order_list);
array_init(return_value);
for (i = 0; i < n; i++) {
- add_next_index_string(return_value, (*entry)->name, 1);
+ add_next_index_string(return_value, (*entry)->name);
entry++;
}
} else {
i = 0;
encodings = mbfl_get_supported_encodings();
while ((encoding = encodings[i++]) != NULL) {
- add_next_index_string(return_value, (char *) encoding->name, 1);
+ add_next_index_string(return_value, (char *) encoding->name);
}
}
/* }}} */
if (encoding->aliases != NULL) {
const char **alias;
for (alias = *encoding->aliases; *alias; ++alias) {
- add_next_index_string(return_value, (char *)*alias, 1);
+ add_next_index_string(return_value, (char *)*alias);
}
}
}
if (!typ || !strcasecmp("all", typ)) {
array_init(return_value);
if (MBSTRG(current_internal_encoding)) {
- add_assoc_string(return_value, "internal_encoding", (char *)MBSTRG(current_internal_encoding)->name, 1);
+ add_assoc_string(return_value, "internal_encoding", (char *)MBSTRG(current_internal_encoding)->name);
}
if (MBSTRG(http_input_identify)) {
- add_assoc_string(return_value, "http_input", (char *)MBSTRG(http_input_identify)->name, 1);
+ add_assoc_string(return_value, "http_input", (char *)MBSTRG(http_input_identify)->name);
}
if (MBSTRG(current_http_output_encoding)) {
- add_assoc_string(return_value, "http_output", (char *)MBSTRG(current_http_output_encoding)->name, 1);
+ add_assoc_string(return_value, "http_output", (char *)MBSTRG(current_http_output_encoding)->name);
}
if ((name = (char *)zend_ini_string("mbstring.http_output_conv_mimetypes", sizeof("mbstring.http_output_conv_mimetypes") - 1, 0)) != NULL) {
- add_assoc_string(return_value, "http_output_conv_mimetypes", name, 1);
+ add_assoc_string(return_value, "http_output_conv_mimetypes", name);
}
add_assoc_long(return_value, "func_overload", MBSTRG(func_overload));
if (MBSTRG(func_overload)){
array_init(&row1);
while (over_func->type > 0) {
if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
- add_assoc_string(&row1, over_func->orig_func, over_func->ovld_func, 1);
+ add_assoc_string(&row1, over_func->orig_func, over_func->ovld_func);
}
over_func++;
}
add_assoc_zval(return_value, "func_overload_list", &row1);
} else {
- add_assoc_string(return_value, "func_overload_list", "no overload", 1);
+ add_assoc_string(return_value, "func_overload_list", "no overload");
}
if (lang != NULL) {
if ((name = (char *)mbfl_no_encoding2name(lang->mail_charset)) != NULL) {
- add_assoc_string(return_value, "mail_charset", name, 1);
+ add_assoc_string(return_value, "mail_charset", name);
}
if ((name = (char *)mbfl_no_encoding2name(lang->mail_header_encoding)) != NULL) {
- add_assoc_string(return_value, "mail_header_encoding", name, 1);
+ add_assoc_string(return_value, "mail_header_encoding", name);
}
if ((name = (char *)mbfl_no_encoding2name(lang->mail_body_encoding)) != NULL) {
- add_assoc_string(return_value, "mail_body_encoding", name, 1);
+ add_assoc_string(return_value, "mail_body_encoding", name);
}
}
add_assoc_long(return_value, "illegal_chars", MBSTRG(illegalchars));
if (MBSTRG(encoding_translation)) {
- add_assoc_string(return_value, "encoding_translation", "On", 1);
+ add_assoc_string(return_value, "encoding_translation", "On");
} else {
- add_assoc_string(return_value, "encoding_translation", "Off", 1);
+ add_assoc_string(return_value, "encoding_translation", "Off");
}
if ((name = (char *)mbfl_no_language2name(MBSTRG(language))) != NULL) {
- add_assoc_string(return_value, "language", name, 1);
+ add_assoc_string(return_value, "language", name);
}
n = MBSTRG(current_detect_order_list_size);
entry = MBSTRG(current_detect_order_list);
size_t i;
array_init(&row2);
for (i = 0; i < n; i++) {
- add_next_index_string(&row2, (*entry)->name, 1);
+ add_next_index_string(&row2, (*entry)->name);
entry++;
}
add_assoc_zval(return_value, "detect_order", &row2);
}
if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
- add_assoc_string(return_value, "substitute_character", "none", 1);
+ add_assoc_string(return_value, "substitute_character", "none");
} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG) {
- add_assoc_string(return_value, "substitute_character", "long", 1);
+ add_assoc_string(return_value, "substitute_character", "long");
} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY) {
- add_assoc_string(return_value, "substitute_character", "entity", 1);
+ add_assoc_string(return_value, "substitute_character", "entity");
} else {
add_assoc_long(return_value, "substitute_character", MBSTRG(current_filter_illegal_substchar));
}
if (MBSTRG(strict_detection)) {
- add_assoc_string(return_value, "strict_detection", "On", 1);
+ add_assoc_string(return_value, "strict_detection", "On");
} else {
- add_assoc_string(return_value, "strict_detection", "Off", 1);
+ add_assoc_string(return_value, "strict_detection", "Off");
}
} else if (!strcasecmp("internal_encoding", typ)) {
if (MBSTRG(current_internal_encoding)) {
array_init(return_value);
while (over_func->type > 0) {
if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
- add_assoc_string(return_value, over_func->orig_func, over_func->ovld_func, 1);
+ add_assoc_string(return_value, over_func->orig_func, over_func->ovld_func);
}
over_func++;
}
size_t i;
array_init(return_value);
for (i = 0; i < n; i++) {
- add_next_index_string(return_value, (*entry)->name, 1);
+ add_next_index_string(return_value, (*entry)->name);
entry++;
}
}
beg = regs->beg[i];
end = regs->end[i];
if (beg >= 0 && beg < end && end <= string_len) {
- add_index_stringl(array, i, (char *)&str[beg], end - beg, 1);
+ add_index_stringl(array, i, (char *)&str[beg], end - beg);
} else {
add_index_bool(array, i, 0);
}
array_init(&subpats);
for (i = 0; i < regs->num_regs; i++) {
- add_next_index_stringl(&subpats, string + regs->beg[i], regs->end[i] - regs->beg[i], 1);
+ add_next_index_stringl(&subpats, string + regs->beg[i], regs->end[i] - regs->beg[i]);
}
ZVAL_COPY_VALUE(&args[0], &subpats);
/* add it to the array */
if ((pos - (OnigUChar *)string) < end) {
if (beg < string_len && beg >= (chunk_pos - (OnigUChar *)string)) {
- add_next_index_stringl(return_value, (char *)chunk_pos, ((OnigUChar *)(string + beg) - chunk_pos), 1);
+ add_next_index_stringl(return_value, (char *)chunk_pos, ((OnigUChar *)(string + beg) - chunk_pos));
--count;
} else {
err = -2;
/* otherwise we just have one last element to add to the array */
n = ((OnigUChar *)(string + string_len) - chunk_pos);
if (n > 0) {
- add_next_index_stringl(return_value, (char *)chunk_pos, n, 1);
+ add_next_index_stringl(return_value, (char *)chunk_pos, n);
} else {
- add_next_index_stringl(return_value, "", 0, 1);
+ add_next_index_stringl(return_value, "", 0);
}
}
/* }}} */
beg = MBREX(search_regs)->beg[i];
end = MBREX(search_regs)->end[i];
if (beg >= 0 && beg <= end && end <= len) {
- add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
+ add_index_stringl(return_value, i, (char *)&str[beg], end - beg);
} else {
add_index_bool(return_value, i, 0);
}
beg = MBREX(search_regs)->beg[i];
end = MBREX(search_regs)->end[i];
if (beg >= 0 && beg <= end && end <= len) {
- add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
+ add_index_stringl(return_value, i, (char *)&str[beg], end - beg);
} else {
add_index_bool(return_value, i, 0);
}
php_error_docref(NULL TSRMLS_CC, E_WARNING, "No algorithms found in module dir");
}
for (i = 0; i < count; i++) {
- add_index_string(return_value, i, modules[i], 1);
+ add_index_string(return_value, i, modules[i]);
}
mcrypt_free_p(modules, count);
}
php_error_docref(NULL TSRMLS_CC, E_WARNING, "No modes found in module dir");
}
for (i = 0; i < count; i++) {
- add_index_string(return_value, i, modules[i], 1);
+ add_index_string(return_value, i, modules[i]);
}
mcrypt_free_p(modules, count);
}
data_len = Z_STRLEN(result->data[result->cur_row][i]);
if (result_type & MSSQL_NUM) {
- add_index_stringl(return_value, i, data, data_len, 1);
+ add_index_stringl(return_value, i, data, data_len);
}
if (result_type & MSSQL_ASSOC) {
- add_assoc_stringl(return_value, result->fields[i].name, data, data_len, 1);
+ add_assoc_stringl(return_value, result->fields[i].name, data, data_len);
}
}
else if (Z_TYPE(result->data[result->cur_row][i]) == IS_LONG) {
object_init(return_value);
- add_property_string(return_value, "name",result->fields[field_offset].name, 1);
+ add_property_string(return_value, "name",result->fields[field_offset].name);
add_property_long(return_value, "max_length",result->fields[field_offset].max_length);
- add_property_string(return_value, "column_source",result->fields[field_offset].column_source, 1);
+ add_property_string(return_value, "column_source",result->fields[field_offset].column_source);
add_property_long(return_value, "numeric", result->fields[field_offset].numeric);
- add_property_string(return_value, "type", php_mssql_get_field_name(Z_TYPE(result->fields[field_offset])), 1);
+ add_property_string(return_value, "type", php_mssql_get_field_name(Z_TYPE(result->fields[field_offset])));
}
/* }}} */
}
object_init(return_value);
- add_property_string(return_value, "name", (mysql_field->name?mysql_field->name:""), 1);
- add_property_string(return_value, "table", (mysql_field->table?mysql_field->table:""), 1);
- add_property_string(return_value, "def", (mysql_field->def?mysql_field->def:""), 1);
+ add_property_string(return_value, "name", (mysql_field->name?mysql_field->name:""));
+ add_property_string(return_value, "table", (mysql_field->table?mysql_field->table:""));
+ add_property_string(return_value, "def", (mysql_field->def?mysql_field->def:""));
add_property_long(return_value, "max_length", mysql_field->max_length);
add_property_long(return_value, "not_null", IS_NOT_NULL(mysql_field->flags)?1:0);
add_property_long(return_value, "primary_key", IS_PRI_KEY(mysql_field->flags)?1:0);
add_property_long(return_value, "unique_key", (mysql_field->flags&UNIQUE_KEY_FLAG?1:0));
add_property_long(return_value, "numeric", IS_NUM(mysql_field->type)?1:0);
add_property_long(return_value, "blob", IS_BLOB(mysql_field->flags)?1:0);
- add_property_string(return_value, "type", php_mysql_get_field_name(mysql_field->type), 1);
+ add_property_string(return_value, "type", php_mysql_get_field_name(mysql_field->type));
add_property_long(return_value, "unsigned", (mysql_field->flags&UNSIGNED_FLAG?1:0));
add_property_long(return_value, "zerofill", (mysql_field->flags&ZEROFILL_FLAG?1:0));
}
/* {{{ php_add_field_properties */
static void php_add_field_properties(zval *value, const MYSQL_FIELD *field TSRMLS_DC)
{
- add_property_string(value, "name",(field->name ? field->name : ""), 1);
- add_property_string(value, "orgname",(field->org_name ? field->org_name : ""), 1);
- add_property_string(value, "table",(field->table ? field->table : ""), 1);
- add_property_string(value, "orgtable",(field->org_table ? field->org_table : ""), 1);
- add_property_string(value, "def",(field->def ? field->def : ""), 1);
- add_property_string(value, "db",(field->db ? field->db : ""), 1);
+ add_property_string(value, "name",(field->name ? field->name : ""));
+ add_property_string(value, "orgname",(field->org_name ? field->org_name : ""));
+ add_property_string(value, "table",(field->table ? field->table : ""));
+ add_property_string(value, "orgtable",(field->org_table ? field->org_table : ""));
+ add_property_string(value, "def",(field->def ? field->def : ""));
+ add_property_string(value, "db",(field->db ? field->db : ""));
/* FIXME: manually set the catalog to "def" due to bug in
* libmysqlclient which does not initialize field->catalog
* and in addition, the catalog is always be "def"
*/
- add_property_string(value, "catalog", "def", 1);
+ add_property_string(value, "catalog", "def");
add_property_long(value, "max_length", field->max_length);
add_property_long(value, "length", field->length);
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+ add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
add_next_index_zval(return_value, single_error);
}
}
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_errno(mysql->mysql));
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql), 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql), 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql));
+ add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql));
add_next_index_zval(return_value, single_error);
}
#endif
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+ add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
add_next_index_zval(return_value, single_error);
}
}
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_stmt_errno(stmt->stmt));
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt), 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt), 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt));
+ add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt));
add_next_index_zval(return_value, single_error);
}
#endif
#endif
object_init(return_value);
- add_property_string(return_value, "charset", (name) ? (char *)name : "", 1);
- add_property_string(return_value, "collation",(collation) ? (char *)collation : "", 1);
- add_property_string(return_value, "dir", (dir) ? (char *)dir : "", 1);
+ add_property_string(return_value, "charset", (name) ? (char *)name : "");
+ add_property_string(return_value, "collation",(collation) ? (char *)collation : "");
+ add_property_string(return_value, "dir", (dir) ? (char *)dir : "");
add_property_long(return_value, "min_length", minlength);
add_property_long(return_value, "max_length", maxlength);
add_property_long(return_value, "number", number);
add_property_long(return_value, "state", state);
- add_property_string(return_value, "comment", (comment) ? (char *)comment : "", 1);
+ add_property_string(return_value, "comment", (comment) ? (char *)comment : "");
}
/* }}} */
#endif
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+ add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
add_next_index_zval(*retval, single_error);
}
}
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_errno(mysql->mysql));
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql), 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql), 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql));
+ add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql));
add_next_index_zval(*retval, single_error);
}
#endif
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+ add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
add_next_index_zval(*retval, single_error);
}
}
MAKE_STD_ZVAL(single_error);
array_init(single_error);
add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_stmt_errno(stmt->stmt));
- add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt), 1);
- add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt), 1);
+ add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt));
+ add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt));
add_next_index_zval(*retval, single_error);
}
#endif
char tmp[25];
sprintf((char *)&tmp, MYSQLND_LLU_SPEC, stats->values[i]);
- add_assoc_string_ex(return_value, names[i].s, names[i].l + 1, tmp, 1);
+ add_assoc_string_ex(return_value, names[i].s, names[i].l + 1, tmp);
}
}
/* }}} */
if (errcode) {
array_init(return_value);
add_assoc_long(return_value, "code", errcode);
- add_assoc_string(return_value, "message", (char*) errbuf, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_string(return_value, "message", (char*) errbuf);
+ efree(errbuf);
add_assoc_long(return_value, "offset", error_offset);
- add_assoc_string(return_value, "sqltext", sqltext ? (char *) sqltext : "", 1);
+ add_assoc_string(return_value, "sqltext", sqltext ? (char *) sqltext : "");
} else {
RETURN_FALSE;
}
add_next_index_null(bind->zval);
} else {
connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
- add_next_index_stringl(bind->zval, (char *)buff, buff_len, 1);
+ add_next_index_stringl(bind->zval, (char *)buff, buff_len);
}
}
}
ZVAL_STRINGL(*entry, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
zend_hash_move_forward(hash);
} else {
- add_next_index_stringl(bind->zval, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
+ add_next_index_stringl(bind->zval, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length);
}
}
break;
array_init(return_value);
- add_assoc_string_ex(return_value, "server", sizeof("server"), server_name, 1);
- add_assoc_string_ex(return_value, "description", sizeof("description"), desc, 1);
+ add_assoc_string_ex(return_value, "server", sizeof("server"), server_name);
+ add_assoc_string_ex(return_value, "description", sizeof("description"), desc);
}
/* }}} */
str = asctime(ta);
len = strlen(str);
if (len > 0 && str[len - 1] == '\n') len--;
- add_assoc_stringl(&persistent_script_report, "last_used", str, len, 1);
+ add_assoc_stringl(&persistent_script_report, "last_used", str, len);
add_assoc_long(&persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
if (ZCG(accel_directives).validate_timestamps) {
add_assoc_long(&persistent_script_report, "timestamp", (long)script->timestamp);
static int add_blacklist_path(zend_blacklist_entry *p, zval *return_value TSRMLS_DC)
{
- add_next_index_stringl(return_value, p->path, p->path_length, 1);
+ add_next_index_stringl(return_value, p->path, p->path_length);
return 0;
}
add_assoc_long(&directives, "opcache.consistency_checks", ZCG(accel_directives).consistency_checks);
add_assoc_long(&directives, "opcache.force_restart_timeout", ZCG(accel_directives).force_restart_timeout);
add_assoc_long(&directives, "opcache.revalidate_freq", ZCG(accel_directives).revalidate_freq);
- add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model), 1);
- add_assoc_string(&directives, "opcache.blacklist_filename", STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename), 1);
+ add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model));
+ add_assoc_string(&directives, "opcache.blacklist_filename", STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename));
add_assoc_long(&directives, "opcache.max_file_size", ZCG(accel_directives).max_file_size);
- add_assoc_string(&directives, "opcache.error_log", STRING_NOT_NULL(ZCG(accel_directives).error_log), 1);
+ add_assoc_string(&directives, "opcache.error_log", STRING_NOT_NULL(ZCG(accel_directives).error_log));
add_assoc_bool(&directives, "opcache.protect_memory", ZCG(accel_directives).protect_memory);
add_assoc_bool(&directives, "opcache.save_comments", ZCG(accel_directives).save_comments);
/*version */
array_init(&version);
- add_assoc_string(&version, "version", ACCELERATOR_VERSION, 1);
- add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME, 1);
+ add_assoc_string(&version, "version", ACCELERATOR_VERSION);
+ add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME);
add_assoc_zval(return_value, "version", &version);
/* blacklist */
if (zend_hash_find(Z_ARRVAL_P(subitem), sname, strlen(sname)+1, (void**)&data) == SUCCESS) {
if (Z_TYPE_PP(data) == IS_ARRAY) {
subentries = *data;
- add_next_index_stringl(subentries, (char *)to_add, to_add_len, 1);
+ add_next_index_stringl(subentries, (char *)to_add, to_add_len);
} else if (Z_TYPE_PP(data) == IS_STRING) {
MAKE_STD_ZVAL(subentries);
array_init(subentries);
- add_next_index_stringl(subentries, Z_STRVAL_PP(data), Z_STRLEN_PP(data), 1);
- add_next_index_stringl(subentries, (char *)to_add, to_add_len, 1);
+ add_next_index_stringl(subentries, Z_STRVAL_PP(data), Z_STRLEN_PP(data));
+ add_next_index_stringl(subentries, (char *)to_add, to_add_len);
zend_hash_update(Z_ARRVAL_P(subitem), sname, strlen(sname)+1, &subentries, sizeof(zval*), NULL);
}
} else {
- add_assoc_stringl(subitem, sname, (char *)to_add, to_add_len, 1);
+ add_assoc_stringl(subitem, sname, (char *)to_add, to_add_len);
}
}
}
static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */
{
- add_assoc_stringl(val, key, (char *)str->data, str->length, 1);
+ add_assoc_stringl(val, key, (char *)str->data, str->length);
}
/* }}} */
array_init(return_value);
if (cert->name) {
- add_assoc_string(return_value, "name", cert->name, 1);
+ add_assoc_string(return_value, "name", cert->name);
}
/* add_assoc_bool(return_value, "valid", cert->valid); */
{
char buf[32];
snprintf(buf, sizeof(buf), "%08lx", X509_subject_name_hash(cert));
- add_assoc_string(return_value, "hash", buf, 1);
+ add_assoc_string(return_value, "hash", buf);
}
add_assoc_name_entry(return_value, "issuer", X509_get_issuer_name(cert), useshortnames TSRMLS_CC);
add_assoc_long(return_value, "version", X509_get_version(cert));
- add_assoc_string(return_value, "serialNumber", i2s_ASN1_INTEGER(NULL, X509_get_serialNumber(cert)), 1);
+ add_assoc_string(return_value, "serialNumber", i2s_ASN1_INTEGER(NULL, X509_get_serialNumber(cert)));
add_assoc_asn1_string(return_value, "validFrom", X509_get_notBefore(cert));
add_assoc_asn1_string(return_value, "validTo", X509_get_notAfter(cert));
tmpstr = (char *)X509_alias_get0(cert, NULL);
if (tmpstr) {
- add_assoc_string(return_value, "alias", tmpstr, 1);
+ add_assoc_string(return_value, "alias", tmpstr);
}
/*
add_assoc_long(return_value, "signaturetypeLONG", X509_get_signature_type(cert));
- add_assoc_string(return_value, "signaturetype", OBJ_nid2sn(X509_get_signature_type(cert)), 1);
- add_assoc_string(return_value, "signaturetypeLN", OBJ_nid2ln(X509_get_signature_type(cert)), 1);
+ add_assoc_string(return_value, "signaturetype", OBJ_nid2sn(X509_get_signature_type(cert)));
+ add_assoc_string(return_value, "signaturetypeLN", OBJ_nid2ln(X509_get_signature_type(cert)));
*/
MAKE_STD_ZVAL(subitem);
array_init(subitem);
add_index_bool(subsub, 1, purpset);
pname = useshortnames ? X509_PURPOSE_get0_sname(purp) : X509_PURPOSE_get0_name(purp);
- add_index_string(subsub, 2, pname, 1);
+ add_index_string(subsub, 2, pname);
/* NOTE: if purpset > 1 then it's a warning - we should mention it ? */
if (nid == NID_subject_alt_name) {
if (openssl_x509v3_subjectAltName(bio_out, extension) == 0) {
BIO_get_mem_ptr(bio_out, &bio_buf);
- add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length, 1);
+ add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length);
} else {
zval_dtor(return_value);
if (certresource == -1 && cert) {
}
else if (X509V3_EXT_print(bio_out, extension, 0, 0)) {
BIO_get_mem_ptr(bio_out, &bio_buf);
- add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length, 1);
+ add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length);
} else {
add_assoc_asn1_string(subitem, extname, X509_EXTENSION_get_data(extension));
}
char *str = emalloc(len + 1); \
BN_bn2bin(pkey->pkey._type->_name, (unsigned char*)str); \
str[len] = 0; \
- add_assoc_stringl(_type, #_name, str, len, 0); \
+ /* TODO: avoid reallocation ??? */ \
+ add_assoc_stringl(_type, #_name, str, len); \
+ efree(str); \
} \
} while (0)
array_init(return_value);
add_assoc_long(return_value, "bits", EVP_PKEY_bits(pkey));
- add_assoc_stringl(return_value, "key", pbio, pbio_len, 1);
+ add_assoc_stringl(return_value, "key", pbio, pbio_len);
/*TODO: Use the real values once the openssl constants are used
* See the enum at the top of this file
*/
array_init(ekeys);
for (i=0; i<nkeys; i++) {
eks[i][eksl[i]] = '\0';
- add_next_index_stringl(ekeys, erealloc(eks[i], eksl[i] + 1), eksl[i], 0);
+ add_next_index_stringl(ekeys, eks[i], eksl[i]);
+ efree(eks[i]);
eks[i] = NULL;
}
#if 0
static void openssl_add_method_or_alias(const OBJ_NAME *name, void *arg) /* {{{ */
{
- add_next_index_string((zval*)arg, (char*)name->name, 1);
+ add_next_index_string((zval*)arg, (char*)name->name);
}
/* }}} */
static void openssl_add_method(const OBJ_NAME *name, void *arg) /* {{{ */
{
if (name->alias == 0) {
- add_next_index_string((zval*)arg, (char*)name->name, 1);
+ add_next_index_string((zval*)arg, (char*)name->name);
}
}
/* }}} */
array_init(&match_pair);
/* Add (match, offset) to the return value */
- add_next_index_stringl(&match_pair, str, len, 1);
+ add_next_index_stringl(&match_pair, str, len);
add_next_index_long(&match_pair, offset);
if (name) {
}
if (subpats) {
- ZVAL_DEREF_REF(subpats);
+ ZVAL_DEREF(subpats);
}
php_pcre_match_impl(pce, subject, subject_len, return_value, subpats,
global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC);
offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], NULL);
} else {
add_next_index_stringl(&match_sets[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
+ offsets[(i<<1)+1] - offsets[i<<1]);
}
}
/*
*/
if (count < num_subpats) {
for (; i < num_subpats; i++) {
- add_next_index_string(&match_sets[i], "", 1);
+ add_next_index_string(&match_sets[i], "");
}
}
} else {
} else {
if (subpat_names[i]) {
add_assoc_stringl(&result_set, subpat_names[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
+ offsets[(i<<1)+1] - offsets[i<<1]);
}
add_next_index_stringl(&result_set, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
+ offsets[(i<<1)+1] - offsets[i<<1]);
}
}
/* And add it to the output array */
} else {
if (subpat_names[i]) {
add_assoc_stringl(subpats, subpat_names[i], (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
+ offsets[(i<<1)+1] - offsets[i<<1]);
}
add_next_index_stringl(subpats, (char *)stringlist[i],
- offsets[(i<<1)+1] - offsets[i<<1], 1);
+ offsets[(i<<1)+1] - offsets[i<<1]);
}
}
}
array_init(&args[0]);
for (i = 0; i < count; i++) {
if (subpat_names[i]) {
- add_assoc_stringl(&args[0], subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1], 1);
+ add_assoc_stringl(&args[0], subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1]);
}
- add_next_index_stringl(&args[0], &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1], 1);
+ add_next_index_stringl(&args[0], &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1]);
}
if (call_user_function_ex(EG(function_table), NULL, function, &retval, 1, args, 0, NULL TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
}
}
if (ZEND_NUM_ARGS() > 4) {
- ZVAL_DEREF_REF(zcount);
+ ZVAL_DEREF(zcount);
zval_dtor(zcount);
ZVAL_LONG(zcount, replace_count);
}
} else {
/* Add the piece to the return value */
add_next_index_stringl(return_value, last_match,
- &subject[offsets[0]]-last_match, 1);
+ &subject[offsets[0]]-last_match);
}
/* One less left to do */
} else {
add_next_index_stringl(return_value,
&subject[offsets[i<<1]],
- match_len, 1);
+ match_len);
}
}
}
add_offset_pair(return_value, &subject[start_offset], subject_len - start_offset, start_offset, NULL);
} else {
/* Add the last piece to the return value */
- add_next_index_stringl(return_value, last_match, subject + subject_len - last_match, 1);
+ add_next_index_stringl(return_value, last_match, subject + subject_len - last_match);
}
}
zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
- add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len, 1);
+ add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len);
zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
}
}
MAKE_STD_ZVAL(info);
array_init(info);
- add_next_index_string(info, *pdo_err, 1);
+ add_next_index_string(info, *pdo_err);
add_next_index_long(info, 0);
zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
MAKE_STD_ZVAL(info);
array_init(info);
- add_next_index_string(info, *pdo_err, 1);
+ add_next_index_string(info, *pdo_err);
if (dbh->methods->fetch_err(dbh, stmt, info TSRMLS_CC)) {
zval **item;
case PDO_ATTR_STATEMENT_CLASS:
array_init(return_value);
- add_next_index_string(return_value, dbh->def_stmt_ce->name, 1);
+ add_next_index_string(return_value, dbh->def_stmt_ce->name);
if (dbh->def_stmt_ctor_args) {
Z_ADDREF_P(dbh->def_stmt_ctor_args);
add_next_index_zval(return_value, dbh->def_stmt_ctor_args);
array_init(return_value);
if (dbh->query_stmt) {
- add_next_index_string(return_value, dbh->query_stmt->error_code, 1);
+ add_next_index_string(return_value, dbh->query_stmt->error_code);
} else {
- add_next_index_string(return_value, dbh->error_code, 1);
+ add_next_index_string(return_value, dbh->error_code);
}
if (dbh->methods->fetch_err) {
zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
- add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len, 1);
+ add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len);
zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
}
}
}
array_init(return_value);
- add_next_index_string(return_value, stmt->error_code, 1);
+ add_next_index_string(return_value, stmt->error_code);
if (stmt->dbh->methods->fetch_err) {
stmt->dbh->methods->fetch_err(stmt->dbh, stmt, return_value TSRMLS_CC);
/* add stock items */
col = &stmt->columns[colno];
- add_assoc_string(return_value, "name", col->name, 1);
+ add_assoc_string(return_value, "name", col->name);
add_assoc_long(return_value, "len", col->maxlen); /* FIXME: unsigned ? */
add_assoc_long(return_value, "precision", col->precision);
if (col->param_type != PDO_PARAM_ZVAL) {
msg, einfo->dberr, einfo->severity, stmt ? stmt->active_query_string : "");
add_next_index_long(info, einfo->dberr);
- add_next_index_string(info, message, 0);
+ // TODO: avoid reallocation ???
+ add_next_index_string(info, message);
+ efree(message);
add_next_index_long(info, einfo->oserr);
add_next_index_long(info, einfo->severity);
if (einfo->oserrstr) {
- add_next_index_string(info, einfo->oserrstr, 1);
+ add_next_index_string(info, einfo->oserrstr);
}
return 1;
add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) );
add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision );
add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale );
- add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1), 1);
- add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1)), 1);
+ add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1));
+ add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1)));
add_assoc_long(return_value, "native_type_id", dbcoltype(H->link, colno+1));
add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1));
i += l;
strcpy(&buf[i++], " ");
}
- add_next_index_string(info, buf, 1);
+ add_next_index_string(info, buf);
} else if (H->last_app_error) {
add_next_index_long(info, -999);
- add_next_index_string(info, const_cast(H->last_app_error),1);
+ add_next_index_string(info, const_cast(H->last_app_error));
}
return 1;
}
if (einfo->errcode) {
add_next_index_long(info, einfo->errcode);
- add_next_index_string(info, einfo->errmsg, 1);
+ add_next_index_string(info, einfo->errmsg);
}
PDO_DBG_RETURN(1);
F = S->fields + colno;
if (F->def) {
- add_assoc_string(return_value, "mysql:def", F->def, 1);
+ add_assoc_string(return_value, "mysql:def", F->def);
}
if (IS_NOT_NULL(F->flags)) {
- add_next_index_string(flags, "not_null", 1);
+ add_next_index_string(flags, "not_null");
}
if (IS_PRI_KEY(F->flags)) {
- add_next_index_string(flags, "primary_key", 1);
+ add_next_index_string(flags, "primary_key");
}
if (F->flags & MULTIPLE_KEY_FLAG) {
- add_next_index_string(flags, "multiple_key", 1);
+ add_next_index_string(flags, "multiple_key");
}
if (F->flags & UNIQUE_KEY_FLAG) {
- add_next_index_string(flags, "unique_key", 1);
+ add_next_index_string(flags, "unique_key");
}
if (IS_BLOB(F->flags)) {
- add_next_index_string(flags, "blob", 1);
+ add_next_index_string(flags, "blob");
}
str = type_to_name_native(F->type);
if (str) {
- add_assoc_string(return_value, "native_type", str, 1);
+ add_assoc_string(return_value, "native_type", str);
}
#ifdef PDO_USE_MYSQLND
#endif
add_assoc_zval(return_value, "flags", flags);
- add_assoc_string(return_value, "table", (char *) (F->table?F->table:""), 1);
+ add_assoc_string(return_value, "table", (char *) (F->table?F->table:""));
PDO_DBG_RETURN(SUCCESS);
} /* }}} */
if (einfo->errcode) {
add_next_index_long(info, einfo->errcode);
- add_next_index_string(info, einfo->errmsg, 1);
+ add_next_index_string(info, einfo->errmsg);
}
return 1;
einfo->file, einfo->line);
add_next_index_long(info, einfo->last_error);
- add_next_index_string(info, message, 0);
- add_next_index_string(info, einfo->last_state, 1);
+ // TODO: avoid reallocation ???
+ add_next_index_string(info, message);
+ efree(message);
+ add_next_index_string(info, einfo->last_state);
return 1;
}
if (einfo->errcode) {
add_next_index_long(info, einfo->errcode);
- add_next_index_string(info, einfo->errmsg, 1);
+ add_next_index_string(info, einfo->errmsg);
}
return 1;
if (ret == -1) {
break; /* copy done */
} else if (ret > 0) {
- add_next_index_stringl(return_value, csv, ret, 1);
+ add_next_index_stringl(return_value, csv, ret);
PQfreemem(csv);
} else {
pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
array_init(return_value);
if (result_type == PDO_FETCH_NUM || result_type == PDO_FETCH_BOTH) {
- add_index_string(return_value, 0, pgsql_notify->relname, 1);
+ add_index_string(return_value, 0, pgsql_notify->relname);
add_index_long(return_value, 1, pgsql_notify->be_pid);
}
if (result_type == PDO_FETCH_ASSOC || result_type == PDO_FETCH_BOTH) {
- add_assoc_string(return_value, "message", pgsql_notify->relname, 1);
+ add_assoc_string(return_value, "message", pgsql_notify->relname);
add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
}
goto done;
}
- add_assoc_string(return_value, "native_type", PQgetvalue(res, 0, 0), 1);
+ add_assoc_string(return_value, "native_type", PQgetvalue(res, 0, 0));
done:
PQclear(res);
return 1;
if (einfo->errcode) {
add_next_index_long(info, einfo->errcode);
- add_next_index_string(info, einfo->errmsg, 1);
+ add_next_index_string(info, einfo->errmsg);
}
return 1;
switch (sqlite3_column_type(S->stmt, colno)) {
case SQLITE_NULL:
- add_assoc_string(return_value, "native_type", "null", 1);
+ add_assoc_string(return_value, "native_type", "null");
break;
case SQLITE_FLOAT:
- add_assoc_string(return_value, "native_type", "double", 1);
+ add_assoc_string(return_value, "native_type", "double");
break;
case SQLITE_BLOB:
- add_next_index_string(flags, "blob", 1);
+ add_next_index_string(flags, "blob");
case SQLITE_TEXT:
- add_assoc_string(return_value, "native_type", "string", 1);
+ add_assoc_string(return_value, "native_type", "string");
break;
case SQLITE_INTEGER:
- add_assoc_string(return_value, "native_type", "integer", 1);
+ add_assoc_string(return_value, "native_type", "integer");
break;
}
str = sqlite3_column_decltype(S->stmt, colno);
if (str) {
- add_assoc_string(return_value, "sqlite:decl_type", (char *)str, 1);
+ add_assoc_string(return_value, "sqlite:decl_type", (char *)str);
}
#ifdef SQLITE_ENABLE_COLUMN_METADATA
str = sqlite3_column_table_name(S->stmt, colno);
if (str) {
- add_assoc_string(return_value, "table", (char *)str, 1);
+ add_assoc_string(return_value, "table", (char *)str);
}
#endif
break;
case PHP_PG_VERSION:
array_init(return_value);
- add_assoc_string(return_value, "client", PG_VERSION, 1);
+ add_assoc_string(return_value, "client", PG_VERSION);
#if HAVE_PQPROTOCOLVERSION
add_assoc_long(return_value, "protocol", PQprotocolVersion(pgsql));
#if HAVE_PQPARAMETERSTATUS
if (PQprotocolVersion(pgsql) >= 3) {
/* 8.0 or grater supports protorol version 3 */
char *tmp;
- add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"), 1);
+ add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"));
tmp = (char*)PQparameterStatus(pgsql, "server_encoding");
- add_assoc_string(return_value, "server_encoding", tmp, 1);
+ add_assoc_string(return_value, "server_encoding", tmp);
tmp = (char*)PQparameterStatus(pgsql, "client_encoding");
- add_assoc_string(return_value, "client_encoding", tmp, 1);
+ add_assoc_string(return_value, "client_encoding", tmp);
tmp = (char*)PQparameterStatus(pgsql, "is_superuser");
- add_assoc_string(return_value, "is_superuser", tmp, 1);
+ add_assoc_string(return_value, "is_superuser", tmp);
tmp = (char*)PQparameterStatus(pgsql, "session_authorization");
- add_assoc_string(return_value, "session_authorization", tmp, 1);
+ add_assoc_string(return_value, "session_authorization", tmp);
tmp = (char*)PQparameterStatus(pgsql, "DateStyle");
- add_assoc_string(return_value, "DateStyle", tmp, 1);
+ add_assoc_string(return_value, "DateStyle", tmp);
tmp = (char*)PQparameterStatus(pgsql, "IntervalStyle");
- add_assoc_string(return_value, "IntervalStyle", tmp ? tmp : "", 1);
+ add_assoc_string(return_value, "IntervalStyle", tmp ? tmp : "");
tmp = (char*)PQparameterStatus(pgsql, "TimeZone");
- add_assoc_string(return_value, "TimeZone", tmp ? tmp : "", 1);
+ add_assoc_string(return_value, "TimeZone", tmp ? tmp : "");
tmp = (char*)PQparameterStatus(pgsql, "integer_datetimes");
- add_assoc_string(return_value, "integer_datetimes", tmp ? tmp : "", 1);
+ add_assoc_string(return_value, "integer_datetimes", tmp ? tmp : "");
tmp = (char*)PQparameterStatus(pgsql, "standard_conforming_strings");
- add_assoc_string(return_value, "standard_conforming_strings", tmp ? tmp : "", 1);
+ add_assoc_string(return_value, "standard_conforming_strings", tmp ? tmp : "");
tmp = (char*)PQparameterStatus(pgsql, "application_name");
- add_assoc_string(return_value, "application_name", tmp ? tmp : "", 1);
+ add_assoc_string(return_value, "application_name", tmp ? tmp : "");
}
#endif
#endif
} else {
char *element = PQgetvalue(pgsql_result, pgsql_row, i);
if (element) {
- char *data;
- int data_len;
- int should_copy=0;
const uint element_len = strlen(element);
- data = safe_estrndup(element, element_len);
- data_len = element_len;
-
if (result_type & PGSQL_NUM) {
- add_index_stringl(return_value, i, data, data_len, should_copy);
- should_copy=1;
+ add_index_stringl(return_value, i, element, element_len);
}
if (result_type & PGSQL_ASSOC) {
field_name = PQfname(pgsql_result, i);
- add_assoc_stringl(return_value, field_name, data, data_len, should_copy);
+ add_assoc_stringl(return_value, field_name, element, element_len);
}
}
}
if (PQgetisnull(pgsql_result, pg_row, colno)) {
add_next_index_null(return_value);
} else {
- add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno), 1);
+ add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno));
}
}
}
RETURN_FALSE;
break;
default:
- add_next_index_string(return_value, csv, 1);
+ add_next_index_string(return_value, csv);
PQfreemem(csv);
break;
}
case EOF:
copydone = 1;
case 0:
- add_next_index_string(return_value, csv, 1);
+ add_next_index_string(return_value, csv);
efree(csv);
csv = (char *)NULL;
break;
}
array_init(return_value);
if (result_type & PGSQL_NUM) {
- add_index_string(return_value, 0, pgsql_notify->relname, 1);
+ add_index_string(return_value, 0, pgsql_notify->relname);
add_index_long(return_value, 1, pgsql_notify->be_pid);
#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
if (atof(PG_VERSION) >= 9.0) {
#endif
#if HAVE_PQPARAMETERSTATUS
- add_index_string(return_value, 2, pgsql_notify->extra, 1);
+ add_index_string(return_value, 2, pgsql_notify->extra);
#endif
}
}
if (result_type & PGSQL_ASSOC) {
- add_assoc_string(return_value, "message", pgsql_notify->relname, 1);
+ add_assoc_string(return_value, "message", pgsql_notify->relname);
add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
if (atof(PG_VERSION) >= 9.0) {
#endif
#if HAVE_PQPARAMETERSTATUS
- add_assoc_string(return_value, "payload", pgsql_notify->extra, 1);
+ add_assoc_string(return_value, "payload", pgsql_notify->extra);
#endif
}
}
MAKE_STD_ZVAL(elem);
array_init(elem);
add_assoc_long(elem, "num", atoi(PQgetvalue(pg_result,i,1)));
- add_assoc_string(elem, "type", PQgetvalue(pg_result,i,2), 1);
+ add_assoc_string(elem, "type", PQgetvalue(pg_result,i,2));
add_assoc_long(elem, "len", atoi(PQgetvalue(pg_result,i,3)));
if (!strcmp(PQgetvalue(pg_result,i,4), "t")) {
add_assoc_bool(elem, "not null", 1);
} else {
char *element = PQgetvalue(pg_result, pg_row, i);
if (element) {
- char *data;
- size_t data_len;
const size_t element_len = strlen(element);
- data = safe_estrndup(element, element_len);
- data_len = element_len;
-
field_name = PQfname(pg_result, i);
- add_assoc_stringl(row, field_name, data, data_len, 0);
+ add_assoc_stringl(row, field_name, element, element_len);
}
}
}
array_init(return_value);
- add_next_index_stringl(return_value, "MD5", 3, 1);
- add_next_index_stringl(return_value, "SHA-1", 5, 1);
+ add_next_index_stringl(return_value, "MD5", 3);
+ add_next_index_stringl(return_value, "SHA-1", 5);
#ifdef PHAR_HASH_OK
- add_next_index_stringl(return_value, "SHA-256", 7, 1);
- add_next_index_stringl(return_value, "SHA-512", 7, 1);
+ add_next_index_stringl(return_value, "SHA-256", 7);
+ add_next_index_stringl(return_value, "SHA-512", 7);
#endif
#if PHAR_HAVE_OPENSSL
- add_next_index_stringl(return_value, "OpenSSL", 7, 1);
+ add_next_index_stringl(return_value, "OpenSSL", 7);
#else
if (zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) {
- add_next_index_stringl(return_value, "OpenSSL", 7, 1);
+ add_next_index_stringl(return_value, "OpenSSL", 7);
}
#endif
}
phar_request_initialize(TSRMLS_C);
if (PHAR_G(has_zlib)) {
- add_next_index_stringl(return_value, "GZ", 2, 1);
+ add_next_index_stringl(return_value, "GZ", 2);
}
if (PHAR_G(has_bz2)) {
- add_next_index_stringl(return_value, "BZIP2", 5, 1);
+ add_next_index_stringl(return_value, "BZIP2", 5);
}
}
/* }}} */
php_stream_close(fp);
}
- add_assoc_string(p_obj->ret, str_key, opened, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_string(p_obj->ret, str_key, opened);
+ efree(opened);
if (save) {
efree(save);
int unknown_len;
array_init(return_value);
- add_assoc_stringl(return_value, "hash", phar_obj->arc.archive->signature, phar_obj->arc.archive->sig_len, 1);
+ add_assoc_stringl(return_value, "hash", phar_obj->arc.archive->signature, phar_obj->arc.archive->sig_len);
switch(phar_obj->arc.archive->sig_flags) {
case PHAR_SIG_MD5:
- add_assoc_stringl(return_value, "hash_type", "MD5", 3, 1);
+ add_assoc_stringl(return_value, "hash_type", "MD5", 3);
break;
case PHAR_SIG_SHA1:
- add_assoc_stringl(return_value, "hash_type", "SHA-1", 5, 1);
+ add_assoc_stringl(return_value, "hash_type", "SHA-1", 5);
break;
case PHAR_SIG_SHA256:
- add_assoc_stringl(return_value, "hash_type", "SHA-256", 7, 1);
+ add_assoc_stringl(return_value, "hash_type", "SHA-256", 7);
break;
case PHAR_SIG_SHA512:
- add_assoc_stringl(return_value, "hash_type", "SHA-512", 7, 1);
+ add_assoc_stringl(return_value, "hash_type", "SHA-512", 7);
break;
case PHAR_SIG_OPENSSL:
- add_assoc_stringl(return_value, "hash_type", "OpenSSL", 7, 1);
+ add_assoc_stringl(return_value, "hash_type", "OpenSSL", 7);
break;
default:
unknown_len = spprintf(&unknown, 0, "Unknown (%u)", phar_obj->arc.archive->sig_flags);
- add_assoc_stringl(return_value, "hash_type", unknown, unknown_len, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl(return_value, "hash_type", unknown, unknown_len);
+ efree(unknown);
break;
}
} else {
array_init(return_value);
- add_assoc_string(return_value, "sysname", u.sysname, 1);
- add_assoc_string(return_value, "nodename", u.nodename, 1);
- add_assoc_string(return_value, "release", u.release, 1);
- add_assoc_string(return_value, "version", u.version, 1);
- add_assoc_string(return_value, "machine", u.machine, 1);
+ add_assoc_string(return_value, "sysname", u.sysname);
+ add_assoc_string(return_value, "nodename", u.nodename);
+ add_assoc_string(return_value, "release", u.release);
+ add_assoc_string(return_value, "version", u.version);
+ add_assoc_string(return_value, "machine", u.machine);
#if defined(_GNU_SOURCE) && !defined(DARWIN) && defined(HAVE_UTSNAME_DOMAINNAME)
- add_assoc_string(return_value, "domainname", u.domainname, 1);
+ add_assoc_string(return_value, "domainname", u.domainname);
#endif
}
/* }}} */
MAKE_STD_ZVAL(array_members);
array_init(array_members);
- add_assoc_string(array_group, "name", g->gr_name, 1);
- add_assoc_string(array_group, "passwd", g->gr_passwd, 1);
+ add_assoc_string(array_group, "name", g->gr_name);
+ add_assoc_string(array_group, "passwd", g->gr_passwd);
for (count=0; g->gr_mem[count] != NULL; count++) {
- add_next_index_string(array_members, g->gr_mem[count], 1);
+ add_next_index_string(array_members, g->gr_mem[count]);
}
zend_hash_update(Z_ARRVAL_P(array_group), "members", sizeof("members"), (void*)&array_members, sizeof(zval*), NULL);
add_assoc_long(array_group, "gid", g->gr_gid);
if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
return 0;
- add_assoc_string(return_value, "name", pw->pw_name, 1);
- add_assoc_string(return_value, "passwd", pw->pw_passwd, 1);
+ add_assoc_string(return_value, "name", pw->pw_name);
+ add_assoc_string(return_value, "passwd", pw->pw_passwd);
add_assoc_long (return_value, "uid", pw->pw_uid);
add_assoc_long (return_value, "gid", pw->pw_gid);
- add_assoc_string(return_value, "gecos", pw->pw_gecos, 1);
- add_assoc_string(return_value, "dir", pw->pw_dir, 1);
- add_assoc_string(return_value, "shell", pw->pw_shell, 1);
+ add_assoc_string(return_value, "gecos", pw->pw_gecos);
+ add_assoc_string(return_value, "dir", pw->pw_dir);
+ add_assoc_string(return_value, "shell", pw->pw_shell);
return 1;
}
/* }}} */
}
if (rl.rlim_cur == RLIM_INFINITY) {
- add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
+ add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
} else {
add_assoc_long(return_value, soft, rl.rlim_cur);
}
if (rl.rlim_max == RLIM_INFINITY) {
- add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
+ add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
} else {
add_assoc_long(return_value, hard, rl.rlim_max);
}
if (wl) {
PspellStringEmulation *els = pspell_word_list_elements(wl);
while ((sug = pspell_string_emulation_next(els)) != 0) {
- add_next_index_string(return_value,(char *)sug,1);
+ add_next_index_string(return_value,(char *)sug);
}
delete_pspell_string_emulation(els);
} else {
if (!what) {
array_init(return_value);
- add_assoc_string(return_value,"line_buffer",SAFE_STRING(rl_line_buffer),1);
+ add_assoc_string(return_value,"line_buffer",SAFE_STRING(rl_line_buffer));
add_assoc_long(return_value,"point",rl_point);
add_assoc_long(return_value,"end",rl_end);
#ifdef HAVE_LIBREADLINE
add_assoc_long(return_value,"mark",rl_mark);
add_assoc_long(return_value,"done",rl_done);
add_assoc_long(return_value,"pending_input",rl_pending_input);
- add_assoc_string(return_value,"prompt",SAFE_STRING(rl_prompt),1);
- add_assoc_string(return_value,"terminal_name",(char *)SAFE_STRING(rl_terminal_name),1);
+ add_assoc_string(return_value,"prompt",SAFE_STRING(rl_prompt));
+ add_assoc_string(return_value,"terminal_name",(char *)SAFE_STRING(rl_terminal_name));
#endif
#if HAVE_ERASE_EMPTY_LINE
add_assoc_long(return_value,"erase_empty_line",rl_erase_empty_line);
#endif
- add_assoc_string(return_value,"library_version",(char *)SAFE_STRING(rl_library_version),1);
- add_assoc_string(return_value,"readline_name",(char *)SAFE_STRING(rl_readline_name),1);
+ add_assoc_string(return_value,"library_version",(char *)SAFE_STRING(rl_library_version));
+ add_assoc_string(return_value,"readline_name",(char *)SAFE_STRING(rl_readline_name));
add_assoc_long(return_value,"attempted_completion_over",rl_attempted_completion_over);
} else {
if (!strcasecmp(what,"line_buffer")) {
if (history) {
int i;
for (i = 0; history[i]; i++) {
- add_next_index_string(return_value,history[i]->line,1);
+ add_next_index_string(return_value,history[i]->line);
}
}
}
}
if (return_output) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
} else {
zval_ptr_dtor(&retval);
}
}
if (return_output) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
} else {
/* No need for _r variant, return of __toString should always be a string */
zend_print_zval(&retval, 0);
array_init(return_value);
if (modifiers & (ZEND_ACC_ABSTRACT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
- add_next_index_stringl(return_value, "abstract", sizeof("abstract")-1, 1);
+ add_next_index_stringl(return_value, "abstract", sizeof("abstract")-1);
}
if (modifiers & (ZEND_ACC_FINAL | ZEND_ACC_FINAL_CLASS)) {
- add_next_index_stringl(return_value, "final", sizeof("final")-1, 1);
+ add_next_index_stringl(return_value, "final", sizeof("final")-1);
}
if (modifiers & ZEND_ACC_IMPLICIT_PUBLIC) {
- add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
+ add_next_index_stringl(return_value, "public", sizeof("public")-1);
}
/* These are mutually exclusive */
switch (modifiers & ZEND_ACC_PPP_MASK) {
case ZEND_ACC_PUBLIC:
- add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
+ add_next_index_stringl(return_value, "public", sizeof("public")-1);
break;
case ZEND_ACC_PRIVATE:
- add_next_index_stringl(return_value, "private", sizeof("private")-1, 1);
+ add_next_index_stringl(return_value, "private", sizeof("private")-1);
break;
case ZEND_ACC_PROTECTED:
- add_next_index_stringl(return_value, "protected", sizeof("protected")-1, 1);
+ add_next_index_stringl(return_value, "protected", sizeof("protected")-1);
break;
}
if (modifiers & ZEND_ACC_STATIC) {
- add_next_index_stringl(return_value, "static", sizeof("static")-1, 1);
+ add_next_index_stringl(return_value, "static", sizeof("static")-1);
}
}
/* }}} */
}
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
}
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
}
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
}
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
if (number == ini_entry->module_number) {
if (ini_entry->value) {
- add_assoc_stringl(retval, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
+ add_assoc_stringl(retval, ini_entry->name, ini_entry->value, ini_entry->value_length);
} else {
add_assoc_null(retval, ini_entry->name);
}
zval empty_var;
ZVAL_NULL(&empty_var);
- ZEND_SET_SYMBOL_WITH_LENGTH(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name->val, name->len, &empty_var, 1, 0);
+ zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name, &empty_var);
}
}
/* }}} */
zend_string *var_name = STR_INIT("_SESSION", sizeof("_SESSION") - 1, 0);
/* Unconditionally destroy existing array -- possible dirty data */
zend_delete_global_variable(var_name TSRMLS_CC);
- STR_RELEASE(var_name);
if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
zval_ptr_dtor(&PS(http_session_vars));
array_init(&session_vars);
ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
-
- ZEND_SET_GLOBAL_VAR_WITH_LENGTH("_SESSION", sizeof("_SESSION") - 1, &PS(http_session_vars), 2, 1);
+ Z_ADDREF_P(&PS(http_session_vars));
+ zend_hash_update_ind(&EG(symbol_table).ht, var_name, &PS(http_session_vars));
+ STR_RELEASE(var_name);
}
/* }}} */
const char *endptr = val + vallen;
zval session_vars;
php_unserialize_data_t var_hash;
+ zend_string *var_name = STR_INIT("_SESSION", sizeof("_SESSION") - 1, 0);
ZVAL_NULL(&session_vars);
PHP_VAR_UNSERIALIZE_INIT(var_hash);
array_init(&session_vars);
}
ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
- ZEND_SET_GLOBAL_VAR_WITH_LENGTH("_SESSION", sizeof("_SESSION") - 1, &PS(http_session_vars), 2, 1);
+ Z_ADDREF_P(&PS(http_session_vars));
+ zend_hash_update_ind(&EG(symbol_table).ht, var_name, &PS(http_session_vars));
+ STR_RELEASE(var_name);
return SUCCESS;
}
/* }}} */
array_init(return_value);
add_assoc_long(return_value, "lifetime", PS(cookie_lifetime));
- add_assoc_string(return_value, "path", PS(cookie_path), 1);
- add_assoc_string(return_value, "domain", PS(cookie_domain), 1);
+ add_assoc_string(return_value, "path", PS(cookie_path));
+ add_assoc_string(return_value, "domain", PS(cookie_domain));
add_assoc_bool(return_value, "secure", PS(cookie_secure));
add_assoc_bool(return_value, "httponly", PS(cookie_httponly));
}
PS(session_status) = php_session_active;
IF_SESSION_VARS() {
progress->cancel_upload |= php_check_cancel_upload(progress TSRMLS_CC);
- ZEND_SET_SYMBOL_WITH_LENGTH(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s->val, progress->key.s->len, &progress->data, 2, 0);
+ if (Z_REFCOUNTED(progress->data)) Z_ADDREF(progress->data);
+ zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s, &progress->data);
}
php_session_flush(TSRMLS_C);
} /* }}} */
array_init(&progress->current_file);
/* Each uploaded file has its own array. Trying to make it close to $_FILES entries. */
- add_assoc_string_ex(&progress->current_file, "field_name", sizeof("field_name") - 1, data->name, 1);
- add_assoc_string_ex(&progress->current_file, "name", sizeof("name") - 1, *data->filename, 1);
+ add_assoc_string_ex(&progress->current_file, "field_name", sizeof("field_name") - 1, data->name);
+ add_assoc_string_ex(&progress->current_file, "name", sizeof("name") - 1, *data->filename);
add_assoc_null_ex(&progress->current_file, "tmp_name", sizeof("tmp_name") - 1);
add_assoc_long_ex(&progress->current_file, "error", sizeof("error") - 1, 0);
}
if (data->temp_filename) {
- add_assoc_string_ex(&progress->current_file, "tmp_name", sizeof("tmp_name") - 1, data->temp_filename, 1);
+ add_assoc_string_ex(&progress->current_file, "tmp_name", sizeof("tmp_name") - 1, data->temp_filename);
}
add_assoc_long_ex(&progress->current_file, "error", sizeof("error") - 1, data->cancel_upload);
{
char *prefix = SXE_NS_PREFIX(ns);
if (zend_hash_str_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix)) == 0) {
- add_assoc_string(return_value, prefix, (char*)ns->href, 1);
+ add_assoc_string(return_value, prefix, (char*)ns->href);
}
}
/* }}} */
add_property_zval(soapvar, "enc_value", ret);
parse_namespace(type_name, &cptype, &ns);
nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
- add_property_string(soapvar, "enc_stype", cptype, 1);
+ add_property_string(soapvar, "enc_stype", cptype);
if (nsptr) {
- add_property_string(soapvar, "enc_ns", (char*)nsptr->href, 1);
+ add_property_string(soapvar, "enc_ns", (char*)nsptr->href);
}
efree(cptype);
if (ns) {efree(ns);}
smart_str_0(&soap_headers);
if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len, 1);
+ add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len);
}
smart_str_appendl(&soap_headers, request, request_size);
smart_str_0(&soap_headers);
if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size, 1);
+ add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size);
}
/* Check to see what HTTP status was sent */
ALLOC_INIT_ZVAL(zcookie);
array_init(zcookie);
- add_index_stringl(zcookie, 0, eqpos + 1, cookie_len, 1);
+ add_index_stringl(zcookie, 0, eqpos + 1, cookie_len);
if (sempos != NULL) {
char *options = cookie + cookie_len+1;
sempos = strstr(options, ";");
if (strstr(options,"path=") == options) {
eqpos = options + sizeof("path=")-1;
- add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);
+ add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
} else if (strstr(options,"domain=") == options) {
eqpos = options + sizeof("domain=")-1;
- add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);
+ add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
} else if (strstr(options,"secure") == options) {
add_index_bool(zcookie, 3, 1);
}
char *t = phpurl->path?phpurl->path:"/";
char *c = strrchr(t, '/');
if (c) {
- add_index_stringl(zcookie, 1, t, c-t, 1);
+ add_index_stringl(zcookie, 1, t, c-t);
}
}
if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 2)) {
- add_index_string(zcookie, 2, phpurl->host, 1);
+ add_index_string(zcookie, 2, phpurl->host);
}
add_assoc_zval_ex(*cookies, name.c, name.len+1, zcookie);
ALLOC_INIT_ZVAL(digest);
array_init(digest);
}
- add_assoc_string(digest, name, val ,1);
+ add_assoc_string(digest, name, val);
}
}
return;
}
- add_property_stringl(this_ptr, "param_name", name, name_length, 1);
+ add_property_stringl(this_ptr, "param_name", name, name_length);
add_property_zval(this_ptr, "param_data", data);
}
/* }}} */
return;
}
- add_property_stringl(this_ptr, "namespace", ns, ns_len, 1);
- add_property_stringl(this_ptr, "name", name, name_len, 1);
+ add_property_stringl(this_ptr, "namespace", ns, ns_len);
+ add_property_stringl(this_ptr, "name", name, name_len);
if (data) {
add_property_zval(this_ptr, "data", data);
}
Z_LVAL_P(actor) == SOAP_ACTOR_UNLIMATERECEIVER)) {
add_property_long(this_ptr, "actor", Z_LVAL_P(actor));
} else if (Z_TYPE_P(actor) == IS_STRING && Z_STRLEN_P(actor) > 0) {
- add_property_stringl(this_ptr, "actor", Z_STRVAL_P(actor), Z_STRLEN_P(actor), 1);
+ add_property_stringl(this_ptr, "actor", Z_STRVAL_P(actor), Z_STRLEN_P(actor));
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid actor");
}
}
if (stype && stype_len > 0) {
- add_property_stringl(this_ptr, "enc_stype", stype, stype_len, 1);
+ add_property_stringl(this_ptr, "enc_stype", stype, stype_len);
}
if (ns && ns_len > 0) {
- add_property_stringl(this_ptr, "enc_ns", ns, ns_len, 1);
+ add_property_stringl(this_ptr, "enc_ns", ns, ns_len);
}
if (name && name_len > 0) {
- add_property_stringl(this_ptr, "enc_name", name, name_len, 1);
+ add_property_stringl(this_ptr, "enc_name", name, name_len);
}
if (namens && namens_len > 0) {
- add_property_stringl(this_ptr, "enc_namens", namens, namens_len, 1);
+ add_property_stringl(this_ptr, "enc_namens", namens, namens_len);
}
}
/* }}} */
zend_hash_internal_pointer_reset_ex(service->soap_functions.ft, &pos);
while (zend_hash_get_current_data_ex(service->soap_functions.ft, (void **)&name, &pos) != FAILURE) {
- add_next_index_string(return_value, Z_STRVAL_PP(name), 1);
+ add_next_index_string(return_value, Z_STRVAL_PP(name));
zend_hash_move_forward_ex(service->soap_functions.ft, &pos);
}
}
zend_hash_internal_pointer_reset_ex(ft, &pos);
while (zend_hash_get_current_data_ex(ft, (void **)&f, &pos) != FAILURE) {
if ((service->type != SOAP_OBJECT && service->type != SOAP_CLASS) || (f->common.fn_flags & ZEND_ACC_PUBLIC)) {
- add_next_index_string(return_value, f->common.function_name, 1);
+ add_next_index_string(return_value, f->common.function_name);
}
zend_hash_move_forward_ex(ft, &pos);
}
/* Fetching non-WSDL mode options */
if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "uri", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "uri", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'uri' option is required in nonWSDL mode");
}
if (zend_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "location", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "location", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
} else if (Z_TYPE_P(wsdl) == IS_NULL) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "'location' option is required in nonWSDL mode");
}
}
if (zend_hash_find(ht, "login", sizeof("login"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
if (zend_hash_find(ht, "password", sizeof("password"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
}
if (zend_hash_find(ht, "authentication", sizeof("authentication"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_LONG &&
}
if (zend_hash_find(ht, "proxy_host", sizeof("proxy_host"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_host", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_proxy_host", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
if (zend_hash_find(ht, "proxy_port", sizeof("proxy_port"), (void**)&tmp) == SUCCESS) {
convert_to_long(*tmp);
add_property_long(this_ptr, "_proxy_port", Z_LVAL_PP(tmp));
}
if (zend_hash_find(ht, "proxy_login", sizeof("proxy_login"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_proxy_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
if (zend_hash_find(ht, "proxy_password", sizeof("proxy_password"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_proxy_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_proxy_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
}
}
}
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_PP(tmp));
} else {
xmlCharEncCloseFunc(encoding);
- add_property_stringl(this_ptr, "_encoding", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_encoding", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
}
}
if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS &&
if (zend_hash_find(ht, "user_agent", sizeof("user_agent"), (void**)&tmp) == SUCCESS &&
Z_TYPE_PP(tmp) == IS_STRING) {
- add_property_stringl(this_ptr, "_user_agent", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+ add_property_stringl(this_ptr, "_user_agent", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
}
if (zend_hash_find(ht, "keep_alive", sizeof("keep_alive"), (void**)&tmp) == SUCCESS &&
if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_request", buf, buf_size, 1);
+ add_property_stringl(this_ptr, "__last_request", buf, buf_size);
}
INIT_ZVAL(func);
ret = FALSE;
} else if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
Z_LVAL_PP(trace) > 0) {
- add_property_stringl(this_ptr, "__last_response", Z_STRVAL_P(response), Z_STRLEN_P(response), 1);
+ add_property_stringl(this_ptr, "__last_response", Z_STRVAL_P(response), Z_STRLEN_P(response));
}
zval_ptr_dtor(¶ms[4]);
zval_ptr_dtor(¶ms[3]);
zend_hash_internal_pointer_reset_ex(&sdl->functions, &pos);
while (zend_hash_get_current_data_ex(&sdl->functions, (void **)&function, &pos) != FAILURE) {
function_to_string((*function), &buf);
- add_next_index_stringl(return_value, buf.c, buf.len, 1);
+ add_next_index_stringl(return_value, buf.c, buf.len);
smart_str_free(&buf);
zend_hash_move_forward_ex(&sdl->functions, &pos);
}
zend_hash_internal_pointer_reset_ex(sdl->types, &pos);
while (zend_hash_get_current_data_ex(sdl->types, (void **)&type, &pos) != FAILURE) {
type_to_string((*type), &buf, 0);
- add_next_index_stringl(return_value, buf.c, buf.len, 1);
+ add_next_index_stringl(return_value, buf.c, buf.len);
smart_str_free(&buf);
zend_hash_move_forward_ex(sdl->types, &pos);
}
ALLOC_INIT_ZVAL(zcookie);
array_init(zcookie);
- add_index_stringl(zcookie, 0, val, val_len, 1);
+ add_index_stringl(zcookie, 0, val, val_len);
add_assoc_zval_ex(*cookies, name, name_len+1, zcookie);
}
}
}
if (location && location_len) {
- add_property_stringl(this_ptr, "location", location, location_len, 1);
+ add_property_stringl(this_ptr, "location", location, location_len);
} else {
zend_hash_del(Z_OBJPROP_P(this_ptr), "location", sizeof("location"));
}
object_init_ex(obj, soap_fault_class_entry);
}
- add_property_string(obj, "faultstring", fault_string ? fault_string : "", 1);
+ add_property_string(obj, "faultstring", fault_string ? fault_string : "");
zend_update_property_string(zend_exception_get_default(TSRMLS_C), obj, "message", sizeof("message")-1, (fault_string ? fault_string : "") TSRMLS_CC);
if (fault_code != NULL) {
int soap_version = SOAP_GLOBAL(soap_version);
if (fault_code_ns) {
- add_property_string(obj, "faultcode", fault_code, 1);
- add_property_string(obj, "faultcodens", fault_code_ns, 1);
+ add_property_string(obj, "faultcode", fault_code);
+ add_property_string(obj, "faultcodens", fault_code_ns);
} else {
if (soap_version == SOAP_1_1) {
- add_property_string(obj, "faultcode", fault_code, 1);
+ add_property_string(obj, "faultcode", fault_code);
if (strcmp(fault_code,"Client") == 0 ||
strcmp(fault_code,"Server") == 0 ||
strcmp(fault_code,"VersionMismatch") == 0 ||
strcmp(fault_code,"MustUnderstand") == 0) {
- add_property_string(obj, "faultcodens", SOAP_1_1_ENV_NAMESPACE, 1);
+ add_property_string(obj, "faultcodens", SOAP_1_1_ENV_NAMESPACE);
}
} else if (soap_version == SOAP_1_2) {
if (strcmp(fault_code,"Client") == 0) {
- add_property_string(obj, "faultcode", "Sender", 1);
- add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+ add_property_string(obj, "faultcode", "Sender");
+ add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
} else if (strcmp(fault_code,"Server") == 0) {
- add_property_string(obj, "faultcode", "Receiver", 1);
- add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+ add_property_string(obj, "faultcode", "Receiver");
+ add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
} else if (strcmp(fault_code,"VersionMismatch") == 0 ||
strcmp(fault_code,"MustUnderstand") == 0 ||
strcmp(fault_code,"DataEncodingUnknown") == 0) {
- add_property_string(obj, "faultcode", fault_code, 1);
- add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+ add_property_string(obj, "faultcode", fault_code);
+ add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
} else {
- add_property_string(obj, "faultcode", fault_code, 1);
+ add_property_string(obj, "faultcode", fault_code);
}
}
}
}
if (fault_actor != NULL) {
- add_property_string(obj, "faultactor", fault_actor, 1);
+ add_property_string(obj, "faultactor", fault_actor);
}
if (fault_detail != NULL) {
add_property_zval(obj, "detail", fault_detail);
}
if (name != NULL) {
- add_property_string(obj, "_name", name, 1);
+ add_property_string(obj, "_name", name);
}
}
if (!EG(autoload_func)) {
if ((fptr = zend_hash_str_find_ptr(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1))) {
array_init(return_value);
- add_next_index_stringl(return_value, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1, 1);
+ add_next_index_stringl(return_value, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1);
return;
}
RETURN_FALSE;
efree(Z_REF(tmp));
}
if (!ZVAL_IS_UNDEF(&retval)) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
} /* }}} */
enclosure[0] = intern->u.file.enclosure;
enclosure[1] = '\0';
- add_next_index_string(return_value, delimiter, 1);
- add_next_index_string(return_value, enclosure, 1);
+ add_next_index_string(return_value, delimiter);
+ add_next_index_string(return_value, enclosure);
}
/* }}} */
array_init(return_value);
- add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion(), 1);
+ add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion());
add_assoc_long(return_value, "versionNumber", sqlite3_libversion_number());
return;
goto err;
}
for (; ch >= *high; ch -= (unsigned int)lstep) {
- add_next_index_stringl(return_value, (const char *)&ch, 1, 1);
+ add_next_index_stringl(return_value, (const char *)&ch, 1);
if (((signed int)ch - lstep) < 0) {
break;
}
goto err;
}
for (; ch <= *high; ch += (unsigned int)lstep) {
- add_next_index_stringl(return_value, (const char *)&ch, 1, 1);
+ add_next_index_stringl(return_value, (const char *)&ch, 1);
if (((signed int)ch + lstep) > 255) {
break;
}
}
} else {
- add_next_index_stringl(return_value, (const char *)low, 1, 1);
+ add_next_index_stringl(return_value, (const char *)low, 1);
}
} else if (Z_TYPE_P(zlow) == IS_DOUBLE || Z_TYPE_P(zhigh) == IS_DOUBLE || is_step_double) {
if (PG(last_error_message)) {
array_init(return_value);
add_assoc_long_ex(return_value, "type", sizeof("type")-1, PG(last_error_type));
- add_assoc_string_ex(return_value, "message", sizeof("message")-1, PG(last_error_message), 1);
- add_assoc_string_ex(return_value, "file", sizeof("file")-1, PG(last_error_file)?PG(last_error_file):"-", 1 );
+ add_assoc_string_ex(return_value, "message", sizeof("message")-1, PG(last_error_message));
+ add_assoc_string_ex(return_value, "file", sizeof("file")-1, PG(last_error_file)?PG(last_error_file):"-");
add_assoc_long_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno));
}
}
fci.retval = &retval;
if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
fci.retval = &retval;
if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
zend_fcall_info_args_clear(&fci, 1);
if (call_user_function_ex(EG(function_table), object, callback, &retval, n_params, params, 0, NULL TSRMLS_CC) == SUCCESS) {
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", Z_STRVAL_P(callback));
if (call_user_function_ex(EG(function_table), object, callback, &retval, num_elems, method_args, 0, NULL TSRMLS_CC) == SUCCESS) {
if (Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s()", Z_STRVAL_P(callback));
}
if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
}
/* }}} */
}
if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
- COPY_PZVAL_TO_ZVAL(*return_value, &retval);
+ ZVAL_COPY_VALUE(return_value, &retval);
}
zend_fcall_info_args_clear(&fci, 1);
array_init(&option);
if (ini_entry->orig_value) {
- add_assoc_stringl(&option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length, 1);
+ add_assoc_stringl(&option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length);
} else if (ini_entry->value) {
- add_assoc_stringl(&option, "global_value", ini_entry->value, ini_entry->value_length, 1);
+ add_assoc_stringl(&option, "global_value", ini_entry->value, ini_entry->value_length);
} else {
add_assoc_null(&option, "global_value");
}
if (ini_entry->value) {
- add_assoc_stringl(&option, "local_value", ini_entry->value, ini_entry->value_length, 1);
+ add_assoc_stringl(&option, "local_value", ini_entry->value, ini_entry->value_length);
} else {
add_assoc_null(&option, "local_value");
}
add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, &option);
} else {
if (ini_entry->value) {
- add_assoc_stringl(ini_array, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
+ add_assoc_stringl(ini_array, ini_entry->name, ini_entry->value, ini_entry->value_length);
} else {
add_assoc_null(ini_array, ini_entry->name);
}
add_assoc_long(return_value, "tm_year", parsed_time.tm_year);
add_assoc_long(return_value, "tm_wday", parsed_time.tm_wday);
add_assoc_long(return_value, "tm_yday", parsed_time.tm_yday);
- add_assoc_string(return_value, "unparsed", unparsed_part, 1);
+ add_assoc_string(return_value, "unparsed", unparsed_part);
}
/* }}} */
if (createobject) {
object_init_ex(return_value, dir_class_entry_ptr);
- add_property_stringl(return_value, "path", dirname, dir_len, 1);
+ add_property_stringl(return_value, "path", dirname, dir_len);
add_property_resource(return_value, "handle", dirp->res);
php_stream_auto_cleanup(dirp); /* so we don't get warnings under debug */
} else {
continue;
}
}
- add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip, 1);
+ add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip);
}
globfree(&globbuf);
for (i = 0 ; hp->h_addr_list[i] != 0 ; i++) {
in = *(struct in_addr *) hp->h_addr_list[i];
- add_next_index_string(return_value, inet_ntoa(in), 1);
+ add_next_index_string(return_value, inet_ntoa(in));
}
}
/* }}} */
array_init(subarray);
- add_assoc_string(subarray, "host", name, 1);
- add_assoc_string(subarray, "class", "IN", 1);
+ add_assoc_string(subarray, "host", name);
+ add_assoc_string(subarray, "class", "IN");
add_assoc_long(subarray, "ttl", ttl);
if (raw) {
add_assoc_long(subarray, "type", type);
- add_assoc_stringl(subarray, "data", (char*) cp, (uint) dlen, 1);
+ add_assoc_stringl(subarray, "data", (char*) cp, (uint) dlen);
cp += dlen;
return cp;
}
switch (type) {
case DNS_T_A:
- add_assoc_string(subarray, "type", "A", 1);
+ add_assoc_string(subarray, "type", "A");
snprintf(name, sizeof(name), "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
- add_assoc_string(subarray, "ip", name, 1);
+ add_assoc_string(subarray, "ip", name);
cp += dlen;
break;
case DNS_T_MX:
- add_assoc_string(subarray, "type", "MX", 1);
+ add_assoc_string(subarray, "type", "MX");
GETSHORT(n, cp);
add_assoc_long(subarray, "pri", n);
/* no break; */
case DNS_T_CNAME:
if (type == DNS_T_CNAME) {
- add_assoc_string(subarray, "type", "CNAME", 1);
+ add_assoc_string(subarray, "type", "CNAME");
}
/* no break; */
case DNS_T_NS:
if (type == DNS_T_NS) {
- add_assoc_string(subarray, "type", "NS", 1);
+ add_assoc_string(subarray, "type", "NS");
}
/* no break; */
case DNS_T_PTR:
if (type == DNS_T_PTR) {
- add_assoc_string(subarray, "type", "PTR", 1);
+ add_assoc_string(subarray, "type", "PTR");
}
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
- add_assoc_string(subarray, "target", name, 1);
+ add_assoc_string(subarray, "target", name);
break;
case DNS_T_HINFO:
/* See RFC 1010 for values */
- add_assoc_string(subarray, "type", "HINFO", 1);
+ add_assoc_string(subarray, "type", "HINFO");
n = *cp & 0xFF;
cp++;
- add_assoc_stringl(subarray, "cpu", (char*)cp, n, 1);
+ add_assoc_stringl(subarray, "cpu", (char*)cp, n);
cp += n;
n = *cp & 0xFF;
cp++;
- add_assoc_stringl(subarray, "os", (char*)cp, n, 1);
+ add_assoc_stringl(subarray, "os", (char*)cp, n);
cp += n;
break;
case DNS_T_TXT:
int ll = 0;
zval entries;
- add_assoc_string(subarray, "type", "TXT", 1);
+ add_assoc_string(subarray, "type", "TXT");
tp = emalloc(dlen + 1);
array_init(&entries);
while (ll < dlen) {
n = cp[ll];
memcpy(tp + ll , cp + ll + 1, n);
- add_next_index_stringl(&entries, (char*)cp + ll + 1, n, 1);
+ add_next_index_stringl(&entries, (char*)cp + ll + 1, n);
ll = ll + n + 1;
}
tp[dlen] = '\0';
cp += dlen;
- add_assoc_stringl(subarray, "txt", (char*)tp, (dlen>0)?dlen - 1:0, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl(subarray, "txt", (char*)tp, (dlen>0)?dlen - 1:0);
+ efree(tp);
add_assoc_zval(subarray, "entries", &entries);
}
break;
case DNS_T_SOA:
- add_assoc_string(subarray, "type", "SOA", 1);
+ add_assoc_string(subarray, "type", "SOA");
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
if (n < 0) {
return NULL;
}
cp += n;
- add_assoc_string(subarray, "mname", name, 1);
+ add_assoc_string(subarray, "mname", name);
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
if (n < 0) {
return NULL;
}
cp += n;
- add_assoc_string(subarray, "rname", name, 1);
+ add_assoc_string(subarray, "rname", name);
GETLONG(n, cp);
add_assoc_long(subarray, "serial", n);
GETLONG(n, cp);
tp++;
}
tp[0] = '\0';
- add_assoc_string(subarray, "type", "AAAA", 1);
- add_assoc_string(subarray, "ipv6", name, 1);
+ add_assoc_string(subarray, "type", "AAAA");
+ add_assoc_string(subarray, "ipv6", name);
break;
case DNS_T_A6:
p = cp;
- add_assoc_string(subarray, "type", "A6", 1);
+ add_assoc_string(subarray, "type", "A6");
n = ((int)cp[0]) & 0xFF;
cp++;
add_assoc_long(subarray, "masklen", n);
tp++;
}
tp[0] = '\0';
- add_assoc_string(subarray, "ipv6", name, 1);
+ add_assoc_string(subarray, "ipv6", name);
if (cp < p + dlen) {
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
- add_assoc_string(subarray, "chain", name, 1);
+ add_assoc_string(subarray, "chain", name);
}
break;
case DNS_T_SRV:
- add_assoc_string(subarray, "type", "SRV", 1);
+ add_assoc_string(subarray, "type", "SRV");
GETSHORT(n, cp);
add_assoc_long(subarray, "pri", n);
GETSHORT(n, cp);
return NULL;
}
cp += n;
- add_assoc_string(subarray, "target", name, 1);
+ add_assoc_string(subarray, "target", name);
break;
case DNS_T_NAPTR:
- add_assoc_string(subarray, "type", "NAPTR", 1);
+ add_assoc_string(subarray, "type", "NAPTR");
GETSHORT(n, cp);
add_assoc_long(subarray, "order", n);
GETSHORT(n, cp);
add_assoc_long(subarray, "pref", n);
n = (cp[0] & 0xFF);
- add_assoc_stringl(subarray, "flags", (char*)++cp, n, 1);
+ add_assoc_stringl(subarray, "flags", (char*)++cp, n);
cp += n;
n = (cp[0] & 0xFF);
- add_assoc_stringl(subarray, "services", (char*)++cp, n, 1);
+ add_assoc_stringl(subarray, "services", (char*)++cp, n);
cp += n;
n = (cp[0] & 0xFF);
- add_assoc_stringl(subarray, "regex", (char*)++cp, n, 1);
+ add_assoc_stringl(subarray, "regex", (char*)++cp, n);
cp += n;
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
- add_assoc_string(subarray, "replacement", name, 1);
+ add_assoc_string(subarray, "replacement", name);
break;
default:
zval_ptr_dtor(subarray);
RETURN_FALSE;
}
cp += i;
- add_next_index_string(mx_list, buf, 1);
+ add_next_index_string(mx_list, buf);
if (weight_list) {
add_next_index_long(weight_list, weight);
}
continue;
}
- add_next_index_string(mx_list, pRec->Data.MX.pNameExchange, 1);
+ add_next_index_string(mx_list, pRec->Data.MX.pNameExchange);
if (weight_list) {
add_next_index_long(weight_list, srv->wPriority);
}
ALLOC_INIT_ZVAL(*subarray);
array_init(*subarray);
- add_assoc_string(*subarray, "host", pRec->pName, 1);
- add_assoc_string(*subarray, "class", "IN", 1);
+ add_assoc_string(*subarray, "host", pRec->pName);
+ add_assoc_string(*subarray, "class", "IN");
add_assoc_long(*subarray, "ttl", ttl);
if (raw) {
add_assoc_long(*subarray, "type", type);
- add_assoc_stringl(*subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength, 1);
+ add_assoc_stringl(*subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength);
return;
}
case DNS_TYPE_A: {
IN_ADDR ipaddr;
ipaddr.S_un.S_addr = (pRec->Data.A.IpAddress);
- add_assoc_string(*subarray, "type", "A", 1);
- add_assoc_string(*subarray, "ip", inet_ntoa(ipaddr), 1);
+ add_assoc_string(*subarray, "type", "A");
+ add_assoc_string(*subarray, "ip", inet_ntoa(ipaddr));
break;
}
case DNS_TYPE_MX:
- add_assoc_string(*subarray, "type", "MX", 1);
+ add_assoc_string(*subarray, "type", "MX");
add_assoc_long(*subarray, "pri", pRec->Data.Srv.wPriority);
/* no break; */
case DNS_TYPE_CNAME:
if (type == DNS_TYPE_CNAME) {
- add_assoc_string(*subarray, "type", "CNAME", 1);
+ add_assoc_string(*subarray, "type", "CNAME");
}
/* no break; */
case DNS_TYPE_NS:
if (type == DNS_TYPE_NS) {
- add_assoc_string(*subarray, "type", "NS", 1);
+ add_assoc_string(*subarray, "type", "NS");
}
/* no break; */
case DNS_TYPE_PTR:
if (type == DNS_TYPE_PTR) {
- add_assoc_string(*subarray, "type", "PTR", 1);
+ add_assoc_string(*subarray, "type", "PTR");
}
- add_assoc_string(*subarray, "target", pRec->Data.MX.pNameExchange, 1);
+ add_assoc_string(*subarray, "target", pRec->Data.MX.pNameExchange);
break;
/* Not available on windows, the query is possible but there is no DNS_HINFO_DATA structure */
long txt_len = 0;
zval *entries;
- add_assoc_string(*subarray, "type", "TXT", 1);
+ add_assoc_string(*subarray, "type", "TXT");
ALLOC_INIT_ZVAL(entries);
array_init(entries);
for (i = 0; i < count; i++) {
int len = strlen(data_txt->pStringArray[i]);
memcpy(txt_dst, data_txt->pStringArray[i], len);
- add_next_index_stringl(entries, data_txt->pStringArray[i], len, 1);
+ add_next_index_stringl(entries, data_txt->pStringArray[i], len);
txt_dst += len;
}
- add_assoc_string(*subarray, "txt", txt, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_string(*subarray, "txt", txt);
+ efree(txt);
add_assoc_zval(*subarray, "entries", entries);
}
break;
{
DNS_SOA_DATA *data_soa = &pRec->Data.Soa;
- add_assoc_string(*subarray, "type", "SOA", 1);
+ add_assoc_string(*subarray, "type", "SOA");
- add_assoc_string(*subarray, "mname", data_soa->pNamePrimaryServer, 1);
- add_assoc_string(*subarray, "rname", data_soa->pNameAdministrator, 1);
+ add_assoc_string(*subarray, "mname", data_soa->pNamePrimaryServer);
+ add_assoc_string(*subarray, "rname", data_soa->pNameAdministrator);
add_assoc_long(*subarray, "serial", data_soa->dwSerialNo);
add_assoc_long(*subarray, "refresh", data_soa->dwRefresh);
add_assoc_long(*subarray, "retry", data_soa->dwRetry);
}
tp[0] = '\0';
- add_assoc_string(*subarray, "type", "AAAA", 1);
- add_assoc_string(*subarray, "ipv6", buf, 1);
+ add_assoc_string(*subarray, "type", "AAAA");
+ add_assoc_string(*subarray, "ipv6", buf);
}
break;
{
DNS_SRV_DATA *data_srv = &pRec->Data.Srv;
- add_assoc_string(*subarray, "type", "SRV", 1);
+ add_assoc_string(*subarray, "type", "SRV");
add_assoc_long(*subarray, "pri", data_srv->wPriority);
add_assoc_long(*subarray, "weight", data_srv->wWeight);
add_assoc_long(*subarray, "port", data_srv->wPort);
- add_assoc_string(*subarray, "target", data_srv->pNameTarget, 1);
+ add_assoc_string(*subarray, "target", data_srv->pNameTarget);
}
break;
{
DNS_NAPTR_DATA * data_naptr = &pRec->Data.Naptr;
- add_assoc_string(*subarray, "type", "NAPTR", 1);
+ add_assoc_string(*subarray, "type", "NAPTR");
add_assoc_long(*subarray, "order", data_naptr->wOrder);
add_assoc_long(*subarray, "pref", data_naptr->wPreference);
- add_assoc_string(*subarray, "flags", data_naptr->pFlags, 1);
- add_assoc_string(*subarray, "services", data_naptr->pService, 1);
- add_assoc_string(*subarray, "regex", data_naptr->pRegularExpression, 1);
- add_assoc_string(*subarray, "replacement", data_naptr->pReplacement, 1);
+ add_assoc_string(*subarray, "flags", data_naptr->pFlags);
+ add_assoc_string(*subarray, "services", data_naptr->pService);
+ add_assoc_string(*subarray, "regex", data_naptr->pRegularExpression);
+ add_assoc_string(*subarray, "replacement", data_naptr->pReplacement);
}
break;
#endif
bufl = l + 1;
buf[bufl] = '\0';
}
- add_next_index_stringl(array, buf, bufl, 1);
+ add_next_index_stringl(array, buf, bufl);
}
b = buf;
}
buf[bufl] = '\0';
}
if (type == 2) {
- add_next_index_stringl(array, buf, bufl, 1);
+ add_next_index_stringl(array, buf, bufl);
}
}
/* For BC */
php_strtolower(name, strlen(name));
if (have_content) {
- add_assoc_string(return_value, name, value, 1);
+ add_assoc_string(return_value, name, value);
} else {
- add_assoc_string(return_value, name, "", 1);
+ add_assoc_string(return_value, name, "");
}
efree(name);
do {
p++;
parse_eol:
- add_index_stringl(return_value, i++, s, p-s, 1);
+ add_index_stringl(return_value, i++, s, p-s);
s = p;
} while ((p = memchr(p, eol_marker, (e-p))));
} else {
s = ++p;
continue;
}
- add_index_stringl(return_value, i++, s, p-s-windows_eol, 1);
+ add_index_stringl(return_value, i++, s, p-s-windows_eol);
s = ++p;
} while ((p = memchr(p, eol_marker, (e-p))));
}
/* 3. Now pass our field back to php */
*comp_end = '\0';
- add_next_index_stringl(return_value, temp, comp_end - temp, 1);
+ add_next_index_stringl(return_value, temp, comp_end - temp);
} while (inc_len > 0);
out:
add_assoc_double(&entry, "key", (double)bucket->key);
}
add_assoc_bool(&entry, "is_dir", bucket->is_dir);
- add_assoc_stringl(&entry, "realpath", bucket->realpath, bucket->realpath_len, 1);
+ add_assoc_stringl(&entry, "realpath", bucket->realpath, bucket->realpath_len);
add_assoc_long(&entry, "expires", bucket->expires);
#ifdef PHP_WIN32
add_assoc_bool(&entry, "is_rvalid", bucket->is_rvalid);
sapi_header_struct *sapi_header = (sapi_header_struct *)data;
if (arg && sapi_header) {
- add_next_index_string((zval *)arg, (char *)(sapi_header->header), 1);
+ add_next_index_string((zval *)arg, (char *)(sapi_header->header));
}
}
size_t l = r->data.ent.entity_len;
memcpy(&entity[1], r->data.ent.entity, l);
entity[l + 1] = ';';
- add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2, 1);
+ add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
} else {
unsigned i,
num_entries;
size_t l = mcpr[0].leading_entry.default_entity_len;
memcpy(&entity[1], mcpr[0].leading_entry.default_entity, l);
entity[l + 1] = ';';
- add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2, 1);
+ add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
}
num_entries = mcpr[0].leading_entry.size;
for (i = 1; i <= num_entries; i++) {
memcpy(&entity[1], mcpr[i].normal_entry.entity, l);
entity[l + 1] = ';';
entity[l + 1] = '\0';
- add_assoc_stringl_ex(arr, key, written_k1 + written_k2, entity, l + 1, 1);
+ add_assoc_stringl_ex(arr, key, written_k1 + written_k2, entity, l + 1);
}
}
}
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(info), markername, strlen(markername))) == NULL) {
/* XXX we onyl catch the 1st tag of it's kind! */
- add_assoc_stringl(info, markername, buffer, length, 1);
+ add_assoc_stringl(info, markername, buffer, length);
}
efree(buffer);
add_index_long(return_value, 1, result->height);
add_index_long(return_value, 2, itype);
snprintf(temp, sizeof(temp), "width=\"%d\" height=\"%d\"", result->width, result->height);
- add_index_string(return_value, 3, temp, 0);
+ add_index_string(return_value, 3, temp);
if (result->bits != 0) {
add_assoc_long(return_value, "bits", result->bits);
if (result->channels != 0) {
add_assoc_long(return_value, "channels", result->channels);
}
- add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype), 1);
+ add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype));
efree(result);
} else {
RETURN_FALSE;
element = zend_hash_str_update(Z_ARRVAL_P(return_value), key, strlen(key), &values);
}
- add_next_index_stringl(element, buffer+inx, len, 1);
+ add_next_index_stringl(element, buffer+inx, len);
inx += len;
tagsfound++;
}
size = len;
- add_assoc_stringl(return_value, n, &input[inputpos], len, 1);
+ add_assoc_stringl(return_value, n, &input[inputpos], len);
break;
}
case 'A': {
break;
}
- add_assoc_stringl(return_value, n, &input[inputpos], len + 1, 1);
+ add_assoc_stringl(return_value, n, &input[inputpos], len + 1);
break;
}
/* New option added for Z to remain in-line with the Perl implementation */
}
len = s;
- add_assoc_stringl(return_value, n, &input[inputpos], len, 1);
+ add_assoc_stringl(return_value, n, &input[inputpos], len);
break;
}
}
buf[len] = '\0';
- add_assoc_stringl(return_value, n, buf, len, 1);
+ add_assoc_stringl(return_value, n, buf, len);
efree(buf);
break;
}
array_init(return_value);
add_assoc_long(return_value, "algo", algo);
- add_assoc_string(return_value, "algoName", algo_name, 1);
+ add_assoc_string(return_value, "algoName", algo_name);
add_assoc_zval(return_value, "options", &options);
}
array_init(return_value);
- add_assoc_string(return_value, "command", proc->command, 1);
+ add_assoc_string(return_value, "command", proc->command);
add_assoc_long(return_value, "pid", (long) proc->child);
#ifdef PHP_WIN32
proc->env = env;
if (pipes != NULL) {
- ZVAL_DEREF_REF(pipes);
+ ZVAL_DEREF(pipes);
zval_dtor(pipes);
}
// Z_SET_REFCOUNT_P(current, refcount);
//??? Z_SET_ISREF_PP(current);
} else {
- add_index_stringl(return_value, objIndex++, string, end-string, 1);
+ add_index_stringl(return_value, objIndex++, string, end-string);
}
}
string = end;
zval_dtor(Z_REFVAL_P(current));
ZVAL_STRINGL(Z_REFVAL_P(current), string, end-string);
} else {
- add_index_stringl(return_value, objIndex++, string, end-string, 1);
+ add_index_stringl(return_value, objIndex++, string, end-string);
}
}
string = end;
zval_dtor(*current);
ZVAL_STRINGL( *current, __buf, 1, 1);
} else {
- add_index_stringl(return_value, objIndex++, &sch, 1, 1);
+ add_index_stringl(return_value, objIndex++, &sch, 1);
}
}
break;
zval_dtor(Z_REFVAL_P(current));
ZVAL_STRING(Z_REFVAL_P(current), buf);
} else {
- add_index_string(return_value, objIndex++, buf, 1);
+ add_index_string(return_value, objIndex++, buf);
}
} else {
if (numVars && objIndex >= argCount) {
add_assoc_zval(return_value, "wrapper_data", &stream->wrapperdata);
}
if (stream->wrapper) {
- add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label, 1);
+ add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label);
}
- add_assoc_string(return_value, "stream_type", (char *)stream->ops->label, 1);
+ add_assoc_string(return_value, "stream_type", (char *)stream->ops->label);
- add_assoc_string(return_value, "mode", stream->mode, 1);
+ add_assoc_string(return_value, "mode", stream->mode);
#if 0 /* TODO: needs updating for new filter API */
if (stream->filterhead) {
array_init(newval);
for (filter = stream->filterhead; filter != NULL; filter = filter->next) {
- add_next_index_string(newval, (char *)filter->fops->label, 1);
+ add_next_index_string(newval, (char *)filter->fops->label);
}
add_assoc_zval(return_value, "filters", newval);
add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0);
if (stream->orig_path) {
- add_assoc_string(return_value, "uri", stream->orig_path, 1);
+ add_assoc_string(return_value, "uri", stream->orig_path);
}
if (!php_stream_populate_meta_data(stream, return_value)) {
p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
if (p2 == NULL) {
- add_next_index_stringl(return_value, p1, Z_STRLEN_P(str), 1);
+ add_next_index_stringl(return_value, p1, Z_STRLEN_P(str));
} else {
do {
- add_next_index_stringl(return_value, p1, p2 - p1, 1);
+ add_next_index_stringl(return_value, p1, p2 - p1);
p1 = p2 + Z_STRLEN_P(delim);
} while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL &&
--limit > 1);
if (p1 <= endp)
- add_next_index_stringl(return_value, p1, endp-p1, 1);
+ add_next_index_stringl(return_value, p1, endp-p1);
}
}
/* }}} */
/* limit is at least -1 therefore no need of bounds checking : i will be always less than found */
for (i = 0;i < to_return;i++) { /* this checks also for to_return > 0 */
add_next_index_stringl(return_value, positions[i],
- (positions[i+1] - Z_STRLEN_P(delim)) - positions[i],
- 1
- );
+ (positions[i+1] - Z_STRLEN_P(delim)) - positions[i]);
}
efree(positions);
}
if (str->len == 0) {
if (limit >= 0) {
- add_next_index_stringl(return_value, "", sizeof("") - 1, 1);
+ add_next_index_stringl(return_value, "", sizeof("") - 1);
}
return;
}
} else if (limit < 0) {
php_explode_negative_limit(&zdelim, &zstr, return_value, limit);
} else {
- add_index_stringl(return_value, 0, str->val, str->len, 1);
+ add_index_stringl(return_value, 0, str->val, str->len);
}
}
/* }}} */
dirname = estrndup(path, path_len);
php_dirname(dirname, path_len);
if (*dirname) {
- add_assoc_string(&tmp, "dirname", dirname, 1);
+ add_assoc_string(&tmp, "dirname", dirname);
}
efree(dirname);
}
if (p) {
idx = p - ret->val;
- add_assoc_stringl(&tmp, "extension", ret->val + idx + 1, ret->len - idx - 1, 1);
+ add_assoc_stringl(&tmp, "extension", ret->val + idx + 1, ret->len - idx - 1);
}
}
p = zend_memrchr(ret->val, '.', ret->len);
idx = p ? (p - ret->val) : ret->len;
- add_assoc_stringl(&tmp, "filename", ret->val, idx, 1);
+ add_assoc_stringl(&tmp, "filename", ret->val, idx);
}
if (ret) {
if (Z_TYPE_P(subject_entry) != IS_ARRAY && Z_TYPE_P(subject_entry) != IS_OBJECT) {
php_str_replace_in_subject(search, replace, subject_entry, &result, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC);
} else {
- Z_ADDREF_P(subject_entry);
- COPY_PZVAL_TO_ZVAL(result, subject_entry);
+ ZVAL_COPY(&result, subject_entry);
}
/* Add to return array */
switch (zend_hash_get_current_key(Z_ARRVAL_P(subject), &string_key,
add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]);
}
- add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point, 1);
- add_assoc_string(return_value, "thousands_sep", currlocdata.thousands_sep, 1);
- add_assoc_string(return_value, "int_curr_symbol", currlocdata.int_curr_symbol, 1);
- add_assoc_string(return_value, "currency_symbol", currlocdata.currency_symbol, 1);
- add_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point, 1);
- add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep, 1);
- add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign, 1);
- add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign, 1);
- add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits );
- add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits );
- add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes );
- add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space );
- add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes );
- add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space );
- add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn );
- add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn );
+ add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point);
+ add_assoc_string(return_value, "thousands_sep", currlocdata.thousands_sep);
+ add_assoc_string(return_value, "int_curr_symbol", currlocdata.int_curr_symbol);
+ add_assoc_string(return_value, "currency_symbol", currlocdata.currency_symbol);
+ add_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point);
+ add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep);
+ add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign);
+ add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign);
+ add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits);
+ add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits);
+ add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes);
+ add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space);
+ add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes);
+ add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space);
+ add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn);
+ add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn);
}
#else
/* Ok, it doesn't look like we have locale info floating around, so I guess it
add_index_long(&grouping, 0, -1);
add_index_long(&mon_grouping, 0, -1);
- add_assoc_string(return_value, "decimal_point", "\x2E", 1);
- add_assoc_string(return_value, "thousands_sep", "", 1);
- add_assoc_string(return_value, "int_curr_symbol", "", 1);
- add_assoc_string(return_value, "currency_symbol", "", 1);
- add_assoc_string(return_value, "mon_decimal_point", "\x2E", 1);
- add_assoc_string(return_value, "mon_thousands_sep", "", 1);
- add_assoc_string(return_value, "positive_sign", "", 1);
- add_assoc_string(return_value, "negative_sign", "", 1);
- add_assoc_long( return_value, "int_frac_digits", CHAR_MAX );
- add_assoc_long( return_value, "frac_digits", CHAR_MAX );
- add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX );
- add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX );
- add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX );
- add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX );
- add_assoc_long( return_value, "p_sign_posn", CHAR_MAX );
- add_assoc_long( return_value, "n_sign_posn", CHAR_MAX );
+ add_assoc_string(return_value, "decimal_point", "\x2E");
+ add_assoc_string(return_value, "thousands_sep", "");
+ add_assoc_string(return_value, "int_curr_symbol", "");
+ add_assoc_string(return_value, "currency_symbol", "");
+ add_assoc_string(return_value, "mon_decimal_point", "\x2E");
+ add_assoc_string(return_value, "mon_thousands_sep", "");
+ add_assoc_string(return_value, "positive_sign", "");
+ add_assoc_string(return_value, "negative_sign", "");
+ add_assoc_long( return_value, "int_frac_digits", CHAR_MAX);
+ add_assoc_long( return_value, "frac_digits", CHAR_MAX);
+ add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX);
+ add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX);
+ add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX);
+ add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX);
+ add_assoc_long( return_value, "p_sign_posn", CHAR_MAX);
+ add_assoc_long( return_value, "n_sign_posn", CHAR_MAX);
#endif
zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping);
switch (type)
{
case 1:
- add_next_index_stringl(return_value, s, p - s, 1);
+ add_next_index_stringl(return_value, s, p - s);
break;
case 2:
- add_index_stringl(return_value, (s - str), s, p - s, 1);
+ add_index_stringl(return_value, (s - str), s, p - s);
break;
default:
word_count++;
array_init_size(return_value, ((str_len - 1) / split_length) + 1);
if (split_length >= str_len) {
- add_next_index_stringl(return_value, str, str_len, 1);
+ add_next_index_stringl(return_value, str, str_len);
return;
}
p = str;
while (n_reg_segments-- > 0) {
- add_next_index_stringl(return_value, p, split_length, 1);
+ add_next_index_stringl(return_value, p, split_length);
p += split_length;
}
if (p != (str + str_len)) {
- add_next_index_stringl(return_value, p, (str + str_len - p), 1);
+ add_next_index_stringl(return_value, p, (str + str_len - p));
}
}
/* }}} */
return;
}
- ZVAL_DEREF_REF(var);
+ ZVAL_DEREF(var);
if (!strcasecmp(type, "integer")) {
convert_to_long(var);
} else if (!strcasecmp(type, "int")) {
/* add the various elements to the array */
if (resource->scheme != NULL)
- add_assoc_string(return_value, "scheme", resource->scheme, 1);
+ add_assoc_string(return_value, "scheme", resource->scheme);
if (resource->host != NULL)
- add_assoc_string(return_value, "host", resource->host, 1);
+ add_assoc_string(return_value, "host", resource->host);
if (resource->port != 0)
add_assoc_long(return_value, "port", resource->port);
if (resource->user != NULL)
- add_assoc_string(return_value, "user", resource->user, 1);
+ add_assoc_string(return_value, "user", resource->user);
if (resource->pass != NULL)
- add_assoc_string(return_value, "pass", resource->pass, 1);
+ add_assoc_string(return_value, "pass", resource->pass);
if (resource->path != NULL)
- add_assoc_string(return_value, "path", resource->path, 1);
+ add_assoc_string(return_value, "path", resource->path);
if (resource->query != NULL)
- add_assoc_string(return_value, "query", resource->query, 1);
+ add_assoc_string(return_value, "query", resource->query);
if (resource->fragment != NULL)
- add_assoc_string(return_value, "fragment", resource->fragment, 1);
+ add_assoc_string(return_value, "fragment", resource->fragment);
done:
php_url_free(resource);
}
}
if ((prev_val = zend_hash_str_find(HASH_OF(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
- add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))), 1);
+ add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
} else { /* some headers may occur more then once, therefor we need to remake the string into an array */
convert_to_array(prev_val);
- add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))), 1);
+ add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
}
*p = c;
//??? Z_SET_ISREF_P(obj);
/* filtername */
- add_property_string(&obj, "filtername", (char*)filtername, 1);
+ add_property_string(&obj, "filtername", (char*)filtername);
/* and the parameters, if any */
if (filterparams) {
add_property_zval(return_value, "bucket", &zbucket);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&zbucket);
- add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
+ add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
add_property_long(return_value, "datalen", bucket->buflen);
}
}
add_property_zval(return_value, "bucket", &zbucket);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&zbucket);
- add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
+ add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
add_property_long(return_value, "datalen", bucket->buflen);
}
/* }}} */
object_init(return_value);
- add_property_string(return_value, "name", result->fields[field_offset].name, 1);
+ add_property_string(return_value, "name", result->fields[field_offset].name);
add_property_long(return_value, "max_length", result->fields[field_offset].max_length);
- add_property_string(return_value, "column_source", result->fields[field_offset].column_source, 1);
+ add_property_string(return_value, "column_source", result->fields[field_offset].column_source);
add_property_long(return_value, "numeric", result->fields[field_offset].numeric);
- add_property_string(return_value, "type", php_sybase_get_field_name(Z_TYPE(result->fields[field_offset])), 1);
+ add_property_string(return_value, "type", php_sybase_get_field_name(Z_TYPE(result->fields[field_offset])));
}
/* }}} */
name = (char *)tidyAttrName(tempattr);
val = (char *)tidyAttrValue(tempattr);
if (name && val) {
- add_assoc_string(attribute, name, val, TRUE);
+ add_assoc_string(attribute, name, val);
}
} while((tempattr = tidyAttrNext(tempattr)));
} else {
opt_value = php_tidy_get_opt_val(obj->ptdoc, opt, &optt TSRMLS_CC);
switch (optt) {
case TidyString:
- add_assoc_string(return_value, opt_name, (char*)opt_value, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_string(return_value, opt_name, (char*)opt_value);
+ efree(opt_value);
break;
case TidyInteger:
CG(increment_lineno) = 0;
}
}
- add_next_index_stringl(&keyword, (char *)zendtext, zendleng, 1);
+ add_next_index_stringl(&keyword, (char *)zendtext, zendleng);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
} else {
- add_next_index_stringl(return_value, (char *)zendtext, zendleng, 1);
+ add_next_index_stringl(return_value, (char *)zendtext, zendleng);
}
if (destroy && Z_TYPE(token) != IS_NULL) {
zval_dtor(&token);
if (zendcursor != zendlimit) {
array_init(&keyword);
add_next_index_long(&keyword, T_INLINE_HTML);
- add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor, 1);
+ add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
}
att = _xml_decode_tag(parser, attributes[0]);
val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
- add_assoc_stringl(args[2], att, val, val_len, 0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl(args[2], att, val, val_len);
+ efree(val);
attributes += 2;
_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
- add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
- add_assoc_string(tag,"type","open",1);
+ add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
+ add_assoc_string(tag,"type","open");
add_assoc_long(tag,"level",parser->level);
parser->ltags[parser->level-1] = estrdup(tag_name);
att = _xml_decode_tag(parser, attributes[0]);
val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
- add_assoc_stringl(atr,att,val,val_len,0);
+ // TODO: avoid reallocation ???
+ add_assoc_stringl(atr,att,val,val_len);
+ efree(val);
atcnt++;
attributes += 2;
zval *tag;
if (parser->lastwasopen) {
- add_assoc_string(*(parser->ctag),"type","complete",1);
+ add_assoc_string(*(parser->ctag),"type","complete");
} else {
MAKE_STD_ZVAL(tag);
_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
- add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
- add_assoc_string(tag,"type","close",1);
+ add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
+ add_assoc_string(tag,"type","close");
add_assoc_long(tag,"level",parser->level);
zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
Z_STRLEN_PP(myval) += decoded_len;
efree(decoded_value);
} else {
- add_assoc_string(*(parser->ctag),"value",decoded_value,0);
+ // TODO: avoid reallocation ???
+ add_assoc_string(*(parser->ctag),"value",decoded_value);
+ efree(decoded_value);
}
} else {
_xml_add_to_info(parser,parser->ltags[parser->level-1] + parser->toffset);
- add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset,1);
- add_assoc_string(tag,"value",decoded_value,0);
- add_assoc_string(tag,"type","cdata",1);
+ add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset);
+ // TODO: avoid reallocation ???
+ add_assoc_string(tag,"value",decoded_value);
+ efree(decoded_value);
+ add_assoc_string(tag,"type","cdata");
add_assoc_long(tag,"level",parser->level);
zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
else return add_next_index_double(list, num);
}
-static int add_string(zval* list, char* id, char* string, int duplicate) {
- if(id) return add_assoc_string(list, id, string, duplicate);
- else return add_next_index_string(list, string, duplicate);
+static int add_string(zval* list, char* id, char* string) {
+ if(id) return add_assoc_string(list, id, string);
+ else return add_next_index_string(list, string);
}
-static int add_stringl(zval* list, char* id, char* string, uint length, int duplicate) {
- if(id) return add_assoc_stringl(list, id, string, length, duplicate);
- else return add_next_index_stringl(list, string, length, duplicate);
+static int add_stringl(zval* list, char* id, char* string, uint length) {
+ if(id) return add_assoc_stringl(list, id, string, length);
+ else return add_next_index_stringl(list, string, length);
}
#endif
ALLOC_ZVAL(new_string);
Z_ADDREF_PP(entry);
- COPY_PZVAL_TO_ZVAL(*new_string, *entry);
+ ZVAL_COPY_VALUE(new_string, *entry);
+//??? COPY_PZVAL_TO_ZVAL(*new_string, *entry);
zend_hash_update(intern->parameter, string_key, string_key_len, &new_string, sizeof(zval*), NULL);
zend_hash_move_forward(Z_ARRVAL_P(array_value));
#define RETURN_SB(sb) \
{ \
array_init(return_value); \
- add_ascii_assoc_string(return_value, "name", (char *)(sb)->name, 1); \
+ add_ascii_assoc_string(return_value, "name", (char *)(sb)->name); \
add_ascii_assoc_long(return_value, "index", (long) (sb)->index); \
add_ascii_assoc_long(return_value, "crc", (long) (sb)->crc); \
add_ascii_assoc_long(return_value, "size", (long) (sb)->size); \
continue;
}
}
- add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip, 1);
+ add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip);
}
globfree(&globbuf);
continue;
}
- add_next_index_string(return_value, fullpath, 1);
+ add_next_index_string(return_value, fullpath);
efree(namelist[i]);
}
efree(namelist);
memset(buf, 0, sizeof(buf));
while (php_stream_gets(stream, buf, sizeof(buf) - 1) != NULL) {
- add_index_string(return_value, i++, buf, 1);
+ add_index_string(return_value, i++, buf);
}
php_stream_close(stream);
}
php_output_handler *handler = *(php_output_handler **) h;
zval *array = (zval *) z;
- add_next_index_stringl(array, handler->name, handler->name_len, 1);
+ add_next_index_stringl(array, handler->name, handler->name_len);
return 0;
}
/* }}} */
ZEND_ASSERT(entry != NULL);
array_init(entry);
- add_assoc_stringl(entry, "name", handler->name, handler->name_len, 1);
+ add_assoc_stringl(entry, "name", handler->name, handler->name_len);
add_assoc_long(entry, "type", (long) (handler->flags & 0xf));
add_assoc_long(entry, "flags", (long) handler->flags);
add_assoc_long(entry, "level", (long) handler->level);
array_init(&meta);
if (!semi) { /* there is only a mime type */
- add_assoc_stringl(&meta, "mediatype", (char *) path, mlen, 1);
+ add_assoc_stringl(&meta, "mediatype", (char *) path, mlen);
mlen = 0;
} else if (sep && sep < semi) { /* there is a mime type */
plen = semi - path;
- add_assoc_stringl(&meta, "mediatype", (char *) path, plen, 1);
+ add_assoc_stringl(&meta, "mediatype", (char *) path, plen);
mlen -= plen;
path += plen;
} else if (semi != path || mlen != sizeof(";base64")-1 || memcmp(path, ";base64", sizeof(";base64")-1)) { /* must be error since parameters are only allowed after mediatype */
plen = sep - path;
vlen = (semi ? semi - sep : mlen - plen) - 1 /* '=' */;
key = estrndup(path, plen);
- add_assoc_stringl_ex(&meta, key, plen, sep + 1, vlen, 1);
+ add_assoc_stringl_ex(&meta, key, plen, sep + 1, vlen);
efree(key);
plen += vlen + 1;
mlen -= plen;
char *key = Ns_SetKey(NSG(conn->headers), i);
char *value = Ns_SetValue(NSG(conn->headers), i);
- add_assoc_string(return_value, key, value, 1);
+ add_assoc_string(return_value, key, value);
}
}
if (!tenv[i].key) {
continue;
}
- if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+ if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
RETURN_FALSE;
}
}
tenv = (table_entry *)env_arr->elts;
for (i = 0; i < env_arr->nelts; ++i) {
if (!tenv[i].key) continue;
- if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+ if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
RETURN_FALSE;
}
}
add_property_long(return_value,"status", rr->status);
if (rr->the_request) {
- add_property_string(return_value,"the_request", rr->the_request, 1);
+ add_property_string(return_value,"the_request", rr->the_request);
}
if (rr->status_line) {
- add_property_string(return_value,"status_line", (char *)rr->status_line, 1);
+ add_property_string(return_value,"status_line", (char *)rr->status_line);
}
if (rr->method) {
- add_property_string(return_value,"method", (char *)rr->method, 1);
+ add_property_string(return_value,"method", (char *)rr->method);
}
if (rr->content_type) {
- add_property_string(return_value,"content_type", (char *)rr->content_type, 1);
+ add_property_string(return_value,"content_type", (char *)rr->content_type);
}
if (rr->handler) {
- add_property_string(return_value,"handler", (char *)rr->handler, 1);
+ add_property_string(return_value,"handler", (char *)rr->handler);
}
if (rr->uri) {
- add_property_string(return_value,"uri", rr->uri, 1);
+ add_property_string(return_value,"uri", rr->uri);
}
if (rr->filename) {
- add_property_string(return_value,"filename", rr->filename, 1);
+ add_property_string(return_value,"filename", rr->filename);
}
if (rr->path_info) {
- add_property_string(return_value,"path_info", rr->path_info, 1);
+ add_property_string(return_value,"path_info", rr->path_info);
}
if (rr->args) {
- add_property_string(return_value,"args", rr->args, 1);
+ add_property_string(return_value,"args", rr->args);
}
if (rr->boundary) {
- add_property_string(return_value,"boundary", rr->boundary, 1);
+ add_property_string(return_value,"boundary", rr->boundary);
}
add_property_long(return_value,"no_cache", rr->no_cache);
#if MODULE_MAGIC_NUMBER >= 19980324
if (rr->unparsed_uri) {
- add_property_string(return_value,"unparsed_uri", rr->unparsed_uri, 1);
+ add_property_string(return_value,"unparsed_uri", rr->unparsed_uri);
}
if(rr->mtime) {
add_property_long(return_value,"mtime", rr->mtime);
for (n = 0; ap_loaded_modules[n]; ++n) {
char *s = (char *) ap_loaded_modules[n]->name;
if ((p = strchr(s, '.'))) {
- add_next_index_stringl(return_value, s, (p - s), 1);
+ add_next_index_stringl(return_value, s, (p - s));
} else {
- add_next_index_string(return_value, s, 1);
+ add_next_index_string(return_value, s);
}
}
}
#define ADD_TIME(name) \
add_property_long(return_value, #name, apr_time_sec(rr->name));
#define ADD_STRING(name) \
- if (rr->name) add_property_string(return_value, #name, (char *) rr->name, 1)
+ if (rr->name) add_property_string(return_value, #name, (char *) rr->name)
PHP_FUNCTION(apache_lookup_uri)
{
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) val = "";
- add_assoc_string(return_value, key, val, 1);
+ add_assoc_string(return_value, key, val);
APR_ARRAY_FOREACH_CLOSE()
}
/* }}} */
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) val = "";
- add_assoc_string(return_value, key, val, 1);
+ add_assoc_string(return_value, key, val);
APR_ARRAY_FOREACH_CLOSE()
}
/* }}} */
for (n = 0; ap_loaded_modules[n]; ++n) {
char *s = (char *) ap_loaded_modules[n]->name;
if ((p = strchr(s, '.'))) {
- add_next_index_stringl(return_value, s, (p - s), 1);
+ add_next_index_stringl(return_value, s, (p - s));
} else {
- add_next_index_string(return_value, s, 1);
+ add_next_index_string(return_value, s);
}
}
}
#define ADD_TIME(name) \
add_property_long(return_value, #name, apr_time_sec(rr->name));
#define ADD_STRING(name) \
- if (rr->name) add_property_string(return_value, #name, (char *) rr->name, 1)
+ if (rr->name) add_property_string(return_value, #name, (char *) rr->name)
PHP_FUNCTION(apache_lookup_uri)
{
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) val = "";
- add_assoc_string(return_value, key, val, 1);
+ add_assoc_string(return_value, key, val);
APR_ARRAY_FOREACH_CLOSE()
}
/* }}} */
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) val = "";
- add_assoc_string(return_value, key, val, 1);
+ add_assoc_string(return_value, key, val);
APR_ARRAY_FOREACH_CLOSE()
}
/* }}} */
for (n = 0; ap_loaded_modules[n]; ++n) {
char *s = (char *) ap_loaded_modules[n]->name;
if ((p = strchr(s, '.'))) {
- add_next_index_stringl(return_value, s, (p - s), 1);
+ add_next_index_stringl(return_value, s, (p - s));
} else {
- add_next_index_string(return_value, s, 1);
+ add_next_index_string(return_value, s);
}
}
}
if (!tenv[i].key) {
continue;
}
- if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+ if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
RETURN_FALSE;
}
}
add_property_long(return_value,"status", rr->status);
if (rr->the_request) {
- add_property_string(return_value,"the_request", rr->the_request, 1);
+ add_property_string(return_value,"the_request", rr->the_request);
}
if (rr->status_line) {
- add_property_string(return_value,"status_line", (char *)rr->status_line, 1);
+ add_property_string(return_value,"status_line", (char *)rr->status_line);
}
if (rr->method) {
- add_property_string(return_value,"method", (char *)rr->method, 1);
+ add_property_string(return_value,"method", (char *)rr->method);
}
if (rr->content_type) {
- add_property_string(return_value,"content_type", (char *)rr->content_type, 1);
+ add_property_string(return_value,"content_type", (char *)rr->content_type);
}
if (rr->handler) {
- add_property_string(return_value,"handler", (char *)rr->handler, 1);
+ add_property_string(return_value,"handler", (char *)rr->handler);
}
if (rr->uri) {
- add_property_string(return_value,"uri", rr->uri, 1);
+ add_property_string(return_value,"uri", rr->uri);
}
if (rr->filename) {
- add_property_string(return_value,"filename", rr->filename, 1);
+ add_property_string(return_value,"filename", rr->filename);
}
if (rr->path_info) {
- add_property_string(return_value,"path_info", rr->path_info, 1);
+ add_property_string(return_value,"path_info", rr->path_info);
}
if (rr->args) {
- add_property_string(return_value,"args", rr->args, 1);
+ add_property_string(return_value,"args", rr->args);
}
if (rr->boundary) {
- add_property_string(return_value,"boundary", rr->boundary, 1);
+ add_property_string(return_value,"boundary", rr->boundary);
}
add_property_long(return_value,"no_cache", rr->no_cache);
add_property_long(return_value,"no_local_copy", rr->no_local_copy);
#if MODULE_MAGIC_NUMBER >= 19980324
if (rr->unparsed_uri) {
- add_property_string(return_value,"unparsed_uri", rr->unparsed_uri, 1);
+ add_property_string(return_value,"unparsed_uri", rr->unparsed_uri);
}
if(rr->mtime) {
add_property_long(return_value,"mtime", rr->mtime);
for (n = 0; ap_loaded_modules[n]; ++n) {
char *s = (char *) ap_loaded_modules[n]->name;
if ((p = strchr(s, '.'))) {
- add_next_index_stringl(return_value, s, (p - s), 1);
+ add_next_index_stringl(return_value, s, (p - s));
} else {
- add_next_index_string(return_value, s, 1);
+ add_next_index_string(return_value, s);
}
}
}
} else {
return;
}
- add_assoc_stringl_ex(return_value, var, var_len+1, val, val_len, 1);
+ add_assoc_stringl_ex(return_value, var, var_len+1, val, val_len);
if (str) {
free_alloca(var, use_heap);
}
continue;
}
val++;
- add_assoc_string_ex(return_value, var, var_len, val, 1);
+ add_assoc_string_ex(return_value, var, var_len, val);
}
if (t != buf && t != NULL) {
efree(t);
do {
p++;
} while (*p == ' ' || *p == '\t');
- add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header), 1);
+ add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header));
free_alloca(s, use_heap);
}
}
while ((value = zend_hash_get_current_data_ptr_ex(headers, &pos)) != NULL) {
zend_hash_get_current_key_ex(headers, &key, NULL, 0, &pos);
//???
- add_assoc_string_ex(return_value, key->val, key->len, value, 1);
+ add_assoc_string_ex(return_value, key->val, key->len, value);
zend_hash_move_forward_ex(headers, &pos);
}
}
do {
p++;
} while (*p == ' ' || *p == '\t');
- add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header), 1);
+ add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header));
free_alloca(s, use_heap);
}
}
static int add_associate_array( const char * pKey, int keyLen, const char * pValue, int valLen,
void * arg )
{
- add_assoc_string_ex( (zval *)arg, (char *)pKey, keyLen+1, (char *)pValue, 1 );
+ add_assoc_string_ex( (zval *)arg, (char *)pKey, keyLen+1, (char *)pValue);
return 1;
}
headerBuf[len] = 0;
if ( len ) {
while( isspace(*++p));
- add_assoc_string_ex(return_value, headerBuf, len+1, p, 1 );
+ add_assoc_string_ex(return_value, headerBuf, len+1, p);
}
}
}
WRONG_PARAM_COUNT;
}
array_init(return_value);
- add_next_index_string(return_value, "mod_rewrite", 1);
- add_next_index_string(return_value, "mod_mime", 1);
- add_next_index_string(return_value, "mod_headers", 1);
- add_next_index_string(return_value, "mod_expires", 1);
+ add_next_index_string(return_value, "mod_rewrite");
+ add_next_index_string(return_value, "mod_mime");
+ add_next_index_string(return_value, "mod_headers");
+ add_next_index_string(return_value, "mod_expires");
}
/* }}} */
array_init(param[0]);
while (*argv) {
- add_next_index_string(param[0], *argv, 1);
+ add_next_index_string(param[0], *argv);
argv++;
}
array_init(param[0]);
while (*argv) {
- add_next_index_string(param[0], *argv, 1);
+ add_next_index_string(param[0], *argv);
argv++;
}
for (i=0; i < rc->rq->headers->hsize; i++) {
entry=rc->rq->headers->ht[i];
while (entry) {
- add_assoc_string(return_value, entry->param->name, entry->param->value, 1);
+ add_assoc_string(return_value, entry->param->name, entry->param->value);
entry=entry->next;
}
}
for (i=0; i < rc->rq->srvhdrs->hsize; i++) {
entry=rc->rq->srvhdrs->ht[i];
while (entry) {
- add_assoc_string(return_value, entry->param->name, entry->param->value, 1);
+ add_assoc_string(return_value, entry->param->name, entry->param->value);
entry=entry->next;
}
}
add_next_index_stringl(
¶ms,
input->argv[param+1]->string,
- input->argv[param+1]->length, 1);
+ input->argv[param+1]->length);
phpdbg_debug(
"created param[%d] from argv[%d]: %s",
projects / php / commitdiff