key               412 TSRM/tsrm_win32.c static shm_pair *shm_get(int key, void *addr)
key               421 TSRM/tsrm_win32.c 		if (!addr && ptr->descriptor->shm_perm.key == key) {
key               591 TSRM/tsrm_win32.c TSRM_API int shmget(int key, int size, int flags)
key               602 TSRM/tsrm_win32.c 	snprintf(shm_segment, sizeof(shm_segment), "TSRM_SHM_SEGMENT:%d", key);
key               603 TSRM/tsrm_win32.c 	snprintf(shm_info, sizeof(shm_info), "TSRM_SHM_DESCRIPTOR:%d", key);
key               629 TSRM/tsrm_win32.c 	shm = shm_get(key, NULL);
key               640 TSRM/tsrm_win32.c 		shm->descriptor->shm_perm.key	= key;
key               653 TSRM/tsrm_win32.c 	if (NULL != shm->descriptor && (shm->descriptor->shm_perm.key != key || size > shm->descriptor->shm_segsz)) {
key               662 TSRM/tsrm_win32.c 	return key;
key               665 TSRM/tsrm_win32.c TSRM_API void *shmat(int key, const void *shmaddr, int flags)
key               667 TSRM/tsrm_win32.c 	shm_pair *shm = shm_get(key, NULL);
key               697 TSRM/tsrm_win32.c TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf) {
key               698 TSRM/tsrm_win32.c 	shm_pair *shm = shm_get(key, NULL);
key               718 TSRM/tsrm_win32.c 				shm->descriptor->shm_perm.key = -1;
key                31 TSRM/tsrm_win32.h 	int			key;
key               108 TSRM/tsrm_win32.h TSRM_API int shmget(int key, int size, int flags);
key               109 TSRM/tsrm_win32.h TSRM_API void *shmat(int key, const void *shmaddr, int flags);
key               111 TSRM/tsrm_win32.h TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf);
key               205 Zend/zend.c    			char key[25];
key               206 Zend/zend.c    			snprintf(key, sizeof(key), ZEND_LONG_FMT, num_key);
key               207 Zend/zend.c    			ZEND_PUTS_EX(key);
key              1073 Zend/zend_API.c 	zend_string *key;
key              1077 Zend/zend_API.c 	ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, value) {
key              1078 Zend/zend_API.c 		if (key) {
key              1081 Zend/zend_API.c 			ZVAL_STR(&member, key);
key              1198 Zend/zend_API.c     	zend_string *key;
key              1201 Zend/zend_API.c     	ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, prop) {
key              1202 Zend/zend_API.c 			property_info = zend_get_property_info(object->ce, key, 1);
key              1218 Zend/zend_API.c    	zend_string *key;
key              1222 Zend/zend_API.c    	ZEND_HASH_FOREACH_KEY_VAL(properties, h, key, prop) {
key              1223 Zend/zend_API.c 		if (key) {
key              1224 Zend/zend_API.c 			if (ZSTR_VAL(key)[0] == '\0') {
key              1227 Zend/zend_API.c 				if (zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len) == SUCCESS) {
key              1242 Zend/zend_API.c 				property_info = zend_get_property_info(object->ce, key, 1);
key              1253 Zend/zend_API.c 					zend_hash_update(object->properties, key, &tmp);
key              1259 Zend/zend_API.c 				prop = zend_hash_update(object->properties, key, prop);
key              1326 Zend/zend_API.c ZEND_API int add_assoc_long_ex(zval *arg, const char *key, size_t key_len, zend_long n) /* {{{ */
key              1331 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1336 Zend/zend_API.c ZEND_API int add_assoc_null_ex(zval *arg, const char *key, size_t key_len) /* {{{ */
key              1341 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1346 Zend/zend_API.c ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, size_t key_len, int b) /* {{{ */
key              1351 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1356 Zend/zend_API.c ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r) /* {{{ */
key              1361 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1366 Zend/zend_API.c ZEND_API int add_assoc_double_ex(zval *arg, const char *key, size_t key_len, double d) /* {{{ */
key              1371 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1376 Zend/zend_API.c ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str) /* {{{ */
key              1381 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1386 Zend/zend_API.c ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, char *str) /* {{{ */
key              1391 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1396 Zend/zend_API.c ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, char *str, size_t length) /* {{{ */
key              1401 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1406 Zend/zend_API.c ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value) /* {{{ */
key              1410 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, value);
key              1571 Zend/zend_API.c ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str) /* {{{ */
key              1576 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1581 Zend/zend_API.c ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, size_t length) /* {{{ */
key              1586 Zend/zend_API.c 	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
key              1636 Zend/zend_API.c ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value) /* {{{ */
key              1640 Zend/zend_API.c 	switch (Z_TYPE_P(key)) {
key              1642 Zend/zend_API.c 			result = zend_symtable_update(ht, Z_STR_P(key), value);
key              1648 Zend/zend_API.c 			zend_error(E_NOTICE, "Resource ID#%d used as offset, casting to integer (%d)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key));
key              1649 Zend/zend_API.c 			result = zend_hash_index_update(ht, Z_RES_HANDLE_P(key), value);
key              1658 Zend/zend_API.c 			result = zend_hash_index_update(ht, Z_LVAL_P(key), value);
key              1661 Zend/zend_API.c 			result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), value);
key              1679 Zend/zend_API.c ZEND_API int add_property_long_ex(zval *arg, const char *key, size_t key_len, zend_long n) /* {{{ */
key              1685 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1693 Zend/zend_API.c ZEND_API int add_property_bool_ex(zval *arg, const char *key, size_t key_len, zend_long b) /* {{{ */
key              1699 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1707 Zend/zend_API.c ZEND_API int add_property_null_ex(zval *arg, const char *key, size_t key_len) /* {{{ */
key              1713 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1721 Zend/zend_API.c ZEND_API int add_property_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r) /* {{{ */
key              1727 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1735 Zend/zend_API.c ZEND_API int add_property_double_ex(zval *arg, const char *key, size_t key_len, double d) /* {{{ */
key              1741 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1749 Zend/zend_API.c ZEND_API int add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str) /* {{{ */
key              1755 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1763 Zend/zend_API.c ZEND_API int add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str) /* {{{ */
key              1769 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1777 Zend/zend_API.c ZEND_API int add_property_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length) /* {{{ */
key              1783 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              1791 Zend/zend_API.c ZEND_API int add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value) /* {{{ */
key              1795 Zend/zend_API.c 	ZVAL_STRINGL(&z_key, key, key_len);
key              2812 Zend/zend_API.c 	zend_string *key;
key              2814 Zend/zend_API.c 	key = zend_string_alloc(class_name_length, 0);
key              2815 Zend/zend_API.c 	zend_str_tolower_copy(ZSTR_VAL(key), class_name, class_name_length);
key              2816 Zend/zend_API.c 	disabled_class = zend_hash_find_ptr(CG(class_table), key);
key              3685 Zend/zend_API.c 	zend_string *key = zend_string_init(name, name_length, ce->type & ZEND_INTERNAL_CLASS);
key              3686 Zend/zend_API.c 	int ret = zend_declare_property_ex(ce, key, property, access_type, NULL);
key              3687 Zend/zend_API.c 	zend_string_release(key);
key              3911 Zend/zend_API.c 	zend_string *key = zend_string_init(name, name_length, 0);
key              3914 Zend/zend_API.c 	property = zend_std_get_static_property(scope, key, 0);
key              3916 Zend/zend_API.c 	zend_string_free(key);
key              4026 Zend/zend_API.c 	zend_string *key = zend_string_init(name, name_length, 0);
key              4029 Zend/zend_API.c 	property = zend_std_get_static_property(scope, key, silent);
key              4031 Zend/zend_API.c 	zend_string_free(key);
key               390 Zend/zend_API.h ZEND_API int add_assoc_long_ex(zval *arg, const char *key, size_t key_len, zend_long n);
key               391 Zend/zend_API.h ZEND_API int add_assoc_null_ex(zval *arg, const char *key, size_t key_len);
key               392 Zend/zend_API.h ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, size_t key_len, int b);
key               393 Zend/zend_API.h ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
key               394 Zend/zend_API.h ZEND_API int add_assoc_double_ex(zval *arg, const char *key, size_t key_len, double d);
key               395 Zend/zend_API.h ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
key               396 Zend/zend_API.h ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, char *str);
key               397 Zend/zend_API.h ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, char *str, size_t length);
key               398 Zend/zend_API.h ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
key               436 Zend/zend_API.h ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str);
key               437 Zend/zend_API.h ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, size_t length);
key               448 Zend/zend_API.h ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
key               450 Zend/zend_API.h ZEND_API int add_property_long_ex(zval *arg, const char *key, size_t key_len, zend_long l);
key               451 Zend/zend_API.h ZEND_API int add_property_null_ex(zval *arg, const char *key, size_t key_len);
key               452 Zend/zend_API.h ZEND_API int add_property_bool_ex(zval *arg, const char *key, size_t key_len, zend_long b);
key               453 Zend/zend_API.h ZEND_API int add_property_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
key               454 Zend/zend_API.h ZEND_API int add_property_double_ex(zval *arg, const char *key, size_t key_len, double d);
key               455 Zend/zend_API.h ZEND_API int add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
key               456 Zend/zend_API.h ZEND_API int add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str);
key               457 Zend/zend_API.h ZEND_API int add_property_stringl_ex(zval *arg, const char *key, size_t key_len,  const char *str, size_t length);
key               458 Zend/zend_API.h ZEND_API int add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
key               549 Zend/zend_API.h #define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
key               866 Zend/zend_ast.c 	zend_string *key;
key               885 Zend/zend_ast.c 			key = zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(zv));
key               886 Zend/zend_ast.c 			smart_str_appendl(str, ZSTR_VAL(key), ZSTR_LEN(key));
key               887 Zend/zend_ast.c 			zend_string_release(key);
key               897 Zend/zend_ast.c 			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(zv), idx, key, val) {
key               903 Zend/zend_ast.c 				if (key) {
key               905 Zend/zend_ast.c 					zend_ast_export_str(str, key);
key               406 Zend/zend_builtin_functions.c 	zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
key               407 Zend/zend_builtin_functions.c 	zend_alter_ini_entry_chars(key, "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
key               408 Zend/zend_builtin_functions.c 	zend_string_release(key);
key               416 Zend/zend_builtin_functions.c 	zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
key               417 Zend/zend_builtin_functions.c 	zend_alter_ini_entry_chars(key, "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
key               418 Zend/zend_builtin_functions.c 	zend_string_release(key);
key               636 Zend/zend_builtin_functions.c 	zend_string *key;
key               676 Zend/zend_builtin_functions.c 	if (zend_hash_get_current_key(target_hash, &key, &num_key) == HASH_KEY_IS_STRING) {
key               677 Zend/zend_builtin_functions.c 		ZVAL_STR_COPY(&tmp, key);
key               780 Zend/zend_builtin_functions.c 	zend_string *key;
key               785 Zend/zend_builtin_functions.c 	ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(src), idx, key, val) {
key               788 Zend/zend_builtin_functions.c 		if (key) {
key               789 Zend/zend_builtin_functions.c 			new_val = zend_hash_add_new(Z_ARRVAL_P(dst), key, val);
key              1083 Zend/zend_builtin_functions.c 	zend_string *key;
key              1085 Zend/zend_builtin_functions.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) {
key              1122 Zend/zend_builtin_functions.c 		zend_hash_add_new(Z_ARRVAL_P(return_value), key, prop);
key              1161 Zend/zend_builtin_functions.c 	zend_string *key;
key              1198 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_STR_KEY_VAL_IND(properties, key, value) {
key              1199 Zend/zend_builtin_functions.c 			if (key) {
key              1200 Zend/zend_builtin_functions.c 				if (zend_check_property_access(zobj, key) == SUCCESS) {
key              1207 Zend/zend_builtin_functions.c 					if (ZSTR_VAL(key)[0] == 0) {
key              1210 Zend/zend_builtin_functions.c 						zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_len);
key              1213 Zend/zend_builtin_functions.c 						zend_hash_add_new(Z_ARRVAL_P(return_value), key, value);
key              1222 Zend/zend_builtin_functions.c static int same_name(zend_string *key, zend_string *name) /* {{{ */
key              1227 Zend/zend_builtin_functions.c 	if (key == name) {
key              1230 Zend/zend_builtin_functions.c 	if (ZSTR_LEN(key) != ZSTR_LEN(name)) {
key              1234 Zend/zend_builtin_functions.c 	ret = memcmp(ZSTR_VAL(lcname), ZSTR_VAL(key), ZSTR_LEN(key)) == 0;
key              1248 Zend/zend_builtin_functions.c 	zend_string *key;
key              1266 Zend/zend_builtin_functions.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, key, mptr) {
key              1277 Zend/zend_builtin_functions.c 			if (!key) {
key              1282 Zend/zend_builtin_functions.c 			    zend_binary_strcasecmp(ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(mptr->common.function_name), len) == 0) {
key              1286 Zend/zend_builtin_functions.c 			    	 !same_name(key, mptr->common.function_name)) {
key              1287 Zend/zend_builtin_functions.c 					ZVAL_STR_COPY(&method_name, zend_find_alias_name(mptr->common.scope, key));
key              1846 Zend/zend_builtin_functions.c 	if ((hash_key->key && ZSTR_VAL(hash_key->key)[0] != 0)
key              1849 Zend/zend_builtin_functions.c 		    !same_name(hash_key->key, ce->name)) {
key              1850 Zend/zend_builtin_functions.c 			add_next_index_str(array, zend_string_copy(hash_key->key));
key              1913 Zend/zend_builtin_functions.c 	if (hash_key->key == NULL || ZSTR_VAL(hash_key->key)[0] == 0) {
key              1918 Zend/zend_builtin_functions.c 		add_next_index_str(internal_ar, zend_string_copy(hash_key->key));
key              1920 Zend/zend_builtin_functions.c 		add_next_index_str(user_ar, zend_string_copy(hash_key->key));
key              2083 Zend/zend_builtin_functions.c 	zend_string *key;
key              2093 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
key              2094 Zend/zend_builtin_functions.c 			if (!key) {
key              2101 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
key              2102 Zend/zend_builtin_functions.c 			if (!key && Z_RES_TYPE_P(val) <= 0) {
key              2116 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
key              2117 Zend/zend_builtin_functions.c 			if (!key && Z_RES_TYPE_P(val) == id) {
key               298 Zend/zend_closures.c static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zval *key) /* {{{ */
key               308 Zend/zend_closures.c 	return std_object_handlers.get_method(object, method, key);
key              2215 Zend/zend_compile.c 			zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
key              2216 Zend/zend_compile.c 			CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key);
key              4833 Zend/zend_compile.c 		zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos);
key              4836 Zend/zend_compile.c 		LITERAL_STR(opline->op1, key);
key              4838 Zend/zend_compile.c 		zend_hash_update_ptr(CG(function_table), key, op_array);
key              5282 Zend/zend_compile.c 		zend_string *key;
key              5291 Zend/zend_compile.c 		key = zend_build_runtime_definition_key(lcname, decl->lex_pos);
key              5294 Zend/zend_compile.c 		LITERAL_STR(opline->op1, key);
key              5296 Zend/zend_compile.c 		zend_hash_update_ptr(CG(class_table), key, ce);
key              5866 Zend/zend_compile.c 			zval *key = zend_ast_get_zval(key_ast);
key              5867 Zend/zend_compile.c 			switch (Z_TYPE_P(key)) {
key              5869 Zend/zend_compile.c 					zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value);
key              5872 Zend/zend_compile.c 					zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value);
key              5876 Zend/zend_compile.c 						zend_dval_to_lval(Z_DVAL_P(key)), value);
key               430 Zend/zend_constants.c zend_constant *zend_quick_get_constant(const zval *key, zend_ulong flags)
key               434 Zend/zend_constants.c 	if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
key               435 Zend/zend_constants.c 		key++;
key               436 Zend/zend_constants.c 		if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
key               439 Zend/zend_constants.c 				key++;
key               440 Zend/zend_constants.c 				if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
key               441 Zend/zend_constants.c 				    key++;
key               442 Zend/zend_constants.c 					if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
key               445 Zend/zend_constants.c 						key--;
key               450 Zend/zend_constants.c 				key--;
key               458 Zend/zend_constants.c static void* zend_hash_add_constant(HashTable *ht, zend_string *key, zend_constant *c)
key               464 Zend/zend_constants.c 	ret = zend_hash_add_ptr(ht, key, copy);
key                79 Zend/zend_constants.h zend_constant *zend_quick_get_constant(const zval *key, zend_ulong flags);
key               447 Zend/zend_exceptions.c #define TRACE_APPEND_KEY(key) do {                                          \
key               448 Zend/zend_exceptions.c 		tmp = zend_hash_str_find(ht, key, sizeof(key)-1);                   \
key               451 Zend/zend_exceptions.c 				zend_error(E_WARNING, "Value for %s is no string", key);    \
key               610 Zend/zend_execute.c 	zend_string *key;
key               613 Zend/zend_execute.c 	ZSTR_ALLOCA_INIT(key, cur_arg_info->class_name, strlen(cur_arg_info->class_name), use_heap);
key               614 Zend/zend_execute.c 	*pce = zend_fetch_class(key, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD));
key               615 Zend/zend_execute.c 	ZSTR_ALLOCA_FREE(key, use_heap);
key                45 Zend/zend_execute.h ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload);
key               295 Zend/zend_execute.h ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type);
key               944 Zend/zend_execute_API.c ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload) /* {{{ */
key               953 Zend/zend_execute_API.c 	if (key) {
key               954 Zend/zend_execute_API.c 		lc_name = Z_STR_P(key);
key               970 Zend/zend_execute_API.c 		if (!key) {
key               980 Zend/zend_execute_API.c 		if (!key) {
key               991 Zend/zend_execute_API.c 			if (!key) {
key              1001 Zend/zend_execute_API.c 		if (!key) {
key              1013 Zend/zend_execute_API.c 		if (!key) {
key              1056 Zend/zend_execute_API.c 	if (!key) {
key              1384 Zend/zend_execute_API.c zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type) /* {{{ */
key              1389 Zend/zend_execute_API.c 		return zend_lookup_class_ex(class_name, key, 0);
key              1390 Zend/zend_execute_API.c 	} else if ((ce = zend_lookup_class_ex(class_name, key, 1)) == NULL) {
key               175 Zend/zend_generators.c 	zval_ptr_dtor(&generator->key);
key               569 Zend/zend_generators.c 		zval_ptr_dtor(&generator->key);
key               570 Zend/zend_generators.c 		if (p->key) {
key               571 Zend/zend_generators.c 			ZVAL_STR_COPY(&generator->key, p->key);
key               573 Zend/zend_generators.c 			ZVAL_LONG(&generator->key, p->h);
key               602 Zend/zend_generators.c 		zval_ptr_dtor(&generator->key);
key               604 Zend/zend_generators.c 			iter->funcs->get_current_key(iter, &generator->key);
key               606 Zend/zend_generators.c 				ZVAL_UNDEF(&generator->key);
key               610 Zend/zend_generators.c 			ZVAL_LONG(&generator->key, iter->index);
key               813 Zend/zend_generators.c ZEND_METHOD(Generator, key)
key               826 Zend/zend_generators.c 	if (EXPECTED(generator->execute_data != NULL && Z_TYPE(root->key) != IS_UNDEF)) {
key               827 Zend/zend_generators.c 		zval *key = &root->key;
key               829 Zend/zend_generators.c 		ZVAL_DEREF(key);
key               830 Zend/zend_generators.c 		ZVAL_COPY(return_value, key);
key              1021 Zend/zend_generators.c static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key) /* {{{ */
key              1029 Zend/zend_generators.c 	if (EXPECTED(Z_TYPE(root->key) != IS_UNDEF)) {
key              1030 Zend/zend_generators.c 		zval *zv = &root->key;
key              1033 Zend/zend_generators.c 		ZVAL_COPY(key, zv);
key              1035 Zend/zend_generators.c 		ZVAL_NULL(key);
key              1108 Zend/zend_generators.c 	ZEND_ME(Generator, key,      arginfo_generator_void, ZEND_ACC_PUBLIC)
key                71 Zend/zend_generators.h 	zval key;
key               483 Zend/zend_hash.c static zend_always_inline Bucket *zend_hash_find_bucket(const HashTable *ht, zend_string *key)
key               490 Zend/zend_hash.c 	h = zend_string_hash_val(key);
key               496 Zend/zend_hash.c 		if (EXPECTED(p->key == key)) { /* check for the same interned string */
key               499 Zend/zend_hash.c 		     EXPECTED(p->key) &&
key               500 Zend/zend_hash.c 		     EXPECTED(ZSTR_LEN(p->key) == ZSTR_LEN(key)) &&
key               501 Zend/zend_hash.c 		     EXPECTED(memcmp(ZSTR_VAL(p->key), ZSTR_VAL(key), ZSTR_LEN(key)) == 0)) {
key               522 Zend/zend_hash.c 			 && p->key
key               523 Zend/zend_hash.c 			 && (ZSTR_LEN(p->key) == len)
key               524 Zend/zend_hash.c 			 && !memcmp(ZSTR_VAL(p->key), str, len)) {
key               544 Zend/zend_hash.c 		if (p->h == h && !p->key) {
key               552 Zend/zend_hash.c static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
key               568 Zend/zend_hash.c 		p = zend_hash_find_bucket(ht, key);
key               615 Zend/zend_hash.c 	p->key = key;
key               616 Zend/zend_hash.c 	if (!ZSTR_IS_INTERNED(key)) {
key               617 Zend/zend_hash.c 		zend_string_addref(key);
key               619 Zend/zend_hash.c 		zend_string_hash_val(key);
key               621 Zend/zend_hash.c 	p->h = h = ZSTR_H(key);
key               631 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
key               633 Zend/zend_hash.c 	return _zend_hash_add_or_update_i(ht, key, pData, flag ZEND_FILE_LINE_RELAY_CC);
key               636 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
key               638 Zend/zend_hash.c 	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
key               641 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
key               643 Zend/zend_hash.c 	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
key               646 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
key               648 Zend/zend_hash.c 	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
key               651 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
key               653 Zend/zend_hash.c 	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
key               658 Zend/zend_hash.c 	zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
key               659 Zend/zend_hash.c 	zval *ret = _zend_hash_add_or_update_i(ht, key, pData, flag ZEND_FILE_LINE_RELAY_CC);
key               660 Zend/zend_hash.c 	zend_string_release(key);
key               666 Zend/zend_hash.c 	zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
key               667 Zend/zend_hash.c 	zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
key               668 Zend/zend_hash.c 	zend_string_release(key);
key               674 Zend/zend_hash.c 	zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
key               675 Zend/zend_hash.c 	zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
key               676 Zend/zend_hash.c 	zend_string_release(key);
key               682 Zend/zend_hash.c 	zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
key               683 Zend/zend_hash.c 	zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
key               684 Zend/zend_hash.c 	zend_string_release(key);
key               690 Zend/zend_hash.c 	zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
key               691 Zend/zend_hash.c 	zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
key               692 Zend/zend_hash.c 	zend_string_delref(key);
key               704 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL zend_hash_add_empty_element(HashTable *ht, zend_string *key)
key               709 Zend/zend_hash.c 	return zend_hash_add(ht, key, &dummy);
key               788 Zend/zend_hash.c 		p->key = NULL;
key               832 Zend/zend_hash.c 	p->key = NULL;
key               939 Zend/zend_hash.c 							q->key = p->key;
key               958 Zend/zend_hash.c 							q->key = p->key;
key              1019 Zend/zend_hash.c 	if (p->key) {
key              1020 Zend/zend_hash.c 		zend_string_release(p->key);
key              1060 Zend/zend_hash.c ZEND_API int ZEND_FASTCALL zend_hash_del(HashTable *ht, zend_string *key)
key              1071 Zend/zend_hash.c 	h = zend_string_hash_val(key);
key              1077 Zend/zend_hash.c 		if ((p->key == key) ||
key              1079 Zend/zend_hash.c 		     p->key &&
key              1080 Zend/zend_hash.c 		     ZSTR_LEN(p->key) == ZSTR_LEN(key) &&
key              1081 Zend/zend_hash.c 		     memcmp(ZSTR_VAL(p->key), ZSTR_VAL(key), ZSTR_LEN(key)) == 0)) {
key              1091 Zend/zend_hash.c ZEND_API int ZEND_FASTCALL zend_hash_del_ind(HashTable *ht, zend_string *key)
key              1102 Zend/zend_hash.c 	h = zend_string_hash_val(key);
key              1108 Zend/zend_hash.c 		if ((p->key == key) ||
key              1110 Zend/zend_hash.c 		     p->key &&
key              1111 Zend/zend_hash.c 		     ZSTR_LEN(p->key) == ZSTR_LEN(key) &&
key              1112 Zend/zend_hash.c 		     memcmp(ZSTR_VAL(p->key), ZSTR_VAL(key), ZSTR_LEN(key)) == 0)) {
key              1158 Zend/zend_hash.c 			 && p->key
key              1159 Zend/zend_hash.c 			 && (ZSTR_LEN(p->key) == len)
key              1160 Zend/zend_hash.c 			 && !memcmp(ZSTR_VAL(p->key), str, len)) {
key              1202 Zend/zend_hash.c 			 && p->key
key              1203 Zend/zend_hash.c 			 && (ZSTR_LEN(p->key) == len)
key              1204 Zend/zend_hash.c 			 && !memcmp(ZSTR_VAL(p->key), str, len)) {
key              1239 Zend/zend_hash.c 		if ((p->h == h) && (p->key == NULL)) {
key              1277 Zend/zend_hash.c 					if (EXPECTED(p->key)) {
key              1278 Zend/zend_hash.c 						zend_string_release(p->key);
key              1285 Zend/zend_hash.c 						if (EXPECTED(p->key)) {
key              1286 Zend/zend_hash.c 							zend_string_release(p->key);
key              1297 Zend/zend_hash.c 						if (EXPECTED(p->key)) {
key              1298 Zend/zend_hash.c 							zend_string_release(p->key);
key              1340 Zend/zend_hash.c 				if (EXPECTED(p->key)) {
key              1341 Zend/zend_hash.c 					zend_string_release(p->key);
key              1348 Zend/zend_hash.c 					if (EXPECTED(p->key)) {
key              1349 Zend/zend_hash.c 						zend_string_release(p->key);
key              1390 Zend/zend_hash.c 					if (EXPECTED(p->key)) {
key              1391 Zend/zend_hash.c 						zend_string_release(p->key);
key              1398 Zend/zend_hash.c 						if (EXPECTED(p->key)) {
key              1399 Zend/zend_hash.c 							zend_string_release(p->key);
key              1408 Zend/zend_hash.c 						if (EXPECTED(p->key)) {
key              1409 Zend/zend_hash.c 							zend_string_release(p->key);
key              1415 Zend/zend_hash.c 							if (EXPECTED(p->key)) {
key              1416 Zend/zend_hash.c 								zend_string_release(p->key);
key              1450 Zend/zend_hash.c 				zend_string_release(p->key);
key              1456 Zend/zend_hash.c 					zend_string_release(p->key);
key              1591 Zend/zend_hash.c 		hash_key.key = p->key;
key              1665 Zend/zend_hash.c 		if (p->key) {
key              1666 Zend/zend_hash.c 			new_entry = zend_hash_update(target, p->key, data);
key              1722 Zend/zend_hash.c 		q->key = NULL;
key              1726 Zend/zend_hash.c 		q->key = p->key;
key              1727 Zend/zend_hash.c 		if (!static_keys && q->key) {
key              1728 Zend/zend_hash.c 			zend_string_addref(q->key);
key              1893 Zend/zend_hash.c 			if (p->key) {
key              1894 Zend/zend_hash.c 				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
key              1913 Zend/zend_hash.c 			if (p->key) {
key              1914 Zend/zend_hash.c 				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
key              1941 Zend/zend_hash.c 	hash_key.key = p->key;
key              1960 Zend/zend_hash.c 			t = zend_hash_update(target, p->key, &p->val);
key              1977 Zend/zend_hash.c ZEND_API zval* ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key)
key              1983 Zend/zend_hash.c 	p = zend_hash_find_bucket(ht, key);
key              1999 Zend/zend_hash.c ZEND_API zend_bool ZEND_FASTCALL zend_hash_exists(const HashTable *ht, zend_string *key)
key              2005 Zend/zend_hash.c 	p = zend_hash_find_bucket(ht, key);
key              2157 Zend/zend_hash.c 		if (p->key) {
key              2158 Zend/zend_hash.c 			*str_index = p->key;
key              2168 Zend/zend_hash.c ZEND_API void ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos)
key              2175 Zend/zend_hash.c 		ZVAL_NULL(key);
key              2178 Zend/zend_hash.c 		if (p->key) {
key              2179 Zend/zend_hash.c 			ZVAL_STR_COPY(key, p->key);
key              2181 Zend/zend_hash.c 			ZVAL_LONG(key, p->h);
key              2194 Zend/zend_hash.c 		if (p->key) {
key              2222 Zend/zend_hash.c 	zend_string *key;
key              2226 Zend/zend_hash.c 	key = p->key;
key              2230 Zend/zend_hash.c 	p->key = q->key;
key              2234 Zend/zend_hash.c 	q->key = key;
key              2298 Zend/zend_hash.c 			if (p->key) {
key              2299 Zend/zend_hash.c 				zend_string_release(p->key);
key              2300 Zend/zend_hash.c 				p->key = NULL;
key              2352 Zend/zend_hash.c 			if (p1->key == NULL && p2->key == NULL) { /* numeric indices */
key              2356 Zend/zend_hash.c 			} else if (p1->key != NULL && p2->key != NULL) { /* string indices */
key              2357 Zend/zend_hash.c 				if (ZSTR_LEN(p1->key) != ZSTR_LEN(p2->key)) {
key              2358 Zend/zend_hash.c 					return ZSTR_LEN(p1->key) > ZSTR_LEN(p2->key) ? 1 : -1;
key              2361 Zend/zend_hash.c 				result = memcmp(ZSTR_VAL(p1->key), ZSTR_VAL(p2->key), ZSTR_LEN(p1->key));
key              2367 Zend/zend_hash.c 				return p1->key != NULL ? 1 : -1;
key              2372 Zend/zend_hash.c 			if (p1->key == NULL) { /* numeric index */
key              2378 Zend/zend_hash.c 				pData2 = zend_hash_find(ht2, p1->key);
key              2463 Zend/zend_hash.c ZEND_API int ZEND_FASTCALL _zend_handle_numeric_str_ex(const char *key, size_t length, zend_ulong *idx)
key              2465 Zend/zend_hash.c 	register const char *tmp = key;
key              2467 Zend/zend_hash.c 	const char *end = key + length;
key              2485 Zend/zend_hash.c 			if (*key == '-') {
key                49 Zend/zend_hash.h 	zend_string *key;
key                70 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
key                71 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
key                72 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
key                73 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
key                74 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
key                76 Zend/zend_hash.h #define zend_hash_update(ht, key, pData) \
key                77 Zend/zend_hash.h 		_zend_hash_update(ht, key, pData ZEND_FILE_LINE_CC)
key                78 Zend/zend_hash.h #define zend_hash_update_ind(ht, key, pData) \
key                79 Zend/zend_hash.h 		_zend_hash_update_ind(ht, key, pData ZEND_FILE_LINE_CC)
key                80 Zend/zend_hash.h #define zend_hash_add(ht, key, pData) \
key                81 Zend/zend_hash.h 		_zend_hash_add(ht, key, pData ZEND_FILE_LINE_CC)
key                82 Zend/zend_hash.h #define zend_hash_add_new(ht, key, pData) \
key                83 Zend/zend_hash.h 		_zend_hash_add_new(ht, key, pData ZEND_FILE_LINE_CC)
key                85 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *key, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
key                86 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key                87 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key                88 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key                89 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key                91 Zend/zend_hash.h #define zend_hash_str_update(ht, key, len, pData) \
key                92 Zend/zend_hash.h 		_zend_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
key                93 Zend/zend_hash.h #define zend_hash_str_update_ind(ht, key, len, pData) \
key                94 Zend/zend_hash.h 		_zend_hash_str_update_ind(ht, key, len, pData ZEND_FILE_LINE_CC)
key                95 Zend/zend_hash.h #define zend_hash_str_add(ht, key, len, pData) \
key                96 Zend/zend_hash.h 		_zend_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
key                97 Zend/zend_hash.h #define zend_hash_str_add_new(ht, key, len, pData) \
key                98 Zend/zend_hash.h 		_zend_hash_str_add_new(ht, key, len, pData ZEND_FILE_LINE_CC)
key               119 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL zend_hash_add_empty_element(HashTable *ht, zend_string *key);
key               120 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_empty_element(HashTable *ht, const char *key, size_t len);
key               146 Zend/zend_hash.h ZEND_API int ZEND_FASTCALL zend_hash_del(HashTable *ht, zend_string *key);
key               147 Zend/zend_hash.h ZEND_API int ZEND_FASTCALL zend_hash_del_ind(HashTable *ht, zend_string *key);
key               148 Zend/zend_hash.h ZEND_API int ZEND_FASTCALL zend_hash_str_del(HashTable *ht, const char *key, size_t len);
key               149 Zend/zend_hash.h ZEND_API int ZEND_FASTCALL zend_hash_str_del_ind(HashTable *ht, const char *key, size_t len);
key               154 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key);
key               155 Zend/zend_hash.h ZEND_API zval* ZEND_FASTCALL zend_hash_str_find(const HashTable *ht, const char *key, size_t len);
key               159 Zend/zend_hash.h ZEND_API zend_bool ZEND_FASTCALL zend_hash_exists(const HashTable *ht, zend_string *key);
key               169 Zend/zend_hash.h ZEND_API void  ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
key               183 Zend/zend_hash.h #define zend_hash_get_current_key_zval(ht, key) \
key               184 Zend/zend_hash.h 	zend_hash_get_current_key_zval_ex(ht, key, &(ht)->nInternalPointer)
key               224 Zend/zend_hash.h ZEND_API int ZEND_FASTCALL _zend_handle_numeric_str_ex(const char *key, size_t length, zend_ulong *idx);
key               249 Zend/zend_hash.h static zend_always_inline int _zend_handle_numeric_str(const char *key, size_t length, zend_ulong *idx)
key               251 Zend/zend_hash.h 	register const char *tmp = key;
key               264 Zend/zend_hash.h 	return _zend_handle_numeric_str_ex(key, length, idx);
key               267 Zend/zend_hash.h #define ZEND_HANDLE_NUMERIC_STR(key, length, idx) \
key               268 Zend/zend_hash.h 	_zend_handle_numeric_str(key, length, &idx)
key               270 Zend/zend_hash.h #define ZEND_HANDLE_NUMERIC(key, idx) \
key               271 Zend/zend_hash.h 	ZEND_HANDLE_NUMERIC_STR(ZSTR_VAL(key), ZSTR_LEN(key), idx)
key               274 Zend/zend_hash.h static zend_always_inline zval *zend_hash_find_ind(const HashTable *ht, zend_string *key)
key               278 Zend/zend_hash.h 	zv = zend_hash_find(ht, key);
key               284 Zend/zend_hash.h static zend_always_inline int zend_hash_exists_ind(const HashTable *ht, zend_string *key)
key               288 Zend/zend_hash.h 	zv = zend_hash_find(ht, key);
key               304 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_update(HashTable *ht, zend_string *key, zval *pData)
key               308 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               311 Zend/zend_hash.h 		return zend_hash_update(ht, key, pData);
key               316 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_update_ind(HashTable *ht, zend_string *key, zval *pData)
key               320 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               323 Zend/zend_hash.h 		return zend_hash_update_ind(ht, key, pData);
key               328 Zend/zend_hash.h static zend_always_inline int zend_symtable_del(HashTable *ht, zend_string *key)
key               332 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               335 Zend/zend_hash.h 		return zend_hash_del(ht, key);
key               340 Zend/zend_hash.h static zend_always_inline int zend_symtable_del_ind(HashTable *ht, zend_string *key)
key               344 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               347 Zend/zend_hash.h 		return zend_hash_del_ind(ht, key);
key               352 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_find(const HashTable *ht, zend_string *key)
key               356 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               359 Zend/zend_hash.h 		return zend_hash_find(ht, key);
key               364 Zend/zend_hash.h static zend_always_inline zval *zend_symtable_find_ind(const HashTable *ht, zend_string *key)
key               368 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               371 Zend/zend_hash.h 		return zend_hash_find_ind(ht, key);
key               376 Zend/zend_hash.h static zend_always_inline int zend_symtable_exists(HashTable *ht, zend_string *key)
key               380 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               383 Zend/zend_hash.h 		return zend_hash_exists(ht, key);
key               388 Zend/zend_hash.h static zend_always_inline int zend_symtable_exists_ind(HashTable *ht, zend_string *key)
key               392 Zend/zend_hash.h 	if (ZEND_HANDLE_NUMERIC(key, idx)) {
key               395 Zend/zend_hash.h 		return zend_hash_exists_ind(ht, key);
key               471 Zend/zend_hash.h static zend_always_inline void *zend_hash_add_ptr(HashTable *ht, zend_string *key, void *pData)
key               476 Zend/zend_hash.h 	zv = zend_hash_add(ht, key, &tmp);
key               485 Zend/zend_hash.h static zend_always_inline void *zend_hash_add_new_ptr(HashTable *ht, zend_string *key, void *pData)
key               490 Zend/zend_hash.h 	zv = zend_hash_add_new(ht, key, &tmp);
key               527 Zend/zend_hash.h static zend_always_inline void *zend_hash_update_ptr(HashTable *ht, zend_string *key, void *pData)
key               532 Zend/zend_hash.h 	zv = zend_hash_update(ht, key, &tmp);
key               555 Zend/zend_hash.h static zend_always_inline void *zend_hash_add_mem(HashTable *ht, zend_string *key, void *pData, size_t size)
key               560 Zend/zend_hash.h 	if ((zv = zend_hash_add(ht, key, &tmp))) {
key               581 Zend/zend_hash.h static zend_always_inline void *zend_hash_update_mem(HashTable *ht, zend_string *key, void *pData, size_t size)
key               587 Zend/zend_hash.h 	return zend_hash_update_ptr(ht, key, p);
key               680 Zend/zend_hash.h static zend_always_inline void *zend_hash_find_ptr(const HashTable *ht, zend_string *key)
key               684 Zend/zend_hash.h 	zv = zend_hash_find(ht, key);
key               792 Zend/zend_hash.h 	_key = _p->key;
key               797 Zend/zend_hash.h 	_key = _p->key;
key               806 Zend/zend_hash.h 	_key = _p->key; \
key               812 Zend/zend_hash.h 	_key = _p->key; \
key               817 Zend/zend_hash.h 	_key = _p->key; \
key               823 Zend/zend_hash.h 	_key = _p->key; \
key               833 Zend/zend_hash.h 	_key = _p->key; \
key               839 Zend/zend_hash.h 	_key = _p->key; \
key               861 Zend/zend_hash.h 	_key = _p->key; \
key               867 Zend/zend_hash.h 	_key = _p->key; \
key               894 Zend/zend_hash.h 		__fill_bkt->key = NULL; \
key               906 Zend/zend_hash.h static zend_always_inline zval *_zend_hash_append(HashTable *ht, zend_string *key, zval *zv)
key               913 Zend/zend_hash.h 	if (!ZSTR_IS_INTERNED(key)) {
key               915 Zend/zend_hash.h 		zend_string_addref(key);
key               916 Zend/zend_hash.h 		zend_string_hash_val(key);		
key               918 Zend/zend_hash.h 	p->key = key;
key               919 Zend/zend_hash.h 	p->h = ZSTR_H(key);
key               928 Zend/zend_hash.h static zend_always_inline zval *_zend_hash_append_ptr(HashTable *ht, zend_string *key, void *ptr)
key               935 Zend/zend_hash.h 	if (!ZSTR_IS_INTERNED(key)) {
key               937 Zend/zend_hash.h 		zend_string_addref(key);
key               938 Zend/zend_hash.h 		zend_string_hash_val(key);		
key               940 Zend/zend_hash.h 	p->key = key;
key               941 Zend/zend_hash.h 	p->h = ZSTR_H(key);
key               950 Zend/zend_hash.h static zend_always_inline void _zend_hash_append_ind(HashTable *ht, zend_string *key, zval *ptr)
key               957 Zend/zend_hash.h 	if (!ZSTR_IS_INTERNED(key)) {
key               959 Zend/zend_hash.h 		zend_string_addref(key);
key               960 Zend/zend_hash.h 		zend_string_hash_val(key);		
key               962 Zend/zend_hash.h 	p->key = key;
key               963 Zend/zend_hash.h 	p->h = ZSTR_H(key);
key               583 Zend/zend_inheritance.c static zend_function *do_inherit_method(zend_string *key, zend_function *parent, zend_class_entry *ce) /* {{{ */
key               585 Zend/zend_inheritance.c 	zval *child = zend_hash_find(&ce->function_table, key);
key               613 Zend/zend_inheritance.c static void do_inherit_property(zend_property_info *parent_info, zend_string *key, zend_class_entry *ce) /* {{{ */
key               615 Zend/zend_inheritance.c 	zval *child = zend_hash_find(&ce->properties_info, key);
key               625 Zend/zend_inheritance.c 					(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->parent->name), ZSTR_VAL(key),
key               626 Zend/zend_inheritance.c 					(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->name), ZSTR_VAL(key));
key               634 Zend/zend_inheritance.c 				zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(ce->parent->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
key               661 Zend/zend_inheritance.c 		_zend_hash_append_ptr(&ce->properties_info, key, child_info);
key               737 Zend/zend_inheritance.c 	zend_string *key;
key               869 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, property_info) {
key               870 Zend/zend_inheritance.c 			do_inherit_property(property_info, key, ce);
key               879 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(&parent_ce->constants_table, key, zv) {
key               880 Zend/zend_inheritance.c 			do_inherit_class_constant(key, zv, ce, parent_ce);
key               889 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
key               890 Zend/zend_inheritance.c 			zend_function *new_func = do_inherit_method(key, func, ce);
key               893 Zend/zend_inheritance.c 				_zend_hash_append_ptr(&ce->function_table, key, new_func);
key               951 Zend/zend_inheritance.c 	zend_string *key;
key               968 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(&ce->constants_table, key, zv) {
key               969 Zend/zend_inheritance.c 			do_inherit_constant_check(&iface->constants_table, zv, key, iface);
key               981 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(&iface->constants_table, key, zv) {
key               982 Zend/zend_inheritance.c 			do_inherit_iface_constant(key, zv, ce, iface);
key               985 Zend/zend_inheritance.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
key               986 Zend/zend_inheritance.c 			zend_function *new_func = do_inherit_method(key, func, ce);
key               989 Zend/zend_inheritance.c 				zend_hash_add_new_ptr(&ce->function_table, key, new_func);
key              1086 Zend/zend_inheritance.c static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_string *key, zend_function *fn, HashTable **overriden) /* {{{ */
key              1091 Zend/zend_inheritance.c 	if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
key              1096 Zend/zend_inheritance.c 				if ((existing_fn = zend_hash_find_ptr(*overriden, key)) != NULL) {
key              1118 Zend/zend_inheritance.c 			zend_hash_update_mem(*overriden, key, fn, sizeof(zend_function));
key              1158 Zend/zend_inheritance.c 	fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
key              1159 Zend/zend_inheritance.c 	zend_add_magic_methods(ce, key, fn);
key              1398 Zend/zend_inheritance.c 	zend_string *key;
key              1414 Zend/zend_inheritance.c 			ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
key              1415 Zend/zend_inheritance.c 				zend_traits_copy_functions(key, fn, ce, &overriden, &exclude_table);
key              1421 Zend/zend_inheritance.c 			ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
key              1422 Zend/zend_inheritance.c 				zend_traits_copy_functions(key, fn, ce, &overriden, NULL);
key               191 Zend/zend_ini.c 	if (!f->key && !s->key) { /* both numeric */
key               193 Zend/zend_ini.c 	} else if (!f->key) { /* f is numeric, s is not */
key               195 Zend/zend_ini.c 	} else if (!s->key) { /* s is numeric, f is not */
key               198 Zend/zend_ini.c 		return zend_binary_strcasecmp(ZSTR_VAL(f->key), ZSTR_LEN(f->key), ZSTR_VAL(s->key), ZSTR_LEN(s->key));
key               207 Zend/zend_interfaces.c ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key)
key               216 Zend/zend_interfaces.c 		ZVAL_ZVAL(key, &retval, 1, 1);
key               222 Zend/zend_interfaces.c 		ZVAL_LONG(key, 0);
key               514 Zend/zend_interfaces.c 	ZEND_ABSTRACT_ME(iterator, key,      NULL)
key                65 Zend/zend_interfaces.h ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key);
key                45 Zend/zend_iterators.h 	void (*get_current_key)(zend_object_iterator *iter, zval *key);
key              1081 Zend/zend_object_handlers.c static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zval *key) /* {{{ */
key              1089 Zend/zend_object_handlers.c 	if (EXPECTED(key != NULL)) {
key              1090 Zend/zend_object_handlers.c 		lc_method_name = Z_STR_P(key);
key              1100 Zend/zend_object_handlers.c 		if (UNEXPECTED(!key)) {
key              1159 Zend/zend_object_handlers.c 	if (UNEXPECTED(!key)) {
key              1172 Zend/zend_object_handlers.c ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zval *key) /* {{{ */
key              1179 Zend/zend_object_handlers.c 	if (EXPECTED(key != NULL)) {
key              1180 Zend/zend_object_handlers.c 		lc_function_name = Z_STR_P(key);
key              1201 Zend/zend_object_handlers.c 			if (UNEXPECTED(!key)) {
key              1262 Zend/zend_object_handlers.c 	if (UNEXPECTED(!key)) {
key                95 Zend/zend_object_handlers.h typedef union _zend_function *(*zend_object_get_method_t)(zend_object **object, zend_string *method, const zval *key);
key               164 Zend/zend_object_handlers.h ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const zval *key);
key               198 Zend/zend_objects.c 		zend_string *key;
key               211 Zend/zend_objects.c 		ZEND_HASH_FOREACH_KEY_VAL(old_object->properties, num_key, key, prop) {
key               218 Zend/zend_objects.c 			if (EXPECTED(key)) {
key               219 Zend/zend_objects.c 				_zend_hash_append(new_object->properties, key, &new_prop);
key                95 Zend/zend_string.c 		if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) {
key                96 Zend/zend_string.c 			if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) {
key                98 Zend/zend_string.c 				return p->key;
key               137 Zend/zend_string.c 	p->key = str;
key               162 Zend/zend_string.c 		ZEND_ASSERT(GC_FLAGS(p->key) & IS_STR_PERSISTENT);
key               163 Zend/zend_string.c 		GC_FLAGS(p->key) |= IS_STR_PERMANENT;
key               179 Zend/zend_string.c 		if (GC_FLAGS(p->key) & IS_STR_PERMANENT) break;
key               183 Zend/zend_string.c 		GC_FLAGS(p->key) &= ~IS_STR_INTERNED;
key               184 Zend/zend_string.c 		GC_REFCOUNT(p->key) = 1;
key               185 Zend/zend_string.c 		zend_string_free(p->key);
key               102 Zend/zend_ts_hash.c ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC)
key               107 Zend/zend_ts_hash.c 	retval = _zend_hash_add_or_update(TS_HASH(ht), key, pData, flag ZEND_FILE_LINE_RELAY_CC);
key               124 Zend/zend_ts_hash.c ZEND_API zval *zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key)
key               129 Zend/zend_ts_hash.c 	retval = zend_hash_add_empty_element(TS_HASH(ht), key);
key               179 Zend/zend_ts_hash.c ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key)
key               184 Zend/zend_ts_hash.c 	retval = zend_hash_del(TS_HASH(ht), key);
key               201 Zend/zend_ts_hash.c ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key)
key               206 Zend/zend_ts_hash.c 	retval = zend_hash_find(TS_HASH(ht), key);
key               223 Zend/zend_ts_hash.c ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key)
key               228 Zend/zend_ts_hash.c 	retval = zend_hash_exists(TS_HASH(ht), key);
key               336 Zend/zend_ts_hash.c ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len)
key               341 Zend/zend_ts_hash.c 	retval = zend_hash_str_find(TS_HASH(ht), key, len);
key               347 Zend/zend_ts_hash.c ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
key               352 Zend/zend_ts_hash.c 	retval = zend_hash_str_update(TS_HASH(ht), key, len, pData);
key               358 Zend/zend_ts_hash.c ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
key               363 Zend/zend_ts_hash.c 	retval = zend_hash_str_add(TS_HASH(ht), key, len, pData);
key                52 Zend/zend_ts_hash.h ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC);
key                53 Zend/zend_ts_hash.h #define zend_ts_hash_update(ht, key, pData) \
key                54 Zend/zend_ts_hash.h 		_zend_ts_hash_add_or_update(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
key                55 Zend/zend_ts_hash.h #define zend_ts_hash_add(ht, key, pData) \
key                56 Zend/zend_ts_hash.h 		_zend_ts_hash_add_or_update(ht, key, pData, HASH_ADD ZEND_FILE_LINE_CC)
key                64 Zend/zend_ts_hash.h ZEND_API zval* zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key);
key                75 Zend/zend_ts_hash.h ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key);
key                79 Zend/zend_ts_hash.h ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key);
key                83 Zend/zend_ts_hash.h ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key);
key               105 Zend/zend_ts_hash.h ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len);
key               106 Zend/zend_ts_hash.h ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key               107 Zend/zend_ts_hash.h ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
key               109 Zend/zend_ts_hash.h #define zend_ts_hash_str_update(ht, key, len, pData) \
key               110 Zend/zend_ts_hash.h 		_zend_ts_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
key               111 Zend/zend_ts_hash.h #define zend_ts_hash_str_add(ht, key, len, pData) \
key               112 Zend/zend_ts_hash.h 		_zend_ts_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
key               171 Zend/zend_types.h 	zend_string      *key;              /* string key or NULL for numerics */
key               270 Zend/zend_variables.c ZEND_API int zval_copy_static_var(zval *p, int num_args, va_list args, zend_hash_key *key) /* {{{ */
key               281 Zend/zend_variables.c 		p = zend_hash_find(symbol_table, key->key);
key               287 Zend/zend_variables.c 				zend_hash_add_new(symbol_table, key->key, &tmp);
key               290 Zend/zend_variables.c 				zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(key->key));
key               297 Zend/zend_variables.c 						zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(key->key));
key               318 Zend/zend_variables.c 	zend_hash_add(target, key->key, p);
key               109 Zend/zend_variables.h ZEND_API int zval_copy_static_var(zval *p, int num_args, va_list args, zend_hash_key *key);
key               650 Zend/zend_virtual_cwd.c 	zend_ulong key = realpath_cache_key(path, path_len);
key               651 Zend/zend_virtual_cwd.c 	zend_ulong n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               655 Zend/zend_virtual_cwd.c 		if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key               695 Zend/zend_virtual_cwd.c 		bucket->key = realpath_cache_key(path, path_len);
key               714 Zend/zend_virtual_cwd.c 		n = bucket->key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               724 Zend/zend_virtual_cwd.c 	zend_ulong key = realpath_cache_key(path, path_len);
key               725 Zend/zend_virtual_cwd.c 	zend_ulong n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               740 Zend/zend_virtual_cwd.c 		} else if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key               214 Zend/zend_virtual_cwd.h 	zend_ulong                    key;
key              4498 Zend/zend_vm_def.h 					zval key;
key              4499 Zend/zend_vm_def.h 					iter->funcs->get_current_key(iter, &key);
key              4504 Zend/zend_vm_def.h 					if (Z_TYPE(key) == IS_STRING) {
key              4507 Zend/zend_vm_def.h 						zend_string_release(Z_STR(key));
key              4511 Zend/zend_vm_def.h 					zval_dtor(&key);
key              5602 Zend/zend_vm_def.h 	zend_string *key;
key              5627 Zend/zend_vm_def.h 				key = Z_STR_P(offset);
key              5629 Zend/zend_vm_def.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              5635 Zend/zend_vm_def.h 					zend_delete_global_variable(key);
key              5637 Zend/zend_vm_def.h 					zend_hash_del(ht, key);
key              5650 Zend/zend_vm_def.h 				key = ZSTR_EMPTY_ALLOC();
key              5663 Zend/zend_vm_def.h 				key = ZSTR_EMPTY_ALLOC();
key              5780 Zend/zend_vm_def.h 				    (UNEXPECTED(!p->key) ||
key              5781 Zend/zend_vm_def.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              5925 Zend/zend_vm_def.h 				    (UNEXPECTED(!p->key) ||
key              5926 Zend/zend_vm_def.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              6048 Zend/zend_vm_def.h 			if (!p->key) {
key              6051 Zend/zend_vm_def.h 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              6084 Zend/zend_vm_def.h 				if (UNEXPECTED(!p->key) ||
key              6085 Zend/zend_vm_def.h 				    EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
key              6092 Zend/zend_vm_def.h 				if (UNEXPECTED(!p->key)) {
key              6094 Zend/zend_vm_def.h 				} else if (ZSTR_VAL(p->key)[0]) {
key              6095 Zend/zend_vm_def.h 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              6100 Zend/zend_vm_def.h 						p->key, &class_name, &prop_name, &prop_name_len);
key              6114 Zend/zend_vm_def.h 				    (UNEXPECTED(!p->key) ||
key              6115 Zend/zend_vm_def.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
key              6226 Zend/zend_vm_def.h 			if (!p->key) {
key              6229 Zend/zend_vm_def.h 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              6276 Zend/zend_vm_def.h 				if (UNEXPECTED(!p->key) ||
key              6277 Zend/zend_vm_def.h 				    EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
key              6284 Zend/zend_vm_def.h 				if (UNEXPECTED(!p->key)) {
key              6286 Zend/zend_vm_def.h 				} else if (ZSTR_VAL(p->key)[0]) {
key              6287 Zend/zend_vm_def.h 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              6292 Zend/zend_vm_def.h 						p->key, &class_name, &prop_name, &prop_name_len);
key              6306 Zend/zend_vm_def.h 				    (UNEXPECTED(!p->key) ||
key              6307 Zend/zend_vm_def.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
key              7318 Zend/zend_vm_def.h 	zval_ptr_dtor(&generator->key);
key              7391 Zend/zend_vm_def.h 		zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
key              7395 Zend/zend_vm_def.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7396 Zend/zend_vm_def.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              7397 Zend/zend_vm_def.h 				zval_copy_ctor_func(&generator->key);
key              7400 Zend/zend_vm_def.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7401 Zend/zend_vm_def.h 		} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              7402 Zend/zend_vm_def.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              7405 Zend/zend_vm_def.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7407 Zend/zend_vm_def.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              7411 Zend/zend_vm_def.h 		if (Z_TYPE(generator->key) == IS_LONG
key              7412 Zend/zend_vm_def.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              7414 Zend/zend_vm_def.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              7419 Zend/zend_vm_def.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              7627 Zend/zend_vm_def.h 	        (EXPECTED(p->key == Z_STR_P(varname)) ||
key              7629 Zend/zend_vm_def.h 	          EXPECTED(p->key != NULL) &&
key              7630 Zend/zend_vm_def.h 	          EXPECTED(ZSTR_LEN(p->key) == Z_STRLEN_P(varname)) &&
key              7631 Zend/zend_vm_def.h 	          EXPECTED(memcmp(ZSTR_VAL(p->key), Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
key              1039 Zend/zend_vm_execute.h 					zval key;
key              1040 Zend/zend_vm_execute.h 					iter->funcs->get_current_key(iter, &key);
key              1045 Zend/zend_vm_execute.h 					if (Z_TYPE(key) == IS_STRING) {
key              1048 Zend/zend_vm_execute.h 						zend_string_release(Z_STR(key));
key              1052 Zend/zend_vm_execute.h 					zval_dtor(&key);
key              3746 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              3747 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              3888 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              3889 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              6534 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              6606 Zend/zend_vm_execute.h 		zval *key = EX_CONSTANT(opline->op2);
key              6610 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6611 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              6612 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              6615 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6616 Zend/zend_vm_execute.h 		} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              6617 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              6620 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6622 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              6626 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              6627 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              6629 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              6634 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              6711 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              6783 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
key              6787 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6788 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              6789 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              6792 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6793 Zend/zend_vm_execute.h 		} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              6794 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              6797 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              6799 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              6803 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              6804 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              6806 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              6811 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              7253 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              7325 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
key              7329 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7330 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              7331 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              7334 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7335 Zend/zend_vm_execute.h 		} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              7336 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              7339 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              7341 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              7345 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              7346 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              7348 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              7353 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              8151 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              8223 Zend/zend_vm_execute.h 		zval *key = NULL;
key              8227 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              8228 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              8229 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              8232 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              8233 Zend/zend_vm_execute.h 		} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              8234 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              8237 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              8239 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              8243 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              8244 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              8246 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              8251 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              10007 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              10079 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
key              10083 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              10084 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              10085 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              10088 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              10089 Zend/zend_vm_execute.h 		} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              10090 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              10093 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              10095 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              10099 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              10100 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              10102 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              10107 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              12150 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              12151 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              12293 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              12294 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              13051 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              13123 Zend/zend_vm_execute.h 		zval *key = EX_CONSTANT(opline->op2);
key              13127 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13128 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              13129 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              13132 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13133 Zend/zend_vm_execute.h 		} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              13134 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              13137 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13139 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              13143 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              13144 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              13146 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              13151 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              13228 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              13300 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
key              13304 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13305 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              13306 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              13309 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13310 Zend/zend_vm_execute.h 		} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              13311 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              13314 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13316 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              13320 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              13321 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              13323 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              13328 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              13405 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              13477 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
key              13481 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13482 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              13483 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              13486 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13487 Zend/zend_vm_execute.h 		} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              13488 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              13491 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13493 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              13497 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              13498 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              13500 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              13505 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              13775 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              13847 Zend/zend_vm_execute.h 		zval *key = NULL;
key              13851 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13852 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              13853 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              13856 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13857 Zend/zend_vm_execute.h 		} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              13858 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              13861 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              13863 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              13867 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              13868 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              13870 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              13875 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              14324 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              14396 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
key              14400 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              14401 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              14402 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              14405 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              14406 Zend/zend_vm_execute.h 		} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              14407 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              14410 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              14412 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              14416 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              14417 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              14419 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              14424 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              15598 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              15599 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              15743 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              15744 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              15866 Zend/zend_vm_execute.h 			if (!p->key) {
key              15869 Zend/zend_vm_execute.h 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              15902 Zend/zend_vm_execute.h 				if (UNEXPECTED(!p->key) ||
key              15903 Zend/zend_vm_execute.h 				    EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
key              15910 Zend/zend_vm_execute.h 				if (UNEXPECTED(!p->key)) {
key              15912 Zend/zend_vm_execute.h 				} else if (ZSTR_VAL(p->key)[0]) {
key              15913 Zend/zend_vm_execute.h 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              15918 Zend/zend_vm_execute.h 						p->key, &class_name, &prop_name, &prop_name_len);
key              15932 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              15933 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
key              16044 Zend/zend_vm_execute.h 			if (!p->key) {
key              16047 Zend/zend_vm_execute.h 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              16094 Zend/zend_vm_execute.h 				if (UNEXPECTED(!p->key) ||
key              16095 Zend/zend_vm_execute.h 				    EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
key              16102 Zend/zend_vm_execute.h 				if (UNEXPECTED(!p->key)) {
key              16104 Zend/zend_vm_execute.h 				} else if (ZSTR_VAL(p->key)[0]) {
key              16105 Zend/zend_vm_execute.h 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
key              16110 Zend/zend_vm_execute.h 						p->key, &class_name, &prop_name, &prop_name_len);
key              16124 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              16125 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
key              17913 Zend/zend_vm_execute.h 	zend_string *key;
key              17938 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              17940 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              17946 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              17948 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              17961 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              17974 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              18065 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              18138 Zend/zend_vm_execute.h 		zval *key = EX_CONSTANT(opline->op2);
key              18142 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18143 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              18144 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              18147 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18148 Zend/zend_vm_execute.h 		} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              18149 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              18152 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18154 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              18158 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              18159 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              18161 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              18166 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              18271 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              18344 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
key              18348 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18349 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              18350 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              18353 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18354 Zend/zend_vm_execute.h 		} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              18355 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              18358 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18360 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              18364 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              18365 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              18367 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              18372 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              18537 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              18610 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
key              18614 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18615 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              18616 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              18619 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18620 Zend/zend_vm_execute.h 		} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              18621 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              18624 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              18626 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              18630 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              18631 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              18633 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              18638 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              19526 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              19599 Zend/zend_vm_execute.h 		zval *key = NULL;
key              19603 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              19604 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              19605 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              19608 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              19609 Zend/zend_vm_execute.h 		} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              19610 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              19613 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              19615 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              19619 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              19620 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              19622 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              19627 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              21069 Zend/zend_vm_execute.h 	zend_string *key;
key              21094 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              21096 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              21102 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              21104 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              21117 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              21130 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              21221 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              21294 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
key              21298 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              21299 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              21300 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              21303 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              21304 Zend/zend_vm_execute.h 		} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              21305 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              21308 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              21310 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              21314 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              21315 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              21317 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              21322 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              22646 Zend/zend_vm_execute.h 	zend_string *key;
key              22671 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              22673 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              22679 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              22681 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              22694 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              22707 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              24028 Zend/zend_vm_execute.h 	zend_string *key;
key              24053 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              24055 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              24061 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              24063 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              24076 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              24089 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              24363 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              24435 Zend/zend_vm_execute.h 		zval *key = EX_CONSTANT(opline->op2);
key              24439 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24440 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              24441 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              24444 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24445 Zend/zend_vm_execute.h 		} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              24446 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              24449 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24451 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              24455 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              24456 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              24458 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              24463 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              24504 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              24576 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
key              24580 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24581 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              24582 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              24585 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24586 Zend/zend_vm_execute.h 		} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              24587 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              24590 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24592 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              24596 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              24597 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              24599 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              24604 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              24645 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              24717 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
key              24721 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24722 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              24723 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              24726 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24727 Zend/zend_vm_execute.h 		} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              24728 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              24731 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              24733 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              24737 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              24738 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              24740 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              24745 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              25184 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              25256 Zend/zend_vm_execute.h 		zval *key = NULL;
key              25260 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              25261 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              25262 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              25265 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              25266 Zend/zend_vm_execute.h 		} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              25267 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              25270 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              25272 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              25276 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              25277 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              25279 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              25284 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              26336 Zend/zend_vm_execute.h 	zend_string *key;
key              26361 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              26363 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              26369 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              26371 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              26384 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              26397 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              26671 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              26743 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
key              26747 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              26748 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              26749 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              26752 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              26753 Zend/zend_vm_execute.h 		} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              26754 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              26757 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              26759 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              26763 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              26764 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              26766 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              26771 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              27829 Zend/zend_vm_execute.h 	zend_string *key;
key              27854 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              27856 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              27862 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              27864 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              27877 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              27890 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              29317 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              29318 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              29459 Zend/zend_vm_execute.h 				    (UNEXPECTED(!p->key) ||
key              29460 Zend/zend_vm_execute.h 				     EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
key              32340 Zend/zend_vm_execute.h 	zend_string *key;
key              32365 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              32367 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              32373 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              32375 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              32388 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              32401 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              32818 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              32890 Zend/zend_vm_execute.h 		zval *key = EX_CONSTANT(opline->op2);
key              32894 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              32895 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              32896 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              32899 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              32900 Zend/zend_vm_execute.h 		} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              32901 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              32904 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              32906 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              32910 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              32911 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              32913 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              32918 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              32960 Zend/zend_vm_execute.h 	        (EXPECTED(p->key == Z_STR_P(varname)) ||
key              32962 Zend/zend_vm_execute.h 	          EXPECTED(p->key != NULL) &&
key              32963 Zend/zend_vm_execute.h 	          EXPECTED(ZSTR_LEN(p->key) == Z_STRLEN_P(varname)) &&
key              32964 Zend/zend_vm_execute.h 	          EXPECTED(memcmp(ZSTR_VAL(p->key), Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
key              33114 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              33186 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
key              33190 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33191 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              33192 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              33195 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33196 Zend/zend_vm_execute.h 		} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              33197 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              33200 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33202 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              33206 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              33207 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              33209 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              33214 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              33787 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              33859 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
key              33863 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33864 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              33865 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              33868 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33869 Zend/zend_vm_execute.h 		} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              33870 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              33873 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              33875 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              33879 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              33880 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              33882 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              33887 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              34982 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              35054 Zend/zend_vm_execute.h 		zval *key = NULL;
key              35058 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              35059 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              35060 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              35063 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              35064 Zend/zend_vm_execute.h 		} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              35065 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              35068 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              35070 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              35074 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              35075 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              35077 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              35082 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              37343 Zend/zend_vm_execute.h 	zend_string *key;
key              37368 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              37370 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              37376 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              37378 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              37391 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              37404 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              37678 Zend/zend_vm_execute.h 	zval_ptr_dtor(&generator->key);
key              37750 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
key              37754 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              37755 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
key              37756 Zend/zend_vm_execute.h 				zval_copy_ctor_func(&generator->key);
key              37759 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              37760 Zend/zend_vm_execute.h 		} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
key              37761 Zend/zend_vm_execute.h 			ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
key              37764 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&generator->key, key);
key              37766 Zend/zend_vm_execute.h 				if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
key              37770 Zend/zend_vm_execute.h 		if (Z_TYPE(generator->key) == IS_LONG
key              37771 Zend/zend_vm_execute.h 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
key              37773 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL(generator->key);
key              37778 Zend/zend_vm_execute.h 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
key              39924 Zend/zend_vm_execute.h 	zend_string *key;
key              39949 Zend/zend_vm_execute.h 				key = Z_STR_P(offset);
key              39951 Zend/zend_vm_execute.h 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
key              39957 Zend/zend_vm_execute.h 					zend_delete_global_variable(key);
key              39959 Zend/zend_vm_execute.h 					zend_hash_del(ht, key);
key              39972 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key              39985 Zend/zend_vm_execute.h 				key = ZSTR_EMPTY_ALLOC();
key               258 ext/com_dotnet/com_handlers.c static union _zend_function *com_method_get(zend_object **object_ptr, zend_string *name, const zval *key)
key                35 ext/com_dotnet/com_iterator.c 	zend_ulong key;
key                74 ext/com_dotnet/com_iterator.c static void com_iter_get_key(zend_object_iterator *iter, zval *key)
key                78 ext/com_dotnet/com_iterator.c 	if (I->key == (zend_ulong)-1) {
key                79 ext/com_dotnet/com_iterator.c 		ZVAL_NULL(key);
key                81 ext/com_dotnet/com_iterator.c 		ZVAL_LONG(key, I->key);
key               102 ext/com_dotnet/com_iterator.c 			I->key++;
key               105 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               110 ext/com_dotnet/com_iterator.c 		if (I->key >= (ULONG) I->sa_max) {
key               111 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               114 ext/com_dotnet/com_iterator.c 		I->key++;
key               115 ext/com_dotnet/com_iterator.c 		if (php_com_safearray_get_elem(&I->safe_array, &I->v, (LONG)I->key) == 0) {
key               116 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               193 ext/com_dotnet/com_iterator.c 			I->key = bound;
key               198 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               227 ext/com_dotnet/com_iterator.c 			I->key = 0;
key               233 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key                58 ext/com_dotnet/com_saproxy.c 	LONG key;
key               319 ext/com_dotnet/com_saproxy.c static union _zend_function *saproxy_method_get(zend_object **object, zend_string *name, const zval *key)
key               473 ext/com_dotnet/com_saproxy.c 	return (I->key < I->imax) ? SUCCESS : FAILURE;
key               483 ext/com_dotnet/com_saproxy.c 	I->indices[I->proxy->dimensions-1] = I->key;
key               506 ext/com_dotnet/com_saproxy.c static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key)
key               510 ext/com_dotnet/com_saproxy.c 	if (I->key == -1) {
key               511 ext/com_dotnet/com_saproxy.c 		ZVAL_NULL(key);
key               513 ext/com_dotnet/com_saproxy.c 		ZVAL_LONG(key, I->key);
key               521 ext/com_dotnet/com_saproxy.c 	if (++I->key >= I->imax) {
key               522 ext/com_dotnet/com_saproxy.c 		I->key = -1;
key               564 ext/com_dotnet/com_saproxy.c 	I->key = I->imin;
key              1778 ext/curl/interface.c 			char *key;
key              1786 ext/curl/interface.c 			key = s;
key              1787 ext/curl/interface.c 			tmp = memchr(key, '=', 64);
key              1791 ext/curl/interface.c 				add_assoc_string(hash, key, val);
key              1901 ext/date/php_date.c static void date_period_it_current_key(zend_object_iterator *iter, zval *key)
key              1904 ext/date/php_date.c 	ZVAL_LONG(key, iterator->current_index);
key                75 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key                80 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key                86 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key                98 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key               103 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key               109 ext/dba/dba.c  	ZEND_ARG_INFO(0, key)
key               203 ext/dba/dba.c  static size_t php_dba_make_key(zval *key, char **key_str, char **key_free)
key               205 ext/dba/dba.c  	if (Z_TYPE_P(key) == IS_ARRAY) {
key               210 ext/dba/dba.c  		if (zend_hash_num_elements(Z_ARRVAL_P(key)) != 2) {
key               214 ext/dba/dba.c  		zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(key), &pos);
key               215 ext/dba/dba.c  		group = zend_hash_get_current_data_ex(Z_ARRVAL_P(key), &pos);
key               216 ext/dba/dba.c  		zend_hash_move_forward_ex(Z_ARRVAL_P(key), &pos);
key               217 ext/dba/dba.c  		name = zend_hash_get_current_data_ex(Z_ARRVAL_P(key), &pos);
key               232 ext/dba/dba.c  		ZVAL_COPY(&tmp, key);
key               246 ext/dba/dba.c  	zval *key;													\
key               249 ext/dba/dba.c  	if (zend_parse_parameters(ac, "zr", &key, &id) == FAILURE) { 	\
key               252 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free)) == 0) {\
key               257 ext/dba/dba.c  	zval *key;													\
key               263 ext/dba/dba.c  		if (zend_parse_parameters(ac, "zr", &key, &id) == FAILURE) { \
key               268 ext/dba/dba.c  		if (zend_parse_parameters(ac, "zlr", &key, &skip, &id) == FAILURE) { \
key               275 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free)) == 0) {\
key               575 ext/dba/dba.c  	zval *key;
key               580 ext/dba/dba.c  	if (zend_parse_parameters(ac, "zsr", &key, &val, &val_len, &id) == FAILURE) {
key               584 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free)) == 0) {
key               602 ext/dba/dba.c  #define FREENOW if(args) {int i; for (i=0; i<ac; i++) { zval_ptr_dtor(&args[i]); } efree(args);} if(key) efree(key)
key               638 ext/dba/dba.c  	char *key = NULL, *error = NULL;
key               673 ext/dba/dba.c  		key = safe_emalloc(keylen, 1, 1);
key               674 ext/dba/dba.c  		key[keylen] = '\0';
key               678 ext/dba/dba.c  			memcpy(key+keylen, Z_STRVAL(args[i]), Z_STRLEN(args[i]));
key               683 ext/dba/dba.c  		if ((le = zend_hash_str_find_ptr(&EG(persistent_list), key, keylen)) != NULL) {
key               954 ext/dba/dba.c  		if (zend_hash_str_update(&EG(persistent_list), key, keylen, &new_le) == NULL) {
key              1064 ext/dba/dba.c  	char *key, *name;
key              1075 ext/dba/dba.c  	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &key, &key_len) == FAILURE) {
key              1079 ext/dba/dba.c  	if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
key              1080 ext/dba/dba.c  		add_next_index_stringl(return_value, key+1, name - (key + 1));
key              1081 ext/dba/dba.c  		add_next_index_stringl(return_value, name+1, key_len - (name - key + 1));
key              1084 ext/dba/dba.c  		add_next_index_stringl(return_value, key, key_len);
key               141 ext/dba/dba_cdb.c # define php_cdb_findnext(cdb, key, len) cdb_findnext(cdb, key, len)
key               142 ext/dba/dba_cdb.c # define php_cdb_find(cdb, key, len) cdb_find(cdb, key, len)
key               145 ext/dba/dba_cdb.c # define php_cdb_findnext(cdb, key, len) cdb_findnext(cdb, key, len)
key               146 ext/dba/dba_cdb.c # define php_cdb_find(cdb, key, len) cdb_find(cdb, key, len)
key               159 ext/dba/dba_cdb.c 	if (php_cdb_find(&cdb->c, key, keylen) == 1) {
key               161 ext/dba/dba_cdb.c 			if (php_cdb_findnext(&cdb->c, key, keylen) != 1) {
key               189 ext/dba/dba_cdb.c 	if (cdb_make_add(&cdb->m, key, keylen, val, vallen) != -1)
key               203 ext/dba/dba_cdb.c 	if (php_cdb_find(&cdb->c, key, keylen) == 1)
key               250 ext/dba/dba_cdb.c 	char *key;
key               271 ext/dba/dba_cdb.c 	key = safe_emalloc(klen, 1, 1);
key               272 ext/dba/dba_cdb.c 	if (cdb_file_read(cdb->file, key, klen) < klen) {
key               273 ext/dba/dba_cdb.c 		efree(key);
key               274 ext/dba/dba_cdb.c 		key = NULL;
key               276 ext/dba/dba_cdb.c 		key[klen] = '\0';
key               283 ext/dba/dba_cdb.c 	return key;
key               291 ext/dba/dba_cdb.c 	char *key;
key               303 ext/dba/dba_cdb.c 	key = safe_emalloc(klen, 1, 1);
key               304 ext/dba/dba_cdb.c 	if (cdb_file_read(cdb->file, key, klen) < klen) {
key               305 ext/dba/dba_cdb.c 		efree(key);
key               306 ext/dba/dba_cdb.c 		key = NULL;
key               308 ext/dba/dba_cdb.c 		key[klen] = '\0';
key               314 ext/dba/dba_cdb.c 	return key;
key                39 ext/dba/dba_db1.c #define DB1_GKEY DBT gkey; gkey.data = (char *) key; gkey.size = keylen
key                39 ext/dba/dba_db2.c 	gkey.data = (char *) key; \
key                52 ext/dba/dba_db3.c 	gkey.data = (char *) key; gkey.size = keylen
key                66 ext/dba/dba_db4.c 	gkey.data = (char *) key; gkey.size = keylen
key                43 ext/dba/dba_dbm.c #define DBM_GKEY datum gkey; gkey.dptr = (char *) key; gkey.dsize = keylen
key               152 ext/dba/dba_dbm.c 	char *key = NULL;
key               157 ext/dba/dba_dbm.c 		key = estrndup(gkey.dptr, gkey.dsize);
key               161 ext/dba/dba_dbm.c 	return key;
key                40 ext/dba/dba_flatfile.c #define FLATFILE_GKEY datum gkey; gkey.dptr = (char *) key; gkey.dsize = keylen
key                96 ext/dba/dba_flatfile.c 			php_error_docref1(NULL, key, E_WARNING, "Operation not possible");
key                99 ext/dba/dba_flatfile.c 			php_error_docref2(NULL, key, val, E_WARNING, "Unknown return value");
key                35 ext/dba/dba_gdbm.c #define GDBM_GKEY datum gkey; gkey.dptr = (char *) key; gkey.dsize = keylen
key               113 ext/dba/dba_gdbm.c 			php_error_docref2(NULL, key, val, E_WARNING, "%s", gdbm_strerror(gdbm_errno));
key               116 ext/dba/dba_gdbm.c 			php_error_docref2(NULL, key, val, E_WARNING, "Unknown return value");
key               141 ext/dba/dba_gdbm.c 	char *key = NULL;
key               149 ext/dba/dba_gdbm.c 		key = estrndup(gkey.dptr, gkey.dsize);
key               155 ext/dba/dba_gdbm.c 	return key;
key                44 ext/dba/dba_inifile.c 	if (!key) { \
key                48 ext/dba/dba_inifile.c 	ini_key = inifile_key_split((char*)key) /* keylen not needed here */
key                98 ext/dba/dba_inifile.c 		php_error_docref1(NULL, key, E_WARNING, "Operation not possible");
key               143 ext/dba/dba_inifile.c 		char *result = inifile_key_string(&dba->curr.key);
key               155 ext/dba/dba_inifile.c 	if (!dba->curr.key.group && !dba->curr.key.name) {
key               160 ext/dba/dba_inifile.c 		char *result = inifile_key_string(&dba->curr.key);
key                35 ext/dba/dba_ndbm.c #define NDBM_GKEY datum gkey; gkey.dptr = (char *) key; gkey.dsize = keylen
key               124 ext/dba/dba_ndbm.c 	char *key = NULL;
key               129 ext/dba/dba_ndbm.c 		key = estrndup(gkey.dptr, gkey.dsize);
key               131 ext/dba/dba_ndbm.c 	return key;
key                86 ext/dba/dba_qdbm.c 	value = dpget(dba->dbf, key, keylen, 0, -1, &value_size);
key               100 ext/dba/dba_qdbm.c 	if (dpput(dba->dbf, key, keylen, val, vallen, mode == 1 ? DP_DKEEP : DP_DOVER)) {
key               105 ext/dba/dba_qdbm.c 		php_error_docref2(NULL, key, val, E_WARNING, "%s", dperrmsg(dpecode));
key               116 ext/dba/dba_qdbm.c 	value = dpget(dba->dbf, key, keylen, 0, -1, NULL);
key               129 ext/dba/dba_qdbm.c 	return dpout(dba->dbf, key, keylen) ? SUCCESS : FAILURE;
key                95 ext/dba/dba_tcadb.c 	value = tcadbget(dba->tcadb, key, keylen, &value_size);
key               114 ext/dba/dba_tcadb.c 		if (tcadbvsiz(dba->tcadb, key, keylen) > -1) {
key               119 ext/dba/dba_tcadb.c 	result = tcadbput(dba->tcadb, key, keylen, val, vallen);
key               125 ext/dba/dba_tcadb.c 	php_error_docref2(NULL, key, val, E_WARNING, "Error updating data");
key               135 ext/dba/dba_tcadb.c 	value = tcadbget(dba->tcadb, key, keylen, &value_len);
key               148 ext/dba/dba_tcadb.c 	return tcadbout(dba->tcadb, key, keylen) ? SUCCESS : FAILURE;
key                46 ext/dba/libcdb/cdb.c static int cdb_match(struct cdb *c, char *key, unsigned int len, uint32 pos)
key                57 ext/dba/libcdb/cdb.c 		if (memcmp(buf, key, n))
key                60 ext/dba/libcdb/cdb.c 		key += n;
key               129 ext/dba/libcdb/cdb.c int cdb_findnext(struct cdb *c, char *key, unsigned int len)
key               136 ext/dba/libcdb/cdb.c 		u = cdb_hash(key, len);
key               166 ext/dba/libcdb/cdb.c 			switch(cdb_match(c, key, len, pos + 8)) {
key               182 ext/dba/libcdb/cdb.c int cdb_find(struct cdb *c, char *key, unsigned int len)
key               185 ext/dba/libcdb/cdb.c 	return cdb_findnext(c, key, len);
key               125 ext/dba/libcdb/cdb_make.c int cdb_make_add(struct cdb_make *c,char *key,unsigned int keylen,char *data,unsigned int datalen)
key               129 ext/dba/libcdb/cdb_make.c 	if (cdb_make_write(c, key, keylen) != 0)
key               133 ext/dba/libcdb/cdb_make.c 	return cdb_make_addend(c, keylen, datalen, cdb_hash(key, keylen));
key               107 ext/dba/libflatfile/flatfile.c 	char *key = key_datum.dptr;
key               130 ext/dba/libflatfile/flatfile.c 		if (size == num && !memcmp(buf, key, size)) {
key               163 ext/dba/libflatfile/flatfile.c 	void *key = key_datum.dptr;
key               179 ext/dba/libflatfile/flatfile.c 			if (!memcmp(buf, key, size)) {
key                50 ext/dba/libinifile/inifile.c void inifile_key_free(key_type *key)
key                52 ext/dba/libinifile/inifile.c 	if (key->group) {
key                53 ext/dba/libinifile/inifile.c 		efree(key->group);
key                55 ext/dba/libinifile/inifile.c 	if (key->name) {
key                56 ext/dba/libinifile/inifile.c 		efree(key->name);
key                58 ext/dba/libinifile/inifile.c 	memset(key, 0, sizeof(key_type));
key                75 ext/dba/libinifile/inifile.c 	inifile_key_free(&ln->key);
key               115 ext/dba/libinifile/inifile.c 	key_type key;
key               119 ext/dba/libinifile/inifile.c 		key.group = estrndup(group_name+1, name - (group_name + 1));
key               120 ext/dba/libinifile/inifile.c 		key.name = estrdup(name+1);
key               122 ext/dba/libinifile/inifile.c 		key.group = estrdup("");
key               123 ext/dba/libinifile/inifile.c 		key.name = estrdup(group_name);
key               125 ext/dba/libinifile/inifile.c 	return key;
key               130 ext/dba/libinifile/inifile.c char * inifile_key_string(const key_type *key)
key               132 ext/dba/libinifile/inifile.c 	if (key->group && *key->group) {
key               134 ext/dba/libinifile/inifile.c 		spprintf(&result, 0, "[%s]%s", key->group, key->name ? key->name : "");
key               136 ext/dba/libinifile/inifile.c 	} else if (key->name) {
key               137 ext/dba/libinifile/inifile.c 		return estrdup(key->name);
key               181 ext/dba/libinifile/inifile.c 					inifile_key_free(&ln->key);
key               182 ext/dba/libinifile/inifile.c 					ln->key.group = etrim(fline+1);
key               183 ext/dba/libinifile/inifile.c 					ln->key.name = estrdup("");
key               196 ext/dba/libinifile/inifile.c 					if (!ln->key.group) {
key               197 ext/dba/libinifile/inifile.c 						ln->key.group = estrdup("");
key               199 ext/dba/libinifile/inifile.c 					if (ln->key.name) {
key               200 ext/dba/libinifile/inifile.c 						efree(ln->key.name);
key               202 ext/dba/libinifile/inifile.c 					ln->key.name = etrim(fline);
key               245 ext/dba/libinifile/inifile.c val_type inifile_fetch(inifile *dba, const key_type *key, int skip) {
key               250 ext/dba/libinifile/inifile.c 	if (skip == -1 && dba->next.key.group && dba->next.key.name && !inifile_key_cmp(&dba->next.key, key)) {
key               263 ext/dba/libinifile/inifile.c 		if (!(res=inifile_key_cmp(&ln.key, key))) {
key               302 ext/dba/libinifile/inifile.c 	ln.key.group = estrdup(dba->curr.key.group ? dba->curr.key.group : "");
key               306 ext/dba/libinifile/inifile.c 	return ln.key.group || ln.key.name;
key               328 ext/dba/libinifile/inifile.c static int inifile_find_group(inifile *dba, const key_type *key, size_t *pos_grp_start)
key               337 ext/dba/libinifile/inifile.c 	if (key->group && strlen(key->group)) {
key               343 ext/dba/libinifile/inifile.c 			if ((res=inifile_key_cmp(&ln.key, key)) < 2) {
key               365 ext/dba/libinifile/inifile.c static int inifile_next_group(inifile *dba, const key_type *key, size_t *pos_grp_start)
key               371 ext/dba/libinifile/inifile.c 	ln.key.group = estrdup(key->group);
key               373 ext/dba/libinifile/inifile.c 		if (inifile_key_cmp(&ln.key, key) == 2) {
key               416 ext/dba/libinifile/inifile.c static int inifile_filter(inifile *dba, inifile *from, const key_type *key, zend_bool *found)
key               425 ext/dba/libinifile/inifile.c 		switch(inifile_key_cmp(&ln.key, key)) {
key               464 ext/dba/libinifile/inifile.c static int inifile_delete_replace_append(inifile *dba, const key_type *key, const val_type *value, int append, zend_bool *found)
key               482 ext/dba/libinifile/inifile.c 	assert(!append || (key->name && value)); /* missuse */
key               485 ext/dba/libinifile/inifile.c 	inifile_find_group(dba, key, &pos_grp_start);
key               486 ext/dba/libinifile/inifile.c 	inifile_next_group(dba, key, &pos_grp_next);
key               513 ext/dba/libinifile/inifile.c 		if (!value || (key->name && strlen(key->name))) {
key               519 ext/dba/libinifile/inifile.c 		if (key->name && strlen(key->name)) {
key               522 ext/dba/libinifile/inifile.c 				ret = inifile_filter(dba, ini_tmp, key, found);
key               530 ext/dba/libinifile/inifile.c 				if (pos_grp_start == pos_grp_next && key->group && strlen(key->group)) {
key               531 ext/dba/libinifile/inifile.c 					php_stream_printf(dba->fp, "[%s]\n", key->group);
key               533 ext/dba/libinifile/inifile.c 				php_stream_printf(dba->fp, "%s=%s\n", key->name, value->value ? value->value : "");
key               567 ext/dba/libinifile/inifile.c int inifile_delete(inifile *dba, const key_type *key)
key               569 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, NULL, 0, NULL);
key               575 ext/dba/libinifile/inifile.c int inifile_delete_ex(inifile *dba, const key_type *key, zend_bool *found)
key               577 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, NULL, 0, found);
key               583 ext/dba/libinifile/inifile.c int inifile_replace(inifile *dba, const key_type *key, const val_type *value)
key               585 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, value, 0, NULL);
key               591 ext/dba/libinifile/inifile.c int inifile_replace_ex(inifile *dba, const key_type *key, const val_type *value, zend_bool *found)
key               593 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, value, 0, found);
key               599 ext/dba/libinifile/inifile.c int inifile_append(inifile *dba, const key_type *key, const val_type *value)
key               601 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, value, 1, NULL);
key                34 ext/dba/libinifile/inifile.h 	key_type key;
key                48 ext/dba/libinifile/inifile.h val_type inifile_fetch(inifile *dba, const key_type *key, int skip);
key                51 ext/dba/libinifile/inifile.h int inifile_delete(inifile *dba, const key_type *key);
key                52 ext/dba/libinifile/inifile.h int inifile_delete_ex(inifile *dba, const key_type *key, zend_bool *found);
key                53 ext/dba/libinifile/inifile.h int inifile_replace(inifile *dba, const key_type *key, const val_type *val);
key                54 ext/dba/libinifile/inifile.h int inifile_replace_ex(inifile *dba, const key_type *key, const val_type *val, zend_bool *found);
key                55 ext/dba/libinifile/inifile.h int inifile_append(inifile *dba, const key_type *key, const val_type *val);
key                59 ext/dba/libinifile/inifile.h char * inifile_key_string(const key_type *key);
key                61 ext/dba/libinifile/inifile.h void inifile_key_free(key_type *key);
key               101 ext/dba/php_dba.h 	char *dba_fetch_##x(dba_info *info, char *key, int keylen, int skip, int *newlen)
key               103 ext/dba/php_dba.h 	int dba_update_##x(dba_info *info, char *key, int keylen, char *val, int vallen, int mode)
key               105 ext/dba/php_dba.h 	int dba_exists_##x(dba_info *info, char *key, int keylen)
key               107 ext/dba/php_dba.h 	int dba_delete_##x(dba_info *info, char *key, int keylen)
key               155 ext/dom/dom_iterators.c static void php_dom_iterator_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key               161 ext/dom/dom_iterators.c 		ZVAL_LONG(key, iter->index);
key               167 ext/dom/dom_iterators.c 			ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
key               169 ext/dom/dom_iterators.c 			ZVAL_NULL(key);
key                97 ext/dom/node.c 	ZEND_ARG_INFO(0, key)
key               103 ext/dom/node.c 	ZEND_ARG_INFO(0, key)
key              3859 ext/gd/gd.c    		zend_string *key;
key              3862 ext/gd/gd.c    		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(EXT), key, item) {
key              3863 ext/gd/gd.c    			if (key == NULL) {
key              3866 ext/gd/gd.c    			if (strcmp("linespacing", ZSTR_VAL(key)) == 0) {
key               151 ext/gd/gdcache.c 	int key;
key               156 ext/gd/gdcache.c cacheTest( void *map, void *key )
key               158 ext/gd/gdcache.c 	return (((key_value_t *)map)->key == *(int *)key);
key               162 ext/gd/gdcache.c cacheFetch( char **error, void *key )
key               170 ext/gd/gdcache.c 	map->key = *(int *)key;
key               187 ext/gd/gdcache.c 	int 			elem, key;
key               191 ext/gd/gdcache.c 	key = 20;
key               192 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               193 ext/gd/gdcache.c 	key = 30;
key               194 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               195 ext/gd/gdcache.c 	key = 40;
key               196 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               197 ext/gd/gdcache.c 	key = 50;
key               198 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               199 ext/gd/gdcache.c 	key = 30;
key               200 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               201 ext/gd/gdcache.c 	key = 30;
key               202 ext/gd/gdcache.c 	elem = *(int *)gdCacheGet(cacheTable, &key);
key               153 ext/gd/libgd/gdcache.c   int key;
key               159 ext/gd/libgd/gdcache.c cacheTest (void *map, void *key)
key               161 ext/gd/libgd/gdcache.c   return (((key_value_t *) map)->key == *(int *) key);
key               165 ext/gd/libgd/gdcache.c cacheFetch (char **error, void *key)
key               170 ext/gd/libgd/gdcache.c   map->key = *(int *) key;
key               187 ext/gd/libgd/gdcache.c   int elem, key;
key               191 ext/gd/libgd/gdcache.c   key = 20;
key               192 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               193 ext/gd/libgd/gdcache.c   key = 30;
key               194 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               195 ext/gd/libgd/gdcache.c   key = 40;
key               196 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               197 ext/gd/libgd/gdcache.c   key = 50;
key               198 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               199 ext/gd/libgd/gdcache.c   key = 30;
key               200 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               201 ext/gd/libgd/gdcache.c   key = 30;
key               202 ext/gd/libgd/gdcache.c   elem = *(int *) gdCacheGet (cacheTable, &key);
key               337 ext/gd/libgd/gdft.c static int fontTest (void *element, void *key)
key               340 ext/gd/libgd/gdft.c 	fontkey_t *b = (fontkey_t *) key;
key               364 ext/gd/libgd/gdft.c static void *fontFetch (char **error, void *key)
key               367 ext/gd/libgd/gdft.c 	fontkey_t *b = (fontkey_t *) key;
key               558 ext/gd/libgd/gdft.c static int tweenColorTest (void *element, void *key)
key               561 ext/gd/libgd/gdft.c 	tweencolorkey_t *b = (tweencolorkey_t *) key;
key               575 ext/gd/libgd/gdft.c static void * tweenColorFetch (char **error, void *key)
key               578 ext/gd/libgd/gdft.c 	tweencolorkey_t *b = (tweencolorkey_t *) key;
key               215 ext/hash/hash.c static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops *ops, void *context, const unsigned char *key, const size_t key_len) {
key               220 ext/hash/hash.c 		ops->hash_update(context, key, key_len);
key               223 ext/hash/hash.c 		memcpy(K, key, key_len);
key               229 ext/hash/hash.c static inline void php_hash_hmac_round(unsigned char *final, const php_hash_ops *ops, void *context, const unsigned char *key, const unsigned char *data, const zend_long data_size) {
key               231 ext/hash/hash.c 	ops->hash_update(context, key, ops->block_size);
key               239 ext/hash/hash.c 	char *algo, *data, *key;
key               248 ext/hash/hash.c 																  &key, &key_len, &raw_output) == FAILURE) {
key               274 ext/hash/hash.c 	php_hash_hmac_prep_key(K, ops, context, (unsigned char *) key, key_len);
key               336 ext/hash/hash.c 	char *algo, *key = NULL;
key               344 ext/hash/hash.c 	if (zend_parse_parameters(argc, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) {
key               368 ext/hash/hash.c 	hash->key = NULL;
key               378 ext/hash/hash.c 			ops->hash_update(context, (unsigned char *) key, key_len);
key               383 ext/hash/hash.c 			memcpy(K, key, key_len);
key               391 ext/hash/hash.c 		hash->key = (unsigned char *) K;
key               522 ext/hash/hash.c 			hash->key[i] ^= 0x6A;
key               527 ext/hash/hash.c 		hash->ops->hash_update(hash->context, hash->key, hash->ops->block_size);
key               532 ext/hash/hash.c 		ZEND_SECURE_ZERO(hash->key, hash->ops->block_size);
key               533 ext/hash/hash.c 		efree(hash->key);
key               534 ext/hash/hash.c 		hash->key = NULL;
key               585 ext/hash/hash.c 	copy_hash->key = ecalloc(1, hash->ops->block_size);
key               586 ext/hash/hash.c 	if (hash->key) {
key               587 ext/hash/hash.c 		memcpy(copy_hash->key, hash->key, hash->ops->block_size);
key               785 ext/hash/hash.c 	if (hash->key) {
key               786 ext/hash/hash.c 		memset(hash->key, 0, hash->ops->block_size);
key               787 ext/hash/hash.c 		efree(hash->key);
key               964 ext/hash/hash.c 				char *key, *digest;
key               973 ext/hash/hash.c 				key = ecalloc(1, times * block_size);
key               985 ext/hash/hash.c 					memcpy( &key[i*block_size], digest, block_size);
key               988 ext/hash/hash.c 				RETVAL_STRINGL(key, bytes);
key               989 ext/hash/hash.c 				ZEND_SECURE_ZERO(key, bytes);
key               992 ext/hash/hash.c 				efree(key);
key              1147 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1154 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1161 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1230 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key                38 ext/hash/hash_gost.c #define R(tables, key, h, i, t, l, r) \
key                41 ext/hash/hash_gost.c 	round(tables, key[0], key[1]) \
key                42 ext/hash/hash_gost.c 	round(tables, key[2], key[3]) \
key                43 ext/hash/hash_gost.c 	round(tables, key[4], key[5]) \
key                44 ext/hash/hash_gost.c 	round(tables, key[6], key[7]) \
key                45 ext/hash/hash_gost.c 	round(tables, key[0], key[1]) \
key                46 ext/hash/hash_gost.c 	round(tables, key[2], key[3]) \
key                47 ext/hash/hash_gost.c 	round(tables, key[4], key[5]) \
key                48 ext/hash/hash_gost.c 	round(tables, key[6], key[7]) \
key                49 ext/hash/hash_gost.c 	round(tables, key[0], key[1]) \
key                50 ext/hash/hash_gost.c 	round(tables, key[2], key[3]) \
key                51 ext/hash/hash_gost.c 	round(tables, key[4], key[5]) \
key                52 ext/hash/hash_gost.c 	round(tables, key[6], key[7]) \
key                53 ext/hash/hash_gost.c 	round(tables, key[7], key[6]) \
key                54 ext/hash/hash_gost.c 	round(tables, key[5], key[4]) \
key                55 ext/hash/hash_gost.c 	round(tables, key[3], key[2]) \
key                56 ext/hash/hash_gost.c 	round(tables, key[1], key[0]) \
key                71 ext/hash/hash_gost.c #define P(key, w) \
key                72 ext/hash/hash_gost.c 	key[0] = (w[0]  & 0x000000ff) | ((w[2] & 0x000000ff) << 8) | \
key                74 ext/hash/hash_gost.c 	key[1] = ((w[0] & 0x0000ff00) >> 8)  | (w[2]  & 0x0000ff00) | \
key                76 ext/hash/hash_gost.c 	key[2] = ((w[0] & 0x00ff0000) >> 16) | ((w[2] & 0x00ff0000) >> 8) | \
key                78 ext/hash/hash_gost.c 	key[3] = ((w[0] & 0xff000000) >> 24) | ((w[2] & 0xff000000) >> 16) | \
key                80 ext/hash/hash_gost.c 	key[4] = (w[1] & 0x000000ff) | ((w[3] & 0x000000ff) << 8) | \
key                82 ext/hash/hash_gost.c 	key[5] = ((w[1] & 0x0000ff00) >> 8) | (w[3]  & 0x0000ff00) | \
key                84 ext/hash/hash_gost.c 	key[6] = ((w[1] & 0x00ff0000) >> 16) | ((w[3] & 0x00ff0000) >> 8) | \
key                86 ext/hash/hash_gost.c 	key[7] = ((w[1] & 0xff000000) >> 24) | ((w[3] & 0xff000000) >> 16) | \
key               199 ext/hash/hash_gost.c 	P(key, w); \
key               200 ext/hash/hash_gost.c 	R((tables), key, h, i, t, l, r); \
key               213 ext/hash/hash_gost.c 	php_hash_uint32 l, r, t, key[8], u[8], v[8], w[8], s[8], *h = context->state, *m = data;
key                60 ext/hash/php_hash.h 	unsigned char *key;
key               625 ext/imap/php_imap.c static zval *add_assoc_object(zval *arg, char *key, zval *tmp)
key               634 ext/imap/php_imap.c 	return zend_hash_str_update(symtable, key, strlen(key), tmp);
key              3520 ext/imap/php_imap.c 	zend_string *key;
key              3633 ext/imap/php_imap.c 					ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(pvalue), key, disp_data) {
key              3635 ext/imap/php_imap.c 						disp_param->attribute = cpystr(ZSTR_VAL(key));
key              3665 ext/imap/php_imap.c 					ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(pvalue), key, disp_data) {
key              3667 ext/imap/php_imap.c 						disp_param->attribute = cpystr(ZSTR_VAL(key));
key              3737 ext/imap/php_imap.c 					ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(pvalue), key, disp_data) {
key              3739 ext/imap/php_imap.c 						disp_param->attribute = cpystr(ZSTR_VAL(key));
key              3769 ext/imap/php_imap.c 					ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(pvalue), key, disp_data) {
key              3771 ext/imap/php_imap.c 						disp_param->attribute = cpystr(ZSTR_VAL(key));
key                38 ext/intl/collator/collator_sort.c 	char* key;       /* pointer to sort key */
key               250 ext/intl/collator/collator_sort.c 	char* key1 = ((collator_sort_key_index_t*)p1)->key;
key               251 ext/intl/collator/collator_sort.c 	char* key2 = ((collator_sort_key_index_t*)p2)->key;
key               492 ext/intl/collator/collator_sort.c 		sortKeyIndxBuf[sortKeyCount].key = (char*)sortKeyBufOffset;    /* remember just offset, cause address */
key               503 ext/intl/collator/collator_sort.c 		sortKeyIndxBuf[j].key = sortKeyBuf + (ptrdiff_t)sortKeyIndxBuf[j].key;
key               109 ext/intl/locale/locale_methods.c static int16_t findOffset(const char* const* list, const char* key)
key               113 ext/intl/locale/locale_methods.c 		if (strcmp(key, *list) == 0) {
key               541 ext/intl/php_intl.c 	ZEND_ARG_INFO( 0, key )
key               101 ext/intl/resourcebundle/resourcebundle_iterator.c static void resourcebundle_iterator_key( zend_object_iterator *iter, zval *key )
key               110 ext/intl/resourcebundle/resourcebundle_iterator.c 		ZVAL_STRING(key, iterator->currentkey);
key               112 ext/intl/resourcebundle/resourcebundle_iterator.c 		ZVAL_LONG(key, iterator->i);
key                53 ext/json/json_encoder.c 		zend_string *key;
key                57 ext/json/json_encoder.c 		ZEND_HASH_FOREACH_KEY(myht, index, key) {
key                58 ext/json/json_encoder.c 			if (key) {
key               148 ext/json/json_encoder.c 		zend_string *key;
key               153 ext/json/json_encoder.c 		ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
key               171 ext/json/json_encoder.c 				if (key) {
key               172 ext/json/json_encoder.c 					if (ZSTR_VAL(key)[0] == '\0' && Z_TYPE_P(val) == IS_OBJECT) {
key               189 ext/json/json_encoder.c 					php_json_escape_string(buf, ZSTR_VAL(key), ZSTR_LEN(key), options & ~PHP_JSON_NUMERIC_CHECK);
key                79 ext/json/json_parser.tab.h 		zend_string *key;
key                49 ext/json/json_parser.y 		zend_string *key;
key                65 ext/json/json_parser.y %type <value> start object key value array errlex
key                70 ext/json/json_parser.y %destructor { zend_string_release($$.key); zval_dtor(&$$.val); } <pair>
key                76 ext/json/json_parser.y int php_json_parser_object_update(php_json_parser *parser, zval *object, zend_string *key, zval *zvalue);
key               149 ext/json/json_parser.y 		key ':' value
key               151 ext/json/json_parser.y 				$$.key = Z_STR($1);
key               154 ext/json/json_parser.y 	|	key errlex
key               202 ext/json/json_parser.y key:
key               253 ext/json/json_parser.y int php_json_parser_object_update(php_json_parser *parser, zval *object, zend_string *key, zval *zvalue)
key               257 ext/json/json_parser.y 		zend_symtable_update(Z_ARRVAL_P(object), key, zvalue);
key               260 ext/json/json_parser.y 		if (ZSTR_LEN(key) == 0) {
key               261 ext/json/json_parser.y 			zend_string_release(key);
key               262 ext/json/json_parser.y 			key = zend_string_init("_empty_", sizeof("_empty_") - 1, 0);
key               263 ext/json/json_parser.y 		} else if (ZSTR_VAL(key)[0] == '\0') {
key               265 ext/json/json_parser.y 			zend_string_release(key);
key               270 ext/json/json_parser.y 		ZVAL_NEW_STR(&zkey, key);
key               277 ext/json/json_parser.y 	zend_string_release(key);
key              1637 ext/ldap/ldap.c static void _ldap_hash_fetch(zval *hashTbl, const char *key, zval **out)
key              1639 ext/ldap/ldap.c 	*out = zend_hash_str_find(Z_ARRVAL_P(hashTbl), key, strlen(key));
key               365 ext/mbstring/oniguruma/regparse.c   st_str_end_key key;
key               367 ext/mbstring/oniguruma/regparse.c   key.s   = (UChar* )str_key;
key               368 ext/mbstring/oniguruma/regparse.c   key.end = (UChar* )end_key;
key               370 ext/mbstring/oniguruma/regparse.c   return onig_st_lookup(table, (st_data_t )(&key), value);
key               377 ext/mbstring/oniguruma/regparse.c   st_str_end_key* key;
key               380 ext/mbstring/oniguruma/regparse.c   key = (st_str_end_key* )xmalloc(sizeof(st_str_end_key));
key               381 ext/mbstring/oniguruma/regparse.c   key->s   = (UChar* )str_key;
key               382 ext/mbstring/oniguruma/regparse.c   key->end = (UChar* )end_key;
key               383 ext/mbstring/oniguruma/regparse.c   result = onig_st_insert(table, (st_data_t )key, value);
key               385 ext/mbstring/oniguruma/regparse.c     xfree(key);
key               416 ext/mbstring/oniguruma/regparse.c i_print_name_entry(UChar* key, NameEntry* e, void* arg)
key               451 ext/mbstring/oniguruma/regparse.c i_free_name_entry(UChar* key, NameEntry* e, void* arg ARG_UNUSED)
key               455 ext/mbstring/oniguruma/regparse.c   xfree(key);
key               508 ext/mbstring/oniguruma/regparse.c i_names(UChar* key ARG_UNUSED, NameEntry* e, INamesArg* arg)
key               541 ext/mbstring/oniguruma/regparse.c i_renumber_name(UChar* key ARG_UNUSED, NameEntry* e, GroupNumRemap* map)
key              4867 ext/mbstring/oniguruma/regparse.c static int type_cclass_hash(type_cclass_key* key)
key              4874 ext/mbstring/oniguruma/regparse.c   p = (UChar* )&(key->enc);
key              4875 ext/mbstring/oniguruma/regparse.c   for (i = 0; i < (int )sizeof(key->enc); i++) {
key              4879 ext/mbstring/oniguruma/regparse.c   p = (UChar* )(&key->type);
key              4880 ext/mbstring/oniguruma/regparse.c   for (i = 0; i < (int )sizeof(key->type); i++) {
key              4884 ext/mbstring/oniguruma/regparse.c   val += key->not;
key              4897 ext/mbstring/oniguruma/regparse.c i_free_shared_class(type_cclass_key* key, Node* node, void* arg ARG_UNUSED)
key              4905 ext/mbstring/oniguruma/regparse.c   if (IS_NOT_NULL(key)) xfree(key);
key              5200 ext/mbstring/oniguruma/regparse.c             type_cclass_key  key;
key              5203 ext/mbstring/oniguruma/regparse.c             key.enc  = env->enc;
key              5204 ext/mbstring/oniguruma/regparse.c             key.not  = tok->u.prop.not;
key              5205 ext/mbstring/oniguruma/regparse.c             key.type = tok->u.prop.ctype;
key              5218 ext/mbstring/oniguruma/regparse.c               if (onig_st_lookup(OnigTypeCClassTable, (st_data_t )&key,
key              5235 ext/mbstring/oniguruma/regparse.c 	    xmemcpy(new_key, &key, sizeof(type_cclass_key));
key                20 ext/mbstring/oniguruma/st.c     st_data_t key;
key                59 ext/mbstring/oniguruma/st.c #define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key))
key                60 ext/mbstring/oniguruma/st.c #define do_hash_bin(key,table) (do_hash(key, table)%(table)->num_bins)
key               218 ext/mbstring/oniguruma/st.c #define PTR_NOT_EQUAL(table, ptr, hash_val, key) \
key               219 ext/mbstring/oniguruma/st.c ((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key)))
key               230 ext/mbstring/oniguruma/st.c     if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\
key               232 ext/mbstring/oniguruma/st.c 	while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
key               240 ext/mbstring/oniguruma/st.c st_lookup(table, key, value)
key               242 ext/mbstring/oniguruma/st.c     register st_data_t key;
key               248 ext/mbstring/oniguruma/st.c     hash_val = do_hash(key, table);
key               260 ext/mbstring/oniguruma/st.c #define ADD_DIRECT(table, key, value, hash_val, bin_pos)\
key               271 ext/mbstring/oniguruma/st.c     entry->key = key;\
key               279 ext/mbstring/oniguruma/st.c st_insert(table, key, value)
key               281 ext/mbstring/oniguruma/st.c     register st_data_t key;
key               287 ext/mbstring/oniguruma/st.c     hash_val = do_hash(key, table);
key               291 ext/mbstring/oniguruma/st.c 	ADD_DIRECT(table, key, value, hash_val, bin_pos);
key               301 ext/mbstring/oniguruma/st.c st_add_direct(table, key, value)
key               303 ext/mbstring/oniguruma/st.c     st_data_t key;
key               308 ext/mbstring/oniguruma/st.c     hash_val = do_hash(key, table);
key               310 ext/mbstring/oniguruma/st.c     ADD_DIRECT(table, key, value, hash_val, bin_pos);
key               381 ext/mbstring/oniguruma/st.c st_delete(table, key, value)
key               383 ext/mbstring/oniguruma/st.c     register st_data_t *key;
key               390 ext/mbstring/oniguruma/st.c     hash_val = do_hash_bin(*key, table);
key               398 ext/mbstring/oniguruma/st.c     if (EQUAL(table, *key, ptr->key)) {
key               402 ext/mbstring/oniguruma/st.c 	*key = ptr->key;
key               408 ext/mbstring/oniguruma/st.c 	if (EQUAL(table, ptr->next->key, *key)) {
key               413 ext/mbstring/oniguruma/st.c 	    *key = tmp->key;
key               423 ext/mbstring/oniguruma/st.c st_delete_safe(table, key, value, never)
key               425 ext/mbstring/oniguruma/st.c     register st_data_t *key;
key               432 ext/mbstring/oniguruma/st.c     hash_val = do_hash_bin(*key, table);
key               441 ext/mbstring/oniguruma/st.c 	if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) {
key               443 ext/mbstring/oniguruma/st.c 	    *key = ptr->key;
key               445 ext/mbstring/oniguruma/st.c 	    ptr->key = ptr->record = never;
key               455 ext/mbstring/oniguruma/st.c delete_never(st_data_t key __attribute__ ((unused)), st_data_t value,
key               458 ext/mbstring/oniguruma/st.c delete_never(key, value, never)
key               459 ext/mbstring/oniguruma/st.c     st_data_t key, value, never;
key               490 ext/mbstring/oniguruma/st.c 	    retval = (*func)(ptr->key, ptr->record, arg);
key                31 ext/mbstring/oniguruma/st.h #define st_is_member(table,key) st_lookup(table,key,(st_data_t *)0)
key               166 ext/mbstring/ucgendat/ucgendat.c     ac_uint4 key;
key               554 ext/mbstring/ucgendat/ucgendat.c     for (i = 0; i < title_used && code > title[i].key; i++) ;
key               565 ext/mbstring/ucgendat/ucgendat.c     title[i].key = cases[2];    /* Title */
key               601 ext/mbstring/ucgendat/ucgendat.c     for (i = 0; i < upper_used && code > upper[i].key; i++) ;
key               612 ext/mbstring/ucgendat/ucgendat.c     upper[i].key = cases[0];    /* Upper */
key               648 ext/mbstring/ucgendat/ucgendat.c     for (i = 0; i < lower_used && code > lower[i].key; i++) ;
key               659 ext/mbstring/ucgendat/ucgendat.c     lower[i].key = cases[1];    /* Lower */
key              1285 ext/mbstring/ucgendat/ucgendat.c 		(unsigned long) tab[i].key, (unsigned long) tab[i].other1,
key                63 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               189 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               197 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               302 ext/mcrypt/mcrypt.c 		&cipher, &cipher_len, &key, &key_len, &data, &data_len, &mode, &iv, &iv_len) == FAILURE) {	\
key               537 ext/mcrypt/mcrypt.c 	char *key, *iv;
key               545 ext/mcrypt/mcrypt.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &mcryptind, &key, &key_len, &iv, &iv_len) == FAILURE) {
key               572 ext/mcrypt/mcrypt.c 	memcpy(key_s, key, key_len);
key              1246 ext/mcrypt/mcrypt.c static void php_mcrypt_do_crypt(char* cipher, const char *key, size_t key_len, const char *data, size_t data_len, char *mode, const char *iv, size_t iv_len, size_t dencrypt, zval* return_value) /* {{{ */
key              1285 ext/mcrypt/mcrypt.c 	if (mcrypt_generic_init(td, (void *) key, (int)key_len, (void *) iv) < 0) {
key              1311 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *mode, *iv = NULL;
key              1315 ext/mcrypt/mcrypt.c 		&key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key              1319 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_ENCRYPT, return_value);
key              1327 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *mode, *iv = NULL;
key              1331 ext/mcrypt/mcrypt.c 		&key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key              1335 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_DECRYPT, return_value);
key               158 ext/mcrypt/mcrypt_filter.c 	char *iv = NULL, *key = NULL;
key               203 ext/mcrypt/mcrypt_filter.c 		key = Z_STRVAL_P(tmpzval);
key               236 ext/mcrypt/mcrypt_filter.c 	result = mcrypt_generic_init(mcrypt_module, key, key_len, iv);
key               363 ext/mysqli/mysqli_fe.c 	ZEND_ARG_INFO(0, key)
key               371 ext/mysqli/mysqli_fe.c 	ZEND_ARG_INFO(0, key)
key               140 ext/mysqli/mysqli_result_iterator.c static void php_mysqli_result_iterator_current_key(zend_object_iterator *iter, zval *key)
key               144 ext/mysqli/mysqli_result_iterator.c 	ZVAL_LONG(key, iterator->row_num);
key              1616 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, ssl_set)(MYSQLND_CONN_DATA * const conn, const char * key, const char * const cert,
key              1625 ext/mysqlnd/mysqlnd.c 		ret = (PASS == net->data->m.set_client_option(net, MYSQLND_OPT_SSL_KEY, key) &&
key              2490 ext/mysqlnd/mysqlnd.c 														const char * const key,
key              2512 ext/mysqlnd/mysqlnd.c 			DBG_INF_FMT("Adding [%s][%s]", key, value);
key              2516 ext/mysqlnd/mysqlnd.c 				zend_hash_str_update(conn->options->connect_attr, key, strlen(key), &attrz);
key               162 ext/mysqlnd/mysqlnd.h #define mysqlnd_ssl_set(conn, key, cert, ca, capath, cipher) ((conn)->data)->m->ssl_set((conn)->data, (key), (cert), (ca), (capath), (cipher))
key                82 ext/mysqlnd/mysqlnd_libmysql_compat.h #define mysql_ssl_set(c,key,cert,ca,capath,cipher)	mysqlnd_ssl_set((c), (key), (cert), (ca), (capath), (cipher))
key               874 ext/mysqlnd/mysqlnd_result.c 							zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
key              1125 ext/mysqlnd/mysqlnd_result.c 					zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
key              1220 ext/mysqlnd/mysqlnd_result.c 					zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data);
key               139 ext/mysqlnd/mysqlnd_result_meta.c 			meta->zend_hash_keys[i].key = idx;
key               584 ext/mysqlnd/mysqlnd_wireprotocol.c 				zend_string * key;
key               586 ext/mysqlnd/mysqlnd_wireprotocol.c 				ZEND_HASH_FOREACH_STR_KEY_VAL(packet->connect_attr, key, entry_value) {
key               587 ext/mysqlnd/mysqlnd_wireprotocol.c 					if (key) { /* HASH_KEY_IS_STRING */
key               590 ext/mysqlnd/mysqlnd_wireprotocol.c 						ca_payload_len += php_mysqlnd_net_store_length_size(ZSTR_LEN(key));
key               591 ext/mysqlnd/mysqlnd_wireprotocol.c 						ca_payload_len += ZSTR_LEN(key);
key               622 ext/mysqlnd/mysqlnd_wireprotocol.c 					zend_string * key;
key               624 ext/mysqlnd/mysqlnd_wireprotocol.c 					ZEND_HASH_FOREACH_STR_KEY_VAL(packet->connect_attr, key, entry_value) {
key               625 ext/mysqlnd/mysqlnd_wireprotocol.c 						if (key) { /* HASH_KEY_IS_STRING */
key               629 ext/mysqlnd/mysqlnd_wireprotocol.c 							p = php_mysqlnd_net_store_length(p, ZSTR_LEN(key));
key               630 ext/mysqlnd/mysqlnd_wireprotocol.c 							memcpy(p, ZSTR_VAL(key), ZSTR_LEN(key));
key               631 ext/mysqlnd/mysqlnd_wireprotocol.c 							p+= ZSTR_LEN(key);
key               127 ext/opcache/Optimizer/compact_literals.c 	zend_string *key = NULL;
key               426 ext/opcache/Optimizer/compact_literals.c 							key = zend_string_alloc(key_len, 0);
key               427 ext/opcache/Optimizer/compact_literals.c 							ZSTR_LEN(key) = snprintf(ZSTR_VAL(key), ZSTR_LEN(key)-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i]));
key               432 ext/opcache/Optimizer/compact_literals.c 							key = zend_string_alloc(key_len, 0);
key               433 ext/opcache/Optimizer/compact_literals.c 							memcpy(ZSTR_VAL(key), Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
key               434 ext/opcache/Optimizer/compact_literals.c 							memcpy(ZSTR_VAL(key) + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
key               435 ext/opcache/Optimizer/compact_literals.c 							memcpy(ZSTR_VAL(key) + Z_STRLEN_P(class_name) + sizeof("::") - 1,
key               439 ext/opcache/Optimizer/compact_literals.c 							key = zend_string_init(Z_STRVAL(op_array->literals[i]), Z_STRLEN(op_array->literals[i]), 0);
key               441 ext/opcache/Optimizer/compact_literals.c 						ZSTR_H(key) = zend_hash_func(ZSTR_VAL(key), ZSTR_LEN(key));
key               442 ext/opcache/Optimizer/compact_literals.c 						ZSTR_H(key) += info[i].flags;
key               445 ext/opcache/Optimizer/compact_literals.c 						(pos = zend_hash_find(&hash, key)) != NULL &&
key               449 ext/opcache/Optimizer/compact_literals.c 						zend_string_release(key);
key               462 ext/opcache/Optimizer/compact_literals.c 							zend_hash_add_new(&hash, key, &zv);
key               463 ext/opcache/Optimizer/compact_literals.c 							zend_string_release(key);
key               702 ext/opcache/Optimizer/zend_optimizer.c 				if ((orig_op_array = zend_hash_find_ptr(&op_array->scope->function_table, q->key)) != NULL) {
key               733 ext/opcache/Optimizer/zend_optimizer.c 					if ((orig_op_array = zend_hash_find_ptr(&op_array->scope->function_table, q->key)) != NULL) {
key               356 ext/opcache/ZendAccelerator.c 		if ((char*)p->key < ZCSG(interned_strings_top)) break;
key               407 ext/opcache/ZendAccelerator.c 		if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) {
key               408 ext/opcache/ZendAccelerator.c 			if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) {
key               409 ext/opcache/ZendAccelerator.c 				return p->key;
key               446 ext/opcache/ZendAccelerator.c 		if ((p->h == h) && (ZSTR_LEN(p->key) == ZSTR_LEN(str))) {
key               447 ext/opcache/ZendAccelerator.c 			if (!memcmp(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str))) {
key               449 ext/opcache/ZendAccelerator.c 				return p->key;
key               467 ext/opcache/ZendAccelerator.c 	p->key = (zend_string*) ZCSG(interned_strings_top);
key               470 ext/opcache/ZendAccelerator.c 	GC_REFCOUNT(p->key) = 1;
key               473 ext/opcache/ZendAccelerator.c 	GC_TYPE_INFO(p->key) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << 8);
key               475 ext/opcache/ZendAccelerator.c 	GC_TYPE(p->key) = IS_STRING;
key               476 ext/opcache/ZendAccelerator.c 	GC_FLAGS(p->key) = IS_STR_INTERNED | IS_STR_PERMANENT;
key               478 ext/opcache/ZendAccelerator.c 	ZSTR_H(p->key) = ZSTR_H(str);
key               479 ext/opcache/ZendAccelerator.c 	ZSTR_LEN(p->key) = ZSTR_LEN(str);
key               480 ext/opcache/ZendAccelerator.c 	memcpy(ZSTR_VAL(p->key), ZSTR_VAL(str), ZSTR_LEN(str));
key               481 ext/opcache/ZendAccelerator.c 	ZVAL_INTERNED_STR(&p->val, p->key);
key               485 ext/opcache/ZendAccelerator.c 	return p->key;
key               511 ext/opcache/ZendAccelerator.c 		if (p->key) {
key               512 ext/opcache/ZendAccelerator.c 			p->key = accel_new_interned_string(p->key);
key               527 ext/opcache/ZendAccelerator.c 		if (p->key) {
key               528 ext/opcache/ZendAccelerator.c 			p->key = accel_new_interned_string(p->key);
key               543 ext/opcache/ZendAccelerator.c 			if (q->key) {
key               544 ext/opcache/ZendAccelerator.c 				q->key = accel_new_interned_string(q->key);
key               555 ext/opcache/ZendAccelerator.c 			if (q->key) {
key               556 ext/opcache/ZendAccelerator.c 				q->key = accel_new_interned_string(q->key);
key               566 ext/opcache/ZendAccelerator.c 			if (q->key) {
key               567 ext/opcache/ZendAccelerator.c 				q->key = accel_new_interned_string(q->key);
key               576 ext/opcache/ZendAccelerator.c 		if (p->key) {
key               577 ext/opcache/ZendAccelerator.c 			p->key = accel_new_interned_string(p->key);
key               592 ext/opcache/ZendAccelerator.c 		if (p->key) {
key               593 ext/opcache/ZendAccelerator.c 			p->key = accel_new_interned_string(p->key);
key              1032 ext/opcache/ZendAccelerator.c 		if (UNEXPECTED((size_t)(cwd_len + path_length + include_path_len + 2) >= sizeof(ZCG(key)))) {
key              1041 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key), path, path_length);
key              1042 ext/opcache/ZendAccelerator.c 		ZCG(key)[path_length] = ':';
key              1044 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key) + key_length, cwd, cwd_len);
key              1048 ext/opcache/ZendAccelerator.c 			ZCG(key)[key_length] = ':';
key              1050 ext/opcache/ZendAccelerator.c 			memcpy(ZCG(key) + key_length, include_path, include_path_len);
key              1064 ext/opcache/ZendAccelerator.c 			if (UNEXPECTED((size_t)(key_length + parent_script_len + 1) >= sizeof(ZCG(key)))) {
key              1067 ext/opcache/ZendAccelerator.c 			ZCG(key)[key_length] = ':';
key              1069 ext/opcache/ZendAccelerator.c 			memcpy(ZCG(key) + key_length, ZSTR_VAL(parent_script), parent_script_len);
key              1072 ext/opcache/ZendAccelerator.c 		ZCG(key)[key_length] = '\0';
key              1074 ext/opcache/ZendAccelerator.c 		return ZCG(key);
key              1138 ext/opcache/ZendAccelerator.c static void zend_accel_add_key(char *key, unsigned int key_length, zend_accel_hash_entry *bucket)
key              1140 ext/opcache/ZendAccelerator.c 	if (!zend_accel_hash_str_find(&ZCSG(hash), key, key_length)) {
key              1148 ext/opcache/ZendAccelerator.c 				memcpy(new_key, key, key_length + 1);
key              1217 ext/opcache/ZendAccelerator.c static zend_persistent_script *cache_script_in_shared_memory(zend_persistent_script *new_persistent_script, char *key, unsigned int key_length, int *from_shared_memory)
key              1250 ext/opcache/ZendAccelerator.c 			if (key &&
key              1253 ext/opcache/ZendAccelerator.c 				zend_accel_add_key(key, key_length, bucket);
key              1264 ext/opcache/ZendAccelerator.c 	memory_used = zend_accel_script_persist_calc(new_persistent_script, key, key_length);
key              1282 ext/opcache/ZendAccelerator.c 	new_persistent_script = zend_accel_script_persist(new_persistent_script, &key, key_length);
key              1308 ext/opcache/ZendAccelerator.c 		if (key &&
key              1310 ext/opcache/ZendAccelerator.c 		    memcmp(key, "phar://", sizeof("phar://") - 1) != 0 &&
key              1312 ext/opcache/ZendAccelerator.c 		     memcmp(ZSTR_VAL(new_persistent_script->full_path), key, key_length) != 0)) {
key              1314 ext/opcache/ZendAccelerator.c 			if (zend_accel_hash_update(&ZCSG(hash), key, key_length, 1, bucket)) {
key              1315 ext/opcache/ZendAccelerator.c 				zend_accel_error(ACCEL_LOG_INFO, "Added key '%s'", key);
key              1401 ext/opcache/ZendAccelerator.c static zend_persistent_script *opcache_compile_file(zend_file_handle *file_handle, int type, char *key, unsigned int key_length, zend_op_array **op_array_p)
key              1416 ext/opcache/ZendAccelerator.c         	if (key == ZCG(key)) {
key              1625 ext/opcache/ZendAccelerator.c 	char *key = NULL;
key              1660 ext/opcache/ZendAccelerator.c 			key = ZCG(key);
key              1667 ext/opcache/ZendAccelerator.c 			key = accel_make_persistent_key(file_handle->filename, strlen(file_handle->filename), &key_length);
key              1668 ext/opcache/ZendAccelerator.c 			if (!key) {
key              1671 ext/opcache/ZendAccelerator.c 			persistent_script = zend_accel_hash_str_find(&ZCSG(hash), key, key_length);
key              1695 ext/opcache/ZendAccelerator.c 					if (key && !persistent_script->corrupted) {
key              1698 ext/opcache/ZendAccelerator.c 						zend_accel_add_key(key, key_length, bucket);
key              1802 ext/opcache/ZendAccelerator.c 		persistent_script = opcache_compile_file(file_handle, type, key, key ? key_length : 0, &op_array);
key              1804 ext/opcache/ZendAccelerator.c 			persistent_script = cache_script_in_shared_memory(persistent_script, key, key ? key_length : 0, &from_shared_memory);
key              1920 ext/opcache/ZendAccelerator.c 			char *key = NULL;
key              1924 ext/opcache/ZendAccelerator.c 				key = accel_make_persistent_key(filename, filename_len, &key_length);
key              1925 ext/opcache/ZendAccelerator.c 				if (key) {
key              1926 ext/opcache/ZendAccelerator.c 					zend_accel_hash_entry *bucket = zend_accel_hash_str_find_entry(&ZCSG(hash), key, key_length);
key              1951 ext/opcache/ZendAccelerator.c 						if (key) {
key              1955 ext/opcache/ZendAccelerator.c 							zend_accel_add_key(key, key_length, bucket);
key              1995 ext/opcache/ZendAccelerator.c 		if (zend_accel_in_shm(p->key)) {
key              1996 ext/opcache/ZendAccelerator.c 			p->key = NULL;
key               265 ext/opcache/ZendAccelerator.h 	char                    key[MAXPATHLEN * 8];
key                74 ext/opcache/zend_accelerator_hash.c zend_accel_hash_entry* zend_accel_hash_update(zend_accel_hash *accel_hash, char *key, uint32_t key_length, zend_bool indirect, void *data)
key                88 ext/opcache/zend_accelerator_hash.c 	hash_value = zend_inline_hash_func(key, key_length);
key                96 ext/opcache/zend_accelerator_hash.c 			&& !memcmp(entry->key, key, key_length)) {
key               133 ext/opcache/zend_accelerator_hash.c 	entry->key = key;
key               140 ext/opcache/zend_accelerator_hash.c static zend_always_inline void* zend_accel_hash_find_ex(zend_accel_hash *accel_hash, char *key, uint32_t key_length, zend_ulong hash_value, int data)
key               148 ext/opcache/zend_accelerator_hash.c 			&& !memcmp(entry->key, key, key_length)) {
key               171 ext/opcache/zend_accelerator_hash.c void* zend_accel_hash_find(zend_accel_hash *accel_hash, zend_string *key)
key               175 ext/opcache/zend_accelerator_hash.c 		ZSTR_VAL(key),
key               176 ext/opcache/zend_accelerator_hash.c 		ZSTR_LEN(key),
key               177 ext/opcache/zend_accelerator_hash.c 		zend_string_hash_val(key),
key               184 ext/opcache/zend_accelerator_hash.c zend_accel_hash_entry* zend_accel_hash_find_entry(zend_accel_hash *accel_hash, zend_string *key)
key               188 ext/opcache/zend_accelerator_hash.c 		ZSTR_VAL(key),
key               189 ext/opcache/zend_accelerator_hash.c 		ZSTR_LEN(key),
key               190 ext/opcache/zend_accelerator_hash.c 		zend_string_hash_val(key),
key               197 ext/opcache/zend_accelerator_hash.c void* zend_accel_hash_str_find(zend_accel_hash *accel_hash, char *key, uint32_t key_length)
key               201 ext/opcache/zend_accelerator_hash.c 		key,
key               203 ext/opcache/zend_accelerator_hash.c 		zend_inline_hash_func(key, key_length),
key               210 ext/opcache/zend_accelerator_hash.c zend_accel_hash_entry* zend_accel_hash_str_find_entry(zend_accel_hash *accel_hash, char *key, uint32_t key_length)
key               214 ext/opcache/zend_accelerator_hash.c 		key,
key               216 ext/opcache/zend_accelerator_hash.c 		zend_inline_hash_func(key, key_length),
key               220 ext/opcache/zend_accelerator_hash.c int zend_accel_hash_unlink(zend_accel_hash *accel_hash, char *key, uint32_t key_length)
key               226 ext/opcache/zend_accelerator_hash.c 	hash_value = zend_inline_hash_func(key, key_length);
key               233 ext/opcache/zend_accelerator_hash.c 			&& !memcmp(entry->key, key, key_length)) {
key                49 ext/opcache/zend_accelerator_hash.h 	char                  *key;
key                69 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key                76 ext/opcache/zend_accelerator_hash.h 		zend_string            *key);
key                80 ext/opcache/zend_accelerator_hash.h 		zend_string            *key);
key                84 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key                89 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key                94 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key               321 ext/opcache/zend_accelerator_module.c 	char *key;
key               324 ext/opcache/zend_accelerator_module.c 	key = accel_make_persistent_key(ZSTR_VAL(filename), ZSTR_LEN(filename), &key_length);
key               325 ext/opcache/zend_accelerator_module.c 	if (key != NULL) {
key               326 ext/opcache/zend_accelerator_module.c 		zend_persistent_script *persistent_script = zend_accel_hash_str_find(&ZCSG(hash), key, key_length);
key               571 ext/opcache/zend_accelerator_module.c 			zend_hash_str_update(Z_ARRVAL_P(return_value), cache_entry->key, cache_entry->key_length, &persistent_script_report);
key               131 ext/opcache/zend_accelerator_util_funcs.c 			_zend_hash_append_ptr(dst, p->key, function);
key               265 ext/opcache/zend_accelerator_util_funcs.c 		q->key = p->key;
key               311 ext/opcache/zend_accelerator_util_funcs.c 		ZEND_ASSERT(p->key != NULL);
key               312 ext/opcache/zend_accelerator_util_funcs.c 		q->key = p->key;
key               369 ext/opcache/zend_accelerator_util_funcs.c 		ZEND_ASSERT(p->key != NULL);
key               370 ext/opcache/zend_accelerator_util_funcs.c 		q->key = p->key;
key               534 ext/opcache/zend_accelerator_util_funcs.c 		ZEND_ASSERT(p->key);
key               535 ext/opcache/zend_accelerator_util_funcs.c 		t = zend_hash_find(target, p->key);
key               537 ext/opcache/zend_accelerator_util_funcs.c 			if (EXPECTED(ZSTR_LEN(p->key) > 0) && EXPECTED(ZSTR_VAL(p->key)[0] == 0)) {
key               539 ext/opcache/zend_accelerator_util_funcs.c 				t = zend_hash_update(target, p->key, &p->val);
key               544 ext/opcache/zend_accelerator_util_funcs.c 			_zend_hash_append_ptr(target, p->key, Z_PTR(p->val));
key               578 ext/opcache/zend_accelerator_util_funcs.c 		ZEND_ASSERT(p->key);
key               579 ext/opcache/zend_accelerator_util_funcs.c 		t = zend_hash_find(target, p->key);
key               581 ext/opcache/zend_accelerator_util_funcs.c 			if (EXPECTED(ZSTR_LEN(p->key) > 0) && EXPECTED(ZSTR_VAL(p->key)[0] == 0)) {
key               583 ext/opcache/zend_accelerator_util_funcs.c 				zend_hash_update_ptr(target, p->key, ARENA_REALLOC(Z_PTR(p->val)));
key               588 ext/opcache/zend_accelerator_util_funcs.c 			_zend_hash_append_ptr(target, p->key, ARENA_REALLOC(Z_PTR(p->val)));
key               622 ext/opcache/zend_accelerator_util_funcs.c 		ZEND_ASSERT(p->key);
key               623 ext/opcache/zend_accelerator_util_funcs.c 		t = zend_hash_find(target, p->key);
key               625 ext/opcache/zend_accelerator_util_funcs.c 			if (EXPECTED(ZSTR_LEN(p->key) > 0) && EXPECTED(ZSTR_VAL(p->key)[0] == 0)) {
key               632 ext/opcache/zend_accelerator_util_funcs.c 			t = _zend_hash_append_ptr(target, p->key, Z_PTR(p->val));
key               262 ext/opcache/zend_file_cache.c 			SERIALIZE_STR(p->key);
key               828 ext/opcache/zend_file_cache.c 			UNSERIALIZE_STR(p->key);
key               120 ext/opcache/zend_persist.c 			if (p->key) {
key               121 ext/opcache/zend_persist.c 				zend_accel_store_interned_string(p->key);
key               148 ext/opcache/zend_persist.c 		if (p->key) {
key               149 ext/opcache/zend_persist.c 			zend_accel_store_interned_string(p->key);
key               202 ext/opcache/zend_persist.c 			if (p->key) {
key               203 ext/opcache/zend_persist.c 				zend_accel_memdup_interned_string(p->key);
key               227 ext/opcache/zend_persist.c 		if (p->key) {
key               228 ext/opcache/zend_persist.c 			zend_accel_memdup_interned_string(p->key);
key               898 ext/opcache/zend_persist.c zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, char **key, unsigned int key_length)
key               906 ext/opcache/zend_persist.c 	if (key && *key) {
key               907 ext/opcache/zend_persist.c 		*key = zend_accel_memdup(*key, key_length + 1);
key                26 ext/opcache/zend_persist.h uint zend_accel_script_persist_calc(zend_persistent_script *script, char *key, unsigned int key_length);
key                27 ext/opcache/zend_persist.h zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, char **key, unsigned int key_length);
key                85 ext/opcache/zend_persist_calc.c 		if (p->key) {
key                86 ext/opcache/zend_persist_calc.c 			zend_uchar flags = GC_FLAGS(p->key) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
key                87 ext/opcache/zend_persist_calc.c 			ADD_INTERNED_STRING(p->key, 1);
key                88 ext/opcache/zend_persist_calc.c 			GC_FLAGS(p->key) |= flags;
key               384 ext/opcache/zend_persist_calc.c uint zend_accel_script_persist_calc(zend_persistent_script *new_persistent_script, char *key, unsigned int key_length)
key               394 ext/opcache/zend_persist_calc.c 	if (key) {
key               395 ext/opcache/zend_persist_calc.c 		ADD_DUP_SIZE(key, key_length + 1);
key               149 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               235 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               242 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               253 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               257 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               262 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               313 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               320 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               327 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               334 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               344 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               351 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               652 ext/openssl/openssl.c static void add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int shortname) /* {{{ */
key               663 ext/openssl/openssl.c 	if (key != NULL) {
key               707 ext/openssl/openssl.c 	if (key != NULL) {
key               708 ext/openssl/openssl.c 		zend_hash_str_update(Z_ARRVAL_P(val), key, strlen(key), &subitem);
key               713 ext/openssl/openssl.c static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */
key               715 ext/openssl/openssl.c 	add_assoc_stringl(val, key, (char *)str->data, str->length);
key               866 ext/openssl/openssl.c #define SET_OPTIONAL_STRING_ARG(key, varname, defval)	\
key               867 ext/openssl/openssl.c 		if (optional_args && (item = zend_hash_str_find(Z_ARRVAL_P(optional_args), key, sizeof(key)-1)) != NULL && Z_TYPE_P(item) == IS_STRING) \
key               872 ext/openssl/openssl.c #define SET_OPTIONAL_LONG_ARG(key, varname, defval)	\
key               873 ext/openssl/openssl.c 	if (optional_args && (item = zend_hash_str_find(Z_ARRVAL_P(optional_args), key, sizeof(key)-1)) != NULL && Z_TYPE_P(item) == IS_LONG) \
key              1878 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              1890 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zkey, 0, "", 1, &keyresource);
key              1891 ext/openssl/openssl.c 	if (key) {
key              1892 ext/openssl/openssl.c 		RETVAL_BOOL(X509_check_private_key(cert, key));
key              1895 ext/openssl/openssl.c 	if (keyresource == NULL && key) {
key              1896 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              2951 ext/openssl/openssl.c 	EVP_PKEY * key = NULL, *priv_key = NULL;
key              2988 ext/openssl/openssl.c 	key = X509_REQ_get_pubkey(csr);
key              2989 ext/openssl/openssl.c 	if (key == NULL) {
key              2993 ext/openssl/openssl.c 	i = X509_REQ_verify(csr, key);
key              3028 ext/openssl/openssl.c 	i = X509_set_pubkey(new_cert, key);
key              3062 ext/openssl/openssl.c 	if (key) {
key              3063 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3231 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              3344 ext/openssl/openssl.c 				key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key              3363 ext/openssl/openssl.c 			key = PEM_read_bio_PrivateKey(in, NULL,NULL, passphrase);
key              3368 ext/openssl/openssl.c 	if (public_key && cert && key == NULL) {
key              3370 ext/openssl/openssl.c 		key = (EVP_PKEY *) X509_get_pubkey(cert);
key              3376 ext/openssl/openssl.c 	if (key && makeresource && resourceval) {
key              3377 ext/openssl/openssl.c 		*resourceval = zend_register_resource(key, le_key);
key              3382 ext/openssl/openssl.c 	return key;
key              3681 ext/openssl/openssl.c 	EVP_PKEY * key;
key              3692 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource);
key              3694 ext/openssl/openssl.c 	if (key == NULL) {
key              3718 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
key              3721 ext/openssl/openssl.c 				pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, (int)passphrase_len, NULL, NULL);
key              3725 ext/openssl/openssl.c 				pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, (int)passphrase_len, NULL, NULL);
key              3737 ext/openssl/openssl.c 	if (key_resource == NULL && key) {
key              3738 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3755 ext/openssl/openssl.c 	EVP_PKEY * key;
key              3766 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource);
key              3768 ext/openssl/openssl.c 	if (key == NULL) {
key              3788 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
key              3791 ext/openssl/openssl.c 				pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, (int)passphrase_len, NULL, NULL);
key              3795 ext/openssl/openssl.c 				pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, (int)passphrase_len, NULL, NULL);
key              3814 ext/openssl/openssl.c 	if (key_resource == NULL && key) {
key              3815 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3847 ext/openssl/openssl.c 	zval *key;
key              3850 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &key) == FAILURE) {
key              3853 ext/openssl/openssl.c 	if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
key              3856 ext/openssl/openssl.c 	zend_list_close(Z_RES_P(key));
key              3888 ext/openssl/openssl.c 	zval *key;
key              3895 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &key) == FAILURE) {
key              3898 ext/openssl/openssl.c 	if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
key              4056 ext/openssl/openssl.c 	PHP_OPENSSL_CHECK_LONG_TO_INT(key_length, key);
key              4430 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              4452 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &keyresval);
key              4453 ext/openssl/openssl.c 	if (key == NULL) {
key              4476 ext/openssl/openssl.c 	if (PKCS7_decrypt(p7, key, cert, out, PKCS7_DETACHED)) {
key              4487 ext/openssl/openssl.c 	if (key && keyresval == NULL) {
key              4488 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              4499 ext/openssl/openssl.c 	zval *key, *crypted;
key              4509 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key              4514 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource);
key              4559 ext/openssl/openssl.c 	zval *key, *crypted;
key              4570 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key              4575 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource);
key              4627 ext/openssl/openssl.c 	zval *key, *crypted;
key              4637 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
key              4641 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource);
key              4686 ext/openssl/openssl.c 	zval *key, *crypted;
key              4697 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key              4702 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource);
key              4776 ext/openssl/openssl.c 	zval *key, *signature;
key              4788 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
key              4791 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource);
key              4839 ext/openssl/openssl.c 	zval *key;
key              4852 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssz|z", &data, &data_len, &signature, &signature_len, &key, &method) == FAILURE) {
key              4874 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource);
key              5242 ext/openssl/openssl.c 	unsigned char *key;
key              5258 ext/openssl/openssl.c 		key = emalloc(keylen);
key              5259 ext/openssl/openssl.c 		memset(key, 0, keylen);
key              5260 ext/openssl/openssl.c 		memcpy(key, password, password_len);
key              5262 ext/openssl/openssl.c 		key = (unsigned char*)password;
key              5279 ext/openssl/openssl.c 	EVP_EncryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key              5304 ext/openssl/openssl.c 	if (key != (unsigned char*)password) {
key              5305 ext/openssl/openssl.c 		efree(key);
key              5325 ext/openssl/openssl.c 	unsigned char *key;
key              5358 ext/openssl/openssl.c 		key = emalloc(keylen);
key              5359 ext/openssl/openssl.c 		memset(key, 0, keylen);
key              5360 ext/openssl/openssl.c 		memcpy(key, password, password_len);
key              5362 ext/openssl/openssl.c 		key = (unsigned char*)password;
key              5375 ext/openssl/openssl.c 	EVP_DecryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key              5390 ext/openssl/openssl.c 	if (key != (unsigned char*)password) {
key              5391 ext/openssl/openssl.c 		efree(key);
key              5434 ext/openssl/openssl.c 	zval *key;
key              5442 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sr", &pub_str, &pub_len, &key) == FAILURE) {
key              5445 ext/openssl/openssl.c 	if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
key               341 ext/openssl/xp_ssl.c 		zend_string *key;
key               348 ext/openssl/xp_ssl.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(val), key, current) {
key               349 ext/openssl/xp_ssl.c 			if (key == NULL || Z_TYPE_P(current) != IS_STRING) {
key               353 ext/openssl/xp_ssl.c 			if (php_x509_fingerprint_cmp(peer, ZSTR_VAL(key), Z_STRVAL_P(current)) != 0) {
key               933 ext/openssl/xp_ssl.c 				EVP_PKEY *key = NULL;
key               938 ext/openssl/xp_ssl.c 					key = X509_get_pubkey(cert);
key               939 ext/openssl/xp_ssl.c 					EVP_PKEY_copy_parameters(key, SSL_get_privatekey(tmpssl));
key               940 ext/openssl/xp_ssl.c 					EVP_PKEY_free(key);
key              1325 ext/openssl/xp_ssl.c 	zend_string *key;
key              1360 ext/openssl/xp_ssl.c 	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(val), key_index, key, current) {
key              1363 ext/openssl/xp_ssl.c 		if (!key) {
key              1392 ext/openssl/xp_ssl.c 				sslsock->sni_certs[i].name = pestrdup(ZSTR_VAL(key), php_stream_is_persistent(stream));
key               863 ext/pcntl/pcntl.c 	zend_string *key;
key               900 ext/pcntl/pcntl.c 		ZEND_HASH_FOREACH_KEY_VAL(envs_hash, key_num, key, element) {
key               902 ext/pcntl/pcntl.c 			if (!key) {
key               903 ext/pcntl/pcntl.c 				key = zend_long_to_str(key_num);
key               905 ext/pcntl/pcntl.c 				zend_string_addref(key);
key               911 ext/pcntl/pcntl.c 			pair_length = Z_STRLEN_P(element) + ZSTR_LEN(key) + 2;
key               913 ext/pcntl/pcntl.c 			strlcpy(*pair, ZSTR_VAL(key), ZSTR_LEN(key) + 1);
key               918 ext/pcntl/pcntl.c 			zend_string_release(key);
key              10049 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c   struct tilegx_spr key;
key              10051 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c   key.number = num;
key              10052 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c   result = bsearch((const void *) &key, (const void *) tilegx_sprs,
key              1344 ext/pdo/pdo_dbh.c static union _zend_function *dbh_method_get(zend_object **object, zend_string *method_name, const zval *key)
key              1353 ext/pdo/pdo_dbh.c 	if ((fbc = std_object_handlers.get_method(object, method_name, key)) == NULL) {
key               450 ext/pdo/pdo_stmt.c 		zend_string *key = NULL;
key               459 ext/pdo/pdo_stmt.c 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input_params), num_index, key, tmp) {
key               462 ext/pdo/pdo_stmt.c 			if (key) {
key               464 ext/pdo/pdo_stmt.c 				param.name = key;
key              2119 ext/pdo/pdo_stmt.c 		zend_string *key = NULL;
key              2120 ext/pdo/pdo_stmt.c 		ZEND_HASH_FOREACH_KEY_PTR(stmt->bound_params, num, key, param) {
key              2121 ext/pdo/pdo_stmt.c 			if (key) {
key              2123 ext/pdo/pdo_stmt.c 					ZSTR_LEN(key), (int) ZSTR_LEN(key), ZSTR_VAL(key));
key              2209 ext/pdo/pdo_stmt.c static union _zend_function *dbstmt_method_get(zend_object **object_pp, zend_string *method_name, const zval *key)
key              2373 ext/pdo/pdo_stmt.c 	zend_ulong key;
key              2407 ext/pdo/pdo_stmt.c static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key)
key              2411 ext/pdo/pdo_stmt.c 	if (I->key == (ulong)-1) {
key              2412 ext/pdo/pdo_stmt.c 		ZVAL_NULL(key);
key              2414 ext/pdo/pdo_stmt.c 		ZVAL_LONG(key, I->key);
key              2431 ext/pdo/pdo_stmt.c 		I->key = (ulong)-1;
key              2437 ext/pdo/pdo_stmt.c 	I->key++;
key              2466 ext/pdo/pdo_stmt.c 		I->key = (ulong)-1;
key              2608 ext/pdo/pdo_stmt.c 	zend_string *method_name, const zval *key)
key               368 ext/pdo_dblib/dblib_driver.c 			if(strcmp(vars[5].optval,tdsver[i].key) == 0) {
key               124 ext/pdo_dblib/php_pdo_dblib_int.h 	const char* key;
key               163 ext/phar/dirstream.c 	result = zend_binary_strcmp(ZSTR_VAL(f->key), ZSTR_LEN(f->key), ZSTR_VAL(s->key), ZSTR_LEN(s->key));
key               103 ext/phar/phar.c 	char *key, *lasts, *end;
key               132 ext/phar/phar.c 	for (key = php_strtok_r(tmp, ds, &lasts);
key               133 ext/phar/phar.c 			key;
key               134 ext/phar/phar.c 			key = php_strtok_r(NULL, ds, &lasts)) {
key               135 ext/phar/phar.c 		end = strchr(key, DEFAULT_DIR_SEPARATOR);
key               138 ext/phar/phar.c 			if (SUCCESS == phar_open_from_filename(key, end - key, NULL, 0, 0, &phar, NULL)) {
key               161 ext/phar/phar.c 			if (SUCCESS == phar_open_from_filename(key, strlen(key), NULL, 0, 0, &phar, NULL)) {
key              1440 ext/phar/phar_object.c 				zval key;
key              1441 ext/phar/phar_object.c 				iter->funcs->get_current_key(iter, &key);
key              1447 ext/phar/phar_object.c 				if (Z_TYPE(key) != IS_STRING) {
key              1448 ext/phar/phar_object.c 					zval_dtor(&key);
key              1453 ext/phar/phar_object.c 				str_key_len = Z_STRLEN(key);
key              1454 ext/phar/phar_object.c 				str_key = estrndup(Z_STRVAL(key), str_key_len);
key              1457 ext/phar/phar_object.c 				zval_dtor(&key);
key              1568 ext/phar/phar_object.c 			zval key;
key              1569 ext/phar/phar_object.c 			iter->funcs->get_current_key(iter, &key);
key              1575 ext/phar/phar_object.c 			if (Z_TYPE(key) != IS_STRING) {
key              1576 ext/phar/phar_object.c 				zval_dtor(&key);
key              1581 ext/phar/phar_object.c 			str_key_len = Z_STRLEN(key);
key              1582 ext/phar/phar_object.c 			str_key = estrndup(Z_STRVAL(key), str_key_len);
key              1585 ext/phar/phar_object.c 			zval_dtor(&key);
key              2992 ext/phar/phar_object.c 	char *error, *key = NULL;
key              3003 ext/phar/phar_object.c 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "l|s", &algo, &key, &key_len) != SUCCESS) {
key              3024 ext/phar/phar_object.c 			PHAR_G(openssl_privatekey) = key;
key               906 ext/phar/stream.c 			str_key = b->key;
key               927 ext/phar/stream.c 				b->key = new_str_key;
key               933 ext/phar/stream.c 			str_key = b->key;
key               945 ext/phar/stream.c 				b->key = new_str_key;
key               951 ext/phar/stream.c 			str_key = b->key;
key               963 ext/phar/stream.c 				b->key = new_str_key;
key                41 ext/phar/util.c static int phar_call_openssl_signverify(int is_sign, php_stream *fp, zend_off_t end, char *key, int key_len, char **signature, int *signature_len);
key              1395 ext/phar/util.c static int phar_call_openssl_signverify(int is_sign, php_stream *fp, zend_off_t end, char *key, int key_len, char **signature, int *signature_len) /* {{{ */
key              1404 ext/phar/util.c 	ZVAL_STRINGL(&zp[2], key, key_len);
key              1495 ext/phar/util.c 			EVP_PKEY *key;
key              1559 ext/phar/util.c 			key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key              1563 ext/phar/util.c 			if (NULL == key) {
key              1590 ext/phar/util.c 			if (EVP_VerifyFinal(&md_ctx, (unsigned char *)sig, sig_len, key) != 1) {
key              1816 ext/phar/util.c 			EVP_PKEY *key;
key              1828 ext/phar/util.c 			key = PEM_read_bio_PrivateKey(in, NULL,NULL, "");
key              1831 ext/phar/util.c 			if (!key) {
key              1840 ext/phar/util.c 			siglen = EVP_PKEY_size(key);
key              1861 ext/phar/util.c 			if (!EVP_SignFinal (md_ctx, sigbuf,(unsigned int *)&siglen, key)) {
key               452 ext/reflection/php_reflection.c 		zend_string *key;
key               455 ext/reflection/php_reflection.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(&ce->constants_table, key, value) {
key               457 ext/reflection/php_reflection.c 			_const_string(str, ZSTR_VAL(key), value, indent);
key               566 ext/reflection/php_reflection.c 		zend_string *key;
key               572 ext/reflection/php_reflection.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, key, mptr) {
key               581 ext/reflection/php_reflection.c 					|| !key
key               582 ext/reflection/php_reflection.c 					|| zend_binary_strcasecmp(ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(mptr->common.function_name), len) == 0)
key               757 ext/reflection/php_reflection.c 	zend_string *key;
key               774 ext/reflection/php_reflection.c 	ZEND_HASH_FOREACH_STR_KEY(static_variables, key) {
key               775 ext/reflection/php_reflection.c 		string_printf(str, "%s    Variable #%d [ $%s ]\n", indent, i++, ZSTR_VAL(key));
key               993 ext/reflection/php_reflection.c 		if (!zend_binary_strcasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key))) {
key              3724 ext/reflection/php_reflection.c 	zend_string *key;
key              3726 ext/reflection/php_reflection.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) {
key              3757 ext/reflection/php_reflection.c 		zend_hash_update(Z_ARRVAL_P(return_value), key, &prop_copy);
key              4316 ext/reflection/php_reflection.c 	if (hash_key->key == NULL) {
key              4320 ext/reflection/php_reflection.c 	if (ZSTR_VAL(hash_key->key)[0] == '\0') {
key              4324 ext/reflection/php_reflection.c 	if (zend_get_property_info(ce, hash_key->key, 1) == NULL) {
key              4329 ext/reflection/php_reflection.c 		property_info.name = hash_key->key;
key              5728 ext/reflection/php_reflection.c 		if (zend_binary_strcasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key))) {
key              5730 ext/reflection/php_reflection.c 			name = hash_key->key;
key               109 ext/session/mod_files.c static char *ps_files_path_create(char *buf, size_t buflen, ps_files *data, const char *key)
key               116 ext/session/mod_files.c 	key_len = strlen(key);
key               122 ext/session/mod_files.c 	p = key;
key               132 ext/session/mod_files.c 	memcpy(buf + n, key, key_len);
key               156 ext/session/mod_files.c static void ps_files_open(ps_files *data, const char *key)
key               164 ext/session/mod_files.c 	if (data->fd < 0 || !data->lastkey || strcmp(key, data->lastkey)) {
key               172 ext/session/mod_files.c 		if (php_session_valid_key(key) == FAILURE) {
key               177 ext/session/mod_files.c 		if (!ps_files_path_create(buf, sizeof(buf), data, key)) {
key               181 ext/session/mod_files.c 		data->lastkey = estrdup(key);
key               223 ext/session/mod_files.c static int ps_files_write(ps_files *data, zend_string *key, zend_string *val)
key               230 ext/session/mod_files.c 	ps_files_open(data, ZSTR_VAL(key));
key               329 ext/session/mod_files.c static int ps_files_key_exists(ps_files *data, const char *key)
key               334 ext/session/mod_files.c 	if (!key || !ps_files_path_create(buf, sizeof(buf), data, key)) {
key               468 ext/session/mod_files.c 	ps_files_open(data, ZSTR_VAL(key));
key               539 ext/session/mod_files.c 	return ps_files_write(data, key, val);
key               565 ext/session/mod_files.c 	if (!ps_files_path_create(buf, sizeof(buf), data, ZSTR_VAL(key))) {
key               578 ext/session/mod_files.c 		return ps_files_write(data, key, val);
key               600 ext/session/mod_files.c 	if (!ps_files_path_create(buf, sizeof(buf), data, ZSTR_VAL(key))) {
key               705 ext/session/mod_files.c 	return ps_files_key_exists(data, ZSTR_VAL(key));
key                54 ext/session/mod_mm.c 	char key[1];		/* inline key */
key               115 ext/session/mod_mm.c static ps_sd *ps_sd_new(ps_mm *data, const char *key)
key               121 ext/session/mod_mm.c 	keylen = strlen(key);
key               130 ext/session/mod_mm.c 	hv = ps_sd_hash(key, keylen);
key               138 ext/session/mod_mm.c 	memcpy(sd->key, key, keylen + 1);
key               151 ext/session/mod_mm.c 	ps_mm_debug(("inserting %s(%p) into slot %d\n", key, sd, slot));
key               160 ext/session/mod_mm.c 	slot = ps_sd_hash(sd->key, strlen(sd->key)) & data->hash_max;
key               181 ext/session/mod_mm.c static ps_sd *ps_sd_lookup(ps_mm *data, const char *key, int rw)
key               186 ext/session/mod_mm.c 	hv = ps_sd_hash(key, strlen(key));
key               190 ext/session/mod_mm.c 		if (ret->hv == hv && !strcmp(ret->key, key)) {
key               205 ext/session/mod_mm.c 	ps_mm_debug(("lookup(%s): ret=%p,hv=%u,slot=%d\n", key, ret, hv, slot));
key               210 ext/session/mod_mm.c static int ps_mm_key_exists(ps_mm *data, const char *key)
key               214 ext/session/mod_mm.c 	if (!key) {
key               217 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key, 0);
key               359 ext/session/mod_mm.c 		&& ps_mm_key_exists(data, key->val) == FAILURE) {
key               361 ext/session/mod_mm.c 		if (key) {
key               394 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key->val, 1);
key               396 ext/session/mod_mm.c 		sd = ps_sd_new(data, key->val);
key               397 ext/session/mod_mm.c 		ps_mm_debug(("new entry for %s\n", key->val));
key               433 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key->val, 0);
key               464 ext/session/mod_mm.c 				ps_mm_debug(("purging %s\n", sd->key));
key               127 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[0], key);
key               147 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[0], key);
key               160 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[0], key);
key               217 ext/session/mod_user.c 		ZVAL_STR_COPY(&args[0], key);
key               225 ext/session/mod_user.c 	return php_session_validate_sid(mod_data, key);
key               233 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[0], key);
key                75 ext/session/mod_user_class.c 	zend_string *key;
key                79 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key                83 ext/session/mod_user_class.c 	if (PS(default_mod)->s_read(&PS(mod_data), key, &val, PS(gc_maxlifetime)) == FAILURE) {
key                95 ext/session/mod_user_class.c 	zend_string *key, *val;
key                99 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &key, &val) == FAILURE) {
key               103 ext/session/mod_user_class.c 	RETURN_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, PS(gc_maxlifetime)));
key               111 ext/session/mod_user_class.c 	zend_string *key;
key               115 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key               119 ext/session/mod_user_class.c 	RETURN_BOOL(SUCCESS == PS(default_mod)->s_destroy(&PS(mod_data), key));
key               162 ext/session/mod_user_class.c 	zend_string *key;
key               166 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key               179 ext/session/mod_user_class.c 	zend_string *key, *val;
key               183 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &key, &val) == FAILURE) {
key               188 ext/session/mod_user_class.c 	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, PS(gc_maxlifetime)));
key                39 ext/session/php_session.h #define PS_READ_ARGS     void **mod_data, zend_string *key, zend_string **val, zend_long maxlifetime
key                40 ext/session/php_session.h #define PS_WRITE_ARGS    void **mod_data, zend_string *key, zend_string *val, zend_long maxlifetime
key                41 ext/session/php_session.h #define PS_DESTROY_ARGS  void **mod_data, zend_string *key
key                44 ext/session/php_session.h #define PS_VALIDATE_SID_ARGS void **mod_data, zend_string *key
key                45 ext/session/php_session.h #define PS_UPDATE_TIMESTAMP_ARGS void **mod_data, zend_string *key, zend_string *val, zend_long maxlifetime
key               133 ext/session/php_session.h 	smart_str key;
key               277 ext/session/php_session.h PHPAPI int php_session_valid_key(const char *key);
key               294 ext/session/php_session.h 	zend_string *key;												\
key               300 ext/session/php_session.h 	ZEND_HASH_FOREACH_KEY(_ht, num_key, key) {						\
key               301 ext/session/php_session.h 		if (key == NULL) {											\
key               306 ext/session/php_session.h 		if ((struc = php_get_session_var(key))) {			\
key               449 ext/session/session.c PHPAPI int php_session_valid_key(const char *key) /* {{{ */
key               456 ext/session/session.c 	for (p = key; (c = *p); p++) {
key               468 ext/session/session.c 	len = p - key;
key               926 ext/session/session.c 			if (ZSTR_LEN(key) > PS_BIN_MAX) continue;
key               927 ext/session/session.c 			smart_str_appendc(&buf, (unsigned char)ZSTR_LEN(key));
key               928 ext/session/session.c 			smart_str_appendl(&buf, ZSTR_VAL(key), ZSTR_LEN(key));
key               931 ext/session/session.c 			if (ZSTR_LEN(key) > PS_BIN_MAX) continue;
key               932 ext/session/session.c 			smart_str_appendc(&buf, (unsigned char) (ZSTR_LEN(key) & PS_BIN_UNDEF));
key               933 ext/session/session.c 			smart_str_appendl(&buf, ZSTR_VAL(key), ZSTR_LEN(key));
key              1010 ext/session/session.c 			smart_str_appendl(&buf, ZSTR_VAL(key), ZSTR_LEN(key));
key              1011 ext/session/session.c 			if (memchr(ZSTR_VAL(key), PS_DELIMITER, ZSTR_LEN(key)) || memchr(ZSTR_VAL(key), PS_UNDEF_MARKER, ZSTR_LEN(key))) {
key              1021 ext/session/session.c 			smart_str_appendl(&buf, ZSTR_VAL(key), ZSTR_LEN(key));
key              2491 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2495 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2500 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2511 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2515 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2849 ext/session/session.c 	if ((progress_ary = zend_symtable_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s)) == NULL) {
key              2887 ext/session/session.c 		zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s, &progress->data);
key              2897 ext/session/session.c 		zend_hash_del(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s);
key              2929 ext/session/session.c 			if (Z_TYPE(progress->sid) && progress->key.s) {
key              2947 ext/session/session.c 					smart_str_free(&progress->key);
key              2948 ext/session/session.c 					smart_str_appends(&progress->key, PS(rfc1867_prefix));
key              2949 ext/session/session.c 					smart_str_appendl(&progress->key, *data->value, value_len);
key              2950 ext/session/session.c 					smart_str_0(&progress->key);
key              2963 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.s) {
key              3022 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.s) {
key              3035 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.s) {
key              3054 ext/session/session.c 			if (Z_TYPE(progress->sid) && progress->key.s) {
key              3069 ext/session/session.c 			smart_str_free(&progress->key);
key                47 ext/shmop/php_shmop.h 	key_t key;
key                50 ext/shmop/shmop.c 	ZEND_ARG_INFO(0, key)
key               149 ext/shmop/shmop.c 	zend_long key, mode, size;
key               155 ext/shmop/shmop.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) {
key               167 ext/shmop/shmop.c 	shmop->key = key;
key               199 ext/shmop/shmop.c 	shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg);
key                61 ext/simplexml/simplexml.c static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key);
key              1007 ext/simplexml/simplexml.c 	zend_string *key;
key              1011 ext/simplexml/simplexml.c 	key = zend_string_init(name, namelen, 0);
key              1012 ext/simplexml/simplexml.c 	if ((data_ptr = zend_hash_find(rv, key)) != NULL) {
key              1022 ext/simplexml/simplexml.c 		zend_hash_add_new(rv, key, value);
key              1024 ext/simplexml/simplexml.c 	zend_string_release(key);
key              1497 ext/simplexml/simplexml.c 	zend_string *key = zend_string_init(prefix, strlen(prefix), 0);
key              1500 ext/simplexml/simplexml.c 	if (!zend_hash_exists(Z_ARRVAL_P(return_value), key)) {
key              1502 ext/simplexml/simplexml.c 		zend_hash_add_new(Z_ARRVAL_P(return_value), key, &zv);
key              1504 ext/simplexml/simplexml.c 	zend_string_release(key);
key              2465 ext/simplexml/simplexml.c static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key              2477 ext/simplexml/simplexml.c 		ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
key              2479 ext/simplexml/simplexml.c 		ZVAL_NULL(key);
key                92 ext/simplexml/sxe.c PHP_METHOD(ce_SimpleXMLIterator, key)
key               188 ext/simplexml/sxe.c 	PHP_ME(ce_SimpleXMLIterator, key,                    arginfo_simplexmliterator__void, ZEND_ACC_PUBLIC)
key              2082 ext/snmp/snmp.c 	zend_string *key;
key              2088 ext/snmp/snmp.c 	ZEND_HASH_FOREACH_KEY_PTR(&php_snmp_properties, num_key, key, hnd) {
key              2092 ext/snmp/snmp.c 		zend_hash_update(props, key, &rv);
key              2192 ext/soap/php_encoding.c 	    ht->arData[ht->nNumUsed-1].key == NULL) {
key              2259 ext/soap/php_encoding.c 				zval key;
key              2260 ext/soap/php_encoding.c 				iter->funcs->get_current_key(iter, &key);
key              2264 ext/soap/php_encoding.c 				array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
key              2266 ext/soap/php_encoding.c 				zval_dtor(&key);
key              2678 ext/soap/php_encoding.c 	xmlNodePtr key;
key              2689 ext/soap/php_encoding.c 			key = xmlNewNode(NULL, BAD_CAST("key"));
key              2690 ext/soap/php_encoding.c 			xmlAddChild(item,key);
key              2693 ext/soap/php_encoding.c 					set_xsi_type(key, "xsd:string");
key              2695 ext/soap/php_encoding.c 				xmlNodeSetContent(key, BAD_CAST(ZSTR_VAL(key_val)));
key              2702 ext/soap/php_encoding.c 					set_xsi_type(key, "xsd:int");
key              2704 ext/soap/php_encoding.c 				xmlNodeSetContentLen(key, BAD_CAST(ZSTR_VAL(tmp.s)), ZSTR_LEN(tmp.s));
key              2722 ext/soap/php_encoding.c 	zval key, value;
key              2744 ext/soap/php_encoding.c 			ZVAL_NULL(&key);
key              2745 ext/soap/php_encoding.c 			master_to_zval(&key, NULL, xmlKey);
key              2749 ext/soap/php_encoding.c 			if (Z_TYPE(key) == IS_STRING) {
key              2750 ext/soap/php_encoding.c 				zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
key              2751 ext/soap/php_encoding.c 			} else if (Z_TYPE(key) == IS_LONG) {
key              2752 ext/soap/php_encoding.c 				zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value);
key              2756 ext/soap/php_encoding.c 			zval_ptr_dtor(&key);
key              3485 ext/soap/php_encoding.c 	zend_string *key;
key              3488 ext/soap/php_encoding.c 	ZEND_HASH_FOREACH_KEY(Z_ARRVAL_P(array), index, key) {
key              3489 ext/soap/php_encoding.c 		if (key || index != i) {
key               806 ext/soap/php_http.c 			zend_string *key;
key               816 ext/soap/php_http.c 					int res = zend_hash_get_current_key(Z_ARRVAL_P(cookies), &key, &numindx);
key               832 ext/soap/php_http.c 								smart_str_append(&soap_headers, key);
key               401 ext/soap/php_packet_soap.c 					smart_str key = {0};
key               405 ext/soap/php_packet_soap.c 						smart_str_appends(&key, (char*)trav->ns->href);
key               406 ext/soap/php_packet_soap.c 						smart_str_appendc(&key,':');
key               408 ext/soap/php_packet_soap.c 					smart_str_appends(&key, (char*)trav->name);
key               409 ext/soap/php_packet_soap.c 					smart_str_0(&key);
key               410 ext/soap/php_packet_soap.c 					if ((hdr = zend_hash_find_ptr(hdrs, key.s)) != NULL) {
key               413 ext/soap/php_packet_soap.c 					smart_str_free(&key);
key              1076 ext/soap/php_schema.c 		smart_str key = {0};
key              1085 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              1092 ext/soap/php_schema.c 					smart_str_appends(&key, (char*)ns->children->content);
key              1095 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1096 ext/soap/php_schema.c 			smart_str_appends(&key, type);
key              1097 ext/soap/php_schema.c 			smart_str_0(&key);
key              1101 ext/soap/php_schema.c 			newModel->u.group_ref = estrndup(ZSTR_VAL(key.s), ZSTR_LEN(key.s));
key              1111 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)ns->children->content);
key              1112 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1113 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)name->children->content);
key              1114 ext/soap/php_schema.c 			smart_str_0(&key);
key              1127 ext/soap/php_schema.c 			if (zend_hash_add_ptr(sdl->groups, key.s, newType) == NULL) {
key              1128 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", ZSTR_VAL(key.s));
key              1133 ext/soap/php_schema.c 		smart_str_free(&key);
key              1507 ext/soap/php_schema.c 		smart_str key = {0};
key              1552 ext/soap/php_schema.c 			smart_str_appends(&key, newType->namens);
key              1553 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1554 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1561 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1564 ext/soap/php_schema.c 		smart_str_0(&key);
key              1565 ext/soap/php_schema.c 		if (zend_hash_add_ptr(addHash, key.s, newType) == NULL) {
key              1567 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", ZSTR_VAL(key.s));
key              1572 ext/soap/php_schema.c 		smart_str_free(&key);
key              1742 ext/soap/php_schema.c 		smart_str key = {0};
key              1754 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              1762 ext/soap/php_schema.c 					smart_str_appends(&key, (char*)ns->children->content);
key              1765 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1766 ext/soap/php_schema.c 			smart_str_appends(&key, attr_name);
key              1767 ext/soap/php_schema.c 			smart_str_0(&key);
key              1768 ext/soap/php_schema.c 			newAttr->ref = estrndup(ZSTR_VAL(key.s), ZSTR_LEN(key.s));
key              1779 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)ns->children->content);
key              1780 ext/soap/php_schema.c 				smart_str_appendc(&key, ':');
key              1783 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)name->children->content);
key              1784 ext/soap/php_schema.c 			smart_str_0(&key);
key              1797 ext/soap/php_schema.c 		if (zend_hash_add_ptr(addHash, key.s, newAttr) == NULL) {
key              1798 ext/soap/php_schema.c 			soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", ZSTR_VAL(key.s));
key              1800 ext/soap/php_schema.c 		smart_str_free(&key);
key              1965 ext/soap/php_schema.c 			smart_str key = {0};
key              1976 ext/soap/php_schema.c 			smart_str_appends(&key, newType->namens);
key              1977 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1978 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1979 ext/soap/php_schema.c 			smart_str_0(&key);
key              1981 ext/soap/php_schema.c 			if (zend_hash_add_ptr(ctx->attributeGroups, key.s, newType) == NULL) {
key              1982 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", ZSTR_VAL(key.s));
key              1985 ext/soap/php_schema.c 			smart_str_free(&key);
key              1989 ext/soap/php_schema.c 			smart_str key = {0};
key              2002 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              2004 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              2005 ext/soap/php_schema.c 			smart_str_appends(&key, group_name);
key              2006 ext/soap/php_schema.c 			smart_str_0(&key);
key              2007 ext/soap/php_schema.c 			newAttr->ref = estrndup(ZSTR_VAL(key.s), ZSTR_LEN(key.s));
key              2010 ext/soap/php_schema.c 			smart_str_free(&key);
key               199 ext/soap/php_sdl.c 	smart_str key = {0};
key               201 ext/soap/php_sdl.c 	smart_str_appends(&key, ns);
key               202 ext/soap/php_sdl.c 	smart_str_appendc(&key, ':');
key               203 ext/soap/php_sdl.c 	smart_str_appends(&key, name);
key               204 ext/soap/php_sdl.c 	smart_str_0(&key);
key               206 ext/soap/php_sdl.c 	binding = zend_hash_find_ptr(sdl->bindings, key.s);
key               208 ext/soap/php_sdl.c 	smart_str_free(&key);
key               531 ext/soap/php_sdl.c 				smart_str key = {0};
key               539 ext/soap/php_sdl.c 					smart_str_appends(&key,hf->ns);
key               540 ext/soap/php_sdl.c 					smart_str_appendc(&key,':');
key               542 ext/soap/php_sdl.c 				smart_str_appends(&key,hf->name);
key               543 ext/soap/php_sdl.c 				smart_str_0(&key);
key               544 ext/soap/php_sdl.c 				if (zend_hash_add_ptr(h->headerfaults, key.s, hf) == NULL) {
key               547 ext/soap/php_sdl.c 				smart_str_free(&key);
key               633 ext/soap/php_sdl.c 			smart_str key = {0};
key               641 ext/soap/php_sdl.c 				smart_str_appends(&key,h->ns);
key               642 ext/soap/php_sdl.c 				smart_str_appendc(&key,':');
key               644 ext/soap/php_sdl.c 			smart_str_appends(&key,h->name);
key               645 ext/soap/php_sdl.c 			smart_str_0(&key);
key               646 ext/soap/php_sdl.c 			if (zend_hash_add_ptr(binding->headers, key.s, h) == NULL) {
key               649 ext/soap/php_sdl.c 			smart_str_free(&key);
key              1795 ext/soap/php_sdl.c static void sdl_serialize_key(zend_string *key, smart_str *out)
key              1797 ext/soap/php_sdl.c 	if (key) {
key              1798 ext/soap/php_sdl.c 		WSDL_CACHE_PUT_INT(ZSTR_LEN(key), out);
key              1799 ext/soap/php_sdl.c 		WSDL_CACHE_PUT_N(ZSTR_VAL(key), ZSTR_LEN(key), out);
key              1851 ext/soap/php_sdl.c 		zend_string *key;
key              1853 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(attr->extraAttributes, key, tmp) {
key              1854 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              1951 ext/soap/php_sdl.c 			zend_string *key;
key              1953 ext/soap/php_sdl.c 			ZEND_HASH_FOREACH_STR_KEY_PTR(type->restrictions->enumeration, key, tmp) {
key              1955 ext/soap/php_sdl.c 				sdl_serialize_key(key, out);
key              1969 ext/soap/php_sdl.c 		zend_string *key;
key              1975 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
key              1976 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              1992 ext/soap/php_sdl.c 		zend_string *key;
key              1994 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
key              1995 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2031 ext/soap/php_sdl.c 		zend_string *key;
key              2033 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(ht, key, tmp) {
key              2034 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2060 ext/soap/php_sdl.c 		zend_string *key;
key              2062 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(body->headers, key, tmp) {
key              2063 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2080 ext/soap/php_sdl.c 				zend_string *key;
key              2082 ext/soap/php_sdl.c 				ZEND_HASH_FOREACH_STR_KEY_PTR(body->headers, key, tmp2) {
key              2083 ext/soap/php_sdl.c 					sdl_serialize_key(key, out);
key              2212 ext/soap/php_sdl.c 		zend_string *key;
key              2214 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->groups, key, tmp) {
key              2215 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2222 ext/soap/php_sdl.c 		zend_string *key;
key              2224 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->types, key, tmp) {
key              2225 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2232 ext/soap/php_sdl.c 		zend_string *key;
key              2234 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->elements, key, tmp) {
key              2235 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2242 ext/soap/php_sdl.c 		zend_string *key;
key              2244 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->encoders, key, tmp) {
key              2245 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2261 ext/soap/php_sdl.c 		zend_string *key;
key              2263 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->bindings, key, tmp) {
key              2264 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2289 ext/soap/php_sdl.c 		zend_string *key;
key              2291 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&sdl->functions, key, tmp) {
key              2292 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2319 ext/soap/php_sdl.c 				zend_string *key;
key              2323 ext/soap/php_sdl.c 				ZEND_HASH_FOREACH_STR_KEY_PTR(tmp->faults, key, fault) {
key              2324 ext/soap/php_sdl.c 					sdl_serialize_key(key, out);
key              2358 ext/soap/php_sdl.c 		zend_string *key;
key              2360 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->requests, key, tmp) {
key              2363 ext/soap/php_sdl.c 			sdl_serialize_key(key, out);
key              2441 ext/soap/php_sdl.c 	zend_string *key;
key              2446 ext/soap/php_sdl.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(headers, key, tmp) {
key              2475 ext/soap/php_sdl.c 		if (key) {
key              2477 ext/soap/php_sdl.c 			zend_hash_str_add_ptr(pheaders, ZSTR_VAL(key), ZSTR_LEN(key), pheader);
key              2505 ext/soap/php_sdl.c 	zend_string *key;
key              2510 ext/soap/php_sdl.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(params, key, tmp) {
key              2532 ext/soap/php_sdl.c 		if (key) {
key              2534 ext/soap/php_sdl.c 			zend_hash_str_add_ptr(pparams, ZSTR_VAL(key), ZSTR_LEN(key), pparam);
key              2547 ext/soap/php_sdl.c 	zend_string *key;
key              2552 ext/soap/php_sdl.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(faults, key, tmp) {
key              2576 ext/soap/php_sdl.c 		if (key) {
key              2578 ext/soap/php_sdl.c 			zend_hash_str_add_ptr(pfaults, ZSTR_VAL(key), ZSTR_LEN(key), pfault);
key              2592 ext/soap/php_sdl.c 	zend_string *key;
key              2626 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(pattr->extraAttributes, key, tmp) {
key              2627 ext/soap/php_sdl.c 			if (key) {
key              2639 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(pattr->extraAttributes, ZSTR_VAL(key), ZSTR_LEN(key), pextra);
key              2698 ext/soap/php_sdl.c 	zend_string *key;
key              2779 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
key              2781 ext/soap/php_sdl.c 			if (key) {
key              2783 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(ptype->elements, ZSTR_VAL(key), ZSTR_LEN(key), pelem);
key              2797 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
key              2799 ext/soap/php_sdl.c 			if (key) {
key              2801 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(ptype->attributes, ZSTR_VAL(key), ZSTR_LEN(key), pattr);
key              2926 ext/soap/php_sdl.c 	zend_string *key;
key              2949 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->groups, key, tmp) {
key              2951 ext/soap/php_sdl.c 			if (key) {
key              2953 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->groups, ZSTR_VAL(key), ZSTR_LEN(key), ptype);
key              2968 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->types, key, tmp) {
key              2970 ext/soap/php_sdl.c 			if (key) {
key              2972 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->types, ZSTR_VAL(key), ZSTR_LEN(key), ptype);
key              2987 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->elements, key, tmp) {
key              2989 ext/soap/php_sdl.c 			if (key) {
key              2991 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->elements, ZSTR_VAL(key), ZSTR_LEN(key), ptype);
key              3006 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->encoders, key, tmp) {
key              3008 ext/soap/php_sdl.c 			if (key) {
key              3010 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->encoders, ZSTR_VAL(key), ZSTR_LEN(key), penc);
key              3048 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(sdl->bindings, key, tmp) {
key              3050 ext/soap/php_sdl.c 			if (key) {
key              3052 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->bindings, ZSTR_VAL(key), ZSTR_LEN(key), pbind);
key              3065 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(&sdl->functions, key, tmp) {
key              3067 ext/soap/php_sdl.c 			if (key) {
key              3069 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(&psdl->functions, ZSTR_VAL(key), ZSTR_LEN(key), pfunc);
key              3085 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(sdl->requests, key, zv) {
key              3091 ext/soap/php_sdl.c 			if (key) {
key              3093 ext/soap/php_sdl.c 				zend_hash_str_add_ptr(psdl->requests, ZSTR_VAL(key), ZSTR_LEN(key), preq);
key              3163 ext/soap/php_sdl.c 	char* key = NULL;
key              3207 ext/soap/php_sdl.c 		key = emalloc(len+sizeof("/wsdl-")-1+user_len+sizeof(md5str));
key              3208 ext/soap/php_sdl.c 		memcpy(key,SOAP_GLOBAL(cache_dir),len);
key              3209 ext/soap/php_sdl.c 		memcpy(key+len,"/wsdl-",sizeof("/wsdl-")-1);
key              3212 ext/soap/php_sdl.c 			memcpy(key+len, user, user_len-1);
key              3214 ext/soap/php_sdl.c 			key[len++] = '-';
key              3216 ext/soap/php_sdl.c 		memcpy(key+len,md5str,sizeof(md5str));
key              3218 ext/soap/php_sdl.c 		if ((sdl = get_sdl_from_cache(key, uri, t-SOAP_GLOBAL(cache_ttl), &cached)) != NULL) {
key              3220 ext/soap/php_sdl.c 			efree(key);
key              3315 ext/soap/php_sdl.c 	if ((cache_wsdl & WSDL_CACHE_DISK) && key) {
key              3317 ext/soap/php_sdl.c 			add_sdl_to_cache(key, uri, t, sdl);
key              3319 ext/soap/php_sdl.c 		efree(key);
key              3336 ext/soap/php_sdl.c 				zend_string *latest_key = NULL, *key;
key              3338 ext/soap/php_sdl.c 				ZEND_HASH_FOREACH_STR_KEY_PTR(SOAP_GLOBAL(mem_cache), key, q) {
key              3341 ext/soap/php_sdl.c 						latest_key = key;
key              1431 ext/soap/soap.c 				zend_string *key;
key              1439 ext/soap/soap.c 				key = zend_string_alloc(Z_STRLEN_P(tmp_function), 0);
key              1440 ext/soap/soap.c 				zend_str_tolower_copy(ZSTR_VAL(key), Z_STRVAL_P(tmp_function), Z_STRLEN_P(tmp_function));
key              1442 ext/soap/soap.c 				if ((f = zend_hash_find_ptr(EG(function_table), key)) == NULL) {
key              1448 ext/soap/soap.c 				zend_hash_update(service->soap_functions.ft, key, &function_copy);
key              1450 ext/soap/soap.c 				zend_string_release(key);
key              1454 ext/soap/soap.c 		zend_string *key;
key              1457 ext/soap/soap.c 		key = zend_string_alloc(Z_STRLEN_P(function_name), 0);
key              1458 ext/soap/soap.c 		zend_str_tolower_copy(ZSTR_VAL(key), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
key              1460 ext/soap/soap.c 		if ((f = zend_hash_find_ptr(EG(function_table), key)) == NULL) {
key              1471 ext/soap/soap.c 		zend_hash_update(service->soap_functions.ft, key, &function_copy);
key              1472 ext/soap/soap.c 		zend_string_release(key);
key              3660 ext/soap/soap.c 						smart_str key = {0};
key              3663 ext/soap/soap.c 							smart_str_appends(&key, (char*)hdr_func->ns->href);
key              3664 ext/soap/soap.c 							smart_str_appendc(&key, ':');
key              3666 ext/soap/soap.c 						smart_str_appendl(&key, Z_STRVAL(h->function_name), Z_STRLEN(h->function_name));
key              3667 ext/soap/soap.c 						smart_str_0(&key);
key              3668 ext/soap/soap.c 						if ((hdr = zend_hash_find_ptr(fnb->input.headers, key.s)) != NULL) {
key              3671 ext/soap/soap.c 						smart_str_free(&key);
key              3903 ext/soap/soap.c 				smart_str key = {0};
key              3907 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
key              3908 ext/soap/soap.c 					smart_str_appendc(&key, ':');
key              3913 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
key              3916 ext/soap/soap.c 				smart_str_0(&key);
key              3918 ext/soap/soap.c 				    (hdr = zend_hash_find_ptr(headers->hdr->headerfaults, key.s)) != NULL) {
key              3922 ext/soap/soap.c 				smart_str_free(&key);
key              4120 ext/soap/soap.c 						smart_str key = {0};
key              4125 ext/soap/soap.c 							smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
key              4126 ext/soap/soap.c 							smart_str_appendc(&key, ':');
key              4131 ext/soap/soap.c 							smart_str_appendl(&key, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
key              4134 ext/soap/soap.c 						smart_str_0(&key);
key              4139 ext/soap/soap.c 							    (hdr = zend_hash_find_ptr(fnb->output.headers, key.s)) != NULL) {
key              4144 ext/soap/soap.c 						smart_str_free(&key);
key              4357 ext/soap/soap.c 					smart_str key = {0};
key              4360 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_P(ns), Z_STRLEN_P(ns));
key              4361 ext/soap/soap.c 					smart_str_appendc(&key, ':');
key              4362 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_P(name), Z_STRLEN_P(name));
key              4363 ext/soap/soap.c 					smart_str_0(&key);
key              4364 ext/soap/soap.c 					if ((hdr = zend_hash_find_ptr(hdrs, key.s)) != NULL) {
key              4371 ext/soap/soap.c 					smart_str_free(&key);
key               107 ext/sockets/conversions.c static int param_get_bool(void *ctx, const char *key, int def)
key               110 ext/sockets/conversions.c 	if ((elem = zend_hash_str_find_ptr(ctx, key, strlen(key))) != NULL) {
key              1504 ext/sockets/conversions.c 	for (kv = key_value_pairs; kv->key != NULL; kv++) {
key              1505 ext/sockets/conversions.c 		zend_hash_str_update_ptr(&ctx.params, kv->key, kv->key_size - 1, kv->value);
key                24 ext/sockets/conversions.h 	const char	*key;
key               116 ext/sockets/multicast.c static int php_get_if_index_from_array(const HashTable *ht, const char *key,
key               121 ext/sockets/multicast.c 	if ((val = zend_hash_str_find(ht, key, strlen(key))) == NULL) {
key               129 ext/sockets/multicast.c static int php_get_address_from_array(const HashTable *ht, const char *key,
key               134 ext/sockets/multicast.c 	if ((val = zend_hash_str_find(ht, key, strlen(key))) == NULL) {
key               135 ext/sockets/multicast.c 		php_error_docref(NULL, E_WARNING, "no key \"%s\" passed in optval", key);
key                96 ext/sockets/sendrecvmsg.c 	anc_reg_key key;
key               107 ext/sockets/sendrecvmsg.c 	key.cmsg_level		= level; \
key               108 ext/sockets/sendrecvmsg.c 	key.cmsg_type		= type; \
key               109 ext/sockets/sendrecvmsg.c 	zend_hash_str_update_mem(&ancillary_registry.ht, (char*)&key, sizeof(key) - 1, (void*)&entry, sizeof(entry))
key               146 ext/sockets/sendrecvmsg.c 	anc_reg_key			key = { cmsg_level, msg_type };
key               159 ext/sockets/sendrecvmsg.c 	if ((entry = zend_hash_str_find_ptr(&ancillary_registry.ht, (char*)&key, sizeof(key) - 1)) != NULL) {
key               810 ext/sockets/sockets.c 	zend_string *key;
key               815 ext/sockets/sockets.c 	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(sock_array), num_key, key, element) {
key               821 ext/sockets/sockets.c 			if (key) {
key               822 ext/sockets/sockets.c 				dest_element = zend_hash_add(Z_ARRVAL(new_hash), key, element);
key               718 ext/spl/php_spl.c 		zend_string *key;
key               720 ext/spl/php_spl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(SPL_G(autoload_functions), key, alfi) {
key               740 ext/spl/php_spl.c 					add_next_index_str(return_value, zend_string_copy(key));
key              1023 ext/spl/spl_array.c static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key              1029 ext/spl/spl_array.c 		zend_user_it_get_current_key(iter, key);
key              1032 ext/spl/spl_array.c 			ZVAL_NULL(key);
key              1034 ext/spl/spl_array.c 			zend_hash_get_current_key_zval_ex(aht, key, spl_array_get_pos_ptr(aht, object));
key              1539 ext/spl/spl_array.c SPL_METHOD(Array, key)
key              1906 ext/spl/spl_array.c 	SPL_ME(Array, key,              arginfo_array_void,             ZEND_ACC_PUBLIC)
key               656 ext/spl/spl_directory.c zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const zval *key) /* {{{ */
key               668 ext/spl/spl_directory.c 	return zend_get_std_object_handlers()->get_method(object, method, key);
key               762 ext/spl/spl_directory.c SPL_METHOD(DirectoryIterator, key)
key              1046 ext/spl/spl_directory.c SPL_METHOD(FilesystemIterator, key)
key              1600 ext/spl/spl_directory.c static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key);
key              1671 ext/spl/spl_directory.c static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key)
key              1675 ext/spl/spl_directory.c 	ZVAL_LONG(key, object->u.dir.index);
key              1748 ext/spl/spl_directory.c static void spl_filesystem_tree_it_current_key(zend_object_iterator *iter, zval *key)
key              1753 ext/spl/spl_directory.c 		ZVAL_STRING(key, object->u.dir.entry.d_name);
key              1756 ext/spl/spl_directory.c 		ZVAL_STRINGL(key, object->file_name, object->file_name_len);
key              1960 ext/spl/spl_directory.c 	SPL_ME(DirectoryIterator, key,           arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key              1985 ext/spl/spl_directory.c 	SPL_ME(FilesystemIterator, key,           arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key              2448 ext/spl/spl_directory.c SPL_METHOD(SplFileObject, key)
key              3072 ext/spl/spl_directory.c 	SPL_ME(SplFileObject, key,            arginfo_splfileinfo_void,          ZEND_ACC_PUBLIC)
key              1021 ext/spl/spl_dllist.c static void spl_dllist_it_get_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key              1025 ext/spl/spl_dllist.c 	ZVAL_LONG(key, iterator->traverse_position);
key              1042 ext/spl/spl_dllist.c SPL_METHOD(SplDoublyLinkedList, key)
key              1380 ext/spl/spl_dllist.c 	SPL_ME(SplDoublyLinkedList, key,             arginfo_dllist_void,            ZEND_ACC_PUBLIC)
key               907 ext/spl/spl_fixedarray.c static void spl_fixedarray_it_get_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key               912 ext/spl/spl_fixedarray.c 		zend_user_it_get_current_key(iter, key);
key               914 ext/spl/spl_fixedarray.c 		ZVAL_LONG(key, object->current);
key               934 ext/spl/spl_fixedarray.c SPL_METHOD(SplFixedArray, key)
key              1085 ext/spl/spl_fixedarray.c 	SPL_ME(SplFixedArray, key,             arginfo_splfixedarray_void,     ZEND_ACC_PUBLIC)
key               937 ext/spl/spl_heap.c static void spl_heap_it_get_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
key               941 ext/spl/spl_heap.c 	ZVAL_LONG(key, object->heap->count - 1);
key               965 ext/spl/spl_heap.c SPL_METHOD(SplHeap, key)
key              1174 ext/spl/spl_heap.c 	SPL_ME(SplHeap,          key,                   arginfo_splheap_void,    ZEND_ACC_PUBLIC)
key              1190 ext/spl/spl_heap.c 	SPL_ME(SplHeap, key,                   arginfo_splheap_void, ZEND_ACC_PUBLIC)
key               223 ext/spl/spl_iterators.c static void spl_recursive_it_get_current_key(zend_object_iterator *iter, zval *key)
key               229 ext/spl/spl_iterators.c 		sub_iter->funcs->get_current_key(sub_iter, key);
key               231 ext/spl/spl_iterators.c 		ZVAL_LONG(key, iter->index);
key               634 ext/spl/spl_iterators.c SPL_METHOD(RecursiveIteratorIterator, key)
key               883 ext/spl/spl_iterators.c static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_string *method, const zval *key)
key               895 ext/spl/spl_iterators.c 	function_handler = std_object_handlers.get_method(zobject, method, key);
key               900 ext/spl/spl_iterators.c 				function_handler = (*zobject)->handlers->get_method(zobject, method, key);
key              1010 ext/spl/spl_iterators.c 	SPL_ME(RecursiveIteratorIterator, key,               arginfo_recursive_it_void,           ZEND_ACC_PUBLIC)
key              1259 ext/spl/spl_iterators.c SPL_METHOD(RecursiveTreeIterator, key)
key              1263 ext/spl/spl_iterators.c 	zval                       prefix, key, postfix, key_copy;
key              1274 ext/spl/spl_iterators.c 		iterator->funcs->get_current_key(iterator, &key);
key              1276 ext/spl/spl_iterators.c 		ZVAL_NULL(&key);
key              1280 ext/spl/spl_iterators.c 		RETVAL_ZVAL(&key, 1, 1);
key              1284 ext/spl/spl_iterators.c 	if (Z_TYPE(key) != IS_STRING) {
key              1285 ext/spl/spl_iterators.c 		if (zend_make_printable_zval(&key, &key_copy)) {
key              1286 ext/spl/spl_iterators.c 			key = key_copy;
key              1293 ext/spl/spl_iterators.c 	str = zend_string_alloc(Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix), 0);
key              1298 ext/spl/spl_iterators.c 	memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key));
key              1299 ext/spl/spl_iterators.c 	ptr += Z_STRLEN(key);
key              1305 ext/spl/spl_iterators.c 	zval_ptr_dtor(&key);
key              1327 ext/spl/spl_iterators.c 	SPL_ME(RecursiveTreeIterator,     key,               arginfo_recursive_it_void,               ZEND_ACC_PUBLIC)
key              1361 ext/spl/spl_iterators.c static union _zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zval *key)
key              1368 ext/spl/spl_iterators.c 	function_handler = std_object_handlers.get_method(object, method, key);
key              1373 ext/spl/spl_iterators.c 				function_handler = (*object)->handlers->get_method(object, method, key);
key              1662 ext/spl/spl_iterators.c 	if (Z_TYPE(intern->current.key) != IS_UNDEF) {
key              1663 ext/spl/spl_iterators.c 		zval_ptr_dtor(&intern->current.key);
key              1664 ext/spl/spl_iterators.c 		ZVAL_UNDEF(&intern->current.key);
key              1708 ext/spl/spl_iterators.c 			intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.key);
key              1710 ext/spl/spl_iterators.c 				zval_ptr_dtor(&intern->current.key);
key              1711 ext/spl/spl_iterators.c 				ZVAL_UNDEF(&intern->current.key);
key              1714 ext/spl/spl_iterators.c 			ZVAL_LONG(&intern->current.key, intern->current.pos);
key              1776 ext/spl/spl_iterators.c SPL_METHOD(dual_it, key)
key              1786 ext/spl/spl_iterators.c 	if (Z_TYPE(intern->current.key) != IS_UNDEF) {
key              1787 ext/spl/spl_iterators.c 		zval *value = &intern->current.key;
key              2007 ext/spl/spl_iterators.c 	if (Z_TYPE(intern->current.data) == IS_UNDEF || Z_TYPE(intern->current.key) == IS_UNDEF) {
key              2012 ext/spl/spl_iterators.c 	ZVAL_COPY_VALUE(&params[1], &intern->current.key);
key              2053 ext/spl/spl_iterators.c 		subject = zval_get_string(&intern->current.key);
key              2098 ext/spl/spl_iterators.c 				zval_ptr_dtor(&intern->current.key);
key              2099 ext/spl/spl_iterators.c 				ZVAL_STR(&intern->current.key, result);
key              2380 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              2620 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              2645 ext/spl/spl_iterators.c 			zval *key = &intern->current.key;
key              2650 ext/spl/spl_iterators.c 			array_set_zval_key(Z_ARRVAL(intern->u.caching.zcache), key, data);
key              2799 ext/spl/spl_iterators.c 		ZVAL_COPY(return_value, &intern->current.key);
key              2819 ext/spl/spl_iterators.c 	zend_string *key;
key              2829 ext/spl/spl_iterators.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz", &key, &value) == FAILURE) {
key              2836 ext/spl/spl_iterators.c 	zend_symtable_update(Z_ARRVAL(intern->u.caching.zcache), key, value);
key              2845 ext/spl/spl_iterators.c 	zend_string *key;
key              2855 ext/spl/spl_iterators.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key              2859 ext/spl/spl_iterators.c 	if ((value = zend_symtable_find(Z_ARRVAL(intern->u.caching.zcache), key)) == NULL) {
key              2860 ext/spl/spl_iterators.c 		zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(key));
key              2874 ext/spl/spl_iterators.c 	zend_string *key;
key              2883 ext/spl/spl_iterators.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key              2887 ext/spl/spl_iterators.c 	zend_symtable_del(Z_ARRVAL(intern->u.caching.zcache), key);
key              2896 ext/spl/spl_iterators.c 	zend_string *key;
key              2905 ext/spl/spl_iterators.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
key              2909 ext/spl/spl_iterators.c 	RETURN_BOOL(zend_symtable_exists(Z_ARRVAL(intern->u.caching.zcache), key));
key              3026 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void,      ZEND_ACC_PUBLIC)
key              3114 ext/spl/spl_iterators.c 	SPL_ME(dual_it,          key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3154 ext/spl/spl_iterators.c SPL_METHOD(NoRewindIterator, key)
key              3212 ext/spl/spl_iterators.c 	SPL_ME(NoRewindIterator, key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3276 ext/spl/spl_iterators.c SPL_METHOD(EmptyIterator, key)
key              3306 ext/spl/spl_iterators.c 	SPL_ME(EmptyIterator, key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3481 ext/spl/spl_iterators.c 	SPL_ME(dual_it,        key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3543 ext/spl/spl_iterators.c 		zval key;
key              3544 ext/spl/spl_iterators.c 		iter->funcs->get_current_key(iter, &key);
key              3548 ext/spl/spl_iterators.c 		array_set_zval_key(Z_ARRVAL_P(return_value), &key, data);
key              3549 ext/spl/spl_iterators.c 		zval_ptr_dtor(&key);
key               136 ext/spl/spl_iterators.h 		zval                 key;
key               600 ext/spl/spl_observer.c SPL_METHOD(SplObjectStorage, key)
key               904 ext/spl/spl_observer.c 	SPL_ME(SplObjectStorage,  key,         arginfo_splobject_void,0)
key              1180 ext/spl/spl_observer.c SPL_METHOD(MultipleIterator, key)
key              1221 ext/spl/spl_observer.c 	SPL_ME(MultipleIterator,  key,                    arginfo_splobject_void,                     0)
key              7103 ext/sqlite3/libsqlite/sqlite3.c   sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
key              7125 ext/sqlite3/libsqlite/sqlite3.c   void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
key              53912 ext/sqlite3/libsqlite/sqlite3.c static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
key              53926 ext/sqlite3/libsqlite/sqlite3.c   if( key==0 ){
key              53930 ext/sqlite3/libsqlite/sqlite3.c   iPtrmap = PTRMAP_PAGENO(pBt, key);
key              53936 ext/sqlite3/libsqlite/sqlite3.c   offset = PTRMAP_PTROFFSET(iPtrmap, key);
key              53945 ext/sqlite3/libsqlite/sqlite3.c     TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
key              53964 ext/sqlite3/libsqlite/sqlite3.c static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
key              53973 ext/sqlite3/libsqlite/sqlite3.c   iPtrmap = PTRMAP_PAGENO(pBt, key);
key              53980 ext/sqlite3/libsqlite/sqlite3.c   offset = PTRMAP_PTROFFSET(iPtrmap, key);
key              60341 ext/sqlite3/libsqlite/sqlite3.c       u32 key = get4byte(&apNew[i]->aData[8]);
key              60342 ext/sqlite3/libsqlite/sqlite3.c       ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
key              64040 ext/sqlite3/libsqlite/sqlite3.c   int key,          /* If true, retrieve from the btree key, not data. */
key              64053 ext/sqlite3/libsqlite/sqlite3.c   if( key ){
key              64067 ext/sqlite3/libsqlite/sqlite3.c       if( key ){
key              123290 ext/sqlite3/libsqlite/sqlite3.c struct AttachKey { int type;  Token key; };
key              146586 ext/sqlite3/libsqlite/sqlite3.c   Blob key;                       /* Last key written to the current block */
key              146755 ext/sqlite3/libsqlite/sqlite3.c     nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm);
key              146760 ext/sqlite3/libsqlite/sqlite3.c     if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){ 
key              146774 ext/sqlite3/libsqlite/sqlite3.c       blobGrowBuffer(&pNode->key, nTerm, &rc);
key              146777 ext/sqlite3/libsqlite/sqlite3.c         if( pNode->key.n ){
key              146784 ext/sqlite3/libsqlite/sqlite3.c         memcpy(pNode->key.a, zTerm, nTerm);
key              146785 ext/sqlite3/libsqlite/sqlite3.c         pNode->key.n = nTerm;
key              146799 ext/sqlite3/libsqlite/sqlite3.c       pNode->key.n = 0;
key              146900 ext/sqlite3/libsqlite/sqlite3.c   nPrefix = fts3PrefixCompress(pLeaf->key.a, pLeaf->key.n, zTerm, nTerm);
key              146932 ext/sqlite3/libsqlite/sqlite3.c     pLeaf->key.n = 0;
key              146949 ext/sqlite3/libsqlite/sqlite3.c         &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist
key              146987 ext/sqlite3/libsqlite/sqlite3.c     assert( *pRc || pNode->key.nAlloc==0 );
key              146989 ext/sqlite3/libsqlite/sqlite3.c     sqlite3_free(pNode->key.a);
key              147030 ext/sqlite3/libsqlite/sqlite3.c     sqlite3_free(pNode->key.a);
key              147046 ext/sqlite3/libsqlite/sqlite3.c   sqlite3_free(pRoot->key.a);
key              147210 ext/sqlite3/libsqlite/sqlite3.c         blobGrowBuffer(&pNode->key, reader.term.n, &rc);
key              147212 ext/sqlite3/libsqlite/sqlite3.c           memcpy(pNode->key.a, reader.term.a, reader.term.n);
key              147213 ext/sqlite3/libsqlite/sqlite3.c           pNode->key.n = reader.term.n;
key              150737 ext/sqlite3/libsqlite/sqlite3.c     unsigned int key = (((unsigned int)c)<<10) | 0x000003FF;
key              150743 ext/sqlite3/libsqlite/sqlite3.c       if( key >= aEntry[iTest] ){
key              150750 ext/sqlite3/libsqlite/sqlite3.c     assert( aEntry[0]<key );
key              150751 ext/sqlite3/libsqlite/sqlite3.c     assert( key>=aEntry[iRes] );
key              150794 ext/sqlite3/libsqlite/sqlite3.c   unsigned int key = (((unsigned int)c)<<3) | 0x00000007;
key              150800 ext/sqlite3/libsqlite/sqlite3.c     if( key >= aDia[iTest] ){
key              150807 ext/sqlite3/libsqlite/sqlite3.c   assert( key>=aDia[iRes] );
key              6896 ext/sqlite3/libsqlite/sqlite3.h   sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
key              6918 ext/sqlite3/libsqlite/sqlite3.h   void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
key               150 ext/standard/array.c 	if (f->key == NULL) {
key               151 ext/standard/array.c 		if (s->key == NULL) {
key               155 ext/standard/array.c 			t = is_numeric_string(s->key->val, s->key->len, &l2, &d, 1);
key               165 ext/standard/array.c 		if (s->key) {
key               166 ext/standard/array.c 			return zendi_smart_strcmp(f->key, s->key);
key               169 ext/standard/array.c 			t = is_numeric_string(f->key->val, f->key->len, &l1, &d, 1);
key               194 ext/standard/array.c 	if (f->key == NULL && s->key == NULL) {
key               198 ext/standard/array.c 		if (f->key) {
key               199 ext/standard/array.c 			d1 = zend_strtod(f->key->val, NULL);
key               203 ext/standard/array.c 		if (s->key) {
key               204 ext/standard/array.c 			d2 = zend_strtod(s->key->val, NULL);
key               228 ext/standard/array.c 	if (f->key) {
key               229 ext/standard/array.c 		s1 = f->key->val;
key               230 ext/standard/array.c 		l1 = f->key->len;
key               235 ext/standard/array.c 	if (s->key) {
key               236 ext/standard/array.c 		s2 = s->key->val;
key               237 ext/standard/array.c 		l2 = s->key->len;
key               261 ext/standard/array.c 	if (f->key) {
key               262 ext/standard/array.c 		s1 = f->key->val;
key               263 ext/standard/array.c 		l1 = f->key->len;
key               268 ext/standard/array.c 	if (s->key) {
key               269 ext/standard/array.c 		s2 = s->key->val;
key               270 ext/standard/array.c 		l2 = s->key->len;
key               294 ext/standard/array.c 	if (f->key) {
key               295 ext/standard/array.c 		s1 = f->key->val;
key               296 ext/standard/array.c 		l1 = f->key->len;
key               301 ext/standard/array.c 	if (s->key) {
key               302 ext/standard/array.c 		s2 = s->key->val;
key               303 ext/standard/array.c 		l2 = s->key->len;
key               345 ext/standard/array.c 	if (f->key) {
key               346 ext/standard/array.c 		s1 = f->key->val;
key               350 ext/standard/array.c 	if (s->key) {
key               351 ext/standard/array.c 		s2 = s->key->val;
key              1105 ext/standard/array.c 	if (f->key == NULL) {
key              1108 ext/standard/array.c 		ZVAL_STR_COPY(&args[0], f->key);
key              1110 ext/standard/array.c 	if (s->key == NULL) {
key              1113 ext/standard/array.c 		ZVAL_STR_COPY(&args[1], s->key);
key              1310 ext/standard/array.c PHP_FUNCTION(key)
key              2061 ext/standard/array.c 			zend_string *key = zval_get_string(entry);
key              2062 ext/standard/array.c 			zend_symtable_update(Z_ARRVAL_P(return_value), key, val);
key              2063 ext/standard/array.c 			zend_string_release(key);
key              2365 ext/standard/array.c 		if (p->key) {
key              2366 ext/standard/array.c 			zend_string_release(p->key);
key              2369 ext/standard/array.c 		p->key = NULL;
key              2433 ext/standard/array.c 		if (p->key == NULL) {
key              2436 ext/standard/array.c 			zend_hash_add_new(&out_hash, p->key, entry);
key              2457 ext/standard/array.c 			if (p->key == NULL) {
key              2461 ext/standard/array.c 				zend_hash_add_new(removed, p->key, entry);
key              2463 ext/standard/array.c 					zend_delete_global_variable(p->key);
key              2465 ext/standard/array.c 					zend_hash_del(in_hash, p->key);
key              2476 ext/standard/array.c 			if (p->key == NULL) {
key              2480 ext/standard/array.c 					zend_delete_global_variable(p->key);
key              2482 ext/standard/array.c 					zend_hash_del(in_hash, p->key);
key              2503 ext/standard/array.c 		if (p->key == NULL) {
key              2506 ext/standard/array.c 			zend_hash_add_new(&out_hash, p->key, entry);
key              2608 ext/standard/array.c 	if (!p->key && Z_ARRVAL_P(stack)->nNextFreeElement > 0 && p->h >= (zend_ulong)(Z_ARRVAL_P(stack)->nNextFreeElement - 1)) {
key              2613 ext/standard/array.c 	if (p->key) {
key              2615 ext/standard/array.c 			zend_delete_global_variable(p->key);
key              2617 ext/standard/array.c 			zend_hash_del(Z_ARRVAL_P(stack), p->key);
key              2670 ext/standard/array.c 	if (p->key) {
key              2672 ext/standard/array.c 			zend_delete_global_variable(p->key);
key              2674 ext/standard/array.c 			zend_hash_del(Z_ARRVAL_P(stack), p->key);
key              2691 ext/standard/array.c 					q->key = NULL;
key              2706 ext/standard/array.c 					q->key = NULL;
key              2726 ext/standard/array.c 			if (p->key == NULL) {
key              2754 ext/standard/array.c 	zend_string *key;
key              2769 ext/standard/array.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(stack), key, value) {
key              2770 ext/standard/array.c 			if (key) {
key              2771 ext/standard/array.c 				zend_hash_add_new(&new_hash, key, value);
key              2781 ext/standard/array.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(stack), key, value) {
key              2782 ext/standard/array.c 			if (key) {
key              2783 ext/standard/array.c 				zend_hash_add_new(&new_hash, key, value);
key              3487 ext/standard/array.c 		zend_string *key = zval_get_string(name);
key              3490 ext/standard/array.c 			prop = zend_read_property(Z_OBJCE_P(data), data, ZSTR_VAL(key), ZSTR_LEN(key), 1, rv);
key              3492 ext/standard/array.c 		zend_string_release(key);
key              3549 ext/standard/array.c 			zend_string *key = zval_get_string(zkeyval);
key              3550 ext/standard/array.c 			zend_symtable_update(Z_ARRVAL_P(return_value), key, zcolval);
key              3551 ext/standard/array.c 			zend_string_release(key);
key              3609 ext/standard/array.c 	zend_string *key;
key              3642 ext/standard/array.c 	ZEND_HASH_FOREACH_STR_KEY_VAL_IND(Z_ARRVAL_P(input), key, value) {
key              3646 ext/standard/array.c 		if (key) {
key              3647 ext/standard/array.c 			zend_hash_add_new(Z_ARRVAL_P(return_value), key, value);
key              3803 ext/standard/array.c 			if (p->key == NULL) {
key              3807 ext/standard/array.c 					zend_delete_global_variable(p->key);
key              3809 ext/standard/array.c 					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
key              3906 ext/standard/array.c 		if (p->key == NULL) {
key              3926 ext/standard/array.c 				if ((data = zend_hash_find_ind(Z_ARRVAL(args[i]), p->key)) == NULL ||
key              3938 ext/standard/array.c 				zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
key              4147 ext/standard/array.c 					if (p->key == NULL) {
key              4150 ext/standard/array.c 						zend_hash_del(Z_ARRVAL_P(return_value), p->key);
key              4163 ext/standard/array.c 				if (p->key == NULL) {
key              4166 ext/standard/array.c 					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
key              4329 ext/standard/array.c 		if (p->key == NULL) {
key              4349 ext/standard/array.c 				if ((data = zend_hash_find_ind(Z_ARRVAL(args[i]), p->key)) != NULL &&
key              4361 ext/standard/array.c 				zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
key              4583 ext/standard/array.c 				if (p->key == NULL) {
key              4586 ext/standard/array.c 					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
key              4656 ext/standard/array.c 	zend_string *str, *key;
key              4702 ext/standard/array.c 	ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL(args[0]), idx, key, value) {
key              4705 ext/standard/array.c 			if (key) {
key              4706 ext/standard/array.c 				value = zend_hash_add_new(Z_ARRVAL_P(return_value), key, value);
key              4951 ext/standard/array.c 			if (hash->arData[k].key == NULL) {
key              5166 ext/standard/array.c 	zval *key;
key              5191 ext/standard/array.c 			key = &args[1];
key              5194 ext/standard/array.c 			key = &args[0];
key              5203 ext/standard/array.c 					ZVAL_LONG(key, num_key);
key              5205 ext/standard/array.c 					ZVAL_STR_COPY(key, string_key);
key              5416 ext/standard/array.c 	zval *key;					/* key to check for */
key              5420 ext/standard/array.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "zH", &key, &array) == FAILURE) {
key              5425 ext/standard/array.c 		Z_PARAM_ZVAL(key)
key              5430 ext/standard/array.c 	switch (Z_TYPE_P(key)) {
key              5432 ext/standard/array.c 			if (zend_symtable_exists_ind(array, Z_STR_P(key))) {
key              5437 ext/standard/array.c 			if (zend_hash_index_exists(array, Z_LVAL_P(key))) {
key              5556 ext/standard/array.c 					zend_string *key = zval_get_string(entry_keys);
key              5558 ext/standard/array.c 						key, entry_values);
key              5559 ext/standard/array.c 					zend_string_release(key);
key               290 ext/standard/assert.c 	zend_string *key;
key               301 ext/standard/assert.c 			key = zend_string_init("assert.active", sizeof("assert.active")-1, 0);
key               302 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
key               303 ext/standard/assert.c 			zend_string_release(key);
key               313 ext/standard/assert.c 			key = zend_string_init("assert.bail", sizeof("assert.bail")-1, 0);
key               314 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
key               315 ext/standard/assert.c 			zend_string_release(key);
key               325 ext/standard/assert.c 			key = zend_string_init("assert.quiet_eval", sizeof("assert.quiet_eval")-1, 0);
key               326 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
key               327 ext/standard/assert.c 			zend_string_release(key);
key               337 ext/standard/assert.c 			key = zend_string_init("assert.warning", sizeof("assert.warning")-1, 0);
key               338 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
key               339 ext/standard/assert.c 			zend_string_release(key);
key               362 ext/standard/assert.c 			zend_string *key = zend_string_init("assert.exception", sizeof("assert.exception")-1, 0);
key               364 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
key               366 ext/standard/assert.c 			zend_string_release(key);
key               589 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, key)
key              3287 ext/standard/basic_functions.c 	PHP_FE(key,																arginfo_key)
key              3410 ext/standard/basic_functions.c 		SetEnvironmentVariable(pe->key, "bugbug");
key              3418 ext/standard/basic_functions.c 		unsetenv(pe->key);
key              3420 ext/standard/basic_functions.c 		SetEnvironmentVariable(pe->key, NULL);
key              3422 ext/standard/basic_functions.c 		_putenv_s(pe->key, "");
key              3428 ext/standard/basic_functions.c 			if (!strncmp(*env, pe->key, pe->key_len) && (*env)[pe->key_len] == '=') {	/* found it */
key              3438 ext/standard/basic_functions.c 	if (!strncmp(pe->key, "TZ", pe->key_len)) {
key              3444 ext/standard/basic_functions.c 	efree(pe->key);
key              4099 ext/standard/basic_functions.c 	pe.key = estrndup(setting, setting_len);
key              4100 ext/standard/basic_functions.c 	if ((p = strchr(pe.key, '='))) {	/* nullify the '=' if there is one */
key              4107 ext/standard/basic_functions.c 	pe.key_len = (int)strlen(pe.key);
key              4119 ext/standard/basic_functions.c 	zend_hash_str_del(&BG(putenv_ht), pe.key, pe.key_len);
key              4124 ext/standard/basic_functions.c 		if (!strncmp(*env, pe.key, pe.key_len) && (*env)[pe.key_len] == '=') {	/* found it */
key              4144 ext/standard/basic_functions.c 	error_code = SetEnvironmentVariable(pe.key, value);
key              4153 ext/standard/basic_functions.c 	&& _putenv_s(pe.key, value ? value : "") == 0
key              4158 ext/standard/basic_functions.c 		zend_hash_str_add_mem(&BG(putenv_ht), pe.key, pe.key_len, &pe, sizeof(putenv_entry));
key              4160 ext/standard/basic_functions.c 		if (!strncmp(pe.key, "TZ", pe.key_len)) {
key              4167 ext/standard/basic_functions.c 		efree(pe.key);
key              4567 ext/standard/basic_functions.c 		if (hash_key->key) {
key              4568 ext/standard/basic_functions.c 			add_assoc_str_ex(retval, ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key), zend_string_copy(Z_STR_P(entry)));
key              4575 ext/standard/basic_functions.c 		zend_hash_update(Z_ARRVAL_P(retval), hash_key->key, &tmp);
key              5275 ext/standard/basic_functions.c 	if (hash_key->key == NULL ||
key              5276 ext/standard/basic_functions.c 		ZSTR_VAL(hash_key->key)[0] != 0
key              5415 ext/standard/basic_functions.c 	zend_string *key;
key              5429 ext/standard/basic_functions.c 	key = zend_string_init("include_path", sizeof("include_path") - 1, 0);
key              5430 ext/standard/basic_functions.c 	if (zend_alter_ini_entry_ex(key, new_value, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0) == FAILURE) {
key              5431 ext/standard/basic_functions.c 		zend_string_release(key);
key              5435 ext/standard/basic_functions.c 	zend_string_release(key);
key              5463 ext/standard/basic_functions.c 	zend_string *key;
key              5468 ext/standard/basic_functions.c 	key = zend_string_init("include_path", sizeof("include_path")-1, 0);
key              5469 ext/standard/basic_functions.c 	zend_restore_ini_entry(key, PHP_INI_STAGE_RUNTIME);
key              5470 ext/standard/basic_functions.c 	zend_string_free(key);
key              5530 ext/standard/basic_functions.c 		zend_string *key = zend_string_init("ignore_user_abort", sizeof("ignore_user_abort") - 1, 0);
key              5531 ext/standard/basic_functions.c 		zend_alter_ini_entry_chars(key, arg ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
key              5532 ext/standard/basic_functions.c 		zend_string_release(key);
key              5831 ext/standard/basic_functions.c 				zend_ulong key = (zend_ulong) zend_atol(Z_STRVAL_P(arg1), (int)Z_STRLEN_P(arg1));
key              5832 ext/standard/basic_functions.c 				if ((find_hash = zend_hash_index_find(Z_ARRVAL_P(arr), key)) == NULL) {
key              5834 ext/standard/basic_functions.c 					find_hash = zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash);
key               250 ext/standard/basic_functions.h 	char *key;
key               342 ext/standard/browscap.c static int browser_reg_compare(zval *browser, int num_args, va_list args, zend_hash_key *key) /* {{{ */
key               548 ext/standard/crypt_blowfish.c static void BF_set_key(const char *key, BF_key expanded, BF_key initial,
key               551 ext/standard/crypt_blowfish.c 	const char *ptr = key;
key               611 ext/standard/crypt_blowfish.c 				ptr = key;
key               654 ext/standard/crypt_blowfish.c static char *BF_crypt(const char *key, const char *setting,
key               700 ext/standard/crypt_blowfish.c 	BF_set_key(key, data.expanded_key, data.ctx.P,
key               821 ext/standard/crypt_blowfish.c char *php_crypt_blowfish_rn(const char *key, const char *setting,
key               840 ext/standard/crypt_blowfish.c 	retval = BF_crypt(key, setting, output, size, 16);
key                24 ext/standard/crypt_blowfish.h extern char *php_crypt_blowfish_rn(const char *key, const char *setting,
key               377 ext/standard/crypt_freesec.c des_setkey(const char *key, struct php_crypt_extended_data *data)
key               383 ext/standard/crypt_freesec.c 		(uint32_t)(u_char)key[3] |
key               384 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[2] << 8) |
key               385 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[1] << 16) |
key               386 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[0] << 24);
key               388 ext/standard/crypt_freesec.c 		(uint32_t)(u_char)key[7] |
key               389 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[6] << 8) |
key               390 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[5] << 16) |
key               391 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[4] << 24);
key               614 ext/standard/crypt_freesec.c _crypt_extended_r(const char *key, const char *setting,
key               630 ext/standard/crypt_freesec.c 		*q++ = *key << 1;
key               631 ext/standard/crypt_freesec.c 		if (*key)
key               632 ext/standard/crypt_freesec.c 			key++;
key               659 ext/standard/crypt_freesec.c 		while (*key) {
key               670 ext/standard/crypt_freesec.c 			while (q - (u_char *) keybuf < sizeof(keybuf) && *key)
key               671 ext/standard/crypt_freesec.c 				*q++ ^= *key++ << 1;
key               729 ext/standard/crypt_freesec.c _crypt_extended(const char *key, const char *setting)
key               739 ext/standard/crypt_freesec.c 	return _crypt_extended_r(key, setting, &data);
key                33 ext/standard/crypt_freesec.h char *_crypt_extended_r(const char *key, const char *setting,
key               334 ext/standard/crypt_sha256.c char * php_sha256_crypt_r(const char *key, const char *salt, char *buffer, int buflen)
key               384 ext/standard/crypt_sha256.c 	key_len = strlen(key);
key               386 ext/standard/crypt_sha256.c 	if ((key - (char *) 0) % __alignof__ (uint32_t) != 0) {
key               388 ext/standard/crypt_sha256.c 		key = copied_key = memcpy(tmp + __alignof__(uint32_t) - (tmp - (char *) 0) % __alignof__(uint32_t), key, key_len);
key               402 ext/standard/crypt_sha256.c 	sha256_process_bytes(key, key_len, &ctx);
key               415 ext/standard/crypt_sha256.c 	sha256_process_bytes(key, key_len, &alt_ctx);
key               421 ext/standard/crypt_sha256.c 	sha256_process_bytes(key, key_len, &alt_ctx);
key               439 ext/standard/crypt_sha256.c 			sha256_process_bytes(key, key_len, &ctx);
key               451 ext/standard/crypt_sha256.c 		sha256_process_bytes(key, key_len, &alt_ctx);
key               593 ext/standard/crypt_sha256.c char * php_sha256_crypt(const char *key, const char *salt)
key               615 ext/standard/crypt_sha256.c 	return php_sha256_crypt_r(key, salt, buffer, buflen);
key               369 ext/standard/crypt_sha512.c php_sha512_crypt_r(const char *key, const char *salt, char *buffer, int buflen) {
key               418 ext/standard/crypt_sha512.c 	key_len = strlen(key);
key               420 ext/standard/crypt_sha512.c 	if ((key - (char *) 0) % __alignof__ (uint64_t) != 0) {
key               422 ext/standard/crypt_sha512.c 		key = copied_key =
key               423 ext/standard/crypt_sha512.c 		memcpy(tmp + __alignof__(uint64_t) - (tmp - (char *) 0) % __alignof__(uint64_t), key, key_len);
key               436 ext/standard/crypt_sha512.c 	sha512_process_bytes(key, key_len, &ctx);
key               449 ext/standard/crypt_sha512.c 	sha512_process_bytes(key, key_len, &alt_ctx);
key               455 ext/standard/crypt_sha512.c 	sha512_process_bytes(key, key_len, &alt_ctx);
key               473 ext/standard/crypt_sha512.c 			sha512_process_bytes(key, key_len, &ctx);
key               485 ext/standard/crypt_sha512.c 		sha512_process_bytes(key, key_len, &alt_ctx);
key               641 ext/standard/crypt_sha512.c php_sha512_crypt(const char *key, const char *salt) {
key               662 ext/standard/crypt_sha512.c 	return php_sha512_crypt_r (key, salt, buffer, buflen);
key              1225 ext/standard/filestat.c 			if (ZEND_LONG_MAX >= bucket->key) {
key              1226 ext/standard/filestat.c 				add_assoc_long_ex(&entry, "key", sizeof("key") - 1, bucket->key);
key              1228 ext/standard/filestat.c 				add_assoc_double_ex(&entry, "key", sizeof("key") - 1, (double)bucket->key);
key              1576 ext/standard/html.c 	char key[9] = ""; /* two unicode code points in UTF-8 */
key              1580 ext/standard/html.c 	written_k1 = write_octet_sequence((unsigned char*)key, charset, orig_cp);
key              1586 ext/standard/html.c 		add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
key              1596 ext/standard/html.c 			add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
key              1615 ext/standard/html.c 			written_k2 = write_octet_sequence((unsigned char*)&key[written_k1], charset, spe_cp);
key              1619 ext/standard/html.c 			add_assoc_stringl_ex(arr, key, written_k1 + written_k2, entity, l + 1);
key                34 ext/standard/http.c 	zend_string *key = NULL;
key                58 ext/standard/http.c 	ZEND_HASH_FOREACH_KEY_VAL_IND(ht, idx, key, zdata) {
key                60 ext/standard/http.c 		if (key) {
key                61 ext/standard/http.c 			if (ZSTR_VAL(key)[0] == '\0' && type != NULL) {
key                65 ext/standard/http.c 				if (zend_check_property_access(zobj, key) != SUCCESS) {
key                69 ext/standard/http.c 				zend_unmangle_property_name_ex(key, &tmp, &prop_name, &prop_len);
key                71 ext/standard/http.c 				prop_name = ZSTR_VAL(key);
key                72 ext/standard/http.c 				prop_len = ZSTR_LEN(key);
key                81 ext/standard/http.c 			if (key) {
key               156 ext/standard/http.c 			if (key) {
key                90 ext/standard/incomplete_class.c static union _zend_function *incomplete_class_get_method(zend_object **object, zend_string *method, const zval *key) /* {{{ */
key                98 ext/standard/info.c 	zend_string *key;
key               110 ext/standard/info.c 			ZEND_HASH_FOREACH_STR_KEY(ht, key) {
key               111 ext/standard/info.c 				if (key) {
key               118 ext/standard/info.c 						php_info_print_html_esc(ZSTR_VAL(key), ZSTR_LEN(key));
key               120 ext/standard/info.c 						php_info_print(ZSTR_VAL(key));
key               199 ext/standard/info.c 	zend_string *key;
key               201 ext/standard/info.c 	key = zend_string_init(name, name_length, 0);
key               202 ext/standard/info.c 	zend_is_auto_global(key);
key               204 ext/standard/info.c 	if ((data = zend_hash_find(&EG(symbol_table), key)) != NULL && (Z_TYPE_P(data) == IS_ARRAY)) {
key               267 ext/standard/info.c 	zend_string_free(key);
key               320 ext/standard/iptc.c 	char *str, key[16];
key               365 ext/standard/iptc.c 		snprintf(key, sizeof(key), "%d#%03d", (unsigned int) dataset, (unsigned int) recnum);
key               371 ext/standard/iptc.c 		if ((element = zend_hash_str_find(Z_ARRVAL_P(return_value), key, strlen(key))) == NULL) {
key               374 ext/standard/iptc.c 			element = zend_hash_str_update(Z_ARRVAL_P(return_value), key, strlen(key), &values);
key                49 ext/standard/php_array.h PHP_FUNCTION(key);
key                52 ext/standard/php_crypt_r.h extern char * php_sha512_crypt_r (const char *key, const char *salt, char *buffer, int buflen);
key                53 ext/standard/php_crypt_r.h extern char * php_sha256_crypt_r (const char *key, const char *salt, char *buffer, int buflen);
key               643 ext/standard/streamsfuncs.c 	zend_string *key;
key               652 ext/standard/streamsfuncs.c 	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(stream_array), num_ind, key, elem) {
key               666 ext/standard/streamsfuncs.c 				if (!key) {
key               669 ext/standard/streamsfuncs.c 					dest_elem = zend_hash_update(Z_ARRVAL(new_array), key, elem);
key              3006 ext/standard/string.c 	char *key;
key              3087 ext/standard/string.c 		key = str + pos;
key              3088 ext/standard/string.c 		if (bitset[((unsigned char)key[0]) / sizeof(zend_ulong)] & (Z_UL(1) << (((unsigned char)key[0]) % sizeof(zend_ulong)))) {
key              3095 ext/standard/string.c 					entry = zend_hash_str_find(pats, key, len);
key               379 ext/standard/url.c 	zend_long key = -1;
key               381 ext/standard/url.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &key) == FAILURE) {
key               391 ext/standard/url.c 	if (key > -1) {
key               392 ext/standard/url.c 		switch (key) {
key               418 ext/standard/url.c 				php_error_docref(NULL, E_WARNING, "Invalid URL component identifier " ZEND_LONG_FMT, key);
key                54 ext/standard/url_scanner_ex.c 	char *key;
key                73 ext/standard/url_scanner_ex.c 	for (key = php_strtok_r(tmp, ",", &lasts);
key                74 ext/standard/url_scanner_ex.c 			key;
key                75 ext/standard/url_scanner_ex.c 			key = php_strtok_r(NULL, ",", &lasts)) {
key                78 ext/standard/url_scanner_ex.c 		val = strchr(key, '=');
key                84 ext/standard/url_scanner_ex.c 			for (q = key; *q; q++)
key                86 ext/standard/url_scanner_ex.c 			keylen = q - key;
key                89 ext/standard/url_scanner_ex.c 			zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
key                38 ext/standard/var.c static void php_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
key                40 ext/standard/var.c 	if (key == NULL) { /* numeric key */
key                44 ext/standard/var.c 		PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
key                51 ext/standard/var.c static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
key                55 ext/standard/var.c 	if (key == NULL) { /* numeric key */
key                58 ext/standard/var.c 		int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
key                69 ext/standard/var.c 			PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
key                85 ext/standard/var.c 	zend_string *key;
key               126 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
key               127 ext/standard/var.c 				php_array_element_dump(val, num, key, level);
key               155 ext/standard/var.c 				zend_string *key;
key               158 ext/standard/var.c 				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
key               159 ext/standard/var.c 					php_object_property_dump(val, num, key, level);
key               210 ext/standard/var.c static void zval_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
key               212 ext/standard/var.c 	if (key == NULL) { /* numeric key */
key               216 ext/standard/var.c 		PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
key               223 ext/standard/var.c static void zval_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
key               227 ext/standard/var.c 	if (key == NULL) { /* numeric key */
key               230 ext/standard/var.c 		zend_unmangle_property_name(key, &class_name, &prop_name);
key               255 ext/standard/var.c 	zend_string *key;
key               294 ext/standard/var.c 		ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
key               295 ext/standard/var.c 			zval_array_element_dump(val, index, key, level);
key               323 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
key               324 ext/standard/var.c 				zval_object_property_dump(val, index, key, level);
key               383 ext/standard/var.c static void php_array_element_export(zval *zv, zend_ulong index, zend_string *key, int level, smart_str *buf) /* {{{ */
key               385 ext/standard/var.c 	if (key == NULL) { /* numeric key */
key               392 ext/standard/var.c 		zend_string *ckey = php_addcslashes(key, 0, "'\\", 2);
key               411 ext/standard/var.c static void php_object_element_export(zval *zv, zend_ulong index, zend_string *key, int level, smart_str *buf) /* {{{ */
key               414 ext/standard/var.c 	if (key != NULL) {
key               419 ext/standard/var.c 		zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
key               443 ext/standard/var.c 	zend_string *key;
key               498 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
key               499 ext/standard/var.c 				php_array_element_export(val, index, key, level, buf);
key               531 ext/standard/var.c 				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
key               532 ext/standard/var.c 					php_object_element_export(val, index, key, level, buf);
key               593 ext/standard/var.c 	zend_ulong key;
key               609 ext/standard/var.c 	key = (zend_ulong) (zend_uintptr_t) Z_COUNTED_P(var);
key               610 ext/standard/var.c 	zv = zend_hash_index_find(&data->ht, key);
key               622 ext/standard/var.c 		zend_hash_index_add_new(&data->ht, key, &zv_n);
key               628 ext/standard/var.c 		zend_hash_index_add_new(&data->ht, key + 1, var);
key               695 ext/standard/var.c 		zend_string *key;
key               704 ext/standard/var.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
key               705 ext/standard/var.c 			if (incomplete_class && strcmp(ZSTR_VAL(key), MAGIC_MEMBER) == 0) {
key               918 ext/standard/var.c 				zend_string *key;
key               922 ext/standard/var.c 				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
key               924 ext/standard/var.c 					if (incomplete_class && strcmp(ZSTR_VAL(key), MAGIC_MEMBER) == 0) {
key               928 ext/standard/var.c 					if (!key) {
key               931 ext/standard/var.c 						php_var_serialize_string(buf, ZSTR_VAL(key), ZSTR_LEN(key));
key               305 ext/standard/var_unserializer.c 		zval key, *data, d, *old_data;
key               308 ext/standard/var_unserializer.c 		ZVAL_UNDEF(&key);
key               310 ext/standard/var_unserializer.c 		if (!php_var_unserialize_ex(&key, p, max, NULL, classes)) {
key               311 ext/standard/var_unserializer.c 			zval_dtor(&key);
key               319 ext/standard/var_unserializer.c 			if (Z_TYPE(key) == IS_LONG) {
key               320 ext/standard/var_unserializer.c 				idx = Z_LVAL(key);
key               329 ext/standard/var_unserializer.c 			} else if (Z_TYPE(key) == IS_STRING) {
key               330 ext/standard/var_unserializer.c 				if (UNEXPECTED(ZEND_HANDLE_NUMERIC(Z_STR(key), idx))) {
key               333 ext/standard/var_unserializer.c 				if (UNEXPECTED((old_data = zend_hash_find(ht, Z_STR(key))) != NULL)) {
key               336 ext/standard/var_unserializer.c 					data = zend_hash_update(ht, Z_STR(key), &d);
key               338 ext/standard/var_unserializer.c 					data = zend_hash_add_new(ht, Z_STR(key), &d);
key               341 ext/standard/var_unserializer.c 				zval_dtor(&key);
key               345 ext/standard/var_unserializer.c 			if (EXPECTED(Z_TYPE(key) == IS_STRING)) {
key               347 ext/standard/var_unserializer.c 				if ((old_data = zend_hash_find(ht, Z_STR(key))) != NULL) {
key               352 ext/standard/var_unserializer.c 					data = zend_hash_update_ind(ht, Z_STR(key), &d);
key               354 ext/standard/var_unserializer.c 					data = zend_hash_add_new(ht, Z_STR(key), &d);
key               356 ext/standard/var_unserializer.c 			} else if (Z_TYPE(key) == IS_LONG) {
key               358 ext/standard/var_unserializer.c 				convert_to_string(&key);
key               361 ext/standard/var_unserializer.c 				zval_dtor(&key);
key               367 ext/standard/var_unserializer.c 			zval_dtor(&key);
key               372 ext/standard/var_unserializer.c 			if (Z_TYPE(key) == IS_LONG) {
key               373 ext/standard/var_unserializer.c 				zend_hash_index_del(ht, Z_LVAL(key));
key               375 ext/standard/var_unserializer.c 				zend_hash_del_ind(ht, Z_STR(key));
key               381 ext/standard/var_unserializer.c 		zval_dtor(&key);
key                57 ext/sysvmsg/php_sysvmsg.h 	key_t key;
key                44 ext/sysvmsg/sysvmsg.c 	ZEND_ARG_INFO(0, key)
key                82 ext/sysvmsg/sysvmsg.c 	ZEND_ARG_INFO(0, key)
key               237 ext/sysvmsg/sysvmsg.c 	zend_long key;
key               239 ext/sysvmsg/sysvmsg.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &key) == FAILURE)	{
key               243 ext/sysvmsg/sysvmsg.c 	if (msgget(key, 0) < 0) {
key               255 ext/sysvmsg/sysvmsg.c 	zend_long key;
key               259 ext/sysvmsg/sysvmsg.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &key, &perms) == FAILURE)	{
key               265 ext/sysvmsg/sysvmsg.c 	mq->key = key;
key               266 ext/sysvmsg/sysvmsg.c 	mq->id = msgget(key, 0);
key               269 ext/sysvmsg/sysvmsg.c 		mq->id = msgget(key, IPC_CREAT | IPC_EXCL | perms);
key               271 ext/sysvmsg/sysvmsg.c 			php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key                44 ext/sysvsem/php_sysvsem.h 	int key;					/* For error reporting. */
key                61 ext/sysvsem/sysvsem.c 	ZEND_ARG_INFO(0, key)
key               191 ext/sysvsem/sysvsem.c 	zend_long key, max_acquire = 1, perm = 0666, auto_release = 1;
key               197 ext/sysvsem/sysvsem.c 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "l|lll", &key, &max_acquire, &perm, &auto_release)) {
key               207 ext/sysvsem/sysvsem.c 	semid = semget(key, 3, perm|IPC_CREAT);
key               209 ext/sysvsem/sysvsem.c 		php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               241 ext/sysvsem/sysvsem.c 			php_error_docref(NULL, E_WARNING, "failed acquiring SYSVSEM_SETVAL for key 0x%lx: %s", key, strerror(errno));
key               249 ext/sysvsem/sysvsem.c 		php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               260 ext/sysvsem/sysvsem.c 			php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               265 ext/sysvsem/sysvsem.c 			php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               270 ext/sysvsem/sysvsem.c 			php_error_docref(NULL, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               282 ext/sysvsem/sysvsem.c 			php_error_docref(NULL, E_WARNING, "failed releasing SYSVSEM_SETVAL for key 0x%lx: %s", key, strerror(errno));
key               288 ext/sysvsem/sysvsem.c 	sem_ptr->key   = key;
key               322 ext/sysvsem/sysvsem.c 		php_error_docref(NULL, E_WARNING, "SysV semaphore %ld (key 0x%x) is not currently acquired", Z_LVAL_P(arg_id), sem_ptr->key);
key               333 ext/sysvsem/sysvsem.c 				php_error_docref(NULL, E_WARNING, "failed to %s key 0x%x: %s", acquire ? "acquire" : "release", sem_ptr->key, strerror(errno));
key                53 ext/sysvshm/php_sysvshm.h 	zend_long key;
key                68 ext/sysvshm/php_sysvshm.h 	key_t key;               /* key set by user */
key                44 ext/sysvshm/sysvshm.c 	ZEND_ARG_INFO(0, key)
key               123 ext/sysvshm/sysvshm.c static int php_put_shm_data(sysvshm_chunk_head *ptr, zend_long key, const char *data, zend_long len);
key               124 ext/sysvshm/sysvshm.c static zend_long php_check_shm_data(sysvshm_chunk_head *ptr, zend_long key);
key               200 ext/sysvshm/sysvshm.c 	shm_list_ptr->key = shm_key;
key               236 ext/sysvshm/sysvshm.c 		php_error_docref(NULL, E_WARNING, "failed for key 0x%x, id %ld: %s", shm_list_ptr->key, Z_LVAL_P(shm_id), strerror(errno));
key               363 ext/sysvshm/sysvshm.c static int php_put_shm_data(sysvshm_chunk_head *ptr, zend_long key, const char *data, zend_long len)
key               371 ext/sysvshm/sysvshm.c 	if ((shm_varpos = php_check_shm_data(ptr, key)) > 0) {
key               380 ext/sysvshm/sysvshm.c 	shm_var->key = key;
key               392 ext/sysvshm/sysvshm.c static zend_long php_check_shm_data(sysvshm_chunk_head *ptr, zend_long key)
key               404 ext/sysvshm/sysvshm.c 		if (shm_var->key == key) {
key               272 ext/wddx/wddx.c 		php_wddx_serialize_var(packet, struc, key);
key               291 ext/wddx/wddx.c 	zend_string *key;
key               305 ext/wddx/wddx.c 		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(retval), idx, key, ent) {
key               306 ext/wddx/wddx.c 			if (key == NULL) {
key               307 ext/wddx/wddx.c 				key = zend_long_to_str(idx);
key               309 ext/wddx/wddx.c 				zend_string_addref(key);
key               311 ext/wddx/wddx.c 			if (php_set_session_var(key, ent, NULL)) {
key               314 ext/wddx/wddx.c 			PS_ADD_VAR(key);
key               315 ext/wddx/wddx.c 			zend_string_release(key);
key               444 ext/wddx/wddx.c 	zend_string *key;
key               501 ext/wddx/wddx.c 		ZEND_HASH_FOREACH_KEY_VAL(objhash, idx, key, ent) {
key               505 ext/wddx/wddx.c 			if (key) {
key               510 ext/wddx/wddx.c 				zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
key               515 ext/wddx/wddx.c 				key = zend_long_to_str(idx);
key               516 ext/wddx/wddx.c 				php_wddx_serialize_var(packet, ent, key);
key               517 ext/wddx/wddx.c 				zend_string_release(key);
key               533 ext/wddx/wddx.c 	zend_string *key;
key               541 ext/wddx/wddx.c 	ZEND_HASH_FOREACH_KEY(target_hash, idx, key) {
key               542 ext/wddx/wddx.c 		if (key) {
key               561 ext/wddx/wddx.c 	ZEND_HASH_FOREACH_KEY_VAL(target_hash, idx, key, ent) {
key               567 ext/wddx/wddx.c 			if (key) {
key               568 ext/wddx/wddx.c 				php_wddx_serialize_var(packet, ent, key);
key               570 ext/wddx/wddx.c 				key = zend_long_to_str(idx);
key               571 ext/wddx/wddx.c 				php_wddx_serialize_var(packet, ent, key);
key               572 ext/wddx/wddx.c 				zend_string_release(key);
key               801 ext/wddx/wddx.c 				char *key;
key               807 ext/wddx/wddx.c 					key = estrndup(p1, p2 - p1);
key               809 ext/wddx/wddx.c 					add_assoc_zval_ex(&ent.data, key, p2 - p1, &tmp);
key               811 ext/wddx/wddx.c 					efree(key);
key               109 ext/xmlrpc/libxmlrpc/queue.c static int  Q_BSearch(queue *q, void *key,
key               719 ext/xmlrpc/libxmlrpc/queue.c    void    *key, *temp;
key               725 ext/xmlrpc/libxmlrpc/queue.c       key = list[ low ];
key               729 ext/xmlrpc/libxmlrpc/queue.c          while(Comp(list[i], key) < 0)
key               733 ext/xmlrpc/libxmlrpc/queue.c          while(Comp(list[j], key) > 0)
key               853 ext/xmlrpc/libxmlrpc/queue.c static int Q_BSearch( queue *q, void *key,
key               863 ext/xmlrpc/libxmlrpc/queue.c       val = Comp(key, index[ mid ]);
key               201 ext/xmlrpc/libxmlrpc/xml_element.c          my_free(attrs->key);
key               425 ext/xmlrpc/libxmlrpc/xml_element.c             xml_elem_writefunc(fptr, iter->key, data, 0);
key               612 ext/xmlrpc/libxmlrpc/xml_element.c             attr->key = strdup(*p);
key               137 ext/xmlrpc/libxmlrpc/xml_element.h    char* key;        /* attribute key   */
key                76 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          if(!strcmp(attr_iter->key, ATTR_ID)) {
key                79 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          if(!strcmp(attr_iter->key, ATTR_TYPE)) {
key               186 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          attr_type->key = strdup(ATTR_TYPE);
key               196 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c             attr_id->key = strdup(ATTR_ID);
key               286 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       version->key = strdup(ATTR_VERSION);
key                68 ext/xmlrpc/libxmlrpc/xml_to_soap.c static xml_element_attr* new_attr(const char* key, const char* val) {
key                71 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		attr->key = key ? strdup(key) : NULL;
key               271 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			if (!strcmp(attr_iter->key, TOKEN_TYPE)) {
key               275 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(attr_iter->key, TOKEN_ARRAY_TYPE)) {
key               279 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(attr_iter->key, TOKEN_MUSTUNDERSTAND)) {
key               283 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(attr_iter->key, TOKEN_ACTOR)) {
key               323 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          if(!strcmp(attr_iter->key, "name")) {
key               326 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          else if(!strcmp(attr_iter->key, "type")) {
key               329 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          else if(!strcmp(attr_iter->key, "basetype")) {
key               332 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          else if(!strcmp(attr_iter->key, "desc")) {
key               335 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          else if(!strcmp(attr_iter->key, "optional")) {
key               340 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          else if(!strcmp(attr_iter->key, "default")) {
key               500 ext/xmlrpc/xmlrpc-epi-php.c static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int depth)
key               516 ext/xmlrpc/xmlrpc-epi-php.c 						XMLRPC_SetValueID(xReturn, key, 0);
key               522 ext/xmlrpc/xmlrpc-epi-php.c 							xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(newvalue), Z_STRLEN(newvalue));
key               525 ext/xmlrpc/xmlrpc-epi-php.c 							xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(val), Z_STRLEN(val));
key               531 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL(val));
key               535 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE(val) == IS_TRUE);
key               539 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueInt(key, Z_LVAL(val));
key               543 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL(val));
key               547 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueString(key, Z_STRVAL(val), Z_STRLEN(val));
key               568 ext/xmlrpc/xmlrpc-epi-php.c 						xReturn = XMLRPC_CreateVector(key, vtype);
key                42 ext/zip/lib/zip_source_pkware.c     zip_uint32_t key[3];
key                82 ext/zip/lib/zip_source_pkware.c     ctx->key[0] = KEY0;
key                83 ext/zip/lib/zip_source_pkware.c     ctx->key[1] = KEY1;
key                84 ext/zip/lib/zip_source_pkware.c     ctx->key[2] = KEY2;
key               109 ext/zip/lib/zip_source_pkware.c 	    tmp = (zip_uint16_t)(ctx->key[2] | 2);
key               119 ext/zip/lib/zip_source_pkware.c 	ctx->key[0] = (zip_uint32_t)crc32(ctx->key[0] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key               120 ext/zip/lib/zip_source_pkware.c 	ctx->key[1] = (ctx->key[1] + (ctx->key[0] & 0xff)) * 134775813 + 1;
key               121 ext/zip/lib/zip_source_pkware.c 	b = (Bytef)(ctx->key[1] >> 24);
key               122 ext/zip/lib/zip_source_pkware.c 	ctx->key[2] = (zip_uint32_t)crc32(ctx->key[2] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key               537 ext/zip/lib/zipint.h bool _zip_hash_delete(zip_hash_t *hash, const zip_uint8_t *key, zip_error_t *error);
key               966 ext/zip/php_zip.c 	zend_string *key;
key               975 ext/zip/php_zip.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(obj->prop_handler, key, hnd) {
key               981 ext/zip/php_zip.c 		zend_hash_update(props, key, ret);
key               782 main/SAPI.c    					zend_string *key = zend_string_init("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
key               783 main/SAPI.c    					zend_alter_ini_entry_chars(key, "0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
key               784 main/SAPI.c    					zend_string_release(key);
key               810 main/SAPI.c    				zend_string *key = zend_string_init("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
key               811 main/SAPI.c    				zend_alter_ini_entry_chars(key,
key               813 main/SAPI.c    				zend_string_release(key);
key              1289 main/main.c    	zend_string *key;
key              1297 main/main.c    	key = zend_string_init("max_execution_time", sizeof("max_execution_time")-1, 0);
key              1298 main/main.c    	if (zend_alter_ini_entry_chars_ex(key, new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0) == SUCCESS) {
key              1303 main/main.c    	zend_string_release(key);
key               279 main/php_ini.c 				char *key = NULL;
key               284 main/php_ini.c 					key = Z_STRVAL_P(arg1);
key               285 main/php_ini.c 					key = key + sizeof("PATH") - 1;
key               291 main/php_ini.c 					TRANSLATE_SLASHES_LOWER(key);
key               295 main/php_ini.c 					key = Z_STRVAL_P(arg1);
key               296 main/php_ini.c 					key = key + sizeof("HOST") - 1;
key               300 main/php_ini.c 					zend_str_tolower(key, key_len); /* host names are case-insensitive. */
key               306 main/php_ini.c 				if (key && key_len > 0) {
key               308 main/php_ini.c 					while (key_len > 0 && (key[key_len - 1] == '/' || key[key_len - 1] == '\\')) {
key               310 main/php_ini.c 						key[key_len] = 0;
key               314 main/php_ini.c 					while (*key && (
key               315 main/php_ini.c 						*key == '=' ||
key               316 main/php_ini.c 						*key == ' ' ||
key               317 main/php_ini.c 						*key == '\t'
key               319 main/php_ini.c 						key++;
key               324 main/php_ini.c 					if ((entry = zend_hash_str_find(target_hash, key, key_len)) == NULL) {
key               329 main/php_ini.c 						entry = zend_hash_str_update(target_hash, key, key_len, &section_arr);
key               238 main/rfc1867.c 	char *key;
key               382 main/rfc1867.c 	if (h->key) {
key               383 main/rfc1867.c 		efree(h->key);
key               414 main/rfc1867.c 	char *key = NULL;
key               437 main/rfc1867.c 			if (buf_value.c && key) {
key               440 main/rfc1867.c 				entry.key = key;
key               444 main/rfc1867.c 				key = NULL;
key               450 main/rfc1867.c 			key = estrdup(line);
key               459 main/rfc1867.c 	if (buf_value.c && key) {
key               462 main/rfc1867.c 		entry.key = key;
key               470 main/rfc1867.c static char *php_mime_get_hdr_value(zend_llist header, char *key)
key               474 main/rfc1867.c 	if (key == NULL) {
key               480 main/rfc1867.c 		if (!strcasecmp(entry->key, key)) {
key               815 main/rfc1867.c 				char *key = NULL, *word = pair;
key               822 main/rfc1867.c 					key = getword(mbuff->input_encoding, &pair, '=');
key               824 main/rfc1867.c 					if (!strcasecmp(key, "name")) {
key               837 main/rfc1867.c 					} else if (!strcasecmp(key, "filename")) {
key               852 main/rfc1867.c 				if (key) {
key               853 main/rfc1867.c 					efree(key);
key               627 main/streams/memory.c 	char *comma, *semi, *sep, *key;
key               699 main/streams/memory.c 			key = estrndup(path, plen);
key               700 main/streams/memory.c 			if (plen != sizeof("mediatype")-1 || memcmp(key, "mediatype", sizeof("mediatype")-1)) {
key               701 main/streams/memory.c 				add_assoc_stringl_ex(&meta, key, plen, sep + 1, vlen);
key               703 main/streams/memory.c 			efree(key);
key               125 sapi/apache2handler/apache_config.c 	if ((orig_per_dir_entry = zend_hash_find_ptr(target_ht, hash_key->key)) == NULL) {
key                61 sapi/apache2handler/php_apache.h #define APR_ARRAY_FOREACH_OPEN(arr, key, val) 		\
key                67 sapi/apache2handler/php_apache.h 		key = elts[i].key;							\
key               177 sapi/apache2handler/php_functions.c 	char *key, *val;
key               188 sapi/apache2handler/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               190 sapi/apache2handler/php_functions.c 		add_assoc_string(return_value, key, val);
key               201 sapi/apache2handler/php_functions.c 	char *key, *val;
key               212 sapi/apache2handler/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               214 sapi/apache2handler/php_functions.c 		add_assoc_string(return_value, key, val);
key               442 sapi/apache2handler/php_functions.c 		char *key, *val;
key               447 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               451 sapi/apache2handler/php_functions.c 			php_info_print_table_row(2, key, val);
key               462 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               466 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
key               471 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               475 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
key               274 sapi/apache2handler/sapi_apache2.c 	char *key, *val;
key               277 sapi/apache2handler/sapi_apache2.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               281 sapi/apache2handler/sapi_apache2.c 		if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len)) {
key               282 sapi/apache2handler/sapi_apache2.c 			php_register_variable_safe(key, val, new_val_len, track_vars_array);
key               363 sapi/cli/php_cli_server.c 	zend_string *key;
key               376 sapi/cli/php_cli_server.c 	ZEND_HASH_FOREACH_STR_KEY_PTR(headers, key, value) {
key               378 sapi/cli/php_cli_server.c 		zend_symtable_update(Z_ARRVAL_P(return_value), key, &tmp);
key               579 sapi/cli/php_cli_server.c static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val) /* {{{ */
key               588 sapi/cli/php_cli_server.c 	if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len)) {
key               589 sapi/cli/php_cli_server.c 		php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array);
key               595 sapi/cli/php_cli_server.c 	if (hash_key->key) {
key               596 sapi/cli/php_cli_server.c 		char *real_key, *key;
key               598 sapi/cli/php_cli_server.c 		key = estrndup(ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key));
key               599 sapi/cli/php_cli_server.c 		for(i=0; i<ZSTR_LEN(hash_key->key); i++) {
key               600 sapi/cli/php_cli_server.c 			if (key[i] == '-') {
key               601 sapi/cli/php_cli_server.c 				key[i] = '_';
key               603 sapi/cli/php_cli_server.c 				key[i] = toupper(key[i]);
key               606 sapi/cli/php_cli_server.c 		spprintf(&real_key, 0, "%s_%s", "HTTP", key);
key               607 sapi/cli/php_cli_server.c 		if (strcmp(key, "CONTENT_TYPE") == 0 || strcmp(key, "CONTENT_LENGTH") == 0) {
key               608 sapi/cli/php_cli_server.c 			sapi_cli_server_register_variable(track_vars_array, key, *entry);
key               611 sapi/cli/php_cli_server.c 		efree(key);
key               545 sapi/fpm/fpm/fpm_conf.c static char *fpm_conf_set_array(zval *key, zval *value, void **config, int convert_to_bool) /* {{{ */
key               559 sapi/fpm/fpm/fpm_conf.c 	kv->key = strdup(Z_STRVAL_P(key));
key               561 sapi/fpm/fpm/fpm_conf.c 	if (!kv->key) {
key               569 sapi/fpm/fpm/fpm_conf.c 			free(kv->key);
key               577 sapi/fpm/fpm/fpm_conf.c 			free(kv->key);
key               584 sapi/fpm/fpm/fpm_conf.c 		free(kv->key);
key               664 sapi/fpm/fpm/fpm_conf.c 		free(kv->key);
key               670 sapi/fpm/fpm/fpm_conf.c 		free(kv->key);
key               676 sapi/fpm/fpm/fpm_conf.c 		free(kv->key);
key              1078 sapi/fpm/fpm/fpm_conf.c 					if (!strcasecmp(kv->key, *p)) {
key              1084 sapi/fpm/fpm/fpm_conf.c 				if (!strcasecmp(kv->key, "error_log") && !strcasecmp(kv->value, "syslog")) {
key              1088 sapi/fpm/fpm/fpm_conf.c 					if (!strcasecmp(kv->key, *p)) {
key              1401 sapi/fpm/fpm/fpm_conf.c static void fpm_conf_ini_parser_array(zval *name, zval *key, zval *value, void *arg) /* {{{ */
key              1407 sapi/fpm/fpm/fpm_conf.c 	if (!Z_STRVAL_P(key) || !Z_STRVAL_P(value) || !*Z_STRVAL_P(key)) {
key              1425 sapi/fpm/fpm/fpm_conf.c 		err = fpm_conf_set_array(key, value, &config, 0);
key              1429 sapi/fpm/fpm/fpm_conf.c 		err = fpm_conf_set_array(key, value, &config, 0);
key              1433 sapi/fpm/fpm/fpm_conf.c 		err = fpm_conf_set_array(key, value, &config, 0);
key              1437 sapi/fpm/fpm/fpm_conf.c 		err = fpm_conf_set_array(key, value, &config, 1);
key              1441 sapi/fpm/fpm/fpm_conf.c 		err = fpm_conf_set_array(key, value, &config, 1);
key              1450 sapi/fpm/fpm/fpm_conf.c 		zlog(ZLOG_ERROR, "[%s:%d] error while parsing '%s[%s]' : %s", ini_filename, ini_lineno, Z_STRVAL_P(name), Z_STRVAL_P(key), err);
key              1648 sapi/fpm/fpm/fpm_conf.c 			zlog(ZLOG_NOTICE, "\tenv[%s] = %s", kv->key, kv->value);
key              1652 sapi/fpm/fpm/fpm_conf.c 			zlog(ZLOG_NOTICE, "\tphp_value[%s] = %s", kv->key, kv->value);
key              1656 sapi/fpm/fpm/fpm_conf.c 			zlog(ZLOG_NOTICE, "\tphp_admin_value[%s] = %s", kv->key, kv->value);
key                19 sapi/fpm/fpm/fpm_conf.h 	char *key;
key               151 sapi/fpm/fpm/fpm_env.c 		setenv(kv->key, kv->value, 1);
key               184 sapi/fpm/fpm/fpm_env.c 		if (!strcmp(kv->key, "USER")) {
key               189 sapi/fpm/fpm/fpm_env.c 		if (!strcmp(kv->key, "HOME")) {
key              1429 sapi/fpm/fpm/fpm_main.c 	char *key;
key              1440 sapi/fpm/fpm/fpm_main.c 	key = Z_STRVAL_P(arg1);
key              1442 sapi/fpm/fpm/fpm_main.c 	if (!key || strlen(key) < 1) {
key              1452 sapi/fpm/fpm/fpm_main.c 		zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: empty value for key '%s'", key);
key              1456 sapi/fpm/fpm/fpm_main.c 	kv.key = key;
key              1460 sapi/fpm/fpm/fpm_main.c 		zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: unable to set '%s'", key);
key                82 sapi/fpm/fpm/fpm_php.c 	char *name = kv->key;
key               121 sapi/fpm/fpm/fpm_php.c 			zlog(ZLOG_ERROR, "Unable to set php_value '%s'", kv->key);
key               127 sapi/fpm/fpm/fpm_php.c 			zlog(ZLOG_ERROR, "Unable to set php_admin_value '%s'", kv->key);
key               259 sapi/fpm/fpm/fpm_php.c char* fpm_php_get_string_from_table(zend_string *table, char *key) /* {{{ */
key               263 sapi/fpm/fpm/fpm_php.c 	if (!table || !key) {
key               278 sapi/fpm/fpm/fpm_php.c 		if (str && !strncmp(ZSTR_VAL(str), key, ZSTR_LEN(str))) {
key                47 sapi/fpm/fpm/fpm_php.h char* fpm_php_get_string_from_table(zend_string *table, char *key);
key                37 sapi/fpm/fpm/fpm_sockets.c 	char *key;
key                57 sapi/fpm/fpm/fpm_sockets.c 			env_value = realloc(env_value, p + (p ? 1 : 0) + strlen(ls->key) + 1 + strlen(fd) + 1);
key                58 sapi/fpm/fpm/fpm_sockets.c 			p += sprintf(env_value + p, "%s%s=%s", p ? "," : "", ls->key, fd);
key                63 sapi/fpm/fpm/fpm_sockets.c 				unlink(ls->key);
key                66 sapi/fpm/fpm/fpm_sockets.c 		free(ls->key);
key                98 sapi/fpm/fpm/fpm_sockets.c static int fpm_sockets_hash_op(int sock, struct sockaddr *sa, char *key, int type, int op) /* {{{ */
key               100 sapi/fpm/fpm/fpm_sockets.c 	if (key == NULL) {
key               103 sapi/fpm/fpm/fpm_sockets.c 				key = alloca(INET6_ADDRSTRLEN+10);
key               104 sapi/fpm/fpm/fpm_sockets.c 				inet_ntop(sa->sa_family, fpm_get_in_addr(sa), key, INET6_ADDRSTRLEN);
key               105 sapi/fpm/fpm/fpm_sockets.c 				sprintf(key+strlen(key), ":%d", fpm_get_in_port(sa));
key               111 sapi/fpm/fpm/fpm_sockets.c 				key = alloca(strlen(sa_un->sun_path) + 1);
key               112 sapi/fpm/fpm/fpm_sockets.c 				strcpy(key, sa_un->sun_path);
key               129 sapi/fpm/fpm/fpm_sockets.c 				if (!strcmp(ls->key, key)) {
key               154 sapi/fpm/fpm/fpm_sockets.c 			ls->key = strdup(key);
key               391 sapi/fpm/fpm/fpm_sockets.c 				unlink(ls->key);
key               393 sapi/fpm/fpm/fpm_sockets.c 			free(ls->key);
key                78 sapi/phpdbg/phpdbg.h #define zend_hash_str_add_tmp(ht, key, len, pData) \
key                79 sapi/phpdbg/phpdbg.h 	_zend_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
key               154 sapi/phpdbg/phpdbg_help.c static char *get_help(const char * const key)
key               162 sapi/phpdbg/phpdbg_help.c 	for (p = phpdbg_help_text; p->key; p++) {
key               163 sapi/phpdbg/phpdbg_help.c 		if (!strcmp(p->key, key)) {
key               180 sapi/phpdbg/phpdbg_help.c 	const char *key, size_t len,      /* pointer and length of key */
key               190 sapi/phpdbg/phpdbg_help.c 			if (c->alias == key[0]) {
key               199 sapi/phpdbg/phpdbg_help.c 			if (!strncmp(c->name, key, len)) {
key                43 sapi/phpdbg/phpdbg_help.h 	char *key;
key               415 sapi/phpdbg/phpdbg_utils.c char *phpdbg_get_property_key(char *key) {
key               416 sapi/phpdbg/phpdbg_utils.c 	if (*key != 0) {
key               417 sapi/phpdbg/phpdbg_utils.c 		return key;
key               419 sapi/phpdbg/phpdbg_utils.c 	return strchr(key + 1, 0) + 1;
key               479 sapi/phpdbg/phpdbg_utils.c 					char *key, *propkey;
key               484 sapi/phpdbg/phpdbg_utils.c 						key = ZSTR_VAL(strkey);
key               487 sapi/phpdbg/phpdbg_utils.c 						keylen = spprintf(&key, 0, ZEND_ULONG_FMT, numkey);
key               489 sapi/phpdbg/phpdbg_utils.c 					propkey = phpdbg_get_property_key(key);
key               491 sapi/phpdbg/phpdbg_utils.c 					namelen = sprintf(name, "%.*s%.*s%s", (int) i, input, (int) (keylen - (propkey - key)), propkey, input[len - 1] == ']'?"]":"");
key               493 sapi/phpdbg/phpdbg_utils.c 						efree(key);
key               595 sapi/phpdbg/phpdbg_utils.c static int phpdbg_xml_array_element_dump(zval *zv, zend_string *key, zend_ulong num) {
key               599 sapi/phpdbg/phpdbg_utils.c 		if (key) { /* string key */
key               600 sapi/phpdbg/phpdbg_utils.c 			phpdbg_xml(" name=\"%.*s\"", (int) ZSTR_LEN(key), ZSTR_VAL(key));
key               618 sapi/phpdbg/phpdbg_utils.c static int phpdbg_xml_object_property_dump(zval *zv, zend_string *key, zend_ulong num) {
key               622 sapi/phpdbg/phpdbg_utils.c 		if (key) { /* string key */
key               624 sapi/phpdbg/phpdbg_utils.c 			int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
key               634 sapi/phpdbg/phpdbg_utils.c 				phpdbg_xml(" name=\"%.*s\" protection=\"public\"", (int) ZSTR_LEN(key), ZSTR_VAL(key));
key               657 sapi/phpdbg/phpdbg_utils.c 	zend_string *class_name, *key;
key               660 sapi/phpdbg/phpdbg_utils.c 	int (*element_dump_func)(zval *zv, zend_string *key, zend_ulong num);
key               714 sapi/phpdbg/phpdbg_utils.c 					ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
key               715 sapi/phpdbg/phpdbg_utils.c 						element_dump_func(val, key, num);
key                86 sapi/phpdbg/phpdbg_utils.h char *phpdbg_get_property_key(char *key);
key               300 sapi/phpdbg/phpdbg_wait.c 		zend_string *key;
key               302 sapi/phpdbg/phpdbg_wait.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(zvp), key, ini_entry) {
key               303 sapi/phpdbg/phpdbg_wait.c 			if (key && Z_TYPE_P(ini_entry) == IS_STRING) {
key               304 sapi/phpdbg/phpdbg_wait.c 				if ((original_ini = zend_hash_find_ptr(EG(ini_directives), key))) {
key               319 sapi/phpdbg/phpdbg_wait.c 		zend_string *key;
key               321 sapi/phpdbg/phpdbg_wait.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(zvp), key, ini_entry) {
key               322 sapi/phpdbg/phpdbg_wait.c 			if (key && Z_TYPE_P(ini_entry) == IS_STRING) {
key               323 sapi/phpdbg/phpdbg_wait.c 				zend_alter_ini_entry_ex(key, Z_STR_P(ini_entry), ZEND_INI_PERDIR, ZEND_INI_STAGE_HTACCESS, 1);
key               455 sapi/phpdbg/phpdbg_watch.c 	zend_string *key;
key               460 sapi/phpdbg/phpdbg_watch.c 	ZEND_HASH_FOREACH_KEY_VAL(HT_WATCH_HT(watch), h, key, zv) {
key               467 sapi/phpdbg/phpdbg_watch.c 		if (key) {
key               468 sapi/phpdbg/phpdbg_watch.c 			new_watch->name_in_parent = key;
key               469 sapi/phpdbg/phpdbg_watch.c 			++GC_REFCOUNT(key);
key               629 sapi/phpdbg/phpdbg_watch.c static int phpdbg_watchpoint_parse_wrapper(char *name, size_t namelen, char *key, size_t keylen, HashTable *parent, zval *zv, int (*callback)(phpdbg_watchpoint_t *)) {
key               633 sapi/phpdbg/phpdbg_watch.c 	watch->name_in_parent = zend_string_init(key, keylen, 0);
key               640 sapi/phpdbg/phpdbg_watch.c 	efree(key);
key               656 sapi/phpdbg/phpdbg_watch.c static int phpdbg_watchpoint_parse_step(char *name, size_t namelen, char *key, size_t keylen, HashTable *parent, zval *zv, int (*callback)(phpdbg_watchpoint_t *)) {
key               668 sapi/phpdbg/phpdbg_watch.c 	watch->name_in_parent = zend_string_init(key, keylen, 0);
key               676 sapi/phpdbg/phpdbg_watch.c 	efree(key);
key                78 win32/registry.c static int LoadDirectory(HashTable *directories, HKEY key, char *path, int path_len, HashTable *parent_ht)
key                84 win32/registry.c 	if (RegQueryInfoKey(key, NULL, NULL, NULL, &keys, &max_key, NULL, &values, &max_name, &max_value, NULL, NULL) == ERROR_SUCCESS) {
key                99 win32/registry.c 				if (RegEnumValue(key, i, name, &name_len, NULL, &type, value, &value_len) == ERROR_SUCCESS) {
key               147 win32/registry.c 				if (RegEnumKeyEx(key, i, name, &name_len, NULL, NULL, NULL, &t) == ERROR_SUCCESS) {
key               148 win32/registry.c 					if (RegOpenKeyEx(key, name, 0, KEY_READ, &subkey) == ERROR_SUCCESS) {