key               410 TSRM/tsrm_win32.c static shm_pair *shm_get(int key, void *addr)
key               420 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 	sprintf(shm_segment, "TSRM_SHM_SEGMENT:%d", key);
key               603 TSRM/tsrm_win32.c 	sprintf(shm_info, "TSRM_SHM_DESCRIPTOR:%d", key);
key               623 TSRM/tsrm_win32.c 	shm = shm_get(key, NULL);
key               629 TSRM/tsrm_win32.c 		shm->descriptor->shm_perm.key	= key;
key               642 TSRM/tsrm_win32.c 	if (NULL != shm->descriptor && (shm->descriptor->shm_perm.key != key || size > shm->descriptor->shm_segsz)) {
key               651 TSRM/tsrm_win32.c 	return key;
key               654 TSRM/tsrm_win32.c TSRM_API void *shmat(int key, const void *shmaddr, int flags)
key               656 TSRM/tsrm_win32.c 	shm_pair *shm = shm_get(key, NULL);
key               686 TSRM/tsrm_win32.c TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf) {
key               687 TSRM/tsrm_win32.c 	shm_pair *shm = shm_get(key, NULL);
key               707 TSRM/tsrm_win32.c 				shm->descriptor->shm_perm.key = -1;
key                28 TSRM/tsrm_win32.h 	int			key;
key               104 TSRM/tsrm_win32.h TSRM_API int shmget(int key, int size, int flags);
key               105 TSRM/tsrm_win32.h TSRM_API void *shmat(int key, const void *shmaddr, int flags);
key               107 TSRM/tsrm_win32.h TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf);
key               177 Zend/zend.c    					char key[25];
key               178 Zend/zend.c    					snprintf(key, sizeof(key), "%ld", num_key);
key               179 Zend/zend.c    					ZEND_PUTS_EX(key);
key              1217 Zend/zend_API.c ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS)) /* {{{ */
key              1224 Zend/zend_API.c ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n) /* {{{ */
key              1231 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1235 Zend/zend_API.c ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len) /* {{{ */
key              1242 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1246 Zend/zend_API.c ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b) /* {{{ */
key              1253 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1257 Zend/zend_API.c ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r) /* {{{ */
key              1264 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1268 Zend/zend_API.c ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d) /* {{{ */
key              1275 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1279 Zend/zend_API.c ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate) /* {{{ */
key              1286 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1290 Zend/zend_API.c ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate) /* {{{ */
key              1297 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key              1301 Zend/zend_API.c ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value) /* {{{ */
key              1303 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
key              1473 Zend/zend_API.c ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate) /* {{{ */
key              1480 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key              1484 Zend/zend_API.c ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate) /* {{{ */
key              1491 Zend/zend_API.c 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key              1539 Zend/zend_API.c ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value) /* {{{ */
key              1543 Zend/zend_API.c 	switch (Z_TYPE_P(key)) {
key              1545 Zend/zend_API.c 			result = zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
key              1551 Zend/zend_API.c 			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(key), Z_LVAL_P(key));
key              1555 Zend/zend_API.c 			result = zend_hash_index_update(ht, Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key              1558 Zend/zend_API.c 			result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), &value, sizeof(zval *), NULL);
key              1573 Zend/zend_API.c ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long n TSRMLS_DC) /* {{{ */
key              1582 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1591 Zend/zend_API.c ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC) /* {{{ */
key              1600 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1609 Zend/zend_API.c ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC) /* {{{ */
key              1618 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1627 Zend/zend_API.c ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long n TSRMLS_DC) /* {{{ */
key              1636 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1645 Zend/zend_API.c ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC) /* {{{ */
key              1654 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1663 Zend/zend_API.c ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC) /* {{{ */
key              1672 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1681 Zend/zend_API.c ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate TSRMLS_DC) /* {{{ */
key              1690 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key              1699 Zend/zend_API.c ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC) /* {{{ */
key              1704 Zend/zend_API.c 	ZVAL_STRINGL(z_key, key, key_len-1, 1);
key               377 Zend/zend_API.h ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
key               379 Zend/zend_API.h ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
key               380 Zend/zend_API.h ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
key               381 Zend/zend_API.h ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
key               382 Zend/zend_API.h ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
key               383 Zend/zend_API.h ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
key               384 Zend/zend_API.h ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
key               385 Zend/zend_API.h ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
key               386 Zend/zend_API.h ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
key               421 Zend/zend_API.h ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
key               422 Zend/zend_API.h ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate);
key               432 Zend/zend_API.h ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
key               434 Zend/zend_API.h ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC);
key               435 Zend/zend_API.h ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC);
key               436 Zend/zend_API.h ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
key               437 Zend/zend_API.h ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
key               438 Zend/zend_API.h ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
key               439 Zend/zend_API.h ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
key               440 Zend/zend_API.h ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length, int duplicate TSRMLS_DC);
key               441 Zend/zend_API.h ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
key               530 Zend/zend_API.h #define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
key               912 Zend/zend_builtin_functions.c 	char *key;
key               918 Zend/zend_builtin_functions.c 		zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key               953 Zend/zend_builtin_functions.c 		zend_hash_update(Z_ARRVAL_P(return_value), key, key_len, &prop_copy, sizeof(zval*), NULL);
key               991 Zend/zend_builtin_functions.c 	char *key;
key              1018 Zend/zend_builtin_functions.c 		if (zend_hash_get_current_key_ex(properties, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
key              1019 Zend/zend_builtin_functions.c 			if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
key              1020 Zend/zend_builtin_functions.c 				zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
key              1023 Zend/zend_builtin_functions.c 				if (IS_INTERNED(key) && prop_name != key) {
key              1038 Zend/zend_builtin_functions.c static int same_name(const char *key, const char *name, zend_uint name_len)
key              1041 Zend/zend_builtin_functions.c 	int ret = memcmp(lcname, key, name_len) == 0;
key              1086 Zend/zend_builtin_functions.c 			char *key;
key              1092 Zend/zend_builtin_functions.c 			if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING) {
key              1098 Zend/zend_builtin_functions.c 			    zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0) {
key              1103 Zend/zend_builtin_functions.c 			    	 !same_name(key, mptr->common.function_name, len))) {
key              1105 Zend/zend_builtin_functions.c 					ZVAL_STRINGL(method_name, zend_find_alias_name(mptr->common.scope, key, key_len - 1), key_len - 1, 1);
key               198 Zend/zend_closures.c static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
key               212 Zend/zend_closures.c 	return std_object_handlers.get_method(object_ptr, method_name, method_len, key TSRMLS_CC);
key               216 Zend/zend_closures.c static zval *zend_closure_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               224 Zend/zend_closures.c static void zend_closure_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
key               230 Zend/zend_closures.c static zval **zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               237 Zend/zend_closures.c static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
key               246 Zend/zend_closures.c static void zend_closure_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1711 Zend/zend_compile.c 		zval key;
key              1743 Zend/zend_compile.c 		build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC);
key              1744 Zend/zend_compile.c 		opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key              1750 Zend/zend_compile.c 		zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
key              2872 Zend/zend_compile.c void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */
key              2904 Zend/zend_compile.c 	if (key) {
key              2905 Zend/zend_compile.c 		SET_NODE(opline->op2, key);
key              3888 Zend/zend_compile.c static int do_interface_constant_check(zval **val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
key              3892 Zend/zend_compile.c 	do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
key              5130 Zend/zend_compile.c 	zval **ns_name, key;
key              5202 Zend/zend_compile.c 	build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);
key              5203 Zend/zend_compile.c 	opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key              5223 Zend/zend_compile.c 	zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL);
key              6427 Zend/zend_compile.c void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */
key              6434 Zend/zend_compile.c 	if (key->op_type != IS_UNUSED) {
key              6438 Zend/zend_compile.c 		tmp = key;
key              6439 Zend/zend_compile.c 		key = value;
key              6446 Zend/zend_compile.c 	if ((key->op_type != IS_UNUSED)) {
key              6447 Zend/zend_compile.c 		if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
key              6450 Zend/zend_compile.c 		if (key->EA & ZEND_PARSED_LIST_EXPR) {
key              6499 Zend/zend_compile.c 	if (key->op_type != IS_UNUSED) {
key              6507 Zend/zend_compile.c 		zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
key               528 Zend/zend_compile.h void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC);
key               622 Zend/zend_compile.h void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC);
key               438 Zend/zend_constants.c zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC)
key               442 Zend/zend_constants.c 	if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
key               443 Zend/zend_constants.c 		key++;
key               444 Zend/zend_constants.c 		if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
key               447 Zend/zend_constants.c 				key++;
key               448 Zend/zend_constants.c 				if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
key               449 Zend/zend_constants.c 				    key++;
key               450 Zend/zend_constants.c 					if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
key               453 Zend/zend_constants.c 						key--;
key               454 Zend/zend_constants.c 						if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key               460 Zend/zend_constants.c 				key--;
key               461 Zend/zend_constants.c 				if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key                80 Zend/zend_constants.h zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC);
key               387 Zend/zend_exceptions.c #define TRACE_APPEND_KEY(key)                                                   \
key               388 Zend/zend_exceptions.c 	if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) {    \
key               390 Zend/zend_exceptions.c 			zend_error(E_WARNING, "Value for %s is no string", key); \
key               688 Zend/zend_execute.c static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval *property_name, int value_type, znode_op *value_op, const zend_execute_data *execute_data, int opcode, const zend_literal *key TSRMLS_DC)
key               769 Zend/zend_execute.c 		Z_OBJ_HT_P(object)->write_property(object, property_name, value, key TSRMLS_CC);
key              1396 Zend/zend_execute.c static void zend_fetch_property_address(temp_variable *result, zval **container_ptr, zval *prop_ptr, const zend_literal *key, int type TSRMLS_DC)
key              1426 Zend/zend_execute.c 		zval **ptr_ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, key TSRMLS_CC);
key              1431 Zend/zend_execute.c 				(ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC)) != NULL) {
key              1442 Zend/zend_execute.c 		zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC);
key                65 Zend/zend_execute.h ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
key               362 Zend/zend_execute.h ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
key               903 Zend/zend_execute_API.c ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
key               918 Zend/zend_execute_API.c 	if (key) {
key               919 Zend/zend_execute_API.c 		lc_name = Z_STRVAL(key->constant);
key               920 Zend/zend_execute_API.c 		lc_length = Z_STRLEN(key->constant) + 1;
key               921 Zend/zend_execute_API.c 		hash = key->hash_value;
key               940 Zend/zend_execute_API.c 		if (!key) {
key               950 Zend/zend_execute_API.c 		if (!key) {
key               958 Zend/zend_execute_API.c 		if (!key) {
key               970 Zend/zend_execute_API.c 		if (!key) {
key              1021 Zend/zend_execute_API.c 	if (!key) {
key              1410 Zend/zend_execute_API.c zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */
key              1415 Zend/zend_execute_API.c 	if (zend_lookup_class_ex(class_name, class_name_len, key, use_autoload, &pce TSRMLS_CC) == FAILURE) {
key               106 Zend/zend_generators.c 	if (generator->key) {
key               107 Zend/zend_generators.c 		zval_ptr_dtor(&generator->key);
key               108 Zend/zend_generators.c 		generator->key = NULL;
key               243 Zend/zend_generators.c static void copy_closure_static_var(zval **var TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
key               249 Zend/zend_generators.c 	zend_hash_quick_update(target, key->arKey, key->nKeyLength, key->h, var, sizeof(zval *), NULL);
key               480 Zend/zend_generators.c ZEND_METHOD(Generator, key)
key               492 Zend/zend_generators.c 	if (generator->key) {
key               493 Zend/zend_generators.c 		RETURN_ZVAL_FAST(generator->key);
key               641 Zend/zend_generators.c static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key TSRMLS_DC) /* {{{ */
key               647 Zend/zend_generators.c 	if (generator->key) {
key               648 Zend/zend_generators.c 		ZVAL_ZVAL(key, generator->key, 1, 0);
key               650 Zend/zend_generators.c 		ZVAL_NULL(key);
key               727 Zend/zend_generators.c 	ZEND_ME(Generator, key,      arginfo_generator_void, ZEND_ACC_PUBLIC)
key                50 Zend/zend_generators.h 	zval *key;
key              1095 Zend/zend_hash.c ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos) {
key              1103 Zend/zend_hash.c 		Z_TYPE_P(key) = IS_NULL;
key              1105 Zend/zend_hash.c 		Z_TYPE_P(key) = IS_STRING;
key              1106 Zend/zend_hash.c 		Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
key              1107 Zend/zend_hash.c 		Z_STRLEN_P(key) = p->nKeyLength - 1;
key              1109 Zend/zend_hash.c 		Z_TYPE_P(key) = IS_LONG;
key              1110 Zend/zend_hash.c 		Z_LVAL_P(key) = p->h;
key               180 Zend/zend_hash.h ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
key               203 Zend/zend_hash.h #define zend_hash_get_current_key_zval(ht, key) \
key               204 Zend/zend_hash.h 	zend_hash_get_current_key_zval_ex(ht, key, NULL)
key               315 Zend/zend_hash.h #define ZEND_HANDLE_NUMERIC_EX(key, length, idx, func) do {					\
key               316 Zend/zend_hash.h 	register const char *tmp = key;											\
key               322 Zend/zend_hash.h 		const char *end = key + length - 1;									\
key               337 Zend/zend_hash.h 			if (*key == '-') {												\
key               350 Zend/zend_hash.h #define ZEND_HANDLE_NUMERIC(key, length, func) do {							\
key               353 Zend/zend_hash.h 	ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func);					\
key               198 Zend/zend_interfaces.c ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key TSRMLS_DC)
key               207 Zend/zend_interfaces.c 		ZVAL_ZVAL(key, retval, 1, 1);
key               213 Zend/zend_interfaces.c 		ZVAL_LONG(key, 0);
key               500 Zend/zend_interfaces.c 	ZEND_ABSTRACT_ME(iterator, key,      NULL)
key                54 Zend/zend_interfaces.h ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key TSRMLS_DC);
key                45 Zend/zend_iterators.h 	void (*get_current_key)(zend_object_iterator *iter, zval *key TSRMLS_DC);
key               302 Zend/zend_object_handlers.c static zend_always_inline struct _zend_property_info *zend_get_property_info_quick(zend_class_entry *ce, zval *member, int silent, const zend_literal *key TSRMLS_DC) /* {{{ */
key               309 Zend/zend_object_handlers.c 	if (key && (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) != NULL) {
key               324 Zend/zend_object_handlers.c 	h = key ? key->hash_value : zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
key               341 Zend/zend_object_handlers.c 					if (key) {
key               342 Zend/zend_object_handlers.c 						CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key               357 Zend/zend_object_handlers.c 		if (key) {
key               358 Zend/zend_object_handlers.c 			CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, scope_property_info);
key               370 Zend/zend_object_handlers.c 			if (key) {
key               371 Zend/zend_object_handlers.c 				CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key               454 Zend/zend_object_handlers.c zval *zend_std_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               473 Zend/zend_object_handlers.c 		key = NULL;
key               481 Zend/zend_object_handlers.c 	property_info = zend_get_property_info_quick(zobj->ce, member, silent || (zobj->ce->__get != NULL), key TSRMLS_CC);
key               555 Zend/zend_object_handlers.c ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
key               571 Zend/zend_object_handlers.c 		key = NULL;
key               574 Zend/zend_object_handlers.c 	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__set != NULL), key TSRMLS_CC);
key               749 Zend/zend_object_handlers.c static zval **zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               763 Zend/zend_object_handlers.c 		key = NULL;
key               770 Zend/zend_object_handlers.c 	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__get != NULL), key TSRMLS_CC);
key               826 Zend/zend_object_handlers.c static void zend_std_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
key               841 Zend/zend_object_handlers.c 		key = NULL;
key               844 Zend/zend_object_handlers.c 	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__unset != NULL), key TSRMLS_CC);
key              1037 Zend/zend_object_handlers.c static union _zend_function *zend_std_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1046 Zend/zend_object_handlers.c 	if (EXPECTED(key != NULL)) {
key              1047 Zend/zend_object_handlers.c 		lc_method_name = Z_STRVAL(key->constant);
key              1048 Zend/zend_object_handlers.c 		hash_value = key->hash_value;
key              1057 Zend/zend_object_handlers.c 		if (UNEXPECTED(!key)) {
key              1113 Zend/zend_object_handlers.c 	if (UNEXPECTED(!key)) {
key              1179 Zend/zend_object_handlers.c ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, const char *function_name_strval, int function_name_strlen, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1186 Zend/zend_object_handlers.c 	if (EXPECTED(key != NULL)) {
key              1187 Zend/zend_object_handlers.c 		lc_function_name = Z_STRVAL(key->constant);
key              1188 Zend/zend_object_handlers.c 		hash_value = key->hash_value;
key              1208 Zend/zend_object_handlers.c 		if (UNEXPECTED(!key)) {
key              1260 Zend/zend_object_handlers.c 	if (UNEXPECTED(!key)) {
key              1268 Zend/zend_object_handlers.c ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, zend_bool silent, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1273 Zend/zend_object_handlers.c 	if (UNEXPECTED(!key) ||
key              1274 Zend/zend_object_handlers.c 	    (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {
key              1275 Zend/zend_object_handlers.c 		if (EXPECTED(key != NULL)) {
key              1276 Zend/zend_object_handlers.c 			hash_value = key->hash_value;
key              1308 Zend/zend_object_handlers.c 		if (EXPECTED(key != NULL)) {
key              1309 Zend/zend_object_handlers.c 			CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key              1325 Zend/zend_object_handlers.c ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1429 Zend/zend_object_handlers.c static int zend_std_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
key              1446 Zend/zend_object_handlers.c 		key = NULL;
key              1453 Zend/zend_object_handlers.c 	property_info = zend_get_property_info_quick(zobj->ce, member, 1, key TSRMLS_CC);
key                34 Zend/zend_object_handlers.h typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC);
key                46 Zend/zend_object_handlers.h typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
key                53 Zend/zend_object_handlers.h typedef zval **(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC);
key                70 Zend/zend_object_handlers.h typedef int (*zend_object_has_property_t)(zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC);
key                76 Zend/zend_object_handlers.h typedef void (*zend_object_unset_property_t)(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC);
key                91 Zend/zend_object_handlers.h typedef union _zend_function *(*zend_object_get_method_t)(zval **object_ptr, char *method, int method_len, const struct _zend_literal *key TSRMLS_DC);
key               158 Zend/zend_object_handlers.h ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, const char *function_name_strval, int function_name_strlen, const struct _zend_literal *key TSRMLS_DC);
key               159 Zend/zend_object_handlers.h ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, zend_bool silent, const struct _zend_literal *key TSRMLS_DC);
key               160 Zend/zend_object_handlers.h ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, const struct _zend_literal *key TSRMLS_DC);
key               166 Zend/zend_object_handlers.h ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
key               198 Zend/zend_variables.c ZEND_API int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
key               210 Zend/zend_variables.c 		if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
key               214 Zend/zend_variables.c 				zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
key               217 Zend/zend_variables.c 				zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
key               236 Zend/zend_variables.c 	if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), NULL) == SUCCESS) {
key                48 Zend/zend_variables.h ZEND_API int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key);
key               642 Zend/zend_virtual_cwd.c 	unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key               644 Zend/zend_virtual_cwd.c 	unsigned long key = realpath_cache_key(path, path_len);
key               646 Zend/zend_virtual_cwd.c 	unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               650 Zend/zend_virtual_cwd.c 		if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key               691 Zend/zend_virtual_cwd.c 		bucket->key = realpath_cache_key(path, path_len TSRMLS_CC);
key               693 Zend/zend_virtual_cwd.c 		bucket->key = realpath_cache_key(path, path_len);
key               713 Zend/zend_virtual_cwd.c 		n = bucket->key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               724 Zend/zend_virtual_cwd.c 	unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key               726 Zend/zend_virtual_cwd.c 	unsigned long key = realpath_cache_key(path, path_len);
key               729 Zend/zend_virtual_cwd.c 	unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key               744 Zend/zend_virtual_cwd.c 		} else if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key               214 Zend/zend_virtual_cwd.h 	unsigned long                  key;
key              3323 Zend/zend_vm_def.h 					zval key;
key              3324 Zend/zend_vm_def.h 					iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key              3329 Zend/zend_vm_def.h 					if (Z_TYPE(key) == IS_STRING) {
key              3332 Zend/zend_vm_def.h 						zval_dtor(&key);
key              3336 Zend/zend_vm_def.h 					zval_dtor(&key);
key              4463 Zend/zend_vm_def.h 	zval *key = NULL;
key              4465 Zend/zend_vm_def.h 		key = &EX_T((opline+1)->result.var).tmp_var;
key              4496 Zend/zend_vm_def.h 			if (key) {
key              4498 Zend/zend_vm_def.h 					ZVAL_LONG(key, int_key);
key              4505 Zend/zend_vm_def.h 					ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key              4520 Zend/zend_vm_def.h 			if (key) {
key              4521 Zend/zend_vm_def.h 				zend_hash_get_current_key_zval(fe_ht, key);
key              4556 Zend/zend_vm_def.h 			if (key) {
key              4558 Zend/zend_vm_def.h 					iter->funcs->get_current_key(iter, key TSRMLS_CC);
key              4564 Zend/zend_vm_def.h 					ZVAL_LONG(key, iter->index);
key              5489 Zend/zend_vm_def.h 	if (generator->key) {
key              5490 Zend/zend_vm_def.h 		zval_ptr_dtor(&generator->key);
key              5575 Zend/zend_vm_def.h 		zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
key              5579 Zend/zend_vm_def.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              5584 Zend/zend_vm_def.h 			INIT_PZVAL_COPY(copy, key);
key              5591 Zend/zend_vm_def.h 			generator->key = copy;
key              5593 Zend/zend_vm_def.h 			Z_ADDREF_P(key);
key              5594 Zend/zend_vm_def.h 			generator->key = key;
key              5597 Zend/zend_vm_def.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              5598 Zend/zend_vm_def.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              5600 Zend/zend_vm_def.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              5608 Zend/zend_vm_def.h 		ALLOC_INIT_ZVAL(generator->key);
key              5609 Zend/zend_vm_def.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key               799 Zend/zend_vm_execute.h 					zval key;
key               800 Zend/zend_vm_execute.h 					iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key               805 Zend/zend_vm_execute.h 					if (Z_TYPE(key) == IS_STRING) {
key               808 Zend/zend_vm_execute.h 						zval_dtor(&key);
key               812 Zend/zend_vm_execute.h 					zval_dtor(&key);
key              4371 Zend/zend_vm_execute.h 	if (generator->key) {
key              4372 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              4456 Zend/zend_vm_execute.h 		zval *key = opline->op2.zv;
key              4460 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              4465 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              4472 Zend/zend_vm_execute.h 			generator->key = copy;
key              4474 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              4475 Zend/zend_vm_execute.h 			generator->key = key;
key              4478 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              4479 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              4481 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              4488 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              4489 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              5073 Zend/zend_vm_execute.h 	if (generator->key) {
key              5074 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              5158 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              5162 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              5167 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              5174 Zend/zend_vm_execute.h 			generator->key = copy;
key              5176 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              5177 Zend/zend_vm_execute.h 			generator->key = key;
key              5180 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              5181 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              5183 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              5190 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              5191 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              6100 Zend/zend_vm_execute.h 	if (generator->key) {
key              6101 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              6185 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              6189 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              6194 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              6201 Zend/zend_vm_execute.h 			generator->key = copy;
key              6203 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              6204 Zend/zend_vm_execute.h 			generator->key = key;
key              6207 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              6208 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              6210 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              6218 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              6219 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              6844 Zend/zend_vm_execute.h 	if (generator->key) {
key              6845 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              6929 Zend/zend_vm_execute.h 		zval *key = NULL;
key              6933 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              6938 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              6945 Zend/zend_vm_execute.h 			generator->key = copy;
key              6947 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              6948 Zend/zend_vm_execute.h 			generator->key = key;
key              6951 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              6952 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              6954 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              6961 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              6962 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              7590 Zend/zend_vm_execute.h 	if (generator->key) {
key              7591 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              7675 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key              7679 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              7684 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              7691 Zend/zend_vm_execute.h 			generator->key = copy;
key              7693 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              7694 Zend/zend_vm_execute.h 			generator->key = key;
key              7697 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              7698 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              7700 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              7707 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              7708 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              9653 Zend/zend_vm_execute.h 	if (generator->key) {
key              9654 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              9738 Zend/zend_vm_execute.h 		zval *key = opline->op2.zv;
key              9742 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              9747 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              9754 Zend/zend_vm_execute.h 			generator->key = copy;
key              9756 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              9757 Zend/zend_vm_execute.h 			generator->key = key;
key              9760 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              9761 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              9763 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              9770 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              9771 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              10357 Zend/zend_vm_execute.h 	if (generator->key) {
key              10358 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              10442 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              10446 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              10451 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              10458 Zend/zend_vm_execute.h 			generator->key = copy;
key              10460 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              10461 Zend/zend_vm_execute.h 			generator->key = key;
key              10464 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              10465 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              10467 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              10474 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              10475 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              11386 Zend/zend_vm_execute.h 	if (generator->key) {
key              11387 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              11471 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              11475 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              11480 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              11487 Zend/zend_vm_execute.h 			generator->key = copy;
key              11489 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              11490 Zend/zend_vm_execute.h 			generator->key = key;
key              11493 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              11494 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              11496 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              11504 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              11505 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              11981 Zend/zend_vm_execute.h 	if (generator->key) {
key              11982 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              12066 Zend/zend_vm_execute.h 		zval *key = NULL;
key              12070 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              12075 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              12082 Zend/zend_vm_execute.h 			generator->key = copy;
key              12084 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              12085 Zend/zend_vm_execute.h 			generator->key = key;
key              12088 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              12089 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              12091 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              12098 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              12099 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              12667 Zend/zend_vm_execute.h 	if (generator->key) {
key              12668 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              12752 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key              12756 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              12761 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              12768 Zend/zend_vm_execute.h 			generator->key = copy;
key              12770 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              12771 Zend/zend_vm_execute.h 			generator->key = key;
key              12774 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              12775 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              12777 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              12784 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              12785 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              13958 Zend/zend_vm_execute.h 	zval *key = NULL;
key              13960 Zend/zend_vm_execute.h 		key = &EX_T((opline+1)->result.var).tmp_var;
key              13991 Zend/zend_vm_execute.h 			if (key) {
key              13993 Zend/zend_vm_execute.h 					ZVAL_LONG(key, int_key);
key              14000 Zend/zend_vm_execute.h 					ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key              14015 Zend/zend_vm_execute.h 			if (key) {
key              14016 Zend/zend_vm_execute.h 				zend_hash_get_current_key_zval(fe_ht, key);
key              14051 Zend/zend_vm_execute.h 			if (key) {
key              14053 Zend/zend_vm_execute.h 					iter->funcs->get_current_key(iter, key TSRMLS_CC);
key              14059 Zend/zend_vm_execute.h 					ZVAL_LONG(key, iter->index);
key              16580 Zend/zend_vm_execute.h 	if (generator->key) {
key              16581 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              16666 Zend/zend_vm_execute.h 		zval *key = opline->op2.zv;
key              16670 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              16675 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              16682 Zend/zend_vm_execute.h 			generator->key = copy;
key              16684 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              16685 Zend/zend_vm_execute.h 			generator->key = key;
key              16688 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              16689 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              16691 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              16698 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              16699 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              18680 Zend/zend_vm_execute.h 	if (generator->key) {
key              18681 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              18766 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              18770 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              18775 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              18782 Zend/zend_vm_execute.h 			generator->key = copy;
key              18784 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              18785 Zend/zend_vm_execute.h 			generator->key = key;
key              18788 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              18789 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              18791 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              18798 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              18799 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              21161 Zend/zend_vm_execute.h 	if (generator->key) {
key              21162 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              21247 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              21251 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              21256 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              21263 Zend/zend_vm_execute.h 			generator->key = copy;
key              21265 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              21266 Zend/zend_vm_execute.h 			generator->key = key;
key              21269 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              21270 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              21272 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              21280 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              21281 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              22331 Zend/zend_vm_execute.h 	if (generator->key) {
key              22332 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              22417 Zend/zend_vm_execute.h 		zval *key = NULL;
key              22421 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              22426 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              22433 Zend/zend_vm_execute.h 			generator->key = copy;
key              22435 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              22436 Zend/zend_vm_execute.h 			generator->key = key;
key              22439 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              22440 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              22442 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              22449 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              22450 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              24466 Zend/zend_vm_execute.h 	if (generator->key) {
key              24467 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              24552 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key              24556 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              24561 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              24568 Zend/zend_vm_execute.h 			generator->key = copy;
key              24570 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              24571 Zend/zend_vm_execute.h 			generator->key = key;
key              24574 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              24575 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              24577 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              24584 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              24585 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              25983 Zend/zend_vm_execute.h 	if (generator->key) {
key              25984 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              26068 Zend/zend_vm_execute.h 		zval *key = opline->op2.zv;
key              26072 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              26077 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              26084 Zend/zend_vm_execute.h 			generator->key = copy;
key              26086 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              26087 Zend/zend_vm_execute.h 			generator->key = key;
key              26090 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              26091 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              26093 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              26100 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              26101 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              27305 Zend/zend_vm_execute.h 	if (generator->key) {
key              27306 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              27390 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              27394 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              27399 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              27406 Zend/zend_vm_execute.h 			generator->key = copy;
key              27408 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              27409 Zend/zend_vm_execute.h 			generator->key = key;
key              27412 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              27413 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              27415 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              27422 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              27423 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              28627 Zend/zend_vm_execute.h 	if (generator->key) {
key              28628 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              28712 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              28716 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              28721 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              28728 Zend/zend_vm_execute.h 			generator->key = copy;
key              28730 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              28731 Zend/zend_vm_execute.h 			generator->key = key;
key              28734 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              28735 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              28737 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              28745 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              28746 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              29059 Zend/zend_vm_execute.h 	if (generator->key) {
key              29060 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              29144 Zend/zend_vm_execute.h 		zval *key = NULL;
key              29148 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              29153 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              29160 Zend/zend_vm_execute.h 			generator->key = copy;
key              29162 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              29163 Zend/zend_vm_execute.h 			generator->key = key;
key              29166 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              29167 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              29169 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              29176 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              29177 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              30378 Zend/zend_vm_execute.h 	if (generator->key) {
key              30379 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              30463 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key              30467 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              30472 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              30479 Zend/zend_vm_execute.h 			generator->key = copy;
key              30481 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              30482 Zend/zend_vm_execute.h 			generator->key = key;
key              30485 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              30486 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              30488 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              30495 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              30496 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              33887 Zend/zend_vm_execute.h 	if (generator->key) {
key              33888 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              33972 Zend/zend_vm_execute.h 		zval *key = opline->op2.zv;
key              33976 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              33981 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              33988 Zend/zend_vm_execute.h 			generator->key = copy;
key              33990 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              33991 Zend/zend_vm_execute.h 			generator->key = key;
key              33994 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              33995 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              33997 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              34004 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              34005 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              35850 Zend/zend_vm_execute.h 	if (generator->key) {
key              35851 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              35935 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              35939 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              35944 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              35951 Zend/zend_vm_execute.h 			generator->key = copy;
key              35953 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              35954 Zend/zend_vm_execute.h 			generator->key = key;
key              35957 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              35958 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              35960 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              35967 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              35968 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              38193 Zend/zend_vm_execute.h 	if (generator->key) {
key              38194 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              38278 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key              38282 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              38287 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              38294 Zend/zend_vm_execute.h 			generator->key = copy;
key              38296 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              38297 Zend/zend_vm_execute.h 			generator->key = key;
key              38300 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              38301 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              38303 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              38311 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              38312 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              39214 Zend/zend_vm_execute.h 	if (generator->key) {
key              39215 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              39299 Zend/zend_vm_execute.h 		zval *key = NULL;
key              39303 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              39308 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              39315 Zend/zend_vm_execute.h 			generator->key = copy;
key              39317 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              39318 Zend/zend_vm_execute.h 			generator->key = key;
key              39321 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              39322 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              39324 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              39331 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              39332 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key              41211 Zend/zend_vm_execute.h 	if (generator->key) {
key              41212 Zend/zend_vm_execute.h 		zval_ptr_dtor(&generator->key);
key              41296 Zend/zend_vm_execute.h 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key              41300 Zend/zend_vm_execute.h 			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key              41305 Zend/zend_vm_execute.h 			INIT_PZVAL_COPY(copy, key);
key              41312 Zend/zend_vm_execute.h 			generator->key = copy;
key              41314 Zend/zend_vm_execute.h 			Z_ADDREF_P(key);
key              41315 Zend/zend_vm_execute.h 			generator->key = key;
key              41318 Zend/zend_vm_execute.h 		if (Z_TYPE_P(generator->key) == IS_LONG
key              41319 Zend/zend_vm_execute.h 		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key              41321 Zend/zend_vm_execute.h 			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key              41328 Zend/zend_vm_execute.h 		ALLOC_INIT_ZVAL(generator->key);
key              41329 Zend/zend_vm_execute.h 		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key                32 ext/com_dotnet/com_handlers.c static zval *com_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key                67 ext/com_dotnet/com_handlers.c static void com_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               199 ext/com_dotnet/com_handlers.c static int com_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
key               225 ext/com_dotnet/com_handlers.c static void com_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
key               262 ext/com_dotnet/com_handlers.c static union _zend_function *com_method_get(zval **object_ptr, char *name, int len, const zend_literal *key TSRMLS_DC)
key                35 ext/com_dotnet/com_iterator.c 	ulong key;
key                77 ext/com_dotnet/com_iterator.c static void com_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key                81 ext/com_dotnet/com_iterator.c 	if (I->key == (ulong)-1) {
key                82 ext/com_dotnet/com_iterator.c 		ZVAL_NULL(key);
key                84 ext/com_dotnet/com_iterator.c 		ZVAL_LONG(key, I->key);
key               105 ext/com_dotnet/com_iterator.c 			I->key++;
key               108 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               113 ext/com_dotnet/com_iterator.c 		if (I->key >= (ULONG) I->sa_max) {
key               114 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               117 ext/com_dotnet/com_iterator.c 		I->key++;
key               118 ext/com_dotnet/com_iterator.c 		if (php_com_safearray_get_elem(&I->safe_array, &I->v, (LONG)I->key TSRMLS_CC) == 0) {
key               119 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               195 ext/com_dotnet/com_iterator.c 			I->key = bound;
key               200 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key               229 ext/com_dotnet/com_iterator.c 			I->key = 0;
key               235 ext/com_dotnet/com_iterator.c 			I->key = (ulong)-1;
key                56 ext/com_dotnet/com_saproxy.c 	LONG key;
key                74 ext/com_dotnet/com_saproxy.c static zval *saproxy_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key                86 ext/com_dotnet/com_saproxy.c static void saproxy_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               296 ext/com_dotnet/com_saproxy.c static int saproxy_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
key               308 ext/com_dotnet/com_saproxy.c static void saproxy_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
key               324 ext/com_dotnet/com_saproxy.c static union _zend_function *saproxy_method_get(zval **object, const char *name, int len, const zend_literal *key TSRMLS_DC)
key               486 ext/com_dotnet/com_saproxy.c 	return (I->key < I->imax) ? SUCCESS : FAILURE;
key               497 ext/com_dotnet/com_saproxy.c 	I->indices[I->proxy->dimensions-1] = I->key;
key               522 ext/com_dotnet/com_saproxy.c static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key               526 ext/com_dotnet/com_saproxy.c 	if (I->key == -1) {
key               527 ext/com_dotnet/com_saproxy.c 		ZVAL_NULL(key);
key               529 ext/com_dotnet/com_saproxy.c 		ZVAL_LONG(key, I->key);
key               537 ext/com_dotnet/com_saproxy.c 	if (++I->key >= I->imax) {
key               538 ext/com_dotnet/com_saproxy.c 		I->key = -1;
key               581 ext/com_dotnet/com_saproxy.c 	I->key = I->imin;	
key              1846 ext/curl/interface.c 			char *key;
key              1854 ext/curl/interface.c 			key = s;
key              1855 ext/curl/interface.c 			tmp = memchr(key, '=', 64);
key              1859 ext/curl/interface.c 				add_assoc_string(hash, key, val, 1);
key               650 ext/date/php_date.c zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC);
key               651 ext/date/php_date.c void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
key               652 ext/date/php_date.c static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC);
key               653 ext/date/php_date.c static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
key              1944 ext/date/php_date.c static void date_period_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key              1947 ext/date/php_date.c 	ZVAL_LONG(key, iterator->current_index);
key              4041 ext/date/php_date.c zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key              4053 ext/date/php_date.c 		key = NULL;
key              4059 ext/date/php_date.c 		retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key              4081 ext/date/php_date.c 		retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key              4108 ext/date/php_date.c void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key              4118 ext/date/php_date.c 		key = NULL;
key              4124 ext/date/php_date.c 		(zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key              4155 ext/date/php_date.c 		(zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key              5116 ext/date/php_date.c static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key              5125 ext/date/php_date.c 	zv = std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key              5139 ext/date/php_date.c static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
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 TSRMLS_DC)
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  		zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &group, &pos);
key               216 ext/dba/dba.c  		zend_hash_move_forward_ex(Z_ARRVAL_P(key), &pos);
key               217 ext/dba/dba.c  		zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &name, &pos);
key               229 ext/dba/dba.c  		zval tmp = *key;
key               245 ext/dba/dba.c  	zval *key;													\
key               248 ext/dba/dba.c  	if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { 	\
key               251 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
key               256 ext/dba/dba.c  	zval *key;													\
key               262 ext/dba/dba.c  		if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { \
key               267 ext/dba/dba.c  		if (zend_parse_parameters(ac TSRMLS_CC, "zlr", &key, &skip, &id) == FAILURE) { \
key               274 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
key               558 ext/dba/dba.c  	zval *key;
key               563 ext/dba/dba.c  	if (zend_parse_parameters(ac TSRMLS_CC, "zsr", &key, &val, &val_len, &id) == FAILURE) {
key               567 ext/dba/dba.c  	if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {
key               585 ext/dba/dba.c  #define FREENOW if(args) efree(args); if(key) efree(key)
key               621 ext/dba/dba.c  	char *key = NULL, *error = NULL;
key               652 ext/dba/dba.c  		key = safe_emalloc(keylen, 1, 1);
key               653 ext/dba/dba.c  		key[keylen] = '\0';
key               657 ext/dba/dba.c  			memcpy(key+keylen, Z_STRVAL_PP(args[i]), Z_STRLEN_PP(args[i]));
key               662 ext/dba/dba.c  		if (zend_hash_find(&EG(persistent_list), key, keylen+1, (void **) &le) == SUCCESS) {
key               941 ext/dba/dba.c  		if (zend_hash_update(&EG(persistent_list), key, keylen+1, &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
key              1049 ext/dba/dba.c  	char *key, *name;
key              1060 ext/dba/dba.c  	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
key              1064 ext/dba/dba.c  	if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
key              1065 ext/dba/dba.c  		add_next_index_stringl(return_value, key+1, name - (key + 1), 1);
key              1066 ext/dba/dba.c  		add_next_index_stringl(return_value, name+1, key_len - (name - key + 1), 1);
key              1069 ext/dba/dba.c  		add_next_index_stringl(return_value, key, key_len, 1);
key               141 ext/dba/dba_cdb.c # define php_cdb_findnext(cdb, key, len) cdb_findnext(cdb, key, len TSRMLS_CC)
key               142 ext/dba/dba_cdb.c # define php_cdb_find(cdb, key, len) cdb_find(cdb, key, len TSRMLS_CC)
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 TSRMLS_CC) != -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                49 ext/dba/dba_db3.c 	gkey.data = (char *) key; gkey.size = keylen
key                67 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 TSRMLS_CC, key, E_WARNING, "Operation not possible");
key                99 ext/dba/dba_flatfile.c 			php_error_docref2(NULL TSRMLS_CC, 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 TSRMLS_CC, key, val, E_WARNING, "%s", gdbm_strerror(gdbm_errno));
key               116 ext/dba/dba_gdbm.c 			php_error_docref2(NULL TSRMLS_CC, 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 TSRMLS_CC, key, E_WARNING, "Operation not possible");
key               142 ext/dba/dba_inifile.c 		char *result = inifile_key_string(&dba->curr.key);
key               154 ext/dba/dba_inifile.c 	if (!dba->curr.key.group && !dba->curr.key.name) {
key               159 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 TSRMLS_CC, 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 TSRMLS_CC, 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 TSRMLS_DC)
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 TSRMLS_DC)
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 TSRMLS_CC)) {
key               182 ext/dba/libcdb/cdb.c int cdb_find(struct cdb *c, char *key, unsigned int len TSRMLS_DC)
key               185 ext/dba/libcdb/cdb.c 	return cdb_findnext(c, key, len TSRMLS_CC);
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 TSRMLS_DC)
key               129 ext/dba/libcdb/cdb_make.c 	if (cdb_make_write(c, key, keylen TSRMLS_CC) != 0)
key               133 ext/dba/libcdb/cdb_make.c 	return cdb_make_addend(c, keylen, datalen, cdb_hash(key, keylen) TSRMLS_CC);
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 TSRMLS_DC) {
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 TSRMLS_CC)) {
key               263 ext/dba/libinifile/inifile.c 		if (!(res=inifile_key_cmp(&ln.key, key TSRMLS_CC))) {
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 TSRMLS_DC) 
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 TSRMLS_CC)) < 2) {
key               365 ext/dba/libinifile/inifile.c static int inifile_next_group(inifile *dba, const key_type *key, size_t *pos_grp_start TSRMLS_DC) 
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 TSRMLS_CC) == 2) {
key               416 ext/dba/libinifile/inifile.c static int inifile_filter(inifile *dba, inifile *from, const key_type *key TSRMLS_DC) 
key               425 ext/dba/libinifile/inifile.c 		switch(inifile_key_cmp(&ln.key, key TSRMLS_CC)) {
key               461 ext/dba/libinifile/inifile.c static int inifile_delete_replace_append(inifile *dba, const key_type *key, const val_type *value, int append TSRMLS_DC) 
key               479 ext/dba/libinifile/inifile.c 	assert(!append || (key->name && value)); /* missuse */
key               482 ext/dba/libinifile/inifile.c 	inifile_find_group(dba, key, &pos_grp_start TSRMLS_CC);
key               483 ext/dba/libinifile/inifile.c 	inifile_next_group(dba, key, &pos_grp_next TSRMLS_CC);
key               510 ext/dba/libinifile/inifile.c 		if (!value || (key->name && strlen(key->name))) {
key               516 ext/dba/libinifile/inifile.c 		if (key->name && strlen(key->name)) {
key               519 ext/dba/libinifile/inifile.c 				ret = inifile_filter(dba, ini_tmp, key TSRMLS_CC);
key               527 ext/dba/libinifile/inifile.c 				if (pos_grp_start == pos_grp_next && key->group && strlen(key->group)) {
key               528 ext/dba/libinifile/inifile.c 					php_stream_printf(dba->fp TSRMLS_CC, "[%s]\n", key->group);
key               530 ext/dba/libinifile/inifile.c 				php_stream_printf(dba->fp TSRMLS_CC, "%s=%s\n", key->name, value->value ? value->value : "");
key               564 ext/dba/libinifile/inifile.c int inifile_delete(inifile *dba, const key_type *key TSRMLS_DC) 
key               566 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, NULL, 0 TSRMLS_CC);
key               572 ext/dba/libinifile/inifile.c int inifile_replace(inifile *dba, const key_type *key, const val_type *value TSRMLS_DC) 
key               574 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, value, 0 TSRMLS_CC);
key               580 ext/dba/libinifile/inifile.c int inifile_append(inifile *dba, const key_type *key, const val_type *value TSRMLS_DC) 
key               582 ext/dba/libinifile/inifile.c 	return inifile_delete_replace_append(dba, key, value, 1 TSRMLS_CC);
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 TSRMLS_DC);
key                51 ext/dba/libinifile/inifile.h int inifile_delete(inifile *dba, const key_type *key TSRMLS_DC);
key                52 ext/dba/libinifile/inifile.h int inifile_replace(inifile *dba, const key_type *key, const val_type *val TSRMLS_DC);
key                53 ext/dba/libinifile/inifile.h int inifile_append(inifile *dba, const key_type *key, const val_type *val TSRMLS_DC);
key                57 ext/dba/libinifile/inifile.h char * inifile_key_string(const key_type *key);
key                59 ext/dba/libinifile/inifile.h void inifile_key_free(key_type *key);
key                98 ext/dba/php_dba.h 	char *dba_fetch_##x(dba_info *info, char *key, int keylen, int skip, int *newlen TSRMLS_DC)
key               100 ext/dba/php_dba.h 	int dba_update_##x(dba_info *info, char *key, int keylen, char *val, int vallen, int mode TSRMLS_DC)
key               102 ext/dba/php_dba.h 	int dba_exists_##x(dba_info *info, char *key, int keylen TSRMLS_DC)
key               104 ext/dba/php_dba.h 	int dba_delete_##x(dba_info *info, char *key, int keylen TSRMLS_DC)
key               160 ext/dom/dom_iterators.c static void php_dom_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key               166 ext/dom/dom_iterators.c 		ZVAL_LONG(key, iter->index);
key               172 ext/dom/dom_iterators.c 			ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name), 1);
key               174 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               307 ext/dom/php_dom.c static zval **dom_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               330 ext/dom/php_dom.c 		retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key               341 ext/dom/php_dom.c zval *dom_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key               376 ext/dom/php_dom.c 		retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key               387 ext/dom/php_dom.c void dom_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               412 ext/dom/php_dom.c 		std_hnd->write_property(object, member, value, key TSRMLS_CC);
key               422 ext/dom/php_dom.c static int dom_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
key               460 ext/dom/php_dom.c 		retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
key              3859 ext/gd/gd.c    			char * key;
key              3862 ext/gd/gd.c    			if (zend_hash_get_current_key_ex(HASH_OF(EXT), &key, NULL, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
key              3870 ext/gd/gd.c    			if (strcmp("linespacing", 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               559 ext/gd/libgd/gdft.c static int tweenColorTest (void *element, void *key)
key               562 ext/gd/libgd/gdft.c 	tweencolorkey_t *b = (tweencolorkey_t *) key;
key               576 ext/gd/libgd/gdft.c static void * tweenColorFetch (char **error, void *key)
key               579 ext/gd/libgd/gdft.c 	tweencolorkey_t *b = (tweencolorkey_t *) key;
key               221 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 int key_len) {
key               226 ext/hash/hash.c 		ops->hash_update(context, key, key_len);
key               229 ext/hash/hash.c 		memcpy(K, key, key_len);
key               235 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 long data_size) {
key               237 ext/hash/hash.c 	ops->hash_update(context, key, ops->block_size);
key               244 ext/hash/hash.c 	char *algo, *data, *digest, *key, *K;
key               252 ext/hash/hash.c 																  &key, &key_len, &raw_output) == FAILURE) {
key               278 ext/hash/hash.c 	php_hash_hmac_prep_key((unsigned char *) K, ops, context, (unsigned char *) key, key_len);		
key               340 ext/hash/hash.c 	char *algo, *key = NULL;
key               347 ext/hash/hash.c 	if (zend_parse_parameters(argc TSRMLS_CC, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) {
key               371 ext/hash/hash.c 	hash->key = NULL;
key               381 ext/hash/hash.c 			ops->hash_update(context, (unsigned char *) key, key_len);
key               386 ext/hash/hash.c 			memcpy(K, key, key_len);
key               394 ext/hash/hash.c 		hash->key = (unsigned char *) K;
key               517 ext/hash/hash.c 			hash->key[i] ^= 0x6A;
key               522 ext/hash/hash.c 		hash->ops->hash_update(hash->context, (unsigned char *) hash->key, hash->ops->block_size);
key               527 ext/hash/hash.c 		memset(hash->key, 0, hash->ops->block_size);
key               528 ext/hash/hash.c 		efree(hash->key);
key               529 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               790 ext/hash/hash.c 	if (hash->key) {
key               791 ext/hash/hash.c 		memset(hash->key, 0, hash->ops->block_size);
key               792 ext/hash/hash.c 		efree(hash->key);
key               966 ext/hash/hash.c 				char *key, *digest;
key               975 ext/hash/hash.c 				key = ecalloc(1, times * block_size);
key               987 ext/hash/hash.c 					memcpy( &key[i*block_size], digest, block_size);
key               990 ext/hash/hash.c 				RETVAL_STRINGL(key, bytes, 1);
key               991 ext/hash/hash.c 				memset(key, 0, bytes);
key               994 ext/hash/hash.c 				efree(key);
key              1145 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1152 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1159 ext/hash/hash.c 	ZEND_ARG_INFO(0, key)
key              1228 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                59 ext/hash/php_hash.h 	unsigned char *key;
key               625 ext/imap/php_imap.c static int add_assoc_object(zval *arg, char *key, zval *tmp TSRMLS_DC)
key               634 ext/imap/php_imap.c 	return zend_hash_update(symtable, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
key              3474 ext/imap/php_imap.c 	char *key;
key              3587 ext/imap/php_imap.c 					zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
key              3588 ext/imap/php_imap.c 					disp_param->attribute = cpystr(key);
key              3621 ext/imap/php_imap.c 					zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
key              3622 ext/imap/php_imap.c 					disp_param->attribute = cpystr(key);
key              3700 ext/imap/php_imap.c 						zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
key              3701 ext/imap/php_imap.c 						disp_param->attribute = cpystr(key);
key              3734 ext/imap/php_imap.c 						zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
key              3735 ext/imap/php_imap.c 						disp_param->attribute = cpystr(key);
key                38 ext/intl/collator/collator_sort.c 	char* key;       /* pointer to sort key */
key               253 ext/intl/collator/collator_sort.c 	char* key1 = ((collator_sort_key_index_t*)p1)->key;
key               254 ext/intl/collator/collator_sort.c 	char* key2 = ((collator_sort_key_index_t*)p2)->key;
key               489 ext/intl/collator/collator_sort.c 		sortKeyIndxBuf[sortKeyCount].key = (char*)sortKeyBufOffset;    /* remeber just offset, cause address */
key               501 ext/intl/collator/collator_sort.c 		sortKeyIndxBuf[j].key = sortKeyBuf + (ptrdiff_t)sortKeyIndxBuf[j].key;
key               552 ext/intl/collator/collator_sort.c 	uint8_t*         key     = NULL;
key               600 ext/intl/collator/collator_sort.c 	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, key, 0);
key               605 ext/intl/collator/collator_sort.c 	key = emalloc(key_len);
key               606 ext/intl/collator/collator_sort.c 	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, key, key_len);
key               611 ext/intl/collator/collator_sort.c 	RETURN_STRINGL((char *)key, key_len - 1, 0);
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               540 ext/intl/php_intl.c 	ZEND_ARG_INFO( 0, key )
key               104 ext/intl/resourcebundle/resourcebundle_iterator.c static void resourcebundle_iterator_key( zend_object_iterator *iter, zval *key TSRMLS_DC )
key               113 ext/intl/resourcebundle/resourcebundle_iterator.c 		ZVAL_STRING(key, iterator->currentkey, 1);
key               115 ext/intl/resourcebundle/resourcebundle_iterator.c 		ZVAL_LONG(key, iterator->i);
key               226 ext/intl/transliterator/transliterator_class.c 		key = NULL;								\
key               251 ext/intl/transliterator/transliterator_class.c 	const struct _zend_literal *key TSRMLS_DC )
key               268 ext/intl/transliterator/transliterator_class.c 		retval = std_object_handlers.get_property_ptr_ptr( object, member, type, key TSRMLS_CC );
key               283 ext/intl/transliterator/transliterator_class.c 	const struct _zend_literal *key TSRMLS_DC ) /* {{{ */
key               302 ext/intl/transliterator/transliterator_class.c 		retval = std_object_handlers.read_property( object, member, type, key TSRMLS_CC );
key               318 ext/intl/transliterator/transliterator_class.c 	const struct _zend_literal *key TSRMLS_DC )
key               334 ext/intl/transliterator/transliterator_class.c 		std_object_handlers.write_property( object, member, value, key TSRMLS_CC );
key               392 ext/json/JSON_parser.c static void attach_zval(JSON_parser jp, int up, int cur, smart_str *key, int assoc TSRMLS_DC)
key               406 ext/json/JSON_parser.c             add_property_zval_ex(root, (key->len ? key->c : "_empty_"), (key->len ? (key->len + 1) : sizeof("_empty_")), child TSRMLS_CC);
key               411 ext/json/JSON_parser.c             add_assoc_zval_ex(root, (key->len ? key->c : ""), (key->len ? (key->len + 1) : sizeof("")), child);
key               413 ext/json/JSON_parser.c         key->len = 0;
key               418 ext/json/JSON_parser.c #define FREE_BUFFERS() smart_str_free(&buf); smart_str_free(&key);
key               448 ext/json/JSON_parser.c     smart_str key = {0};
key               553 ext/json/JSON_parser.c                         add_property_zval_ex(jp->the_zstack[jp->top], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
key               556 ext/json/JSON_parser.c                         add_assoc_zval_ex(jp->the_zstack[jp->top], (key.len ? key.c : ""), (key.len ? (key.len + 1) : sizeof("")), mval);
key               558 ext/json/JSON_parser.c                     key.len = 0;
key               617 ext/json/JSON_parser.c                         attach_zval(jp, jp->top - 1, jp->top, &key, assoc TSRMLS_CC);
key               645 ext/json/JSON_parser.c                         attach_zval(jp, jp->top - 1, jp->top, &key, assoc TSRMLS_CC);
key               659 ext/json/JSON_parser.c                     SWAP_BUFFERS(buf, key);
key               698 ext/json/JSON_parser.c                                     add_property_zval_ex(jp->the_zstack[jp->top], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
key               701 ext/json/JSON_parser.c                                     add_assoc_zval_ex(jp->the_zstack[jp->top], (key.len ? key.c : ""), (key.len ? (key.len + 1) : sizeof("")), mval);
key               703 ext/json/JSON_parser.c                                 key.len = 0;
key               188 ext/json/json.c 		char *key;
key               196 ext/json/json.c 			i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key               271 ext/json/json.c 		char *key;
key               280 ext/json/json.c 			i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key               302 ext/json/json.c 						if (key[0] == '\0' && Z_TYPE_PP(val) == IS_OBJECT) {
key               319 ext/json/json.c 						json_escape_string(buf, key, key_len - 1, options & ~PHP_JSON_NUMERIC_CHECK TSRMLS_CC);
key              1586 ext/ldap/ldap.c static void _ldap_hash_fetch(zval *hashTbl, const char *key, zval **out)
key              1589 ext/ldap/ldap.c 	if (zend_hash_find(Z_ARRVAL_P(hashTbl), key, strlen(key)+1, (void **) &fetched) == SUCCESS) {
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               205 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               213 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               221 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               229 ext/mcrypt/mcrypt.c 	ZEND_ARG_INFO(0, key)
key               336 ext/mcrypt/mcrypt.c 		&cipher, &cipher_len, &key, &key_len, &data, &data_len, &mode, &iv, &iv_len) == FAILURE) {	\
key               565 ext/mcrypt/mcrypt.c 	char *key, *iv;
key               573 ext/mcrypt/mcrypt.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &mcryptind, &key, &key_len, &iv, &iv_len) == FAILURE) {
key               598 ext/mcrypt/mcrypt.c 	memcpy(key_s, key, key_len);
key              1265 ext/mcrypt/mcrypt.c static void php_mcrypt_do_crypt(char* cipher, const char *key, int key_len, const char *data, int data_len, char *mode, const char *iv, int iv_len, int dencrypt, zval* return_value TSRMLS_DC) /* {{{ */
key              1304 ext/mcrypt/mcrypt.c 	if (mcrypt_generic_init(td, (void *) key, key_len, (void *) iv) < 0) {
key              1328 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *mode, *iv = NULL;
key              1332 ext/mcrypt/mcrypt.c 		&key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key              1336 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_ENCRYPT, return_value TSRMLS_CC);
key              1344 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *mode, *iv = NULL;
key              1348 ext/mcrypt/mcrypt.c 		&key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key              1352 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_DECRYPT, return_value TSRMLS_CC);
key              1361 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *iv = NULL;
key              1368 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ecb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key              1377 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *iv = NULL;
key              1384 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cbc", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key              1393 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *iv = NULL;
key              1400 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cfb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key              1409 ext/mcrypt/mcrypt.c 	char *cipher, *key, *data, *iv = NULL;
key              1416 ext/mcrypt/mcrypt.c 	php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ofb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key               158 ext/mcrypt/mcrypt_filter.c 	char *iv = NULL, *key = NULL;
key               203 ext/mcrypt/mcrypt_filter.c 		key = Z_STRVAL_PP(tmpzval);
key               236 ext/mcrypt/mcrypt_filter.c 	result = mcrypt_generic_init(mcrypt_module, key, key_len, iv);
key               321 ext/mysqli/mysqli.c zval *mysqli_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key               353 ext/mysqli/mysqli.c 		retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key               364 ext/mysqli/mysqli.c void mysqli_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               392 ext/mysqli/mysqli.c 		std_hnd->write_property(object, member, value, key TSRMLS_CC);
key               413 ext/mysqli/mysqli.c static int mysqli_object_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
key               425 ext/mysqli/mysqli.c 				zval *value = mysqli_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key               436 ext/mysqli/mysqli.c 				zval *value = mysqli_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key               450 ext/mysqli/mysqli.c 		ret = std_hnd->has_property(object, member, has_set_exists, key TSRMLS_CC);
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               153 ext/mysqli/mysqli_result_iterator.c static void php_mysqli_result_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key               157 ext/mysqli/mysqli_result_iterator.c 	ZVAL_LONG(key, iterator->row_num);
key              1618 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, ssl_set)(MYSQLND_CONN_DATA * const conn, const char * key, const char * const cert,
key              1627 ext/mysqlnd/mysqlnd.c 		ret = (PASS == net->data->m.set_client_option(net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) &&
key              2521 ext/mysqlnd/mysqlnd.c 														const char * const key,
key              2543 ext/mysqlnd/mysqlnd.c 			DBG_INF_FMT("Adding [%s][%s]", key, value);
key              2549 ext/mysqlnd/mysqlnd.c 				zend_hash_update(conn->options->connect_attr, key, strlen(key), &copyv, sizeof(char *), NULL);
key               167 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) TSRMLS_CC)
key                44 ext/mysqlnd/mysqlnd_bt.c #define TRACE_APPEND_KEY(key)                                            \
key                45 ext/mysqlnd/mysqlnd_bt.c 	if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \
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               954 ext/mysqlnd/mysqlnd_result.c 												   meta->zend_hash_keys[i].key,
key               957 ext/mysqlnd/mysqlnd_result.c 							zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, (void *) &data, sizeof(zval *), NULL);
key              1209 ext/mysqlnd/mysqlnd_result.c 										   meta->zend_hash_keys[i].key,
key              1213 ext/mysqlnd/mysqlnd_result.c 										   meta->zend_hash_keys[i].key,
key              1310 ext/mysqlnd/mysqlnd_result.c 										   meta->zend_hash_keys[i].key,
key              1314 ext/mysqlnd/mysqlnd_result.c 										   meta->zend_hash_keys[i].key,
key                55 ext/mysqlnd/mysqlnd_result_meta.c mysqlnd_is_key_numeric(const char * key, size_t length, long *idx)
key                57 ext/mysqlnd/mysqlnd_result_meta.c 	register const char * tmp = key;
key                64 ext/mysqlnd/mysqlnd_result_meta.c 			const char *end=key+length-1;
key                76 ext/mysqlnd/mysqlnd_result_meta.c 				if (*key=='-') {
key                77 ext/mysqlnd/mysqlnd_result_meta.c 					*idx = strtol(key, NULL, 10);
key                82 ext/mysqlnd/mysqlnd_result_meta.c 					*idx = strtol(key, NULL, 10);
key               187 ext/mysqlnd/mysqlnd_result_meta.c 			meta->zend_hash_keys[i].key = idx;
key               189 ext/mysqlnd/mysqlnd_result_meta.c 			meta->zend_hash_keys[i].key =
key               100 ext/opcache/Optimizer/compact_literals.c 	char *key;
key               359 ext/opcache/Optimizer/compact_literals.c 							key = emalloc(key_len);
key               360 ext/opcache/Optimizer/compact_literals.c 							key_len = snprintf(key, key_len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i].constant));
key               364 ext/opcache/Optimizer/compact_literals.c 							key = emalloc(key_len);
key               365 ext/opcache/Optimizer/compact_literals.c 							memcpy(key, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
key               366 ext/opcache/Optimizer/compact_literals.c 							memcpy(key + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
key               367 ext/opcache/Optimizer/compact_literals.c 							memcpy(key + Z_STRLEN_P(class_name) + sizeof("::") - 1,
key               371 ext/opcache/Optimizer/compact_literals.c 							key = Z_STRVAL(op_array->literals[i].constant);
key               374 ext/opcache/Optimizer/compact_literals.c 						h = zend_hash_func(key, key_len);
key               378 ext/opcache/Optimizer/compact_literals.c 						zend_hash_quick_find(&hash, key, key_len, h, (void**)&pos) == SUCCESS &&
key               383 ext/opcache/Optimizer/compact_literals.c 							efree(key);
key               396 ext/opcache/Optimizer/compact_literals.c 							zend_hash_quick_add(&hash, key, key_len, h, (void**)&j, sizeof(int), NULL);
key               398 ext/opcache/Optimizer/compact_literals.c 								efree(key);
key               225 ext/opcache/ZendAccelerator.c 						char *key;
key               227 ext/opcache/ZendAccelerator.c 						key = zend_shared_alloc(ZCG(include_path_len) + 2);
key               228 ext/opcache/ZendAccelerator.c 						if (key) {
key               229 ext/opcache/ZendAccelerator.c 							memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key               230 ext/opcache/ZendAccelerator.c 							key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key               231 ext/opcache/ZendAccelerator.c 							ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key               232 ext/opcache/ZendAccelerator.c 							zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key               977 ext/opcache/ZendAccelerator.c 					char *key;
key               979 ext/opcache/ZendAccelerator.c 					key = zend_shared_alloc(ZCG(include_path_len) + 2);
key               980 ext/opcache/ZendAccelerator.c 					if (key) {
key               981 ext/opcache/ZendAccelerator.c 						memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key               982 ext/opcache/ZendAccelerator.c 						key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key               983 ext/opcache/ZendAccelerator.c 						ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key               984 ext/opcache/ZendAccelerator.c 						zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key              1020 ext/opcache/ZendAccelerator.c 		if ((size_t)key_length >= sizeof(ZCG(key))) {
key              1024 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key), cwd, cwd_len);
key              1025 ext/opcache/ZendAccelerator.c 		ZCG(key)[cwd_len] = ':';
key              1027 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key) + cwd_len + 1, file_handle->filename, path_length);
key              1029 ext/opcache/ZendAccelerator.c 		ZCG(key)[cwd_len + 1 + path_length] = ':';
key              1034 ext/opcache/ZendAccelerator.c 			memcpy(ZCG(key) + cur_len, parent_script, parent_script_len);
key              1036 ext/opcache/ZendAccelerator.c 			ZCG(key)[cur_len] = ':';
key              1039 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key) + cur_len, include_path, include_path_len);
key              1040 ext/opcache/ZendAccelerator.c 		ZCG(key)[key_length] = '\0';
key              1044 ext/opcache/ZendAccelerator.c 		if ((size_t)key_length >= sizeof(ZCG(key))) {
key              1048 ext/opcache/ZendAccelerator.c 		memcpy(ZCG(key), file_handle->filename, key_length + 1);
key              1052 ext/opcache/ZendAccelerator.c 	return ZCG(key);
key              1114 ext/opcache/ZendAccelerator.c static void zend_accel_add_key(char *key, unsigned int key_length, zend_accel_hash_entry *bucket TSRMLS_DC)
key              1116 ext/opcache/ZendAccelerator.c 	if (!zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) {
key              1124 ext/opcache/ZendAccelerator.c 				memcpy(new_key, key, key_length + 1);
key              1135 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 TSRMLS_DC)
key              1175 ext/opcache/ZendAccelerator.c 				zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key              1183 ext/opcache/ZendAccelerator.c 	memory_used = zend_accel_script_persist_calc(new_persistent_script, key, key_length TSRMLS_CC);
key              1198 ext/opcache/ZendAccelerator.c 	new_persistent_script = zend_accel_script_persist(new_persistent_script, &key, key_length TSRMLS_CC);
key              1219 ext/opcache/ZendAccelerator.c 		    memcmp(key, "phar://", sizeof("phar://") - 1) != 0 &&
key              1221 ext/opcache/ZendAccelerator.c 		     memcmp(new_persistent_script->full_path, key, key_length) != 0)) {
key              1223 ext/opcache/ZendAccelerator.c 			if (zend_accel_hash_update(&ZCSG(hash), key, key_length + 1, 1, bucket)) {
key              1224 ext/opcache/ZendAccelerator.c 				zend_accel_error(ACCEL_LOG_INFO, "Added key '%s'", key);
key              1292 ext/opcache/ZendAccelerator.c static zend_persistent_script *compile_and_cache_file(zend_file_handle *file_handle, int type, char *key, unsigned int key_length, zend_op_array **op_array_p, int *from_shared_memory TSRMLS_DC)
key              1309 ext/opcache/ZendAccelerator.c         	if (key == ZCG(key)) {
key              1461 ext/opcache/ZendAccelerator.c 	return cache_script_in_shared_memory(new_persistent_script, key, key_length, from_shared_memory TSRMLS_CC);
key              1468 ext/opcache/ZendAccelerator.c 	char *key = NULL;
key              1515 ext/opcache/ZendAccelerator.c 		key = ZCG(key);
key              1519 ext/opcache/ZendAccelerator.c 		if ((key = accel_make_persistent_key(file_handle, &key_length TSRMLS_CC)) == NULL) {
key              1522 ext/opcache/ZendAccelerator.c 		persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key              1559 ext/opcache/ZendAccelerator.c 					zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key              1638 ext/opcache/ZendAccelerator.c 		persistent_script = compile_and_cache_file(file_handle, type, key, key_length, &op_array, &from_shared_memory TSRMLS_CC);
key              1850 ext/opcache/ZendAccelerator.c 				char *key = NULL;
key              1873 ext/opcache/ZendAccelerator.c 					memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key              1881 ext/opcache/ZendAccelerator.c 				key = accel_make_persistent_key_ex(handle, filename_len, &key_length TSRMLS_CC);
key              1883 ext/opcache/ZendAccelerator.c 				    key &&
key              1884 ext/opcache/ZendAccelerator.c 					(persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key              1905 ext/opcache/ZendAccelerator.c 						if (key && !ZCG(accel_directives).revalidate_path) {
key              1909 ext/opcache/ZendAccelerator.c 							zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key              1981 ext/opcache/ZendAccelerator.c 					memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key              2020 ext/opcache/ZendAccelerator.c 			char *key = NULL;
key              2032 ext/opcache/ZendAccelerator.c 					memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key              2044 ext/opcache/ZendAccelerator.c 			key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC);
key              2046 ext/opcache/ZendAccelerator.c 			    key &&
key              2047 ext/opcache/ZendAccelerator.c 				(persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key              2065 ext/opcache/ZendAccelerator.c 					if (key && !ZCG(accel_directives).revalidate_path) {
key              2069 ext/opcache/ZendAccelerator.c 						zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key              2073 ext/opcache/ZendAccelerator.c 					ZCG(cache_opline) = (EG(opline_ptr) && key) ? *EG(opline_ptr): NULL;
key              2074 ext/opcache/ZendAccelerator.c 					ZCG(cache_persistent_script) = key ? persistent_script : NULL;
key              2153 ext/opcache/ZendAccelerator.c 					ZCSG(include_paths).hash_table[zend_inline_hash_func(ZCSG(include_paths).hash_entries[0].key, ZCSG(include_paths).hash_entries[0].key_length) % ZCSG(include_paths).max_num_entries] = &ZCSG(include_paths).hash_entries[0];
key              2655 ext/opcache/ZendAccelerator.c 				char *key;
key              2658 ext/opcache/ZendAccelerator.c 				key = zend_shared_alloc(ZCG(include_path_len) + 2);
key              2659 ext/opcache/ZendAccelerator.c 				if (key) {
key              2660 ext/opcache/ZendAccelerator.c 					memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key              2661 ext/opcache/ZendAccelerator.c 					key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key              2662 ext/opcache/ZendAccelerator.c 					ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key              2663 ext/opcache/ZendAccelerator.c 					zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key               274 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, zend_uint 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               143 ext/opcache/zend_accelerator_hash.c void* zend_accel_hash_find(zend_accel_hash *accel_hash, char *key, zend_uint key_length)
key               149 ext/opcache/zend_accelerator_hash.c 	hash_value = zend_inline_hash_func(key, key_length);
key               156 ext/opcache/zend_accelerator_hash.c 			&& !memcmp(entry->key, key, key_length)) {
key               171 ext/opcache/zend_accelerator_hash.c zend_accel_hash_entry* zend_accel_hash_find_entry(zend_accel_hash *accel_hash, char *key, zend_uint key_length)
key               177 ext/opcache/zend_accelerator_hash.c 	hash_value = zend_inline_hash_func(key, key_length);
key               184 ext/opcache/zend_accelerator_hash.c 			&& !memcmp(entry->key, key, key_length)) {
key               196 ext/opcache/zend_accelerator_hash.c int zend_accel_hash_unlink(zend_accel_hash *accel_hash, char *key, zend_uint key_length)
key               202 ext/opcache/zend_accelerator_hash.c 	hash_value = zend_inline_hash_func(key, key_length);
key               209 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 		char                   *key,
key                81 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key                86 ext/opcache/zend_accelerator_hash.h 		char                   *key,
key               315 ext/opcache/zend_accelerator_module.c 	char *key;
key               332 ext/opcache/zend_accelerator_module.c 	if ((key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC)) != NULL) {
key               333 ext/opcache/zend_accelerator_module.c 		persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key               542 ext/opcache/zend_accelerator_module.c 			zend_hash_update(return_value->value.ht, cache_entry->key, cache_entry->key_length, &persistent_script_report, sizeof(zval *), NULL);
key               705 ext/opcache/zend_persist.c zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, char **key, unsigned int key_length TSRMLS_DC)
key               711 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 TSRMLS_DC);
key                27 ext/opcache/zend_persist.h zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, char **key, unsigned int key_length TSRMLS_DC);
key               362 ext/opcache/zend_persist_calc.c uint zend_accel_script_persist_calc(zend_persistent_script *new_persistent_script, char *key, unsigned int key_length TSRMLS_DC)
key               369 ext/opcache/zend_persist_calc.c 	ADD_DUP_SIZE(key, key_length + 1);
key               145 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               231 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               238 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               249 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               253 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               258 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               309 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               316 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               323 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               330 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               340 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               347 ext/openssl/openssl.c 	ZEND_ARG_INFO(0, key)
key               627 ext/openssl/openssl.c static void add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int shortname TSRMLS_DC) /* {{{ */
key               638 ext/openssl/openssl.c 	if (key != NULL) {
key               685 ext/openssl/openssl.c 	if (key != NULL) {
key               686 ext/openssl/openssl.c 		zend_hash_update(HASH_OF(val), key, strlen(key) + 1, (void *)&subitem, sizeof(subitem), NULL);
key               691 ext/openssl/openssl.c static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */
key               693 ext/openssl/openssl.c 	add_assoc_stringl(val, key, (char *)str->data, str->length, 1);
key               844 ext/openssl/openssl.c #define SET_OPTIONAL_STRING_ARG(key, varname, defval)	\
key               845 ext/openssl/openssl.c 	if (optional_args && zend_hash_find(Z_ARRVAL_P(optional_args), key, sizeof(key), (void**)&item) == SUCCESS && Z_TYPE_PP(item) == IS_STRING) \
key               850 ext/openssl/openssl.c #define SET_OPTIONAL_LONG_ARG(key, varname, defval)	\
key               851 ext/openssl/openssl.c 	if (optional_args && zend_hash_find(Z_ARRVAL_P(optional_args), key, sizeof(key), (void**)&item) == SUCCESS && Z_TYPE_PP(item) == IS_LONG) \
key              1842 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              1854 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zkey, 0, "", 1, &keyresource TSRMLS_CC);
key              1855 ext/openssl/openssl.c 	if (key) {
key              1856 ext/openssl/openssl.c 		RETVAL_BOOL(X509_check_private_key(cert, key));
key              1859 ext/openssl/openssl.c 	if (keyresource == -1 && key) {
key              1860 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              2945 ext/openssl/openssl.c 	EVP_PKEY * key = NULL, *priv_key = NULL;
key              2982 ext/openssl/openssl.c 	key = X509_REQ_get_pubkey(csr);
key              2983 ext/openssl/openssl.c 	if (key == NULL) {
key              2987 ext/openssl/openssl.c 	i = X509_REQ_verify(csr, key);
key              3021 ext/openssl/openssl.c 	i = X509_set_pubkey(new_cert, key);
key              3055 ext/openssl/openssl.c 	if (key) {
key              3056 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3225 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              3338 ext/openssl/openssl.c 				key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key              3357 ext/openssl/openssl.c 			key = PEM_read_bio_PrivateKey(in, NULL,NULL, passphrase);
key              3362 ext/openssl/openssl.c 	if (public_key && cert && key == NULL) {
key              3364 ext/openssl/openssl.c 		key = (EVP_PKEY *) X509_get_pubkey(cert);
key              3370 ext/openssl/openssl.c 	if (key && makeresource && resourceval) {
key              3371 ext/openssl/openssl.c 		*resourceval = ZEND_REGISTER_RESOURCE(NULL, key, le_key);
key              3376 ext/openssl/openssl.c 	return key;
key              3646 ext/openssl/openssl.c 	EVP_PKEY * key;
key              3655 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key              3657 ext/openssl/openssl.c 	if (key == NULL) {
key              3681 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
key              3684 ext/openssl/openssl.c 				pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key              3688 ext/openssl/openssl.c 				pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key              3700 ext/openssl/openssl.c 	if (key_resource == -1 && key) {
key              3701 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3719 ext/openssl/openssl.c 	EVP_PKEY * key;
key              3728 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key              3730 ext/openssl/openssl.c 	if (key == NULL) {
key              3750 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
key              3753 ext/openssl/openssl.c 				pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key              3757 ext/openssl/openssl.c 				pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key              3776 ext/openssl/openssl.c 	if (key_resource == -1 && key) {
key              3777 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              3809 ext/openssl/openssl.c 	zval *key;
key              3812 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key              3815 ext/openssl/openssl.c 	ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key              3816 ext/openssl/openssl.c 	zend_list_delete(Z_LVAL_P(key));
key              3847 ext/openssl/openssl.c 	zval *key;
key              3854 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key              3857 ext/openssl/openssl.c 	ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key              4397 ext/openssl/openssl.c 	EVP_PKEY * key = NULL;
key              4417 ext/openssl/openssl.c 	key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &keyresval TSRMLS_CC);
key              4418 ext/openssl/openssl.c 	if (key == NULL) {
key              4441 ext/openssl/openssl.c 	if (PKCS7_decrypt(p7, key, cert, out, PKCS7_DETACHED)) { 
key              4452 ext/openssl/openssl.c 	if (key && keyresval == -1) {
key              4453 ext/openssl/openssl.c 		EVP_PKEY_free(key);
key              4464 ext/openssl/openssl.c 	zval **key, *crypted;
key              4474 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) { 
key              4479 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key              4522 ext/openssl/openssl.c 	zval **key, *crypted;
key              4533 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key              4538 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key              4588 ext/openssl/openssl.c 	zval **key, *crypted;
key              4598 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
key              4603 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key              4646 ext/openssl/openssl.c 	zval **key, *crypted;
key              4657 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key              4662 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key              4734 ext/openssl/openssl.c 	zval **key, *signature;
key              4746 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
key              4749 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key              4796 ext/openssl/openssl.c 	zval **key;
key              4807 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssZ|z", &data, &data_len, &signature, &signature_len, &key, &method) == FAILURE) {
key              4827 ext/openssl/openssl.c 	pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key              5175 ext/openssl/openssl.c 	unsigned char *outbuf, *key;
key              5189 ext/openssl/openssl.c 		key = emalloc(keylen);
key              5190 ext/openssl/openssl.c 		memset(key, 0, keylen);
key              5191 ext/openssl/openssl.c 		memcpy(key, password, password_len);
key              5193 ext/openssl/openssl.c 		key = (unsigned char*)password;
key              5209 ext/openssl/openssl.c 	EVP_EncryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key              5234 ext/openssl/openssl.c 	if (key != (unsigned char*)password) {
key              5235 ext/openssl/openssl.c 		efree(key);
key              5254 ext/openssl/openssl.c 	unsigned char *outbuf, *key;
key              5286 ext/openssl/openssl.c 		key = emalloc(keylen);
key              5287 ext/openssl/openssl.c 		memset(key, 0, keylen);
key              5288 ext/openssl/openssl.c 		memcpy(key, password, password_len);
key              5290 ext/openssl/openssl.c 		key = (unsigned char*)password;
key              5302 ext/openssl/openssl.c 	EVP_DecryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key              5316 ext/openssl/openssl.c 	if (key != (unsigned char*)password) {
key              5317 ext/openssl/openssl.c 		efree(key);
key              5360 ext/openssl/openssl.c 	zval *key;
key              5368 ext/openssl/openssl.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr", &pub_str, &pub_len, &key) == FAILURE) {
key              5371 ext/openssl/openssl.c 	ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key               305 ext/openssl/xp_ssl.c 		char *key;
key               318 ext/openssl/xp_ssl.c 			int key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(val), &key, &key_len, &key_index, 0, &pos);
key               324 ext/openssl/xp_ssl.c 			if (php_x509_fingerprint_cmp(peer, key, Z_STRVAL_PP(current) TSRMLS_CC) != 0) {
key               913 ext/openssl/xp_ssl.c 				EVP_PKEY *key = NULL;
key               918 ext/openssl/xp_ssl.c 					key = X509_get_pubkey(cert);
key               919 ext/openssl/xp_ssl.c 					EVP_PKEY_copy_parameters(key, SSL_get_privatekey(tmpssl));
key               920 ext/openssl/xp_ssl.c 					EVP_PKEY_free(key);
key              1321 ext/openssl/xp_ssl.c 	char *key;
key              1363 ext/openssl/xp_ssl.c 		key_type = zend_hash_get_current_key_ex(Z_ARRVAL_PP(val), &key, &key_len, &key_index, 0, &pos);
key              1393 ext/openssl/xp_ssl.c 				sslsock->sni_certs[i].name = pestrdup(key, php_stream_is_persistent(stream));
key               752 ext/pcntl/pcntl.c 	char *key;
key               792 ext/pcntl/pcntl.c 			switch (return_val = zend_hash_get_current_key_ex(envs_hash, &key, &key_length, &key_num, 0, NULL)) {
key               794 ext/pcntl/pcntl.c 					key = emalloc(101);
key               795 ext/pcntl/pcntl.c 					snprintf(key, 100, "%ld", key_num);
key               796 ext/pcntl/pcntl.c 					key_length = strlen(key);
key               808 ext/pcntl/pcntl.c 			strlcpy(*pair, key, key_length);
key               813 ext/pcntl/pcntl.c 			if (return_val == HASH_KEY_IS_LONG) efree(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              1356 ext/pdo/pdo_dbh.c 	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
key              1368 ext/pdo/pdo_dbh.c 	if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len, key TSRMLS_CC)) == NULL) {
key              2217 ext/pdo/pdo_stmt.c static void dbstmt_prop_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key              2226 ext/pdo/pdo_stmt.c 		std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key              2230 ext/pdo/pdo_stmt.c static void dbstmt_prop_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
key              2239 ext/pdo/pdo_stmt.c 		std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key              2249 ext/pdo/pdo_stmt.c    	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
key              2442 ext/pdo/pdo_stmt.c 	ulong key;
key              2481 ext/pdo/pdo_stmt.c static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key              2485 ext/pdo/pdo_stmt.c 	if (I->key == (ulong)-1) {
key              2486 ext/pdo/pdo_stmt.c 		ZVAL_NULL(key);
key              2488 ext/pdo/pdo_stmt.c 		ZVAL_LONG(key, I->key);
key              2508 ext/pdo/pdo_stmt.c 		I->key = (ulong)-1;
key              2515 ext/pdo/pdo_stmt.c 	I->key++;
key              2546 ext/pdo/pdo_stmt.c 		I->key = (ulong)-1;
key              2562 ext/pdo/pdo_stmt.c static zval *row_prop_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key              2590 ext/pdo/pdo_stmt.c 				return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key              2606 ext/pdo/pdo_stmt.c static void row_prop_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key              2616 ext/pdo/pdo_stmt.c static int row_prop_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
key              2645 ext/pdo/pdo_stmt.c static void row_prop_delete(zval *object, zval *offset, const zend_literal *key TSRMLS_DC)
key              2684 ext/pdo/pdo_stmt.c 	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
key               316 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               103 ext/phar/phar.c 	char *key, *lasts, *end;
key               133 ext/phar/phar.c 	for (key = php_strtok_r(tmp, ds, &lasts);
key               134 ext/phar/phar.c 			key;
key               135 ext/phar/phar.c 			key = php_strtok_r(NULL, ds, &lasts)) {
key               136 ext/phar/phar.c 		end = strchr(key, DEFAULT_DIR_SEPARATOR);
key               139 ext/phar/phar.c 			if (SUCCESS == phar_open_from_filename(key, end - key, NULL, 0, 0, &phar, NULL TSRMLS_CC)) {
key               162 ext/phar/phar.c 			if (SUCCESS == phar_open_from_filename(key, strlen(key), NULL, 0, 0, &phar, NULL TSRMLS_CC)) {
key              1457 ext/phar/phar_object.c 				zval key;
key              1458 ext/phar/phar_object.c 				iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key              1464 ext/phar/phar_object.c 				if (Z_TYPE(key) != IS_STRING) {
key              1465 ext/phar/phar_object.c 					zval_dtor(&key);
key              1470 ext/phar/phar_object.c 				str_key_len = Z_STRLEN(key);
key              1471 ext/phar/phar_object.c 				str_key = estrndup(Z_STRVAL(key), str_key_len);
key              1474 ext/phar/phar_object.c 				zval_dtor(&key);
key              1585 ext/phar/phar_object.c 			zval key;
key              1586 ext/phar/phar_object.c 			iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key              1592 ext/phar/phar_object.c 			if (Z_TYPE(key) != IS_STRING) {
key              1593 ext/phar/phar_object.c 				zval_dtor(&key);
key              1598 ext/phar/phar_object.c 			str_key_len = Z_STRLEN(key);
key              1599 ext/phar/phar_object.c 			str_key = estrndup(Z_STRVAL(key), str_key_len);
key              1602 ext/phar/phar_object.c 			zval_dtor(&key);
key              3034 ext/phar/phar_object.c 	char *error, *key = NULL;
key              3045 ext/phar/phar_object.c 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &algo, &key, &key_len) != SUCCESS) {
key              3066 ext/phar/phar_object.c 			PHAR_G(openssl_privatekey) = key;
key                41 ext/phar/util.c static int phar_call_openssl_signverify(int is_sign, php_stream *fp, off_t end, char *key, int key_len, char **signature, int *signature_len TSRMLS_DC);
key              1407 ext/phar/util.c static int phar_call_openssl_signverify(int is_sign, php_stream *fp, off_t end, char *key, int key_len, char **signature, int *signature_len TSRMLS_DC) /* {{{ */
key              1419 ext/phar/util.c 	ZVAL_STRINGL(zkey, key, key_len, 1);
key              1532 ext/phar/util.c 			EVP_PKEY *key;
key              1600 ext/phar/util.c 			key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key              1604 ext/phar/util.c 			if (NULL == key) {
key              1631 ext/phar/util.c 			if (EVP_VerifyFinal(&md_ctx, (unsigned char *)sig, sig_len, key) != 1) {
key              1857 ext/phar/util.c 			EVP_PKEY *key;
key              1869 ext/phar/util.c 			key = PEM_read_bio_PrivateKey(in, NULL,NULL, "");
key              1872 ext/phar/util.c 			if (!key) {
key              1881 ext/phar/util.c 			siglen = EVP_PKEY_size(key);
key              1902 ext/phar/util.c 			if (!EVP_SignFinal (md_ctx, sigbuf,(unsigned int *)&siglen, key)) {
key               456 ext/reflection/php_reflection.c 			char *key;
key               463 ext/reflection/php_reflection.c 				zend_hash_get_current_key_ex(&ce->constants_table, &key, &key_len, &num_index, 0, &pos);
key               465 ext/reflection/php_reflection.c 				_const_string(str, key, *value, indent TSRMLS_CC);
key               626 ext/reflection/php_reflection.c 					char *key;
key               634 ext/reflection/php_reflection.c 						|| zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING
key               635 ext/reflection/php_reflection.c 						|| zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0)
key               825 ext/reflection/php_reflection.c 	char *key;
key               846 ext/reflection/php_reflection.c 		zend_hash_get_current_key_ex(static_variables, &key, &key_len, &num_index, 0, &pos);
key               847 ext/reflection/php_reflection.c 		string_printf(str, "%s    Variable #%d [ $%s ]\n", indent, i++, key);
key              3423 ext/reflection/php_reflection.c 	char *key;
key              3429 ext/reflection/php_reflection.c 		zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key              3463 ext/reflection/php_reflection.c 		add_assoc_zval(return_value, key, prop_copy);
key              6153 ext/reflection/php_reflection.c static void _reflection_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key              6165 ext/reflection/php_reflection.c 		zend_std_obj_handlers->write_property(object, member, value, key TSRMLS_CC);
key                74 ext/session/mod_files.c static char *ps_files_path_create(char *buf, size_t buflen, ps_files *data, const char *key)
key                81 ext/session/mod_files.c 	key_len = strlen(key);
key                87 ext/session/mod_files.c 	p = key;
key                97 ext/session/mod_files.c 	memcpy(buf + n, key, key_len);
key               121 ext/session/mod_files.c static void ps_files_open(ps_files *data, const char *key TSRMLS_DC)
key               127 ext/session/mod_files.c 	if (data->fd < 0 || !data->lastkey || strcmp(key, data->lastkey)) {
key               135 ext/session/mod_files.c 		if (php_session_valid_key(key) == FAILURE) {
key               140 ext/session/mod_files.c 		if (!ps_files_path_create(buf, sizeof(buf), data, key)) {
key               144 ext/session/mod_files.c 		data->lastkey = estrdup(key);
key               239 ext/session/mod_files.c static int ps_files_key_exists(ps_files *data, const char *key TSRMLS_DC)
key               244 ext/session/mod_files.c 	if (!key || !ps_files_path_create(buf, sizeof(buf), data, key)) {
key               346 ext/session/mod_files.c 		ps_files_key_exists(data, key TSRMLS_CC) == FAILURE) {
key               348 ext/session/mod_files.c 		if (key) {
key               410 ext/session/mod_files.c 	ps_files_open(data, key TSRMLS_CC);
key               445 ext/session/mod_files.c 	if (!ps_files_path_create(buf, sizeof(buf), data, 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               131 ext/session/mod_mm.c 	hv = ps_sd_hash(key, keylen);
key               139 ext/session/mod_mm.c 	memcpy(sd->key, key, keylen + 1);
key               152 ext/session/mod_mm.c 	ps_mm_debug(("inserting %s(%p) into slot %d\n", key, sd, slot));
key               161 ext/session/mod_mm.c 	slot = ps_sd_hash(sd->key, strlen(sd->key)) & data->hash_max;
key               182 ext/session/mod_mm.c static ps_sd *ps_sd_lookup(ps_mm *data, const char *key, int rw)
key               187 ext/session/mod_mm.c 	hv = ps_sd_hash(key, strlen(key));
key               191 ext/session/mod_mm.c 		if (ret->hv == hv && !strcmp(ret->key, key)) {
key               206 ext/session/mod_mm.c 	ps_mm_debug(("lookup(%s): ret=%p,hv=%u,slot=%d\n", key, ret, hv, slot));
key               211 ext/session/mod_mm.c static int ps_mm_key_exists(ps_mm *data, const char *key TSRMLS_DC)
key               215 ext/session/mod_mm.c 	if (!key) {
key               218 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key, 0);
key               360 ext/session/mod_mm.c 		&& ps_mm_key_exists(data, key TSRMLS_CC) == FAILURE) {
key               362 ext/session/mod_mm.c 		if (key) {
key               398 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key, 1);
key               400 ext/session/mod_mm.c 		sd = ps_sd_new(data, key);
key               401 ext/session/mod_mm.c 		ps_mm_debug(("new entry for %s\n", key));
key               437 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key, 0);
key               468 ext/session/mod_mm.c 				ps_mm_debug(("purging %s\n", sd->key));
key               133 ext/session/mod_user.c 	SESS_ZVAL_STRING((char*)key, args[0]);
key               154 ext/session/mod_user.c 	SESS_ZVAL_STRING((char*)key, args[0]);
key               167 ext/session/mod_user.c 	SESS_ZVAL_STRING((char*)key, args[0]);
key                74 ext/session/mod_user_class.c 	char *key, *val;
key                79 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
key                83 ext/session/mod_user_class.c 	if (PS(default_mod)->s_read(&PS(mod_data), key, &val, &val_len TSRMLS_CC) == FAILURE) {
key                98 ext/session/mod_user_class.c 	char *key, *val;
key               103 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_len, &val, &val_len) == FAILURE) {
key               107 ext/session/mod_user_class.c 	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, val_len TSRMLS_CC));
key               115 ext/session/mod_user_class.c 	char *key;
key               120 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
key               124 ext/session/mod_user_class.c 	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_destroy(&PS(mod_data), key TSRMLS_CC));
key                37 ext/session/php_session.h #define PS_READ_ARGS void **mod_data, const char *key, char **val, int *vallen TSRMLS_DC
key                38 ext/session/php_session.h #define PS_WRITE_ARGS void **mod_data, const char *key, const char *val, const int vallen TSRMLS_DC
key                39 ext/session/php_session.h #define PS_DESTROY_ARGS void **mod_data, const char *key TSRMLS_DC
key               105 ext/session/php_session.h 	smart_str key;
key               239 ext/session/php_session.h PHPAPI int php_session_valid_key(const char *key);
key               256 ext/session/php_session.h 	char *key;													\
key               266 ext/session/php_session.h 				(key_type = zend_hash_get_current_key_ex(_ht, &key, &key_length, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTENT; \
key               273 ext/session/php_session.h 			if (php_get_session_var(key, key_length, &struc TSRMLS_CC) == SUCCESS) {	\
key               440 ext/session/session.c PHPAPI int php_session_valid_key(const char *key) /* {{{ */
key               447 ext/session/session.c 	for (p = key; (c = *p); p++) {
key               459 ext/session/session.c 	len = p - key;
key               899 ext/session/session.c 			smart_str_appendl(&buf, key, key_length);
key               904 ext/session/session.c 			smart_str_appendl(&buf, key, key_length);
key               983 ext/session/session.c 			smart_str_appendl(&buf, key, key_length);
key               984 ext/session/session.c 			if (memchr(key, PS_DELIMITER, key_length) || memchr(key, PS_UNDEF_MARKER, key_length)) {
key               994 ext/session/session.c 			smart_str_appendl(&buf, key, key_length);
key              2270 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2274 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2279 ext/session/session.c 	ZEND_ARG_INFO(0, key)
key              2600 ext/session/session.c 	if (zend_symtable_find(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1, (void**)&progress_ary) != SUCCESS) {
key              2637 ext/session/session.c 		ZEND_SET_SYMBOL_WITH_LENGTH(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1, progress->data, 2, 0);
key              2647 ext/session/session.c 		zend_hash_del(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1);
key              2679 ext/session/session.c 			if (Z_TYPE(progress->sid) && progress->key.c) {
key              2698 ext/session/session.c 					smart_str_free(&progress->key);
key              2699 ext/session/session.c 					smart_str_appendl(&progress->key, PS(rfc1867_prefix).c, PS(rfc1867_prefix).len);
key              2700 ext/session/session.c 					smart_str_appendl(&progress->key, *data->value, value_len);
key              2701 ext/session/session.c 					smart_str_0(&progress->key);
key              2714 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.c) {
key              2776 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.c) {
key              2789 ext/session/session.c 			if (!Z_TYPE(progress->sid) || !progress->key.c) {
key              2807 ext/session/session.c 			if (Z_TYPE(progress->sid) && progress->key.c) {
key              2822 ext/session/session.c 			smart_str_free(&progress->key);
key                44 ext/shmop/php_shmop.h 	key_t key;
key                50 ext/shmop/shmop.c 	ZEND_ARG_INFO(0, key)
key               159 ext/shmop/shmop.c 	long key, mode, size;
key               166 ext/shmop/shmop.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) {
key               178 ext/shmop/shmop.c 	shmop->key = key;
key               210 ext/shmop/shmop.c 	shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg);
key                62 ext/simplexml/simplexml.c static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC);
key               392 ext/simplexml/simplexml.c static zval * sxe_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key               683 ext/simplexml/simplexml.c static void sxe_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               697 ext/simplexml/simplexml.c static zval** sxe_property_get_adr(zval *object, zval *member, int fetch_type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               849 ext/simplexml/simplexml.c static int sxe_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
key               974 ext/simplexml/simplexml.c static void sxe_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
key              2385 ext/simplexml/simplexml.c static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key              2397 ext/simplexml/simplexml.c 		ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name), 1);
key              2399 ext/simplexml/simplexml.c 		ZVAL_NULL(key);
key                88 ext/simplexml/sxe.c PHP_METHOD(ce_SimpleXMLIterator, key)
key               180 ext/simplexml/sxe.c 	PHP_ME(ce_SimpleXMLIterator, key,                    arginfo_simplexmliterator__void, ZEND_ACC_PUBLIC)
key              1976 ext/snmp/snmp.c zval *php_snmp_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key              2006 ext/snmp/snmp.c 		retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key              2018 ext/snmp/snmp.c void php_snmp_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key              2045 ext/snmp/snmp.c 		std_hnd->write_property(object, member, value, key TSRMLS_CC);
key              2056 ext/snmp/snmp.c static int php_snmp_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC)
key              2067 ext/snmp/snmp.c 				zval *value = php_snmp_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key              2077 ext/snmp/snmp.c 				zval *value = php_snmp_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key              2090 ext/snmp/snmp.c 		ret = std_hnd->has_property(object, member, has_set_exists, key TSRMLS_CC);
key              2104 ext/snmp/snmp.c 	char *key;
key              2115 ext/snmp/snmp.c 		zend_hash_get_current_key_ex(&php_snmp_properties, &key, &key_len, &num_key, 0, &pos);
key              2120 ext/snmp/snmp.c 		zend_hash_update(props, key, key_len, (void *)&val, sizeof(zval *), NULL);
key              2349 ext/soap/php_encoding.c 				zval key;
key              2350 ext/soap/php_encoding.c 				iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key              2354 ext/soap/php_encoding.c 				array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val);
key              2356 ext/soap/php_encoding.c 				zval_dtor(&key);
key              2792 ext/soap/php_encoding.c 			xmlNodePtr key;
key              2800 ext/soap/php_encoding.c 			key = xmlNewNode(NULL, BAD_CAST("key"));
key              2801 ext/soap/php_encoding.c 			xmlAddChild(item,key);
key              2804 ext/soap/php_encoding.c 					set_xsi_type(key, "xsd:string");
key              2806 ext/soap/php_encoding.c 				xmlNodeSetContent(key, BAD_CAST(key_val));
key              2813 ext/soap/php_encoding.c 					set_xsi_type(key, "xsd:int");
key              2815 ext/soap/php_encoding.c 				xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len);
key              2835 ext/soap/php_encoding.c 	zval *ret, *key, *value;
key              2857 ext/soap/php_encoding.c 			key = master_to_zval(NULL, xmlKey TSRMLS_CC);
key              2860 ext/soap/php_encoding.c 			if (Z_TYPE_P(key) == IS_STRING) {
key              2861 ext/soap/php_encoding.c 				zend_symtable_update(Z_ARRVAL_P(ret), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
key              2862 ext/soap/php_encoding.c 			} else if (Z_TYPE_P(key) == IS_LONG) {
key              2863 ext/soap/php_encoding.c 				zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key              2867 ext/soap/php_encoding.c 			zval_ptr_dtor(&key);
key               815 ext/soap/php_http.c 			char *key;
key               826 ext/soap/php_http.c 					int res = zend_hash_get_current_key_ex(Z_ARRVAL_PP(cookies), &key, &key_len, &numindx, 0, NULL);
key               842 ext/soap/php_http.c 								smart_str_appendl(&soap_headers, key, key_len-1);
key               403 ext/soap/php_packet_soap.c 					smart_str key = {0};
key               407 ext/soap/php_packet_soap.c 						smart_str_appends(&key, (char*)trav->ns->href);
key               408 ext/soap/php_packet_soap.c 						smart_str_appendc(&key,':');
key               410 ext/soap/php_packet_soap.c 					smart_str_appends(&key, (char*)trav->name);
key               411 ext/soap/php_packet_soap.c 					smart_str_0(&key);
key               412 ext/soap/php_packet_soap.c 					if (zend_hash_find(hdrs, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key               415 ext/soap/php_packet_soap.c 					smart_str_free(&key);
key              1074 ext/soap/php_schema.c 		smart_str key = {0};
key              1083 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              1090 ext/soap/php_schema.c 					smart_str_appends(&key, (char*)ns->children->content);
key              1093 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1094 ext/soap/php_schema.c 			smart_str_appends(&key, type);
key              1095 ext/soap/php_schema.c 			smart_str_0(&key);
key              1099 ext/soap/php_schema.c 			newModel->u.group_ref = estrdup(key.c);
key              1109 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)ns->children->content);
key              1110 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1111 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)name->children->content);
key              1112 ext/soap/php_schema.c 			smart_str_0(&key);
key              1125 ext/soap/php_schema.c 			if (zend_hash_add(sdl->groups, key.c, key.len+1, (void**)&newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key              1126 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.c);
key              1131 ext/soap/php_schema.c 		smart_str_free(&key);
key              1505 ext/soap/php_schema.c 		smart_str key = {0};
key              1550 ext/soap/php_schema.c 			smart_str_appends(&key, newType->namens);
key              1551 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1552 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1559 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1562 ext/soap/php_schema.c 		smart_str_0(&key);
key              1563 ext/soap/php_schema.c 		if (zend_hash_add(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key              1565 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.c);
key              1570 ext/soap/php_schema.c 		smart_str_free(&key);
key              1740 ext/soap/php_schema.c 		smart_str key = {0};
key              1752 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              1760 ext/soap/php_schema.c 					smart_str_appends(&key, (char*)ns->children->content);
key              1763 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1764 ext/soap/php_schema.c 			smart_str_appends(&key, attr_name);
key              1765 ext/soap/php_schema.c 			smart_str_0(&key);
key              1766 ext/soap/php_schema.c 			newAttr->ref = estrdup(key.c);
key              1777 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)ns->children->content);
key              1778 ext/soap/php_schema.c 				smart_str_appendc(&key, ':');
key              1781 ext/soap/php_schema.c 			smart_str_appends(&key, (char*)name->children->content);
key              1782 ext/soap/php_schema.c 			smart_str_0(&key);
key              1795 ext/soap/php_schema.c 		if (zend_hash_add(addHash, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL) != SUCCESS) {
key              1796 ext/soap/php_schema.c 			soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.c);
key              1798 ext/soap/php_schema.c 		smart_str_free(&key);
key              1959 ext/soap/php_schema.c 			smart_str key = {0};
key              1970 ext/soap/php_schema.c 			smart_str_appends(&key, newType->namens);
key              1971 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1972 ext/soap/php_schema.c 			smart_str_appends(&key, newType->name);
key              1973 ext/soap/php_schema.c 			smart_str_0(&key);
key              1975 ext/soap/php_schema.c 			if (zend_hash_add(ctx->attributeGroups, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key              1976 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.c);
key              1979 ext/soap/php_schema.c 			smart_str_free(&key);
key              1983 ext/soap/php_schema.c 			smart_str key = {0};
key              1996 ext/soap/php_schema.c 				smart_str_appends(&key, (char*)nsptr->href);
key              1998 ext/soap/php_schema.c 			smart_str_appendc(&key, ':');
key              1999 ext/soap/php_schema.c 			smart_str_appends(&key, group_name);
key              2000 ext/soap/php_schema.c 			smart_str_0(&key);
key              2001 ext/soap/php_schema.c 			newAttr->ref = estrdup(key.c);
key              2004 ext/soap/php_schema.c 			smart_str_free(&key);
key              2143 ext/soap/php_schema.c 							char* key;
key              2163 ext/soap/php_schema.c 							zend_hash_get_current_key_ex((*tmp)->attributes, &key, &key_len, NULL, 0, NULL);
key              2164 ext/soap/php_schema.c 							zend_hash_add(ht, key, key_len, &newAttr, sizeof(sdlAttributePtr), NULL);
key               201 ext/soap/php_sdl.c 	smart_str key = {0};
key               203 ext/soap/php_sdl.c 	smart_str_appends(&key, ns);
key               204 ext/soap/php_sdl.c 	smart_str_appendc(&key, ':');
key               205 ext/soap/php_sdl.c 	smart_str_appends(&key, name);
key               206 ext/soap/php_sdl.c 	smart_str_0(&key);
key               208 ext/soap/php_sdl.c 	zend_hash_find(sdl->bindings, key.c, key.len, (void **)&binding);
key               210 ext/soap/php_sdl.c 	smart_str_free(&key);
key               535 ext/soap/php_sdl.c 				smart_str key = {0};
key               543 ext/soap/php_sdl.c 					smart_str_appends(&key,hf->ns);
key               544 ext/soap/php_sdl.c 					smart_str_appendc(&key,':');
key               546 ext/soap/php_sdl.c 				smart_str_appends(&key,hf->name);
key               547 ext/soap/php_sdl.c 				smart_str_0(&key);
key               548 ext/soap/php_sdl.c 				if (zend_hash_add(h->headerfaults, key.c, key.len+1, (void**)&hf, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
key               551 ext/soap/php_sdl.c 				smart_str_free(&key);
key               640 ext/soap/php_sdl.c 			smart_str key = {0};
key               648 ext/soap/php_sdl.c 				smart_str_appends(&key,h->ns);
key               649 ext/soap/php_sdl.c 				smart_str_appendc(&key,':');
key               651 ext/soap/php_sdl.c 			smart_str_appends(&key,h->name);
key               652 ext/soap/php_sdl.c 			smart_str_0(&key);
key               653 ext/soap/php_sdl.c 			if (zend_hash_add(binding->headers, key.c, key.len+1, (void**)&h, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
key               656 ext/soap/php_sdl.c 			smart_str_free(&key);
key              1804 ext/soap/php_sdl.c 	char *key;
key              1808 ext/soap/php_sdl.c 	if (zend_hash_get_current_key_ex(ht, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              1810 ext/soap/php_sdl.c 		WSDL_CACHE_PUT_N(key, key_len, out);
key              2448 ext/soap/php_sdl.c 	char *key;
key              2484 ext/soap/php_sdl.c 		if (zend_hash_get_current_key_ex(headers, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2485 ext/soap/php_sdl.c 			zend_hash_add(pheaders, key, key_len, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
key              2516 ext/soap/php_sdl.c 	char *key;
key              2545 ext/soap/php_sdl.c 		if (zend_hash_get_current_key_ex(params, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2546 ext/soap/php_sdl.c 			zend_hash_add(pparams, key, key_len, (void*)&pparam, sizeof(sdlParamPtr), NULL);
key              2563 ext/soap/php_sdl.c 	char *key;
key              2594 ext/soap/php_sdl.c 		if (zend_hash_get_current_key_ex(faults, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2595 ext/soap/php_sdl.c 			zend_hash_add(pfaults, key, key_len, (void*)&pfault, sizeof(sdlParamPtr), NULL);
key              2612 ext/soap/php_sdl.c 	char *key;
key              2649 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(attr->extraAttributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {			
key              2660 ext/soap/php_sdl.c 				zend_hash_add(pattr->extraAttributes, key, key_len, (void*)&pextra, sizeof(sdlExtraAttributePtr), NULL);
key              2724 ext/soap/php_sdl.c 	char *key;
key              2811 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(type->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2812 ext/soap/php_sdl.c 				zend_hash_add(ptype->elements, key, key_len, (void*)&pelem, sizeof(sdlTypePtr), NULL);
key              2830 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(type->attributes, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2831 ext/soap/php_sdl.c 				zend_hash_add(ptype->attributes, key, key_len, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
key              2958 ext/soap/php_sdl.c 	char *key;
key              2985 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->groups, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              2986 ext/soap/php_sdl.c 				zend_hash_add(psdl->groups, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key              3005 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->types, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3006 ext/soap/php_sdl.c 				zend_hash_add(psdl->types, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key              3025 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->elements, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3026 ext/soap/php_sdl.c 				zend_hash_add(psdl->elements, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key              3045 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->encoders, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3046 ext/soap/php_sdl.c 				zend_hash_add(psdl->encoders, key, key_len, (void*)&penc, sizeof(encodePtr), NULL);
key              3092 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->bindings, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3093 ext/soap/php_sdl.c 				zend_hash_add(psdl->bindings, key, key_len, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
key              3110 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(&sdl->functions, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3111 ext/soap/php_sdl.c 				zend_hash_add(&psdl->functions, key, key_len, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
key              3133 ext/soap/php_sdl.c 			if (zend_hash_get_current_key_ex(sdl->requests, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key              3134 ext/soap/php_sdl.c 				zend_hash_add(psdl->requests, key, key_len, (void*)&preq, sizeof(sdlFunctionPtr), NULL);
key              3200 ext/soap/php_sdl.c 	char* key = NULL;
key              3242 ext/soap/php_sdl.c 		key = emalloc(len+sizeof("/wsdl-")-1+user_len+sizeof(md5str));
key              3243 ext/soap/php_sdl.c 		memcpy(key,SOAP_GLOBAL(cache_dir),len);
key              3244 ext/soap/php_sdl.c 		memcpy(key+len,"/wsdl-",sizeof("/wsdl-")-1);
key              3247 ext/soap/php_sdl.c 			memcpy(key+len, user, user_len-1);
key              3249 ext/soap/php_sdl.c 			key[len++] = '-';
key              3251 ext/soap/php_sdl.c 		memcpy(key+len,md5str,sizeof(md5str));
key              3253 ext/soap/php_sdl.c 		if ((sdl = get_sdl_from_cache(key, uri, t-SOAP_GLOBAL(cache_ttl), &cached TSRMLS_CC)) != NULL) {
key              3255 ext/soap/php_sdl.c 			efree(key);
key              3359 ext/soap/php_sdl.c 	if ((cache_wsdl & WSDL_CACHE_DISK) && key) {
key              3361 ext/soap/php_sdl.c 			add_sdl_to_cache(key, uri, t, sdl TSRMLS_CC);
key              3363 ext/soap/php_sdl.c 		efree(key);
key              3381 ext/soap/php_sdl.c 				char *key = NULL;
key              3390 ext/soap/php_sdl.c 						zend_hash_get_current_key_ex(SOAP_GLOBAL(mem_cache), &key, &key_len, &idx, 0, &pos);
key              3393 ext/soap/php_sdl.c 				if (key) {
key              3394 ext/soap/php_sdl.c 					zend_hash_del(SOAP_GLOBAL(mem_cache), key, key_len);
key              1423 ext/soap/soap.c 				char *key;
key              1433 ext/soap/soap.c 				key = emalloc(key_len + 1);
key              1434 ext/soap/soap.c 				zend_str_tolower_copy(key, Z_STRVAL_PP(tmp_function), key_len);
key              1436 ext/soap/soap.c 				if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key              1443 ext/soap/soap.c 				zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key              1445 ext/soap/soap.c 				efree(key);
key              1450 ext/soap/soap.c 		char *key;
key              1455 ext/soap/soap.c 		key = emalloc(key_len + 1);
key              1456 ext/soap/soap.c 		zend_str_tolower_copy(key, Z_STRVAL_P(function_name), key_len);
key              1458 ext/soap/soap.c 		if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key              1470 ext/soap/soap.c 		zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key              1471 ext/soap/soap.c 		efree(key);
key              3663 ext/soap/soap.c 						smart_str key = {0};
key              3666 ext/soap/soap.c 							smart_str_appends(&key, (char*)hdr_func->ns->href);
key              3667 ext/soap/soap.c 							smart_str_appendc(&key, ':');
key              3669 ext/soap/soap.c 						smart_str_appendl(&key, Z_STRVAL(h->function_name), Z_STRLEN(h->function_name));
key              3670 ext/soap/soap.c 						smart_str_0(&key);
key              3671 ext/soap/soap.c 						if (zend_hash_find(fnb->input.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key              3674 ext/soap/soap.c 						smart_str_free(&key);
key              3911 ext/soap/soap.c 				smart_str key = {0};
key              3915 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key              3916 ext/soap/soap.c 					smart_str_appendc(&key, ':');
key              3921 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key              3924 ext/soap/soap.c 				smart_str_0(&key);
key              3926 ext/soap/soap.c 				    zend_hash_find(headers->hdr->headerfaults, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key              3930 ext/soap/soap.c 				smart_str_free(&key);
key              4133 ext/soap/soap.c 						smart_str key = {0};
key              4138 ext/soap/soap.c 							smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key              4139 ext/soap/soap.c 							smart_str_appendc(&key, ':');
key              4144 ext/soap/soap.c 							smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key              4147 ext/soap/soap.c 						smart_str_0(&key);
key              4152 ext/soap/soap.c 							    zend_hash_find(fnb->output.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key              4157 ext/soap/soap.c 						smart_str_free(&key);
key              4373 ext/soap/soap.c 					smart_str key = {0};
key              4376 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_PP(ns), Z_STRLEN_PP(ns));
key              4377 ext/soap/soap.c 					smart_str_appendc(&key, ':');
key              4378 ext/soap/soap.c 					smart_str_appendl(&key, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
key              4379 ext/soap/soap.c 					smart_str_0(&key);
key              4380 ext/soap/soap.c 					if (zend_hash_find(hdrs, key.c, key.len+1,(void**)&hdr) == SUCCESS) {
key              4387 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 (zend_hash_find(ctx, key, strlen(key) + 1, (void**)&elem) == SUCCESS) {
key              1543 ext/sockets/conversions.c 	for (kv = key_value_pairs; kv->key != NULL; kv++) {
key              1544 ext/sockets/conversions.c 		zend_hash_update(&ctx.params, kv->key, kv->key_size,
key                24 ext/sockets/conversions.h 	const char	*key;
key               114 ext/sockets/multicast.c static int php_get_if_index_from_array(const HashTable *ht, const char *key,
key               119 ext/sockets/multicast.c 	if (zend_hash_find(ht, key, strlen(key) + 1, (void **)&val) == FAILURE) {
key               127 ext/sockets/multicast.c static int php_get_address_from_array(const HashTable *ht, const char *key,
key               133 ext/sockets/multicast.c 	if (zend_hash_find(ht, key, strlen(key) + 1, (void **)&val) == FAILURE) {
key               134 ext/sockets/multicast.c 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", key);
key                92 ext/sockets/sendrecvmsg.c 	anc_reg_key key;
key               103 ext/sockets/sendrecvmsg.c 	key.cmsg_level		= level; \
key               104 ext/sockets/sendrecvmsg.c 	key.cmsg_type		= type; \
key               105 ext/sockets/sendrecvmsg.c 	zend_hash_update(&ancillary_registry.ht, (char*)&key, sizeof(key), \
key               143 ext/sockets/sendrecvmsg.c 	anc_reg_key			key = { cmsg_level, msg_type };
key               156 ext/sockets/sendrecvmsg.c 	if (zend_hash_find(&ancillary_registry.ht, (char*)&key, sizeof(key),
key               798 ext/sockets/sockets.c 	char 		*key;
key               816 ext/sockets/sockets.c 			switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(sock_array), &key, &key_len, &num_key, 0, NULL)) {
key               818 ext/sockets/sockets.c 					zend_hash_add(new_hash, key, key_len, (void *)element, sizeof(zval *), (void **)&dest_element);
key               754 ext/spl/php_spl.c 				   char *key;
key               757 ext/spl/php_spl.c 				   zend_hash_get_current_key_ex(SPL_G(autoload_functions), &key, &len, &dummy, 0, &function_pos); 
key               758 ext/spl/php_spl.c 				   add_next_index_stringl(return_value, key, len - 1, 1);
key               306 ext/spl/spl_array.c 	char *key;
key               322 ext/spl/spl_array.c 		key = Z_STRVAL_P(offset);
key               325 ext/spl/spl_array.c 		if (zend_symtable_find(ht, key, len, (void **) &retval) == FAILURE) {
key               328 ext/spl/spl_array.c 					zend_error(E_NOTICE, "Undefined index: %s", key);
key               334 ext/spl/spl_array.c 					zend_error(E_NOTICE,"Undefined index: %s", key);
key               338 ext/spl/spl_array.c 				    zend_symtable_update(ht, key, len, (void**)&value, sizeof(void*), (void **)&retval);
key               344 ext/spl/spl_array.c 		key = "";
key               849 ext/spl/spl_array.c static zval *spl_array_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               854 ext/spl/spl_array.c 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key               857 ext/spl/spl_array.c 	return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key               860 ext/spl/spl_array.c static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
key               865 ext/spl/spl_array.c 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key               869 ext/spl/spl_array.c 	std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key               872 ext/spl/spl_array.c static zval **spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key               877 ext/spl/spl_array.c 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key               880 ext/spl/spl_array.c 	return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key               883 ext/spl/spl_array.c static int spl_array_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
key               888 ext/spl/spl_array.c 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key               891 ext/spl/spl_array.c 	return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
key               894 ext/spl/spl_array.c static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
key               899 ext/spl/spl_array.c 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key               904 ext/spl/spl_array.c 	std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key              1043 ext/spl/spl_array.c static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key              1050 ext/spl/spl_array.c 		zend_user_it_get_current_key(iter, key TSRMLS_CC);
key              1053 ext/spl/spl_array.c 			ZVAL_NULL(key);
key              1055 ext/spl/spl_array.c 			zend_hash_get_current_key_zval_ex(aht, key, &object->pos);
key              1560 ext/spl/spl_array.c SPL_METHOD(Array, key)
key              1945 ext/spl/spl_array.c 	SPL_ME(Array, key,              arginfo_array_void,             ZEND_ACC_PUBLIC)
key               665 ext/spl/spl_directory.c zend_function *spl_filesystem_object_get_method_check(zval **object_ptr, char *method, int method_len, const struct _zend_literal *key TSRMLS_DC) /* {{{ */
key               672 ext/spl/spl_directory.c 		key = NULL;
key               675 ext/spl/spl_directory.c 	return zend_get_std_object_handlers()->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key               769 ext/spl/spl_directory.c SPL_METHOD(DirectoryIterator, key)
key              1066 ext/spl/spl_directory.c SPL_METHOD(FilesystemIterator, key)
key              1634 ext/spl/spl_directory.c static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC);
key              1711 ext/spl/spl_directory.c static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key              1715 ext/spl/spl_directory.c 	ZVAL_LONG(key, object->u.dir.index);
key              1789 ext/spl/spl_directory.c static void spl_filesystem_tree_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key              1794 ext/spl/spl_directory.c 		ZVAL_STRING(key, object->u.dir.entry.d_name, 1);
key              1797 ext/spl/spl_directory.c 		ZVAL_STRINGL(key, object->file_name, object->file_name_len, 1);
key              2005 ext/spl/spl_directory.c 	SPL_ME(DirectoryIterator, key,           arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key              2030 ext/spl/spl_directory.c 	SPL_ME(FilesystemIterator, key,           arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key              2484 ext/spl/spl_directory.c SPL_METHOD(SplFileObject, key)
key              3106 ext/spl/spl_directory.c 	SPL_ME(SplFileObject, key,            arginfo_splfileinfo_void,          ZEND_ACC_PUBLIC)
key              1029 ext/spl/spl_dllist.c static void spl_dllist_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key              1033 ext/spl/spl_dllist.c 	ZVAL_LONG(key, iterator->traverse_position);
key              1050 ext/spl/spl_dllist.c SPL_METHOD(SplDoublyLinkedList, key)
key              1389 ext/spl/spl_dllist.c 	SPL_ME(SplDoublyLinkedList, key,             arginfo_dllist_void,            ZEND_ACC_PUBLIC)
key               951 ext/spl/spl_fixedarray.c static void spl_fixedarray_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key               957 ext/spl/spl_fixedarray.c 		zend_user_it_get_current_key(iter, key TSRMLS_CC);
key               959 ext/spl/spl_fixedarray.c 		ZVAL_LONG(key, iterator->object->current);
key               980 ext/spl/spl_fixedarray.c SPL_METHOD(SplFixedArray, key)
key              1131 ext/spl/spl_fixedarray.c 	SPL_ME(SplFixedArray, key,             arginfo_splfixedarray_void,     ZEND_ACC_PUBLIC)
key               953 ext/spl/spl_heap.c static void spl_heap_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
key               957 ext/spl/spl_heap.c 	ZVAL_LONG(key, iterator->object->heap->count - 1);
key               984 ext/spl/spl_heap.c SPL_METHOD(SplHeap, key)
key              1190 ext/spl/spl_heap.c 	SPL_ME(SplHeap,          key,                   arginfo_splheap_void,    ZEND_ACC_PUBLIC)
key              1205 ext/spl/spl_heap.c 	SPL_ME(SplHeap, key,                   arginfo_splheap_void, ZEND_ACC_PUBLIC)
key               210 ext/spl/spl_iterators.c static void spl_recursive_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
key               216 ext/spl/spl_iterators.c 		sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC);
key               218 ext/spl/spl_iterators.c 		ZVAL_LONG(key, iter->index);
key               628 ext/spl/spl_iterators.c SPL_METHOD(RecursiveIteratorIterator, key)
key               872 ext/spl/spl_iterators.c static union _zend_function *spl_recursive_it_get_method(zval **object_ptr, char *method, int method_len, const zend_literal *key TSRMLS_DC)
key               884 ext/spl/spl_iterators.c 	function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key               889 ext/spl/spl_iterators.c 				function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key               999 ext/spl/spl_iterators.c 	SPL_ME(RecursiveIteratorIterator, key,               arginfo_recursive_it_void,           ZEND_ACC_PUBLIC)
key              1243 ext/spl/spl_iterators.c SPL_METHOD(RecursiveTreeIterator, key)
key              1247 ext/spl/spl_iterators.c 	zval                       prefix, key, postfix, key_copy;
key              1258 ext/spl/spl_iterators.c 		iterator->funcs->get_current_key(iterator, &key TSRMLS_CC);
key              1260 ext/spl/spl_iterators.c 		ZVAL_NULL(&key);
key              1264 ext/spl/spl_iterators.c 		zval *key_ptr = &key;
key              1266 ext/spl/spl_iterators.c 		zval_dtor(&key);
key              1270 ext/spl/spl_iterators.c 	if (Z_TYPE(key) != IS_STRING) {
key              1272 ext/spl/spl_iterators.c 		zend_make_printable_zval(&key, &key_copy, &use_copy);
key              1274 ext/spl/spl_iterators.c 			key = key_copy;
key              1281 ext/spl/spl_iterators.c 	str_len = Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix);
key              1287 ext/spl/spl_iterators.c 	memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key));
key              1288 ext/spl/spl_iterators.c 	ptr += Z_STRLEN(key);
key              1294 ext/spl/spl_iterators.c 	zval_dtor(&key);
key              1316 ext/spl/spl_iterators.c 	SPL_ME(RecursiveTreeIterator,     key,               arginfo_recursive_it_void,               ZEND_ACC_PUBLIC)
key              1350 ext/spl/spl_iterators.c static union _zend_function *spl_dual_it_get_method(zval **object_ptr, char *method, int method_len, const zend_literal *key TSRMLS_DC)
key              1357 ext/spl/spl_iterators.c 	function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key              1362 ext/spl/spl_iterators.c 				function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key              1665 ext/spl/spl_iterators.c 	if (intern->current.key) {
key              1666 ext/spl/spl_iterators.c 		zval_ptr_dtor(&intern->current.key);
key              1667 ext/spl/spl_iterators.c 		intern->current.key = NULL;
key              1711 ext/spl/spl_iterators.c 		MAKE_STD_ZVAL(intern->current.key);
key              1713 ext/spl/spl_iterators.c 			intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, intern->current.key TSRMLS_CC);
key              1715 ext/spl/spl_iterators.c 				zval_ptr_dtor(&intern->current.key);
key              1716 ext/spl/spl_iterators.c 				intern->current.key = NULL;
key              1719 ext/spl/spl_iterators.c 			ZVAL_LONG(intern->current.key, intern->current.pos);
key              1781 ext/spl/spl_iterators.c SPL_METHOD(dual_it, key)
key              1791 ext/spl/spl_iterators.c 	if (intern->current.key) {
key              1792 ext/spl/spl_iterators.c 		RETURN_ZVAL(intern->current.key, 1, 0);
key              2009 ext/spl/spl_iterators.c 	if (intern->current.data == NULL || intern->current.key == NULL) {
key              2014 ext/spl/spl_iterators.c 	params[1] = &intern->current.key;
key              2055 ext/spl/spl_iterators.c 		subject_ptr = intern->current.key;
key              2113 ext/spl/spl_iterators.c 			zval_ptr_dtor(&intern->current.key);
key              2114 ext/spl/spl_iterators.c 			MAKE_STD_ZVAL(intern->current.key);
key              2115 ext/spl/spl_iterators.c 			ZVAL_STRINGL(intern->current.key, result, result_len, 0);
key              2428 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              2669 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              2695 ext/spl/spl_iterators.c 			zval *key = intern->current.key;
key              2700 ext/spl/spl_iterators.c 			array_set_zval_key(HASH_OF(intern->u.caching.zcache), key, zcacheval);
key              2860 ext/spl/spl_iterators.c 		MAKE_COPY_ZVAL(&intern->current.key, return_value);
key              3088 ext/spl/spl_iterators.c 	SPL_ME(dual_it,         key,              arginfo_recursive_it_void,      ZEND_ACC_PUBLIC)
key              3173 ext/spl/spl_iterators.c 	SPL_ME(dual_it,          key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3213 ext/spl/spl_iterators.c SPL_METHOD(NoRewindIterator, key)
key              3270 ext/spl/spl_iterators.c 	SPL_ME(NoRewindIterator, key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3334 ext/spl/spl_iterators.c SPL_METHOD(EmptyIterator, key)
key              3364 ext/spl/spl_iterators.c 	SPL_ME(EmptyIterator, key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3539 ext/spl/spl_iterators.c 	SPL_ME(dual_it,        key,              arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key              3601 ext/spl/spl_iterators.c 		zval key;
key              3602 ext/spl/spl_iterators.c 		iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key              3606 ext/spl/spl_iterators.c 		array_set_zval_key(Z_ARRVAL_P(return_value), &key, *data);
key              3607 ext/spl/spl_iterators.c 		zval_dtor(&key);
key               136 ext/spl/spl_iterators.h 		zval                 *key;
key               667 ext/spl/spl_observer.c SPL_METHOD(SplObjectStorage, key)
key               983 ext/spl/spl_observer.c 	SPL_ME(SplObjectStorage,  key,         arginfo_splobject_void,0)
key              1266 ext/spl/spl_observer.c SPL_METHOD(MultipleIterator, key)
key              1307 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               928 ext/standard/array.c PHP_FUNCTION(key)
key              1046 ext/standard/array.c 		  *key=NULL;		/* Entry key */
key              1049 ext/standard/array.c 	args[1] = &key;
key              1091 ext/standard/array.c 			MAKE_STD_ZVAL(key);
key              1092 ext/standard/array.c 			zend_hash_get_current_key_zval(target_hash, key);
key              1100 ext/standard/array.c 				if (key) {
key              1101 ext/standard/array.c 					zval_ptr_dtor(&key);
key              1102 ext/standard/array.c 					key = NULL;
key              1108 ext/standard/array.c 		if (key) {
key              1109 ext/standard/array.c 			zval_ptr_dtor(&key);
key              1110 ext/standard/array.c 			key = NULL;
key              1570 ext/standard/array.c 			zval key, *key_ptr = *entry;
key              1573 ext/standard/array.c 				key = **entry;
key              1574 ext/standard/array.c 				zval_copy_ctor(&key);
key              1575 ext/standard/array.c 				convert_to_string(&key);
key              1576 ext/standard/array.c 				key_ptr = &key;
key              1583 ext/standard/array.c 				zval_dtor(&key);
key              1860 ext/standard/array.c 	char *key = NULL;
key              1882 ext/standard/array.c 	zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &key_len, &index, 0, NULL);
key              1883 ext/standard/array.c 	if (key && Z_ARRVAL_P(stack) == &EG(symbol_table)) {
key              1884 ext/standard/array.c 		zend_delete_global_variable(key, key_len - 1 TSRMLS_CC);
key              1886 ext/standard/array.c 		zend_hash_del_key_or_index(Z_ARRVAL_P(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
key              4070 ext/standard/array.c     zval *key = NULL;
key              4096 ext/standard/array.c 			args[1] = &key;
key              4100 ext/standard/array.c 				args[0] = &key;
key              4113 ext/standard/array.c 				MAKE_STD_ZVAL(key);
key              4117 ext/standard/array.c 						Z_TYPE_P(key) = IS_LONG;
key              4118 ext/standard/array.c 						Z_LVAL_P(key) = num_key;
key              4122 ext/standard/array.c 						ZVAL_STRINGL(key, string_key, string_key_len - 1, 1);
key              4137 ext/standard/array.c 					zval_ptr_dtor(&key);
key              4300 ext/standard/array.c 	zval *key;					/* key to check for */
key              4303 ext/standard/array.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zH", &key, &array) == FAILURE) {
key              4307 ext/standard/array.c 	switch (Z_TYPE_P(key)) {
key              4309 ext/standard/array.c 			if (zend_symtable_exists(array, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1)) {
key              4314 ext/standard/array.c 			if (zend_hash_index_exists(array, Z_LVAL_P(key))) {
key              4441 ext/standard/array.c 			zval key, *key_ptr = *entry_keys;
key              4444 ext/standard/array.c 				key = **entry_keys;
key              4445 ext/standard/array.c 				zval_copy_ctor(&key);
key              4446 ext/standard/array.c 				convert_to_string(&key);
key              4447 ext/standard/array.c 				key_ptr = &key;
key              4454 ext/standard/array.c 				zval_dtor(&key);
key               589 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, key)
key              3280 ext/standard/basic_functions.c 	PHP_FE(key,																arginfo_key)
key              3401 ext/standard/basic_functions.c 		SetEnvironmentVariable(pe->key, "bugbug");
key              3409 ext/standard/basic_functions.c 		unsetenv(pe->key);
key              3411 ext/standard/basic_functions.c 		SetEnvironmentVariable(pe->key, NULL);
key              3413 ext/standard/basic_functions.c 		_putenv_s(pe->key, "");
key              3419 ext/standard/basic_functions.c 			if (!strncmp(*env, pe->key, pe->key_len) && (*env)[pe->key_len] == '=') {	/* found it */
key              3429 ext/standard/basic_functions.c 	if (!strncmp(pe->key, "TZ", pe->key_len)) {
key              3435 ext/standard/basic_functions.c 	efree(pe->key);
key              4071 ext/standard/basic_functions.c 	pe.key = estrndup(setting, setting_len);
key              4072 ext/standard/basic_functions.c 	if ((p = strchr(pe.key, '='))) {	/* nullify the '=' if there is one */
key              4079 ext/standard/basic_functions.c 	pe.key_len = strlen(pe.key);
key              4091 ext/standard/basic_functions.c 	zend_hash_del(&BG(putenv_ht), pe.key, pe.key_len+1);
key              4096 ext/standard/basic_functions.c 		if (!strncmp(*env, pe.key, pe.key_len) && (*env)[pe.key_len] == '=') {	/* found it */
key              4116 ext/standard/basic_functions.c 	error_code = SetEnvironmentVariable(pe.key, value);
key              4125 ext/standard/basic_functions.c 	&& _putenv_s(pe.key, value ? value : "") == 0
key              4130 ext/standard/basic_functions.c 		zend_hash_add(&BG(putenv_ht), pe.key, pe.key_len + 1, (void **) &pe, sizeof(putenv_entry), NULL);
key              4132 ext/standard/basic_functions.c 		if (!strncmp(pe.key, "TZ", pe.key_len)) {
key              4139 ext/standard/basic_functions.c 		efree(pe.key);
key              5877 ext/standard/basic_functions.c 				ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1));
key              5878 ext/standard/basic_functions.c 				if (zend_hash_index_find(Z_ARRVAL_P(arr), key, (void **) &find_hash) == FAILURE) {
key              5883 ext/standard/basic_functions.c 					zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash, sizeof(zval *), NULL);
key               247 ext/standard/basic_functions.h 	char *key;
key               372 ext/standard/browscap.c static int browser_reg_compare(zval **browser TSRMLS_DC, 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               379 ext/standard/crypt_freesec.c des_setkey(const char *key, struct php_crypt_extended_data *data)
key               385 ext/standard/crypt_freesec.c 		(uint32_t)(u_char)key[3] |
key               386 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[2] << 8) |
key               387 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[1] << 16) |
key               388 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[0] << 24);
key               390 ext/standard/crypt_freesec.c 		(uint32_t)(u_char)key[7] |
key               391 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[6] << 8) |
key               392 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[5] << 16) |
key               393 ext/standard/crypt_freesec.c 		((uint32_t)(u_char)key[4] << 24);
key               616 ext/standard/crypt_freesec.c _crypt_extended_r(const char *key, const char *setting,
key               632 ext/standard/crypt_freesec.c 		*q++ = *key << 1;
key               633 ext/standard/crypt_freesec.c 		if (*key)
key               634 ext/standard/crypt_freesec.c 			key++;
key               661 ext/standard/crypt_freesec.c 		while (*key) {
key               672 ext/standard/crypt_freesec.c 			while (q - (u_char *) keybuf < sizeof(keybuf) && *key)
key               673 ext/standard/crypt_freesec.c 				*q++ ^= *key++ << 1;
key               731 ext/standard/crypt_freesec.c _crypt_extended(const char *key, const char *setting)
key               741 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               594 ext/standard/crypt_sha256.c char * php_sha256_crypt(const char *key, const char *salt)
key               616 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              1212 ext/standard/filestat.c 			if (LONG_MAX >= bucket->key) {
key              1213 ext/standard/filestat.c 				add_assoc_long(entry, "key", bucket->key);
key              1215 ext/standard/filestat.c 				add_assoc_double(entry, "key", (double)bucket->key);
key              1562 ext/standard/html.c 	char key[9] = ""; /* two unicode code points in UTF-8 */
key              1566 ext/standard/html.c 	written_k1 = write_octet_sequence(key, charset, orig_cp);
key              1572 ext/standard/html.c 		add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key              1582 ext/standard/html.c 			add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key              1601 ext/standard/html.c 			written_k2 = write_octet_sequence(&key[written_k1], charset, spe_cp);
key              1605 ext/standard/html.c 			add_assoc_stringl_ex(arr, key, written_k1 + written_k2 + 1, entity, l + 1, 1);
key                34 ext/standard/http.c 	char *key = NULL;
key                59 ext/standard/http.c 		(key_type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL)) != HASH_KEY_NON_EXISTENT;
key                62 ext/standard/http.c 		if (key_type == HASH_KEY_IS_STRING && key_len && key[key_len-1] == '\0') {
key                68 ext/standard/http.c 		if (key && *key == '\0' && type != NULL) {
key                72 ext/standard/http.c 			if (zend_check_property_access(zobj, key, key_len TSRMLS_CC) != SUCCESS) {
key                76 ext/standard/http.c 			zend_unmangle_property_name_ex(key, key_len, &tmp, (const char**)&key, &key_len);
key                86 ext/standard/http.c 					ekey = php_raw_url_encode(key, key_len, &ekey_len);
key                88 ext/standard/http.c 					ekey = php_url_encode(key, key_len, &ekey_len);
key               154 ext/standard/http.c 					ekey = php_raw_url_encode(key, key_len, &ekey_len);
key               156 ext/standard/http.c 					ekey = php_url_encode(key, key_len, &ekey_len);
key                57 ext/standard/incomplete_class.c static zval *incomplete_class_get_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key                69 ext/standard/incomplete_class.c static void incomplete_class_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
key                75 ext/standard/incomplete_class.c static zval **incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
key                82 ext/standard/incomplete_class.c static void incomplete_class_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
key                88 ext/standard/incomplete_class.c static int incomplete_class_has_property(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC) /* {{{ */
key                95 ext/standard/incomplete_class.c static union _zend_function *incomplete_class_get_method(zval **object, char *method, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
key               104 ext/standard/info.c 	char *key;
key               118 ext/standard/info.c 			while (zend_hash_get_current_key_ex(ht, &key, &len, NULL, 0, &pos) == HASH_KEY_IS_STRING)
key               121 ext/standard/info.c 					php_info_print_html_esc(key, len-1);
key               123 ext/standard/info.c 					php_info_print(key);
key               126 ext/standard/info.c 				if (zend_hash_get_current_key_ex(ht, &key, &len, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
key               316 ext/standard/iptc.c 	unsigned char *buffer, recnum, dataset, key[ 16 ];
key               362 ext/standard/iptc.c 		snprintf(key, sizeof(key), "%d#%03d", (unsigned int) dataset, (unsigned int) recnum);
key               368 ext/standard/iptc.c 		if (zend_hash_find(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void **) &element) == FAILURE) {
key               372 ext/standard/iptc.c 			zend_hash_update(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void *) &values, sizeof(zval*), (void **) &element);
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               661 ext/standard/streamsfuncs.c 		char *key;
key               668 ext/standard/streamsfuncs.c 				&key, &key_len, &num_ind, 0, NULL);
key               688 ext/standard/streamsfuncs.c 					zend_hash_update(new_hash, key, key_len, (void *)elem, sizeof(zval *), (void **)&dest_elem);
key               379 ext/standard/url.c 	long key = -1;
key               381 ext/standard/url.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "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 TSRMLS_CC, E_WARNING, "Invalid URL component identifier %ld", key);
key                49 ext/standard/url_scanner_ex.c 	char *key;
key                68 ext/standard/url_scanner_ex.c 	for (key = php_strtok_r(tmp, ",", &lasts);
key                69 ext/standard/url_scanner_ex.c 			key;
key                70 ext/standard/url_scanner_ex.c 			key = php_strtok_r(NULL, ",", &lasts)) {
key                73 ext/standard/url_scanner_ex.c 		val = strchr(key, '=');
key                79 ext/standard/url_scanner_ex.c 			for (q = key; *q; q++)
key                81 ext/standard/url_scanner_ex.c 			keylen = q - key;
key                84 ext/standard/url_scanner_ex.c 			zend_hash_add(ctx->tags, key, keylen, val, strlen(val)+1, NULL);
key               358 ext/standard/var.c 		char *key, *tmp_str;
key               360 ext/standard/var.c 		key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
key               361 ext/standard/var.c 		tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
key               369 ext/standard/var.c 		efree(key);
key               634 ext/standard/var.c 		char *key;
key               648 ext/standard/var.c 			i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);
key               654 ext/standard/var.c 			if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
key               849 ext/standard/var.c 				char *key;
key               857 ext/standard/var.c 					i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key               861 ext/standard/var.c 					if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
key               870 ext/standard/var.c 							php_var_serialize_string(buf, key, key_len - 1);
key               308 ext/standard/var_unserializer.c 		zval *key, *data, **old_data;
key               310 ext/standard/var_unserializer.c 		ALLOC_INIT_ZVAL(key);
key               312 ext/standard/var_unserializer.c 		if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
key               313 ext/standard/var_unserializer.c             var_push_dtor_no_addref(var_hash, &key);
key               317 ext/standard/var_unserializer.c 		if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
key               318 ext/standard/var_unserializer.c             var_push_dtor_no_addref(var_hash, &key);
key               325 ext/standard/var_unserializer.c             var_push_dtor_no_addref(var_hash, &key);
key               331 ext/standard/var_unserializer.c 			switch (Z_TYPE_P(key)) {
key               333 ext/standard/var_unserializer.c 				if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
key               336 ext/standard/var_unserializer.c 				zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
key               339 ext/standard/var_unserializer.c 				if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key               342 ext/standard/var_unserializer.c 				zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
key               347 ext/standard/var_unserializer.c 			convert_to_string(key);
key               348 ext/standard/var_unserializer.c 			if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key               351 ext/standard/var_unserializer.c 			zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,
key               355 ext/standard/var_unserializer.c         var_push_dtor_no_addref(var_hash, &key);
key                54 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               234 ext/sysvmsg/sysvmsg.c 	long key;
key               236 ext/sysvmsg/sysvmsg.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &key) == FAILURE)	{
key               240 ext/sysvmsg/sysvmsg.c 	if (msgget(key, 0) < 0) {
key               253 ext/sysvmsg/sysvmsg.c 	long key;
key               257 ext/sysvmsg/sysvmsg.c 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &key, &perms) == FAILURE)	{
key               263 ext/sysvmsg/sysvmsg.c 	mq->key = key;
key               264 ext/sysvmsg/sysvmsg.c 	mq->id = msgget(key, 0);
key               267 ext/sysvmsg/sysvmsg.c 		mq->id = msgget(key, IPC_CREAT | IPC_EXCL | perms);
key               269 ext/sysvmsg/sysvmsg.c 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key                41 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 	long key, max_acquire = 1, perm = 0666, auto_release = 1;
key               197 ext/sysvsem/sysvsem.c 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "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 TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               241 ext/sysvsem/sysvsem.c 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed acquiring SYSVSEM_SETVAL for key 0x%lx: %s", key, strerror(errno));
key               249 ext/sysvsem/sysvsem.c 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               260 ext/sysvsem/sysvsem.c 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               265 ext/sysvsem/sysvsem.c 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               270 ext/sysvsem/sysvsem.c 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key               282 ext/sysvsem/sysvsem.c 			php_error_docref(NULL TSRMLS_CC, 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               319 ext/sysvsem/sysvsem.c 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "SysV semaphore %ld (key 0x%x) is not currently acquired", Z_LVAL_P(arg_id), sem_ptr->key);
key               330 ext/sysvsem/sysvsem.c 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to %s key 0x%x: %s", acquire ? "acquire" : "release", sem_ptr->key, strerror(errno));
key                41 ext/sysvshm/php_sysvshm.h 	long key;
key                56 ext/sysvshm/php_sysvshm.h 	key_t key;               /* key set by user */
key                44 ext/sysvshm/sysvshm.c 	ZEND_ARG_INFO(0, key)
key               119 ext/sysvshm/sysvshm.c static int php_put_shm_data(sysvshm_chunk_head *ptr, long key, const char *data, long len);
key               120 ext/sysvshm/sysvshm.c static long php_check_shm_data(sysvshm_chunk_head *ptr, long key);
key               196 ext/sysvshm/sysvshm.c 	shm_list_ptr->key = shm_key;
key               232 ext/sysvshm/sysvshm.c 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%x, id %ld: %s", shm_list_ptr->key, Z_LVAL_P(shm_id), strerror(errno));
key               359 ext/sysvshm/sysvshm.c static int php_put_shm_data(sysvshm_chunk_head *ptr, long key, const char *data, long len)
key               367 ext/sysvshm/sysvshm.c 	if ((shm_varpos = php_check_shm_data(ptr, key)) > 0) {
key               376 ext/sysvshm/sysvshm.c 	shm_var->key = key;
key               388 ext/sysvshm/sysvshm.c static long php_check_shm_data(sysvshm_chunk_head *ptr, long key)
key               400 ext/sysvshm/sysvshm.c 		if (shm_var->key == key) {
key               273 ext/wddx/wddx.c 		php_wddx_serialize_var(packet, *struc, key, key_length TSRMLS_CC);
key               295 ext/wddx/wddx.c 	char *key;
key               316 ext/wddx/wddx.c 			hash_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(retval), &key, &key_length, &idx, 0, NULL);
key               321 ext/wddx/wddx.c 					key = tmp;
key               324 ext/wddx/wddx.c 					php_set_session_var(key, key_length-1, *ent, NULL TSRMLS_CC);
key               325 ext/wddx/wddx.c 					PS_ADD_VAR(key);
key               461 ext/wddx/wddx.c 	const char *key;
key               532 ext/wddx/wddx.c 			if (zend_hash_get_current_key_ex(objhash, &key, &key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
key               535 ext/wddx/wddx.c 				zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
key               559 ext/wddx/wddx.c 	char *key;
key               575 ext/wddx/wddx.c 		type = zend_hash_get_current_key(target_hash, &key, &idx, 0);
key               605 ext/wddx/wddx.c 			ent_type = zend_hash_get_current_key_ex(target_hash, &key, &key_len, &idx, 0, NULL);
key               608 ext/wddx/wddx.c 				php_wddx_serialize_var(packet, *ent, key, key_len TSRMLS_CC);
key               852 ext/wddx/wddx.c 				char *key;
key               858 ext/wddx/wddx.c 					key = estrndup(p1, p2 - p1);
key               861 ext/wddx/wddx.c 					add_assoc_zval_ex(ent.data, key, p2 - p1 + 1, tmp);
key               863 ext/wddx/wddx.c 					efree(key);
key               116 ext/xmlreader/php_xmlreader.c zval **xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key               139 ext/xmlreader/php_xmlreader.c 		retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key               150 ext/xmlreader/php_xmlreader.c zval *xmlreader_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
key               182 ext/xmlreader/php_xmlreader.c 		retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key               193 ext/xmlreader/php_xmlreader.c void xmlreader_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
key               218 ext/xmlreader/php_xmlreader.c 		std_hnd->write_property(object, member, value, key TSRMLS_CC);
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               520 ext/xmlrpc/xmlrpc-epi-php.c static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int depth TSRMLS_DC)
key               533 ext/xmlrpc/xmlrpc-epi-php.c 						XMLRPC_SetValueID(xReturn, key, 0);
key               540 ext/xmlrpc/xmlrpc-epi-php.c 							xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(newvalue), Z_STRLEN_P(newvalue));
key               543 ext/xmlrpc/xmlrpc-epi-php.c 							xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
key               549 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL_P(val));
key               553 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
key               557 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueInt(key, Z_LVAL_P(val));
key               561 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL_P(val));
key               565 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueString(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
key               587 ext/xmlrpc/xmlrpc-epi-php.c 						xReturn = XMLRPC_CreateVector(key, vtype);
key                44 ext/zip/lib/zip_source_pkware.c     zip_uint32_t key[3];
key                86 ext/zip/lib/zip_source_pkware.c     ctx->key[0] = KEY0;
key                87 ext/zip/lib/zip_source_pkware.c     ctx->key[1] = KEY1;
key                88 ext/zip/lib/zip_source_pkware.c     ctx->key[2] = KEY2;
key               114 ext/zip/lib/zip_source_pkware.c 	    tmp = (zip_uint16_t)(ctx->key[2] | 2);
key               124 ext/zip/lib/zip_source_pkware.c 	ctx->key[0] = (zip_uint32_t)crc32(ctx->key[0] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key               125 ext/zip/lib/zip_source_pkware.c 	ctx->key[1] = (ctx->key[1] + (ctx->key[0] & 0xff)) * 134775813 + 1;
key               126 ext/zip/lib/zip_source_pkware.c 	b = ctx->key[1] >> 24;
key               127 ext/zip/lib/zip_source_pkware.c 	ctx->key[2] = (zip_uint32_t)crc32(ctx->key[2] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key                59 ext/zip/php_zip.c #define KEY_ARG_DC , const zend_literal *key
key                60 ext/zip/php_zip.c #define KEY_ARG_CC , key
key               902 ext/zip/php_zip.c 		key = NULL;
key               911 ext/zip/php_zip.c 		if (key) {
key               912 ext/zip/php_zip.c 			ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
key               946 ext/zip/php_zip.c 		key = NULL;
key               955 ext/zip/php_zip.c 		if (key) {
key               956 ext/zip/php_zip.c 			ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
key               996 ext/zip/php_zip.c 		key = NULL;
key              1005 ext/zip/php_zip.c 		if (key) {
key              1006 ext/zip/php_zip.c 			ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
key              1052 ext/zip/php_zip.c 	char *key;
key              1066 ext/zip/php_zip.c 		zend_hash_get_current_key_ex(obj->prop_handler, &key, &key_len, &num_key, 0, &pos);
key              1072 ext/zip/php_zip.c 		zend_hash_update(props, key, key_len, (void *)&val, sizeof(zval *), NULL);
key               282 main/php_ini.c 				char *key = NULL;
key               287 main/php_ini.c 					key = Z_STRVAL_P(arg1);
key               288 main/php_ini.c 					key = key + sizeof("PATH") - 1;
key               294 main/php_ini.c 					TRANSLATE_SLASHES_LOWER(key);
key               298 main/php_ini.c 					key = Z_STRVAL_P(arg1);
key               299 main/php_ini.c 					key = key + sizeof("HOST") - 1;
key               303 main/php_ini.c 					zend_str_tolower(key, key_len); /* host names are case-insensitive. */
key               309 main/php_ini.c 				if (key && key_len > 0) {
key               311 main/php_ini.c 					while (key_len > 0 && (key[key_len - 1] == '/' || key[key_len - 1] == '\\')) {
key               313 main/php_ini.c 						key[key_len] = 0;
key               317 main/php_ini.c 					while (*key && (
key               318 main/php_ini.c 						*key == '=' ||
key               319 main/php_ini.c 						*key == ' ' ||
key               320 main/php_ini.c 						*key == '\t'
key               322 main/php_ini.c 						key++;
key               327 main/php_ini.c 					if (zend_hash_find(target_hash, key, key_len + 1, (void **) &entry) == FAILURE) {
key               335 main/php_ini.c 						zend_hash_update(target_hash, key, key_len + 1, section_arr, sizeof(zval), (void **) &entry);
key               233 main/rfc1867.c 	char *key;
key               377 main/rfc1867.c 	if (h->key) {
key               378 main/rfc1867.c 		efree(h->key);
key               409 main/rfc1867.c 	char *key = NULL;
key               433 main/rfc1867.c 			if(buf_value.c && key) {
key               436 main/rfc1867.c 				entry.key = key;
key               440 main/rfc1867.c 				key = NULL;
key               446 main/rfc1867.c 			key = estrdup(line);
key               454 main/rfc1867.c 	if(buf_value.c && key) {
key               457 main/rfc1867.c 		entry.key = key;
key               465 main/rfc1867.c static char *php_mime_get_hdr_value(zend_llist header, char *key)
key               469 main/rfc1867.c 	if (key == NULL) {
key               475 main/rfc1867.c 		if (!strcasecmp(entry->key, key)) {
key               810 main/rfc1867.c 				char *key = NULL, *word = pair;
key               817 main/rfc1867.c 					key = getword(mbuff->input_encoding, &pair, '=' TSRMLS_CC);
key               819 main/rfc1867.c 					if (!strcasecmp(key, "name")) {
key               832 main/rfc1867.c 					} else if (!strcasecmp(key, "filename")) {
key               847 main/rfc1867.c 				if (key) {
key               848 main/rfc1867.c 					efree(key);
key               628 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 + 1, sep + 1, vlen, 1);
key               703 main/streams/memory.c 			efree(key);
key               273 sapi/aolserver/aolserver.c 		char *key = Ns_SetKey(NSG(conn->headers), i);
key               276 sapi/aolserver/aolserver.c 		add_assoc_string(return_value, key, value, 1);
key               311 sapi/aolserver/aolserver.c 		char *key = Ns_SetKey(NSG(conn->headers), i);
key               316 sapi/aolserver/aolserver.c 		snprintf(buf, NS_BUF_SIZE, "HTTP_%s", key);
key               529 sapi/aolserver/aolserver.c 		char *key = Ns_SetKey(set, i);
key               532 sapi/aolserver/aolserver.c 		if (global && !strcasecmp(key, "map")) {
key               544 sapi/aolserver/aolserver.c 		} else if (!global && !strcasecmp(key, "php_value")) {
key                74 sapi/apache/mod_php5.c 	char *key;
key               273 sapi/apache/mod_php5.c 		if (sapi_module.input_filter(PARSE_SERVER, elts[i].key, &val, val_len, &new_val_len TSRMLS_CC)) {
key               274 sapi/apache/mod_php5.c 			php_register_variable_safe(elts[i].key, val, new_val_len, track_vars_array TSRMLS_CC);
key               569 sapi/apache/mod_php5.c 	zend_alter_ini_entry(per_dir_entry->key, per_dir_entry->key_length+1, per_dir_entry->value, per_dir_entry->value_length, per_dir_entry->type, per_dir_entry->htaccess?PHP_INI_STAGE_HTACCESS:PHP_INI_STAGE_ACTIVATE);
key               715 sapi/apache/mod_php5.c 	free(per_dir_entry->key);
key               726 sapi/apache/mod_php5.c 	per_dir_entry->key = (char *) malloc(tmp.key_length+1);
key               727 sapi/apache/mod_php5.c 	memcpy(per_dir_entry->key, tmp.key, tmp.key_length);
key               728 sapi/apache/mod_php5.c 	per_dir_entry->key[per_dir_entry->key_length] = 0;
key               818 sapi/apache/mod_php5.c 	per_dir_entry.key = (char *) malloc(per_dir_entry.key_length+1);
key               819 sapi/apache/mod_php5.c 	memcpy(per_dir_entry.key, arg1, per_dir_entry.key_length);
key               820 sapi/apache/mod_php5.c 	per_dir_entry.key[per_dir_entry.key_length] = 0;
key               826 sapi/apache/mod_php5.c 	zend_hash_update(conf, per_dir_entry.key, per_dir_entry.key_length, &per_dir_entry, sizeof(php_per_dir_entry), NULL);
key               256 sapi/apache/php_apache.c 			php_info_print_table_row(2, elts[i].key, elts[i].val);
key               275 sapi/apache/php_apache.c 			if (env[i].key) {
key               276 sapi/apache/php_apache.c 				php_info_print_table_row(2, env[i].key, env[i].val);
key               283 sapi/apache/php_apache.c 			if (env[i].key) {
key               284 sapi/apache/php_apache.c 				php_info_print_table_row(2, env[i].key, env[i].val);
key               404 sapi/apache/php_apache.c 		if (!tenv[i].key) {
key               407 sapi/apache/php_apache.c 		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
key               426 sapi/apache/php_apache.c 		if (!tenv[i].key) continue;
key               427 sapi/apache/php_apache.c 		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
key                60 sapi/apache2filter/php_apache.h #define APR_ARRAY_FOREACH_OPEN(arr, key, val) 		\
key                66 sapi/apache2filter/php_apache.h 		key = elts[i].key;							\
key               157 sapi/apache2filter/php_functions.c 	char *key, *val;
key               164 sapi/apache2filter/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               166 sapi/apache2filter/php_functions.c 		add_assoc_string(return_value, key, val, 1);
key               177 sapi/apache2filter/php_functions.c 	char *key, *val;
key               184 sapi/apache2filter/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               186 sapi/apache2filter/php_functions.c 		add_assoc_string(return_value, key, val, 1);
key               232 sapi/apache2filter/sapi_apache2.c 	char *key, *val;
key               235 sapi/apache2filter/sapi_apache2.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               239 sapi/apache2filter/sapi_apache2.c 		if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len TSRMLS_CC)) {
key               240 sapi/apache2filter/sapi_apache2.c 			php_register_variable_safe(key, val, new_val_len, track_vars_array TSRMLS_CC);
key                58 sapi/apache2handler/php_apache.h #define APR_ARRAY_FOREACH_OPEN(arr, key, val) 		\
key                64 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, 1);
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, 1);
key               438 sapi/apache2handler/php_functions.c 		char *key, *val;
key               443 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               447 sapi/apache2handler/php_functions.c 			php_info_print_table_row(2, key, val);
key               458 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               462 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
key               467 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               471 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
key               272 sapi/apache2handler/sapi_apache2.c 	char *key, *val;
key               275 sapi/apache2handler/sapi_apache2.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
key               279 sapi/apache2handler/sapi_apache2.c 		if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), (unsigned int *)&new_val_len TSRMLS_CC)) {
key               280 sapi/apache2handler/sapi_apache2.c 			php_register_variable_safe(key, val, new_val_len, track_vars_array TSRMLS_CC);
key                98 sapi/apache_hooks/mod_php5.c 	char *key;
key               400 sapi/apache_hooks/mod_php5.c 		php_register_variable(elts[i].key, val, track_vars_array  TSRMLS_CC);
key               619 sapi/apache_hooks/mod_php5.c 	zend_alter_ini_entry(per_dir_entry->key, per_dir_entry->key_length+1, per_dir_entry->value, per_dir_entry->value_length, per_dir_entry->type, PHP_INI_STAGE_ACTIVATE);
key               768 sapi/apache_hooks/mod_php5.c 	free(per_dir_entry->key);
key               779 sapi/apache_hooks/mod_php5.c 	per_dir_entry->key = (char *) malloc(tmp.key_length+1);
key               780 sapi/apache_hooks/mod_php5.c 	memcpy(per_dir_entry->key, tmp.key, tmp.key_length);
key               781 sapi/apache_hooks/mod_php5.c 	per_dir_entry->key[per_dir_entry->key_length] = 0;
key               916 sapi/apache_hooks/mod_php5.c 	per_dir_entry.key = (char *) malloc(per_dir_entry.key_length+1);
key               917 sapi/apache_hooks/mod_php5.c 	memcpy(per_dir_entry.key, arg1, per_dir_entry.key_length);
key               918 sapi/apache_hooks/mod_php5.c 	per_dir_entry.key[per_dir_entry.key_length] = 0;
key               924 sapi/apache_hooks/mod_php5.c 	zend_hash_update(conf, per_dir_entry.key, per_dir_entry.key_length, &per_dir_entry, sizeof(php_per_dir_entry), NULL);
key              1667 sapi/apache_hooks/php_apache.c 			php_info_print_table_row(2, elts[i].key, elts[i].val);
key              1686 sapi/apache_hooks/php_apache.c 			if (env[i].key) {
key              1687 sapi/apache_hooks/php_apache.c 				php_info_print_table_row(2, env[i].key, env[i].val);
key              1694 sapi/apache_hooks/php_apache.c 			if (env[i].key) {
key              1695 sapi/apache_hooks/php_apache.c 				php_info_print_table_row(2, env[i].key, env[i].val);
key              1766 sapi/apache_hooks/php_apache.c 		if (!tenv[i].key) {
key              1769 sapi/apache_hooks/php_apache.c 		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
key               485 sapi/cli/php_cli_server.c 	char *key;
key               501 sapi/cli/php_cli_server.c 		zend_hash_get_current_key_ex(headers, &key, &key_len, NULL, 0, &pos);
key               502 sapi/cli/php_cli_server.c 		add_assoc_string_ex(return_value, key, key_len, *value_pointer, 1);
key               708 sapi/cli/php_cli_server.c static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val TSRMLS_DC) /* {{{ */
key               717 sapi/cli/php_cli_server.c 	if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len TSRMLS_CC)) {
key               718 sapi/cli/php_cli_server.c 		php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array TSRMLS_CC);
key               725 sapi/cli/php_cli_server.c 		char *real_key, *key;
key               727 sapi/cli/php_cli_server.c 		key = estrndup(hash_key->arKey, hash_key->nKeyLength);
key               729 sapi/cli/php_cli_server.c 			if (key[i] == '-') {
key               730 sapi/cli/php_cli_server.c 				key[i] = '_';
key               732 sapi/cli/php_cli_server.c 				key[i] = toupper(key[i]);
key               735 sapi/cli/php_cli_server.c 		spprintf(&real_key, 0, "%s_%s", "HTTP", key);
key               736 sapi/cli/php_cli_server.c 		if (strcmp(key, "CONTENT_TYPE") == 0 || strcmp(key, "CONTENT_LENGTH") == 0) {
key               737 sapi/cli/php_cli_server.c 			sapi_cli_server_register_variable(track_vars_array, key, *entry TSRMLS_CC);
key               740 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 TSRMLS_DC) /* {{{ */
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              1629 sapi/fpm/fpm/fpm_conf.c 			zlog(ZLOG_NOTICE, "\tenv[%s] = %s", kv->key, kv->value);
key              1633 sapi/fpm/fpm/fpm_conf.c 			zlog(ZLOG_NOTICE, "\tphp_value[%s] = %s", kv->key, kv->value);
key              1637 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              1457 sapi/fpm/fpm/fpm_main.c 	char *key;
key              1468 sapi/fpm/fpm/fpm_main.c 	key = Z_STRVAL_P(arg1);
key              1470 sapi/fpm/fpm/fpm_main.c 	if (!key || strlen(key) < 1) {
key              1480 sapi/fpm/fpm/fpm_main.c 		zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: empty value for key '%s'", key);
key              1484 sapi/fpm/fpm/fpm_main.c 	kv.key = key;
key              1488 sapi/fpm/fpm/fpm_main.c 		zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: unable to set '%s'", key);
key                84 sapi/fpm/fpm/fpm_php.c 	char *name = kv->key;
key               123 sapi/fpm/fpm/fpm_php.c 			zlog(ZLOG_ERROR, "Unable to set php_value '%s'", kv->key);
key               129 sapi/fpm/fpm/fpm_php.c 			zlog(ZLOG_ERROR, "Unable to set php_admin_value '%s'", kv->key);
key               261 sapi/fpm/fpm/fpm_php.c char* fpm_php_get_string_from_table(char *table, char *key TSRMLS_DC) /* {{{ */
key               267 sapi/fpm/fpm/fpm_php.c 	if (!table || !key) {
key               286 sapi/fpm/fpm/fpm_php.c 				if (!strncmp(string_key, key, string_len)) {
key                47 sapi/fpm/fpm/fpm_php.h char* fpm_php_get_string_from_table(char *table, char *key TSRMLS_DC);
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               401 sapi/fpm/fpm/fpm_sockets.c 				unlink(ls->key);
key               403 sapi/fpm/fpm/fpm_sockets.c 			free(ls->key);
key              1095 sapi/phpdbg/phpdbg_bp.c 		char *key;
key              1132 sapi/phpdbg/phpdbg_bp.c 			(*table), &key, &klen, &idx, 0, &position)) {
key              1135 sapi/phpdbg/phpdbg_bp.c 				zend_hash_del((*table), key, klen);
key               148 sapi/phpdbg/phpdbg_help.c static char *get_help(const char * const key TSRMLS_DC)
key               156 sapi/phpdbg/phpdbg_help.c 	for (p = phpdbg_help_text; p->key; p++) {
key               157 sapi/phpdbg/phpdbg_help.c 		if (!strcmp(p->key, key)) {
key               174 sapi/phpdbg/phpdbg_help.c 	const char *key, size_t len,      /* pointer and length of key */
key               184 sapi/phpdbg/phpdbg_help.c 			if (c->alias == key[0]) {
key               193 sapi/phpdbg/phpdbg_help.c 			if (!strncmp(c->name, key, len)) {
key                43 sapi/phpdbg/phpdbg_help.h 	char *key;
key               129 sapi/phpdbg/phpdbg_utils.h static void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos) {
key               135 sapi/phpdbg/phpdbg_utils.h 		Z_TYPE_P(key) = IS_NULL;
key               137 sapi/phpdbg/phpdbg_utils.h 		Z_TYPE_P(key) = IS_STRING;
key               138 sapi/phpdbg/phpdbg_utils.h 		Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
key               139 sapi/phpdbg/phpdbg_utils.h 		Z_STRLEN_P(key) = p->nKeyLength - 1;
key               141 sapi/phpdbg/phpdbg_utils.h 		Z_TYPE_P(key) = IS_LONG;
key               142 sapi/phpdbg/phpdbg_utils.h 		Z_LVAL_P(key) = p->h;
key               141 sapi/phpdbg/phpdbg_watch.c static char *phpdbg_get_property_key(char *key) {
key               142 sapi/phpdbg/phpdbg_watch.c 	if (*key != 0) {
key               143 sapi/phpdbg/phpdbg_watch.c 		return key;
key               145 sapi/phpdbg/phpdbg_watch.c 	return strchr(key + 1, 0) + 1;
key               172 sapi/phpdbg/phpdbg_watch.c 		zval key;
key               183 sapi/phpdbg/phpdbg_watch.c 			zend_hash_get_current_key_zval_ex(ht, &key, &position);
key               184 sapi/phpdbg/phpdbg_watch.c 			if (Z_TYPE(key) == IS_STRING) {
key               185 sapi/phpdbg/phpdbg_watch.c 				new_watch->name_in_parent = zend_strndup(Z_STRVAL(key), Z_STRLEN(key));
key               186 sapi/phpdbg/phpdbg_watch.c 				new_watch->name_in_parent_len = Z_STRLEN(key);
key               189 sapi/phpdbg/phpdbg_watch.c 				new_watch->name_in_parent_len = asprintf(&new_watch->name_in_parent, "%ld", Z_LVAL(key));
key               226 sapi/phpdbg/phpdbg_watch.c 			zval key;
key               236 sapi/phpdbg/phpdbg_watch.c 				zend_hash_get_current_key_zval_ex(ht, &key, &position);
key               238 sapi/phpdbg/phpdbg_watch.c 				if (Z_TYPE(key) == IS_STRING) {
key               239 sapi/phpdbg/phpdbg_watch.c 					str_len = asprintf(&str, "%.*s%s%s%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", phpdbg_get_property_key(Z_STRVAL(key)), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
key               241 sapi/phpdbg/phpdbg_watch.c 					str_len = asprintf(&str, "%.*s%s%li%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", Z_LVAL(key), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
key               336 sapi/phpdbg/phpdbg_watch.c 					zval *key = emalloc(sizeof(zval));
key               339 sapi/phpdbg/phpdbg_watch.c 					zend_hash_get_current_key_zval_ex(parent, key, &position);
key               340 sapi/phpdbg/phpdbg_watch.c 					convert_to_string(key);
key               341 sapi/phpdbg/phpdbg_watch.c 					watch->str = malloc(i + Z_STRLEN_P(key) + 2);
key               342 sapi/phpdbg/phpdbg_watch.c 					watch->str_len = sprintf(watch->str, "%.*s%s%s", (int)i, input, phpdbg_get_property_key(Z_STRVAL_P(key)), input[len - 1] == ']'?"]":"");
key               343 sapi/phpdbg/phpdbg_watch.c 					efree(key);
key                60 win32/registry.c static int LoadDirectory(HashTable *directories, HKEY key, char *path, int path_len, HashTable *parent_ht)
key                66 win32/registry.c 	if (RegQueryInfoKey(key, NULL, NULL, NULL, &keys, &max_key, NULL, &values, &max_name, &max_value, NULL, NULL) == ERROR_SUCCESS) {
key                78 win32/registry.c 				if (RegEnumValue(key, i, name, &name_len, NULL, &type, value, &value_len) == ERROR_SUCCESS) {
key               138 win32/registry.c 				if (RegEnumKeyEx(key, i, name, &name_len, NULL, NULL, NULL, &t) == ERROR_SUCCESS) {
key               139 win32/registry.c 					if (RegOpenKeyEx(key, name, 0, KEY_READ, &subkey) == ERROR_SUCCESS) {