mirror of
https://github.com/php/php-src.git
synced 2024-09-21 09:57:23 +00:00
More usage of known zend_str instead of C string (#11381)
This commit is contained in:
parent
962a777a37
commit
d5ad75108e
@ -3529,7 +3529,7 @@ static bool zend_is_callable_check_class(zend_string *name, zend_class_entry *sc
|
||||
*strict_class = 1;
|
||||
ret = 1;
|
||||
}
|
||||
} else if (zend_string_equals_literal(lcname, "static")) {
|
||||
} else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_STATIC))) {
|
||||
zend_class_entry *called_scope = zend_get_called_scope(frame);
|
||||
|
||||
if (!called_scope) {
|
||||
@ -4560,7 +4560,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry
|
||||
}
|
||||
}
|
||||
|
||||
if (zend_string_equals_literal_ci(name, "class")) {
|
||||
if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_CLASS))) {
|
||||
zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR,
|
||||
"A class constant must not be called 'class'; it is reserved for class name fetching");
|
||||
}
|
||||
|
@ -101,7 +101,7 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_constant(zend_string *name, ze
|
||||
|
||||
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_class_const_or_name(zend_ast *class_name, zend_ast *name) {
|
||||
zend_string *name_str = zend_ast_get_str(name);
|
||||
if (zend_string_equals_literal_ci(name_str, "class")) {
|
||||
if (zend_string_equals_ci(name_str, ZSTR_KNOWN(ZEND_STR_CLASS))) {
|
||||
zend_string_release(name_str);
|
||||
return zend_ast_create(ZEND_AST_CLASS_NAME, class_name);
|
||||
} else {
|
||||
|
@ -114,7 +114,7 @@ ZEND_METHOD(SensitiveParameterValue, __construct)
|
||||
Z_PARAM_ZVAL(value)
|
||||
ZEND_PARSE_PARAMETERS_END();
|
||||
|
||||
zend_update_property(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), "value", strlen("value"), value);
|
||||
zend_update_property_ex(zend_ce_sensitive_parameter_value, Z_OBJ_P(ZEND_THIS), ZSTR_KNOWN(ZEND_STR_VALUE), value);
|
||||
}
|
||||
|
||||
ZEND_METHOD(SensitiveParameterValue, getValue)
|
||||
|
@ -1322,7 +1322,7 @@ ZEND_FUNCTION(get_defined_functions)
|
||||
} ZEND_HASH_FOREACH_END();
|
||||
|
||||
zend_hash_str_add_new(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal);
|
||||
zend_hash_str_add_new(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user);
|
||||
zend_hash_add_new(Z_ARRVAL_P(return_value), ZSTR_KNOWN(ZEND_STR_USER), &user);
|
||||
}
|
||||
/* }}} */
|
||||
|
||||
|
@ -1429,7 +1429,7 @@ ZEND_API zend_string *zend_type_to_string(zend_type type) {
|
||||
}
|
||||
|
||||
static bool is_generator_compatible_class_type(zend_string *name) {
|
||||
return zend_string_equals_literal_ci(name, "Traversable")
|
||||
return zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_TRAVERSABLE))
|
||||
|| zend_string_equals_literal_ci(name, "Iterator")
|
||||
|| zend_string_equals_literal_ci(name, "Generator");
|
||||
}
|
||||
@ -1617,7 +1617,7 @@ uint32_t zend_get_class_fetch_type(const zend_string *name) /* {{{ */
|
||||
return ZEND_FETCH_CLASS_SELF;
|
||||
} else if (zend_string_equals_literal_ci(name, "parent")) {
|
||||
return ZEND_FETCH_CLASS_PARENT;
|
||||
} else if (zend_string_equals_literal_ci(name, "static")) {
|
||||
} else if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_STATIC))) {
|
||||
return ZEND_FETCH_CLASS_STATIC;
|
||||
} else {
|
||||
return ZEND_FETCH_CLASS_DEFAULT;
|
||||
@ -2821,7 +2821,7 @@ static bool is_this_fetch(zend_ast *ast) /* {{{ */
|
||||
{
|
||||
if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) {
|
||||
zval *name = zend_ast_get_zval(ast->child[0]);
|
||||
return Z_TYPE_P(name) == IS_STRING && zend_string_equals_literal(Z_STR_P(name), "this");
|
||||
return Z_TYPE_P(name) == IS_STRING && zend_string_equals(Z_STR_P(name), ZSTR_KNOWN(ZEND_STR_THIS));
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -4522,7 +4522,7 @@ static zend_result zend_try_compile_special_func(znode *result, zend_string *lcn
|
||||
return zend_compile_func_cuf(result, args, lcname);
|
||||
} else if (zend_string_equals_literal(lcname, "in_array")) {
|
||||
return zend_compile_func_in_array(result, args);
|
||||
} else if (zend_string_equals_literal(lcname, "count")
|
||||
} else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_COUNT))
|
||||
|| zend_string_equals_literal(lcname, "sizeof")) {
|
||||
return zend_compile_func_count(result, args, lcname);
|
||||
} else if (zend_string_equals_literal(lcname, "get_class")) {
|
||||
@ -4872,7 +4872,7 @@ static void zend_compile_static_var_common(zend_string *var_name, zval *value, u
|
||||
|
||||
value = zend_hash_update(CG(active_op_array)->static_variables, var_name, value);
|
||||
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as static variable");
|
||||
}
|
||||
|
||||
@ -4888,7 +4888,7 @@ static void zend_compile_static_var(zend_ast *ast) /* {{{ */
|
||||
zend_ast *var_ast = ast->child[0];
|
||||
zend_string *var_name = zend_ast_get_str(var_ast);
|
||||
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as static variable");
|
||||
}
|
||||
|
||||
@ -6089,7 +6089,7 @@ static void zend_compile_try(zend_ast *ast) /* {{{ */
|
||||
zend_resolve_class_name_ast(class_ast));
|
||||
opline->extended_value = zend_alloc_cache_slot();
|
||||
|
||||
if (var_name && zend_string_equals_literal(var_name, "this")) {
|
||||
if (var_name && zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
|
||||
}
|
||||
|
||||
@ -6925,7 +6925,7 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32
|
||||
if (EX_VAR_TO_NUM(var_node.u.op.var) != i) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s",
|
||||
ZSTR_VAL(name));
|
||||
} else if (zend_string_equals_literal(name, "this")) {
|
||||
} else if (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as parameter");
|
||||
}
|
||||
|
||||
@ -7152,7 +7152,7 @@ static void zend_compile_closure_binding(znode *closure, zend_op_array *op_array
|
||||
zend_op *opline;
|
||||
zval *value;
|
||||
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
|
||||
}
|
||||
|
||||
@ -7196,7 +7196,7 @@ static void find_implicit_binds_recursively(closure_info *info, zend_ast *ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (zend_string_equals_literal(name, "this")) {
|
||||
if (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
/* $this does not need to be explicitly imported. */
|
||||
return;
|
||||
}
|
||||
|
@ -314,7 +314,7 @@ ZEND_API zval *zend_get_class_constant_ex(zend_string *class_name, zend_string *
|
||||
} else {
|
||||
ce = scope->parent;
|
||||
}
|
||||
} else if (zend_string_equals_literal_ci(class_name, "static")) {
|
||||
} else if (zend_string_equals_ci(class_name, ZSTR_KNOWN(ZEND_STR_STATIC))) {
|
||||
ce = zend_get_called_scope(EG(current_execute_data));
|
||||
if (UNEXPECTED(!ce)) {
|
||||
zend_throw_error(NULL, "Cannot access \"static\" when no class scope is active");
|
||||
@ -419,7 +419,7 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope,
|
||||
} else {
|
||||
ce = scope->parent;
|
||||
}
|
||||
} else if (zend_string_equals_literal_ci(class_name, "static")) {
|
||||
} else if (zend_string_equals_ci(class_name, ZSTR_KNOWN(ZEND_STR_STATIC))) {
|
||||
ce = zend_get_called_scope(EG(current_execute_data));
|
||||
if (UNEXPECTED(!ce)) {
|
||||
zend_throw_error(NULL, "Cannot access \"static\" when no class scope is active");
|
||||
|
@ -62,12 +62,12 @@ static void zend_verify_enum_properties(zend_class_entry *ce)
|
||||
zend_property_info *property_info;
|
||||
|
||||
ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, property_info) {
|
||||
if (zend_string_equals_literal(property_info->name, "name")) {
|
||||
if (zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_NAME))) {
|
||||
continue;
|
||||
}
|
||||
if (
|
||||
ce->enum_backing_type != IS_UNDEF
|
||||
&& zend_string_equals_literal(property_info->name, "value")
|
||||
&& zend_string_equals(property_info->name, ZSTR_KNOWN(ZEND_STR_VALUE))
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
@ -344,8 +344,8 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry
|
||||
&class_type->function_table, "rewind", sizeof("rewind") - 1);
|
||||
funcs_ptr->zf_valid = zend_hash_str_find_ptr(
|
||||
&class_type->function_table, "valid", sizeof("valid") - 1);
|
||||
funcs_ptr->zf_key = zend_hash_str_find_ptr(
|
||||
&class_type->function_table, "key", sizeof("key") - 1);
|
||||
funcs_ptr->zf_key = zend_hash_find_ptr(
|
||||
&class_type->function_table, ZSTR_KNOWN(ZEND_STR_KEY));
|
||||
funcs_ptr->zf_current = zend_hash_str_find_ptr(
|
||||
&class_type->function_table, "current", sizeof("current") - 1);
|
||||
funcs_ptr->zf_next = zend_hash_str_find_ptr(
|
||||
|
@ -1377,7 +1377,7 @@ static inline zend_result build_mime_structure_from_hash(php_curl *ch, zval *zpo
|
||||
curl_seek_callback seekfunc = seek_cb;
|
||||
#endif
|
||||
|
||||
prop = zend_read_property(curl_CURLFile_class, Z_OBJ_P(current), "name", sizeof("name")-1, 0, &rv);
|
||||
prop = zend_read_property_ex(curl_CURLFile_class, Z_OBJ_P(current), ZSTR_KNOWN(ZEND_STR_NAME), /* silent */ false, &rv);
|
||||
ZVAL_DEREF(prop);
|
||||
if (Z_TYPE_P(prop) != IS_STRING) {
|
||||
php_error_docref(NULL, E_WARNING, "Invalid filename for key %s", ZSTR_VAL(string_key));
|
||||
|
@ -1622,7 +1622,8 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
|
||||
zval *tmp;
|
||||
char *xquery;
|
||||
|
||||
tmp = zend_hash_str_find(ht, "query", sizeof("query")-1);
|
||||
/* Find "query" key */
|
||||
tmp = zend_hash_find(ht, ZSTR_KNOWN(ZEND_STR_QUERY));
|
||||
if (!tmp) {
|
||||
/* if mode == 0 then $xpath arg is 3, if mode == 1 then $xpath is 4 */
|
||||
zend_argument_value_error(3 + mode, "must have a \"query\" key");
|
||||
|
@ -708,7 +708,7 @@ ftp_mlsd_parse_line(HashTable *ht, const char *input) {
|
||||
|
||||
/* Extract pathname */
|
||||
ZVAL_STRINGL(&zstr, sp + 1, end - sp - 1);
|
||||
zend_hash_str_update(ht, "name", sizeof("name")-1, &zstr);
|
||||
zend_hash_update(ht, ZSTR_KNOWN(ZEND_STR_NAME), &zstr);
|
||||
end = sp;
|
||||
|
||||
while (input < end) {
|
||||
|
@ -1978,7 +1978,7 @@ PHP_FUNCTION(iconv_mime_encode)
|
||||
if (pref != NULL) {
|
||||
zval *pzval;
|
||||
|
||||
if ((pzval = zend_hash_str_find_deref(Z_ARRVAL_P(pref), "scheme", sizeof("scheme") - 1)) != NULL) {
|
||||
if ((pzval = zend_hash_find_deref(Z_ARRVAL_P(pref), ZSTR_KNOWN(ZEND_STR_SCHEME))) != NULL) {
|
||||
if (Z_TYPE_P(pzval) == IS_STRING && Z_STRLEN_P(pzval) > 0) {
|
||||
switch (Z_STRVAL_P(pzval)[0]) {
|
||||
case 'B': case 'b':
|
||||
|
@ -412,7 +412,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
|
||||
struct berval control_value = { 0L, NULL };
|
||||
int control_value_alloc = 0;
|
||||
|
||||
if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "value", sizeof("value") - 1)) != NULL) {
|
||||
if ((val = zend_hash_find(Z_ARRVAL_P(array), ZSTR_KNOWN(ZEND_STR_VALUE))) != NULL) {
|
||||
if (Z_TYPE_P(val) != IS_ARRAY) {
|
||||
tmpstring = zval_get_string(val);
|
||||
if (EG(exception)) {
|
||||
@ -634,7 +634,8 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
|
||||
} else if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "offset", sizeof("offset") - 1)) != NULL) {
|
||||
vlvInfo.ldvlv_attrvalue = NULL;
|
||||
vlvInfo.ldvlv_offset = zval_get_long(tmp);
|
||||
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "count", sizeof("count") - 1)) != NULL) {
|
||||
/* Find "count" key */
|
||||
if ((tmp = zend_hash_find(Z_ARRVAL_P(val), ZSTR_KNOWN(ZEND_STR_COUNT))) != NULL) {
|
||||
vlvInfo.ldvlv_count = zval_get_long(tmp);
|
||||
} else {
|
||||
rc = -1;
|
||||
|
@ -4822,7 +4822,7 @@ ZEND_EXT_API int zend_jit_config(zend_string *jit, int stage)
|
||||
JIT_G(trigger) = ZEND_JIT_ON_HOT_TRACE;
|
||||
JIT_G(opt_flags) = ZEND_JIT_REG_ALLOC_GLOBAL | ZEND_JIT_CPU_AVX;
|
||||
return SUCCESS;
|
||||
} else if (zend_string_equals_literal_ci(jit, "function")) {
|
||||
} else if (zend_string_equals_ci(jit, ZSTR_KNOWN(ZEND_STR_FUNCTION))) {
|
||||
JIT_G(enabled) = 1;
|
||||
JIT_G(on) = 1;
|
||||
JIT_G(opt_level) = ZEND_JIT_LEVEL_OPT_SCRIPT;
|
||||
|
@ -1121,7 +1121,7 @@ void zend_update_parent_ce(zend_class_entry *ce)
|
||||
if (zend_class_implements_interface(ce, zend_ce_iterator)) {
|
||||
ce->iterator_funcs_ptr->zf_rewind = zend_hash_str_find_ptr(&ce->function_table, "rewind", sizeof("rewind") - 1);
|
||||
ce->iterator_funcs_ptr->zf_valid = zend_hash_str_find_ptr(&ce->function_table, "valid", sizeof("valid") - 1);
|
||||
ce->iterator_funcs_ptr->zf_key = zend_hash_str_find_ptr(&ce->function_table, "key", sizeof("key") - 1);
|
||||
ce->iterator_funcs_ptr->zf_key = zend_hash_find_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_KEY));
|
||||
ce->iterator_funcs_ptr->zf_current = zend_hash_str_find_ptr(&ce->function_table, "current", sizeof("current") - 1);
|
||||
ce->iterator_funcs_ptr->zf_next = zend_hash_str_find_ptr(&ce->function_table, "next", sizeof("next") - 1);
|
||||
}
|
||||
|
@ -319,12 +319,12 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *ret
|
||||
|
||||
switch (sqlite3_column_type(S->stmt, colno)) {
|
||||
case SQLITE_NULL:
|
||||
add_assoc_string(return_value, "native_type", "null");
|
||||
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_NULL_LOWERCASE));
|
||||
add_assoc_long(return_value, "pdo_type", PDO_PARAM_NULL);
|
||||
break;
|
||||
|
||||
case SQLITE_FLOAT:
|
||||
add_assoc_string(return_value, "native_type", "double");
|
||||
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_DOUBLE));
|
||||
add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
|
||||
break;
|
||||
|
||||
@ -333,12 +333,12 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *ret
|
||||
/* TODO Check this is correct */
|
||||
ZEND_FALLTHROUGH;
|
||||
case SQLITE_TEXT:
|
||||
add_assoc_string(return_value, "native_type", "string");
|
||||
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_STRING));
|
||||
add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
|
||||
break;
|
||||
|
||||
case SQLITE_INTEGER:
|
||||
add_assoc_string(return_value, "native_type", "integer");
|
||||
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_INTEGER));
|
||||
add_assoc_long(return_value, "pdo_type", PDO_PARAM_INT);
|
||||
break;
|
||||
}
|
||||
|
@ -4296,7 +4296,7 @@ static php_pgsql_data_type php_pgsql_get_data_type(const zend_string *type_name)
|
||||
/* This is stupid way to do. I'll fix it when I decide how to support
|
||||
user defined types. (Yasuo) */
|
||||
/* boolean */
|
||||
if (zend_string_equals_literal(type_name, "bool")|| zend_string_equals_literal(type_name, "boolean"))
|
||||
if (zend_string_equals(type_name, ZSTR_KNOWN(ZEND_STR_BOOL)) ||zend_string_equals(type_name, ZSTR_KNOWN(ZEND_STR_BOOLEAN)))
|
||||
return PG_BOOL;
|
||||
/* object id */
|
||||
if (zend_string_equals_literal(type_name, "oid"))
|
||||
|
@ -1560,7 +1560,7 @@ ZEND_METHOD(Reflection, getModifierNames)
|
||||
}
|
||||
|
||||
if (modifiers & ZEND_ACC_STATIC) {
|
||||
add_next_index_stringl(return_value, "static", sizeof("static")-1);
|
||||
add_next_index_str(return_value, ZSTR_KNOWN(ZEND_STR_STATIC));
|
||||
}
|
||||
|
||||
if (modifiers & (ZEND_ACC_READONLY | ZEND_ACC_READONLY_CLASS)) {
|
||||
@ -7137,7 +7137,7 @@ ZEND_METHOD(ReflectionFiber, getCallable)
|
||||
static zval *_reflection_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot)
|
||||
{
|
||||
if (zend_hash_exists(&object->ce->properties_info, name)
|
||||
&& (zend_string_equals_literal(name, "name") || zend_string_equals_literal(name, "class")))
|
||||
&& (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_NAME)) || zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_CLASS))))
|
||||
{
|
||||
zend_throw_exception_ex(reflection_exception_ptr, 0,
|
||||
"Cannot set read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name));
|
||||
|
@ -1927,7 +1927,7 @@ PHP_FUNCTION(session_module_name)
|
||||
}
|
||||
|
||||
if (name) {
|
||||
if (zend_string_equals_literal_ci(name, "user")) {
|
||||
if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_USER))) {
|
||||
zend_argument_value_error(1, "cannot be \"user\"");
|
||||
RETURN_THROWS();
|
||||
}
|
||||
@ -1967,7 +1967,7 @@ static inline void set_user_save_handler_ini(void) {
|
||||
zend_string *ini_name, *ini_val;
|
||||
|
||||
ini_name = ZSTR_INIT_LITERAL("session.save_handler", 0);
|
||||
ini_val = ZSTR_INIT_LITERAL("user", 0);
|
||||
ini_val = ZSTR_KNOWN(ZEND_STR_USER);
|
||||
PS(set_handler) = 1;
|
||||
zend_alter_ini_entry(ini_name, ini_val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
|
||||
PS(set_handler) = 0;
|
||||
|
@ -2191,7 +2191,8 @@ static zend_function* php_sxe_find_fptr_count(zend_class_entry *ce)
|
||||
}
|
||||
|
||||
if (inherited) {
|
||||
fptr_count = zend_hash_str_find_ptr(&ce->function_table, "count", sizeof("count") - 1);
|
||||
/* Find count() method */
|
||||
fptr_count = zend_hash_find_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
|
||||
if (fptr_count->common.scope == parent) {
|
||||
fptr_count = NULL;
|
||||
}
|
||||
|
@ -584,8 +584,8 @@ PHP_METHOD(SoapFault, __toString)
|
||||
this_ptr = ZEND_THIS;
|
||||
faultcode = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "faultcode", sizeof("faultcode")-1, 1, &rv1);
|
||||
faultstring = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "faultstring", sizeof("faultstring")-1, 1, &rv2);
|
||||
file = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "file", sizeof("file")-1, 1, &rv3);
|
||||
line = zend_read_property(soap_fault_class_entry, Z_OBJ_P(this_ptr), "line", sizeof("line")-1, 1, &rv4);
|
||||
file = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr), ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv3);
|
||||
line = zend_read_property_ex(soap_fault_class_entry, Z_OBJ_P(this_ptr), ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv4);
|
||||
|
||||
zend_call_method_with_0_params(
|
||||
Z_OBJ_P(ZEND_THIS), Z_OBJCE_P(ZEND_THIS), NULL, "gettraceasstring", &trace);
|
||||
@ -1107,7 +1107,7 @@ static void _soap_server_exception(soapServicePtr service, sdlFunctionPtr functi
|
||||
} else if (instanceof_function(Z_OBJCE(exception_object), zend_ce_error)) {
|
||||
if (service->send_errors) {
|
||||
zval rv;
|
||||
zend_string *msg = zval_get_string(zend_read_property(zend_ce_error, Z_OBJ(exception_object), "message", sizeof("message")-1, 0, &rv));
|
||||
zend_string *msg = zval_get_string(zend_read_property_ex(zend_ce_error, Z_OBJ(exception_object), ZSTR_KNOWN(ZEND_STR_MESSAGE), /* silent */ false, &rv));
|
||||
add_soap_fault_ex(&exception_object, this_ptr, "Server", ZSTR_VAL(msg), NULL, NULL);
|
||||
zend_string_release_ex(msg, 0);
|
||||
} else {
|
||||
@ -1943,7 +1943,7 @@ PHP_METHOD(SoapClient, __construct)
|
||||
php_stream_context_set_option(context, "ssl", "passphrase", tmp);
|
||||
}
|
||||
}
|
||||
if ((tmp = zend_hash_str_find(ht, "trace", sizeof("trace")-1)) != NULL &&
|
||||
if ((tmp = zend_hash_find(ht, ZSTR_KNOWN(ZEND_STR_TRACE))) != NULL &&
|
||||
(Z_TYPE_P(tmp) == IS_TRUE ||
|
||||
(Z_TYPE_P(tmp) == IS_LONG && Z_LVAL_P(tmp) == 1))) {
|
||||
ZVAL_TRUE(Z_CLIENT_TRACE_P(this_ptr));
|
||||
@ -2747,7 +2747,7 @@ static void set_soap_fault(zval *obj, char *fault_code_ns, char *fault_code, cha
|
||||
}
|
||||
|
||||
ZVAL_STRING(Z_FAULT_STRING_P(obj), fault_string ? fault_string : "");
|
||||
zend_update_property_string(zend_ce_exception, Z_OBJ_P(obj), "message", sizeof("message")-1, (fault_string ? fault_string : ""));
|
||||
zend_update_property_ex(zend_ce_exception, Z_OBJ_P(obj), ZSTR_KNOWN(ZEND_STR_MESSAGE), Z_FAULT_STRING_P(obj));
|
||||
|
||||
if (fault_code != NULL) {
|
||||
int soap_version = SOAP_GLOBAL(soap_version);
|
||||
|
@ -125,12 +125,12 @@ ZEND_GET_MODULE(sodium)
|
||||
/* Remove argument information from backtrace to prevent information leaks */
|
||||
static void sodium_remove_param_values_from_backtrace(zend_object *obj) {
|
||||
zval rv;
|
||||
zval *trace = zend_read_property(zend_get_exception_base(obj), obj, "trace", sizeof("trace")-1, 0, &rv);
|
||||
zval *trace = zend_read_property_ex(zend_get_exception_base(obj), obj, ZSTR_KNOWN(ZEND_STR_TRACE), /* silent */ false, &rv);
|
||||
if (trace && Z_TYPE_P(trace) == IS_ARRAY) {
|
||||
zval *frame;
|
||||
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(trace), frame) {
|
||||
if (Z_TYPE_P(frame) == IS_ARRAY) {
|
||||
zval *args = zend_hash_str_find(Z_ARRVAL_P(frame), "args", sizeof("args")-1);
|
||||
zval *args = zend_hash_find(Z_ARRVAL_P(frame), ZSTR_KNOWN(ZEND_STR_ARGS));
|
||||
if (args) {
|
||||
zval_ptr_dtor(args);
|
||||
ZVAL_EMPTY_ARRAY(args);
|
||||
|
@ -211,7 +211,8 @@ static zend_object *spl_array_object_new_ex(zend_class_entry *class_type, zend_o
|
||||
if (intern->fptr_offset_del->common.scope == parent) {
|
||||
intern->fptr_offset_del = NULL;
|
||||
}
|
||||
intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
|
||||
/* Find count() method */
|
||||
intern->fptr_count = zend_hash_find_ptr(&class_type->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
|
||||
if (intern->fptr_count->common.scope == parent) {
|
||||
intern->fptr_count = NULL;
|
||||
}
|
||||
|
@ -375,7 +375,8 @@ static zend_object *spl_dllist_object_new_ex(zend_class_entry *class_type, zend_
|
||||
if (intern->fptr_offset_del->common.scope == parent) {
|
||||
intern->fptr_offset_del = NULL;
|
||||
}
|
||||
intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
|
||||
/* Find count() method */
|
||||
intern->fptr_count = zend_hash_find_ptr(&class_type->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
|
||||
if (intern->fptr_count->common.scope == parent) {
|
||||
intern->fptr_count = NULL;
|
||||
}
|
||||
|
@ -282,7 +282,8 @@ static zend_object *spl_fixedarray_object_new_ex(zend_class_entry *class_type, z
|
||||
ZEND_ASSERT(parent);
|
||||
|
||||
if (UNEXPECTED(inherited)) {
|
||||
zend_function *fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
|
||||
/* Find count() method */
|
||||
zend_function *fptr_count = zend_hash_find_ptr(&class_type->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
|
||||
if (fptr_count->common.scope == parent) {
|
||||
fptr_count = NULL;
|
||||
}
|
||||
|
@ -451,7 +451,8 @@ static zend_object *spl_heap_object_new_ex(zend_class_entry *class_type, zend_ob
|
||||
if (intern->fptr_cmp->common.scope == parent) {
|
||||
intern->fptr_cmp = NULL;
|
||||
}
|
||||
intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
|
||||
/* Find count() method */
|
||||
intern->fptr_count = zend_hash_find_ptr(&class_type->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
|
||||
if (intern->fptr_count->common.scope == parent) {
|
||||
intern->fptr_count = NULL;
|
||||
}
|
||||
|
@ -1777,7 +1777,7 @@ static zend_long php_extract_ref_if_exists(zend_array *arr, zend_array *symbol_t
|
||||
if (zend_string_equals_literal(var_name, "GLOBALS")) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
}
|
||||
@ -1823,7 +1823,7 @@ static zend_long php_extract_if_exists(zend_array *arr, zend_array *symbol_table
|
||||
if (zend_string_equals_literal(var_name, "GLOBALS")) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
}
|
||||
@ -1856,7 +1856,7 @@ static zend_long php_extract_ref_overwrite(zend_array *arr, zend_array *symbol_t
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
}
|
||||
@ -1906,7 +1906,7 @@ static zend_long php_extract_overwrite(zend_array *arr, zend_array *symbol_table
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
}
|
||||
@ -1965,7 +1965,7 @@ static zend_long php_extract_ref_prefix_if_exists(zend_array *arr, zend_array *s
|
||||
}
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2019,7 +2019,7 @@ static zend_long php_extract_prefix_if_exists(zend_array *arr, zend_array *symbo
|
||||
}
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2082,7 +2082,7 @@ static zend_long php_extract_ref_prefix_same(zend_array *arr, zend_array *symbol
|
||||
prefix:
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2108,7 +2108,7 @@ prefix:
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
goto prefix;
|
||||
}
|
||||
if (Z_ISREF_P(entry)) {
|
||||
@ -2154,7 +2154,7 @@ static zend_long php_extract_prefix_same(zend_array *arr, zend_array *symbol_tab
|
||||
prefix:
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2180,7 +2180,7 @@ prefix:
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
goto prefix;
|
||||
}
|
||||
ZVAL_DEREF(entry);
|
||||
@ -2213,7 +2213,7 @@ static zend_long php_extract_ref_prefix_all(zend_array *arr, zend_array *symbol_
|
||||
zend_string_release_ex(str, 0);
|
||||
}
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2260,7 +2260,7 @@ static zend_long php_extract_prefix_all(zend_array *arr, zend_array *symbol_tabl
|
||||
zend_string_release_ex(str, 0);
|
||||
}
|
||||
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2298,7 +2298,7 @@ static zend_long php_extract_ref_prefix_invalid(zend_array *arr, zend_array *sym
|
||||
ZEND_HASH_FOREACH_KEY_VAL(arr, num_key, var_name, entry) {
|
||||
if (var_name) {
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))
|
||||
|| zend_string_equals_literal(var_name, "this")) {
|
||||
|| zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
zval_ptr_dtor_str(&final_name);
|
||||
@ -2316,7 +2316,7 @@ static zend_long php_extract_ref_prefix_invalid(zend_array *arr, zend_array *sym
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2353,7 +2353,7 @@ static zend_long php_extract_prefix_invalid(zend_array *arr, zend_array *symbol_
|
||||
ZEND_HASH_FOREACH_KEY_VAL(arr, num_key, var_name, entry) {
|
||||
if (var_name) {
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))
|
||||
|| zend_string_equals_literal(var_name, "this")) {
|
||||
|| zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
|
||||
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
|
||||
zval_ptr_dtor_str(&final_name);
|
||||
@ -2371,7 +2371,7 @@ static zend_long php_extract_prefix_invalid(zend_array *arr, zend_array *symbol_
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
|
||||
if (zend_string_equals(Z_STR(final_name), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_throw_error(NULL, "Cannot re-assign $this");
|
||||
return -1;
|
||||
} else {
|
||||
@ -2414,7 +2414,7 @@ static zend_long php_extract_ref_skip(zend_array *arr, zend_array *symbol_table)
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
continue;
|
||||
}
|
||||
orig_var = zend_hash_find_known_hash(symbol_table, var_name);
|
||||
@ -2462,7 +2462,7 @@ static zend_long php_extract_skip(zend_array *arr, zend_array *symbol_table) /*
|
||||
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
|
||||
continue;
|
||||
}
|
||||
if (zend_string_equals_literal(var_name, "this")) {
|
||||
if (zend_string_equals(var_name, ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
continue;
|
||||
}
|
||||
orig_var = zend_hash_find_known_hash(symbol_table, var_name);
|
||||
@ -2601,7 +2601,7 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu
|
||||
ZVAL_DEREF(value_ptr);
|
||||
Z_TRY_ADDREF_P(value_ptr);
|
||||
zend_hash_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), value_ptr);
|
||||
} else if (zend_string_equals_literal(Z_STR_P(entry), "this")) {
|
||||
} else if (zend_string_equals(Z_STR_P(entry), ZSTR_KNOWN(ZEND_STR_THIS))) {
|
||||
zend_object *object = zend_get_this_object(EG(current_execute_data));
|
||||
if (object) {
|
||||
ZVAL_OBJ_COPY(&data, object);
|
||||
|
@ -889,7 +889,7 @@ PHPAPI void php_stat(zend_string *filename, int type, zval *return_value)
|
||||
case S_IFCHR: RETURN_STRING("char");
|
||||
case S_IFDIR: RETURN_STRING("dir");
|
||||
case S_IFBLK: RETURN_STRING("block");
|
||||
case S_IFREG: RETURN_STRING("file");
|
||||
case S_IFREG: RETURN_STR(ZSTR_KNOWN(ZEND_STR_FILE)); /* "file" */
|
||||
#if defined(S_IFSOCK) && !defined(PHP_WIN32)
|
||||
case S_IFSOCK: RETURN_STRING("socket");
|
||||
#endif
|
||||
|
@ -917,7 +917,7 @@ static zend_result set_proc_descriptor_from_array(zval *descitem, descriptorspec
|
||||
} else if (zend_string_equals_literal(ztype, "socket")) {
|
||||
/* Set descriptor to socketpair */
|
||||
retval = set_proc_descriptor_to_socket(&descriptors[ndesc]);
|
||||
} else if (zend_string_equals_literal(ztype, "file")) {
|
||||
} else if (zend_string_equals(ztype, ZSTR_KNOWN(ZEND_STR_FILE))) {
|
||||
/* Set descriptor to file */
|
||||
if ((zfile = get_string_parameter(descitem, 1, "file name parameter for 'file'")) == NULL) {
|
||||
goto finish;
|
||||
@ -940,7 +940,7 @@ static zend_result set_proc_descriptor_from_array(zval *descitem, descriptorspec
|
||||
|
||||
retval = redirect_proc_descriptor(
|
||||
&descriptors[ndesc], (int)Z_LVAL_P(ztarget), descriptors, ndesc, nindex);
|
||||
} else if (zend_string_equals_literal(ztype, "null")) {
|
||||
} else if (zend_string_equals(ztype, ZSTR_KNOWN(ZEND_STR_NULL_LOWERCASE))) {
|
||||
/* Set descriptor to blackhole (discard all data written) */
|
||||
retval = set_proc_descriptor_to_blackhole(&descriptors[ndesc]);
|
||||
} else if (zend_string_equals_literal(ztype, "pty")) {
|
||||
|
@ -100,31 +100,31 @@ PHP_FUNCTION(settype)
|
||||
} else {
|
||||
ptr = Z_REFVAL_P(var);
|
||||
}
|
||||
if (zend_string_equals_literal_ci(type, "integer")) {
|
||||
if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_INTEGER))) {
|
||||
convert_to_long(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "int")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_INT))) {
|
||||
convert_to_long(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "float")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_FLOAT))) {
|
||||
convert_to_double(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "double")) { /* deprecated */
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_DOUBLE))) { /* deprecated */
|
||||
convert_to_double(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "string")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_STRING))) {
|
||||
convert_to_string(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "array")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_ARRAY))) {
|
||||
convert_to_array(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "object")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_OBJECT))) {
|
||||
convert_to_object(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "bool")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_BOOL))) {
|
||||
convert_to_boolean(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "boolean")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_BOOLEAN))) {
|
||||
convert_to_boolean(ptr);
|
||||
} else if (zend_string_equals_literal_ci(type, "null")) {
|
||||
} else if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_NULL_LOWERCASE))) {
|
||||
convert_to_null(ptr);
|
||||
} else {
|
||||
if (ptr == &tmp) {
|
||||
zval_ptr_dtor(&tmp);
|
||||
}
|
||||
if (zend_string_equals_literal_ci(type, "resource")) {
|
||||
if (zend_string_equals_ci(type, ZSTR_KNOWN(ZEND_STR_RESOURCE))) {
|
||||
zend_value_error("Cannot convert to resource type");
|
||||
} else {
|
||||
zend_argument_value_error(2, "must be a valid type");
|
||||
|
@ -762,7 +762,7 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
|
||||
if (parser->lastwasopen) {
|
||||
zval *myval;
|
||||
/* check if the current tag already has a value - if yes append to that! */
|
||||
if ((myval = zend_hash_str_find(Z_ARRVAL_P(parser->ctag), "value", sizeof("value") - 1))) {
|
||||
if ((myval = zend_hash_find(Z_ARRVAL_P(parser->ctag), ZSTR_KNOWN(ZEND_STR_VALUE)))) {
|
||||
size_t newlen = Z_STRLEN_P(myval) + ZSTR_LEN(decoded_value);
|
||||
Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
|
||||
strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
|
||||
@ -781,7 +781,7 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
|
||||
ZEND_HASH_REVERSE_FOREACH_VAL(Z_ARRVAL(parser->data), curtag) {
|
||||
if ((mytype = zend_hash_str_find(Z_ARRVAL_P(curtag),"type", sizeof("type") - 1))) {
|
||||
if (zend_string_equals_literal(Z_STR_P(mytype), "cdata")) {
|
||||
if ((myval = zend_hash_str_find(Z_ARRVAL_P(curtag), "value", sizeof("value") - 1))) {
|
||||
if ((myval = zend_hash_find(Z_ARRVAL_P(curtag), ZSTR_KNOWN(ZEND_STR_VALUE)))) {
|
||||
size_t newlen = Z_STRLEN_P(myval) + ZSTR_LEN(decoded_value);
|
||||
Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
|
||||
strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
|
||||
|
@ -169,7 +169,7 @@ static PHP_INI_MH(OnSetFacility)
|
||||
}
|
||||
#endif
|
||||
#ifdef LOG_USER
|
||||
if (zend_string_equals_literal(facility, "LOG_USER") || zend_string_equals_literal(facility, "user")) {
|
||||
if (zend_string_equals(facility, ZSTR_KNOWN(ZEND_STR_USER)) || zend_string_equals_literal(facility, "LOG_USER")) {
|
||||
PG(syslog_facility) = LOG_USER;
|
||||
return SUCCESS;
|
||||
}
|
||||
|
@ -1076,7 +1076,7 @@ do_repeat:
|
||||
|
||||
if (EG(exception)) {
|
||||
zval rv;
|
||||
zval *msg = zend_read_property(zend_ce_exception, EG(exception), "message", sizeof("message")-1, 0, &rv);
|
||||
zval *msg = zend_read_property_ex(zend_ce_exception, EG(exception), ZSTR_KNOWN(ZEND_STR_MESSAGE), /* silent */ false, &rv);
|
||||
zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
|
||||
zend_object_release(EG(exception));
|
||||
EG(exception) = NULL;
|
||||
|
@ -361,7 +361,7 @@ static void append_essential_headers(smart_str* buffer, php_cli_server_client *c
|
||||
zval *val;
|
||||
struct timeval tv = {0};
|
||||
|
||||
if (NULL != (val = zend_hash_str_find(&client->request.headers, "host", sizeof("host")-1))) {
|
||||
if (NULL != (val = zend_hash_find(&client->request.headers, ZSTR_KNOWN(ZEND_STR_HOST)))) {
|
||||
smart_str_appends_ex(buffer, "Host: ", persistent);
|
||||
smart_str_append_ex(buffer, Z_STR_P(val), persistent);
|
||||
smart_str_appends_ex(buffer, "\r\n", persistent);
|
||||
|
@ -534,7 +534,7 @@ static char *fpm_conf_set_pm(zval *value, void **config, intptr_t offset) /* {{{
|
||||
{
|
||||
zend_string *val = Z_STR_P(value);
|
||||
struct fpm_worker_pool_config_s *c = *config;
|
||||
if (zend_string_equals_literal_ci(val, "static")) {
|
||||
if (zend_string_equals_ci(val, ZSTR_KNOWN(ZEND_STR_STATIC))) {
|
||||
c->pm = PM_STYLE_STATIC;
|
||||
} else if (zend_string_equals_literal_ci(val, "dynamic")) {
|
||||
c->pm = PM_STYLE_DYNAMIC;
|
||||
|
@ -171,24 +171,24 @@ static void phpdbg_dump_prototype(zval *tmp) /* {{{ */
|
||||
{
|
||||
zval *funcname, *class, class_zv, *args, *argstmp;
|
||||
|
||||
funcname = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("function"));
|
||||
funcname = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_FUNCTION));
|
||||
|
||||
if ((class = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("object")))) {
|
||||
if ((class = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_OBJECT)))) {
|
||||
ZVAL_NEW_STR(&class_zv, Z_OBJCE_P(class)->name);
|
||||
class = &class_zv;
|
||||
} else {
|
||||
class = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("class"));
|
||||
class = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_CLASS));
|
||||
}
|
||||
|
||||
if (class) {
|
||||
zval *type = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("type"));
|
||||
zval *type = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_TYPE));
|
||||
|
||||
phpdbg_out("%s%s%s(", Z_STRVAL_P(class), Z_STRVAL_P(type), Z_STRVAL_P(funcname));
|
||||
} else {
|
||||
phpdbg_out("%s(", Z_STRVAL_P(funcname));
|
||||
}
|
||||
|
||||
args = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("args"));
|
||||
args = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_ARGS));
|
||||
|
||||
if (args) {
|
||||
const zend_function *func = NULL;
|
||||
@ -287,8 +287,8 @@ void phpdbg_dump_backtrace(size_t num) /* {{{ */
|
||||
phpdbg_out(" (internal function)\n");
|
||||
}
|
||||
|
||||
file = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("file"));
|
||||
line = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("line"));
|
||||
file = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_FILE));
|
||||
line = zend_hash_find(Z_ARRVAL_P(tmp), ZSTR_KNOWN(ZEND_STR_LINE));
|
||||
zend_hash_move_forward_ex(Z_ARRVAL(zbacktrace), &position);
|
||||
}
|
||||
|
||||
|
@ -715,8 +715,8 @@ static inline void phpdbg_handle_exception(void) /* {{{ */
|
||||
EG(exception) = NULL;
|
||||
|
||||
zend_call_known_instance_method_with_0_params(ex->ce->__tostring, ex, &tmp);
|
||||
file = zval_get_string(zend_read_property(zend_get_exception_base(ex), ex, ZEND_STRL("file"), 1, &rv));
|
||||
line = zval_get_long(zend_read_property(zend_get_exception_base(ex), ex, ZEND_STRL("line"), 1, &rv));
|
||||
file = zval_get_string(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv));
|
||||
line = zval_get_long(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv));
|
||||
|
||||
if (EG(exception)) {
|
||||
EG(exception) = NULL;
|
||||
@ -724,7 +724,7 @@ static inline void phpdbg_handle_exception(void) /* {{{ */
|
||||
} else {
|
||||
zend_update_property_string(zend_get_exception_base(ex), ex, ZEND_STRL("string"), Z_STRVAL(tmp));
|
||||
zval_ptr_dtor(&tmp);
|
||||
msg = zval_get_string(zend_read_property(zend_get_exception_base(ex), ex, ZEND_STRL("string"), 1, &rv));
|
||||
msg = zval_get_string(zend_read_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_STRING), /* silent */ true, &rv));
|
||||
}
|
||||
|
||||
phpdbg_error("Uncaught %s in %s on line " ZEND_LONG_FMT, ZSTR_VAL(ex->ce->name), ZSTR_VAL(file), line);
|
||||
@ -1695,9 +1695,9 @@ void phpdbg_execute_ex(zend_execute_data *execute_data) /* {{{ */
|
||||
PHPDBG_G(handled_exception) = exception;
|
||||
|
||||
zval rv;
|
||||
zend_string *file = zval_get_string(zend_read_property(zend_get_exception_base(exception), exception, ZEND_STRL("file"), 1, &rv));
|
||||
zend_long line = zval_get_long(zend_read_property(zend_get_exception_base(exception), exception, ZEND_STRL("line"), 1, &rv));
|
||||
zend_string *msg = zval_get_string(zend_read_property(zend_get_exception_base(exception), exception, ZEND_STRL("message"), 1, &rv));
|
||||
zend_string *file = zval_get_string(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_FILE), /* silent */ true, &rv));
|
||||
zend_long line = zval_get_long(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_LINE), /* silent */ true, &rv));
|
||||
zend_string *msg = zval_get_string(zend_read_property_ex(zend_get_exception_base(exception), exception, ZSTR_KNOWN(ZEND_STR_MESSAGE), /* silent */ true, &rv));
|
||||
|
||||
phpdbg_error("Uncaught %s in %s on line " ZEND_LONG_FMT ": %.*s",
|
||||
ZSTR_VAL(exception->ce->name), ZSTR_VAL(file), line,
|
||||
|
@ -1365,7 +1365,7 @@ static int phpdbg_watchpoint_parse_symtables(char *input, size_t len, int (*call
|
||||
int ret;
|
||||
|
||||
if (scope && len >= 5 && !memcmp("$this", input, 5)) {
|
||||
zend_hash_str_add(EG(current_execute_data)->symbol_table, ZEND_STRL("this"), &EG(current_execute_data)->This);
|
||||
zend_hash_add(EG(current_execute_data)->symbol_table, ZSTR_KNOWN(ZEND_STR_THIS), &EG(current_execute_data)->This);
|
||||
}
|
||||
|
||||
if (callback == phpdbg_create_array_watchpoint) {
|
||||
|
Loading…
Reference in New Issue
Block a user