key 612 TSRM/tsrm_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key 614 TSRM/tsrm_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len);
key 616 TSRM/tsrm_virtual_cwd.c unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 620 TSRM/tsrm_virtual_cwd.c if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key 661 TSRM/tsrm_virtual_cwd.c bucket->key = realpath_cache_key(path, path_len TSRMLS_CC);
key 663 TSRM/tsrm_virtual_cwd.c bucket->key = realpath_cache_key(path, path_len);
key 683 TSRM/tsrm_virtual_cwd.c n = bucket->key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 694 TSRM/tsrm_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key 696 TSRM/tsrm_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len);
key 699 TSRM/tsrm_virtual_cwd.c unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 714 TSRM/tsrm_virtual_cwd.c } else if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key 212 TSRM/tsrm_virtual_cwd.h unsigned long key;
key 420 TSRM/tsrm_win32.c if (!addr && ptr->descriptor->shm_perm.key == key) {
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 656 TSRM/tsrm_win32.c shm_pair *shm = shm_get(key, NULL);
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 176 Zend/zend.c char key[25];
key 177 Zend/zend.c snprintf(key, sizeof(key), "%ld", num_key);
key 178 Zend/zend.c ZEND_PUTS_EX(key);
key 1232 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1243 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1254 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1265 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1276 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1287 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1298 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1304 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
key 1481 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key 1492 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key 1544 Zend/zend_API.c switch (Z_TYPE_P(key)) {
key 1546 Zend/zend_API.c result = zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
key 1552 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 1556 Zend/zend_API.c result = zend_hash_index_update(ht, Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key 1559 Zend/zend_API.c result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), &value, sizeof(zval *), NULL);
key 1583 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1601 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1619 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1637 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1655 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1673 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1691 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1705 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 527 Zend/zend_API.h #define add_method(arg, key, method) add_assoc_function((arg), (key), (method))
key 909 Zend/zend_builtin_functions.c char *key;
key 915 Zend/zend_builtin_functions.c zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key 950 Zend/zend_builtin_functions.c add_assoc_zval(return_value, key, prop_copy);
key 988 Zend/zend_builtin_functions.c char *key;
key 1015 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 1016 Zend/zend_builtin_functions.c if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
key 1017 Zend/zend_builtin_functions.c zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
key 1031 Zend/zend_builtin_functions.c int ret = memcmp(lcname, key, name_len) == 0;
key 1076 Zend/zend_builtin_functions.c char *key;
key 1082 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 1088 Zend/zend_builtin_functions.c zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0) {
key 1093 Zend/zend_builtin_functions.c !same_name(key, mptr->common.function_name, len))) {
key 1095 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 197 Zend/zend_closures.c return std_object_handlers.get_method(object_ptr, method_name, method_len, key TSRMLS_CC);
key 1698 Zend/zend_compile.c zval key;
key 1716 Zend/zend_compile.c build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC);
key 1717 Zend/zend_compile.c opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key 1723 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 2785 Zend/zend_compile.c if (key) {
key 2786 Zend/zend_compile.c SET_NODE(opline->op2, key);
key 3753 Zend/zend_compile.c do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
key 4989 Zend/zend_compile.c zval **ns_name, key;
key 5061 Zend/zend_compile.c build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);
key 5062 Zend/zend_compile.c opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key 5082 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 6317 Zend/zend_compile.c if (key->op_type != IS_UNUSED) {
key 6321 Zend/zend_compile.c tmp = key;
key 6322 Zend/zend_compile.c key = value;
key 6329 Zend/zend_compile.c if ((key->op_type != IS_UNUSED)) {
key 6330 Zend/zend_compile.c if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
key 6333 Zend/zend_compile.c if (key->EA & ZEND_PARSED_LIST_EXPR) {
key 6382 Zend/zend_compile.c if (key->op_type != IS_UNUSED) {
key 6390 Zend/zend_compile.c zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
key 455 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 456 Zend/zend_constants.c key++;
key 457 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 460 Zend/zend_constants.c key++;
key 461 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 462 Zend/zend_constants.c key++;
key 463 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 466 Zend/zend_constants.c key--;
key 467 Zend/zend_constants.c if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key 473 Zend/zend_constants.c key--;
key 474 Zend/zend_constants.c if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key 381 Zend/zend_exceptions.c if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \
key 383 Zend/zend_exceptions.c zend_error(E_WARNING, "Value for %s is no string", key); \
key 739 Zend/zend_execute.c Z_OBJ_HT_P(object)->write_property(object, property_name, value, key TSRMLS_CC);
key 1384 Zend/zend_execute.c zval **ptr_ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, key TSRMLS_CC);
key 1389 Zend/zend_execute.c (ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC)) != NULL) {
key 1400 Zend/zend_execute.c zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC);
key 1023 Zend/zend_execute_API.c if (key) {
key 1024 Zend/zend_execute_API.c lc_name = Z_STRVAL(key->constant);
key 1025 Zend/zend_execute_API.c lc_length = Z_STRLEN(key->constant) + 1;
key 1026 Zend/zend_execute_API.c hash = key->hash_value;
key 1045 Zend/zend_execute_API.c if (!key) {
key 1055 Zend/zend_execute_API.c if (!key) {
key 1063 Zend/zend_execute_API.c if (!key) {
key 1075 Zend/zend_execute_API.c if (!key) {
key 1126 Zend/zend_execute_API.c if (!key) {
key 1520 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 246 Zend/zend_generators.c zend_hash_quick_update(target, key->arKey, key->nKeyLength, key->h, var, sizeof(zval *), NULL);
key 489 Zend/zend_generators.c if (generator->key) {
key 490 Zend/zend_generators.c RETURN_ZVAL(generator->key, 1, 0);
key 644 Zend/zend_generators.c if (generator->key) {
key 645 Zend/zend_generators.c ZVAL_ZVAL(key, generator->key, 1, 0);
key 647 Zend/zend_generators.c ZVAL_NULL(key);
key 724 Zend/zend_generators.c ZEND_ME(Generator, key, arginfo_generator_void, ZEND_ACC_PUBLIC)
key 50 Zend/zend_generators.h zval *key;
key 1182 Zend/zend_hash.c Z_TYPE_P(key) = IS_NULL;
key 1184 Zend/zend_hash.c Z_TYPE_P(key) = IS_STRING;
key 1185 Zend/zend_hash.c Z_STRVAL_P(key) = estrndup(p->arKey, p->nKeyLength - 1);
key 1186 Zend/zend_hash.c Z_STRLEN_P(key) = p->nKeyLength - 1;
key 1188 Zend/zend_hash.c Z_TYPE_P(key) = IS_LONG;
key 1189 Zend/zend_hash.c Z_LVAL_P(key) = p->h;
key 204 Zend/zend_hash.h zend_hash_get_current_key_zval_ex(ht, key, NULL)
key 311 Zend/zend_hash.h register const char *tmp = key; \
key 317 Zend/zend_hash.h const char *end = key + length - 1; \
key 332 Zend/zend_hash.h if (*key == '-') { \
key 348 Zend/zend_hash.h ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func); \
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 45 Zend/zend_iterators.h void (*get_current_key)(zend_object_iterator *iter, zval *key TSRMLS_DC);
key 277 Zend/zend_object_handlers.c if (key && (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) != NULL) {
key 292 Zend/zend_object_handlers.c h = key ? key->hash_value : zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
key 309 Zend/zend_object_handlers.c if (key) {
key 310 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 325 Zend/zend_object_handlers.c if (key) {
key 326 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, scope_property_info);
key 338 Zend/zend_object_handlers.c if (key) {
key 339 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 441 Zend/zend_object_handlers.c key = NULL;
key 449 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, silent || (zobj->ce->__get != NULL), key TSRMLS_CC);
key 539 Zend/zend_object_handlers.c key = NULL;
key 542 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__set != NULL), key TSRMLS_CC);
key 731 Zend/zend_object_handlers.c key = NULL;
key 738 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__get != NULL), key TSRMLS_CC);
key 809 Zend/zend_object_handlers.c key = NULL;
key 812 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__unset != NULL), key TSRMLS_CC);
key 1017 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1018 Zend/zend_object_handlers.c lc_method_name = Z_STRVAL(key->constant);
key 1019 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1028 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1084 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1160 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1161 Zend/zend_object_handlers.c lc_function_name = Z_STRVAL(key->constant);
key 1162 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1182 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1234 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1247 Zend/zend_object_handlers.c if (UNEXPECTED(!key) ||
key 1248 Zend/zend_object_handlers.c (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {
key 1249 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1250 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1282 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1283 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 1420 Zend/zend_object_handlers.c key = NULL;
key 1427 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, 1, key TSRMLS_CC);
key 205 Zend/zend_variables.c if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
key 209 Zend/zend_variables.c zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
key 212 Zend/zend_variables.c zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
key 231 Zend/zend_variables.c if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), NULL) == SUCCESS) {
key 4248 Zend/zend_vm_def.h zval *key = NULL;
key 4250 Zend/zend_vm_def.h key = &EX_T((opline+1)->result.var).tmp_var;
key 4281 Zend/zend_vm_def.h if (key) {
key 4283 Zend/zend_vm_def.h ZVAL_LONG(key, int_key);
key 4290 Zend/zend_vm_def.h ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key 4305 Zend/zend_vm_def.h if (key) {
key 4306 Zend/zend_vm_def.h zend_hash_get_current_key_zval(fe_ht, key);
key 4341 Zend/zend_vm_def.h if (key) {
key 4343 Zend/zend_vm_def.h iter->funcs->get_current_key(iter, key TSRMLS_CC);
key 4349 Zend/zend_vm_def.h ZVAL_LONG(key, iter->index);
key 5254 Zend/zend_vm_def.h if (generator->key) {
key 5255 Zend/zend_vm_def.h zval_ptr_dtor(&generator->key);
key 5339 Zend/zend_vm_def.h zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
key 5343 Zend/zend_vm_def.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 5348 Zend/zend_vm_def.h INIT_PZVAL_COPY(copy, key);
key 5355 Zend/zend_vm_def.h generator->key = copy;
key 5357 Zend/zend_vm_def.h Z_ADDREF_P(key);
key 5358 Zend/zend_vm_def.h generator->key = key;
key 5361 Zend/zend_vm_def.h if (Z_TYPE_P(generator->key) == IS_LONG
key 5362 Zend/zend_vm_def.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 5364 Zend/zend_vm_def.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 5372 Zend/zend_vm_def.h ALLOC_INIT_ZVAL(generator->key);
key 5373 Zend/zend_vm_def.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 4089 Zend/zend_vm_execute.h if (generator->key) {
key 4090 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 4172 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 4176 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 4181 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 4188 Zend/zend_vm_execute.h generator->key = copy;
key 4190 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 4191 Zend/zend_vm_execute.h generator->key = key;
key 4194 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 4195 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 4197 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 4204 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 4205 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 4782 Zend/zend_vm_execute.h if (generator->key) {
key 4783 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 4865 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 4869 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 4874 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 4881 Zend/zend_vm_execute.h generator->key = copy;
key 4883 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 4884 Zend/zend_vm_execute.h generator->key = key;
key 4887 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 4888 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 4890 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 4897 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 4898 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 5802 Zend/zend_vm_execute.h if (generator->key) {
key 5803 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 5885 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 5889 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 5894 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 5901 Zend/zend_vm_execute.h generator->key = copy;
key 5903 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 5904 Zend/zend_vm_execute.h generator->key = key;
key 5907 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 5908 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 5910 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 5918 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 5919 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 6534 Zend/zend_vm_execute.h if (generator->key) {
key 6535 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 6617 Zend/zend_vm_execute.h zval *key = NULL;
key 6621 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 6626 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 6633 Zend/zend_vm_execute.h generator->key = copy;
key 6635 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 6636 Zend/zend_vm_execute.h generator->key = key;
key 6639 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 6640 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 6642 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 6649 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 6650 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 7286 Zend/zend_vm_execute.h if (generator->key) {
key 7287 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 7369 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 7373 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 7378 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 7385 Zend/zend_vm_execute.h generator->key = copy;
key 7387 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 7388 Zend/zend_vm_execute.h generator->key = key;
key 7391 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 7392 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 7394 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 7401 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 7402 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 9317 Zend/zend_vm_execute.h if (generator->key) {
key 9318 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 9400 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 9404 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 9409 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 9416 Zend/zend_vm_execute.h generator->key = copy;
key 9418 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 9419 Zend/zend_vm_execute.h generator->key = key;
key 9422 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 9423 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 9425 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 9432 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 9433 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 10012 Zend/zend_vm_execute.h if (generator->key) {
key 10013 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 10095 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 10099 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 10104 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 10111 Zend/zend_vm_execute.h generator->key = copy;
key 10113 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 10114 Zend/zend_vm_execute.h generator->key = key;
key 10117 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 10118 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 10120 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 10127 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 10128 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 11034 Zend/zend_vm_execute.h if (generator->key) {
key 11035 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 11117 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 11121 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 11126 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 11133 Zend/zend_vm_execute.h generator->key = copy;
key 11135 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 11136 Zend/zend_vm_execute.h generator->key = key;
key 11139 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 11140 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 11142 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 11150 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 11151 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 11619 Zend/zend_vm_execute.h if (generator->key) {
key 11620 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 11702 Zend/zend_vm_execute.h zval *key = NULL;
key 11706 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 11711 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 11718 Zend/zend_vm_execute.h generator->key = copy;
key 11720 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 11721 Zend/zend_vm_execute.h generator->key = key;
key 11724 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 11725 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 11727 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 11734 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 11735 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 12311 Zend/zend_vm_execute.h if (generator->key) {
key 12312 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 12394 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 12398 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 12403 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 12410 Zend/zend_vm_execute.h generator->key = copy;
key 12412 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 12413 Zend/zend_vm_execute.h generator->key = key;
key 12416 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 12417 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 12419 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 12426 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 12427 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 13561 Zend/zend_vm_execute.h zval *key = NULL;
key 13563 Zend/zend_vm_execute.h key = &EX_T((opline+1)->result.var).tmp_var;
key 13594 Zend/zend_vm_execute.h if (key) {
key 13596 Zend/zend_vm_execute.h ZVAL_LONG(key, int_key);
key 13603 Zend/zend_vm_execute.h ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key 13618 Zend/zend_vm_execute.h if (key) {
key 13619 Zend/zend_vm_execute.h zend_hash_get_current_key_zval(fe_ht, key);
key 13654 Zend/zend_vm_execute.h if (key) {
key 13656 Zend/zend_vm_execute.h iter->funcs->get_current_key(iter, key TSRMLS_CC);
key 13662 Zend/zend_vm_execute.h ZVAL_LONG(key, iter->index);
key 16210 Zend/zend_vm_execute.h if (generator->key) {
key 16211 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 16295 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 16299 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 16304 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 16311 Zend/zend_vm_execute.h generator->key = copy;
key 16313 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 16314 Zend/zend_vm_execute.h generator->key = key;
key 16317 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 16318 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 16320 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 16327 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 16328 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 18309 Zend/zend_vm_execute.h if (generator->key) {
key 18310 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 18394 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 18398 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 18403 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 18410 Zend/zend_vm_execute.h generator->key = copy;
key 18412 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 18413 Zend/zend_vm_execute.h generator->key = key;
key 18416 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 18417 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 18419 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 18426 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 18427 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 20790 Zend/zend_vm_execute.h if (generator->key) {
key 20791 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 20875 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 20879 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 20884 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 20891 Zend/zend_vm_execute.h generator->key = copy;
key 20893 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 20894 Zend/zend_vm_execute.h generator->key = key;
key 20897 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 20898 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 20900 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 20908 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 20909 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 21949 Zend/zend_vm_execute.h if (generator->key) {
key 21950 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 22034 Zend/zend_vm_execute.h zval *key = NULL;
key 22038 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 22043 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 22050 Zend/zend_vm_execute.h generator->key = copy;
key 22052 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 22053 Zend/zend_vm_execute.h generator->key = key;
key 22056 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 22057 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 22059 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 22066 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 22067 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 24097 Zend/zend_vm_execute.h if (generator->key) {
key 24098 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 24182 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 24186 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 24191 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 24198 Zend/zend_vm_execute.h generator->key = copy;
key 24200 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 24201 Zend/zend_vm_execute.h generator->key = key;
key 24204 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 24205 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 24207 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 24214 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 24215 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 25609 Zend/zend_vm_execute.h if (generator->key) {
key 25610 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 25692 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 25696 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 25701 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 25708 Zend/zend_vm_execute.h generator->key = copy;
key 25710 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 25711 Zend/zend_vm_execute.h generator->key = key;
key 25714 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 25715 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 25717 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 25724 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 25725 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 26935 Zend/zend_vm_execute.h if (generator->key) {
key 26936 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 27018 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 27022 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 27027 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 27034 Zend/zend_vm_execute.h generator->key = copy;
key 27036 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 27037 Zend/zend_vm_execute.h generator->key = key;
key 27040 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 27041 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 27043 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 27050 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 27051 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 28261 Zend/zend_vm_execute.h if (generator->key) {
key 28262 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 28344 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 28348 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 28353 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 28360 Zend/zend_vm_execute.h generator->key = copy;
key 28362 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 28363 Zend/zend_vm_execute.h generator->key = key;
key 28366 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 28367 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 28369 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 28377 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 28378 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 28690 Zend/zend_vm_execute.h if (generator->key) {
key 28691 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 28773 Zend/zend_vm_execute.h zval *key = NULL;
key 28777 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 28782 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 28789 Zend/zend_vm_execute.h generator->key = copy;
key 28791 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 28792 Zend/zend_vm_execute.h generator->key = key;
key 28795 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 28796 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 28798 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 28805 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 28806 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 30013 Zend/zend_vm_execute.h if (generator->key) {
key 30014 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 30096 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 30100 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 30105 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 30112 Zend/zend_vm_execute.h generator->key = copy;
key 30114 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 30115 Zend/zend_vm_execute.h generator->key = key;
key 30118 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 30119 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 30121 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 30128 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 30129 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 33514 Zend/zend_vm_execute.h if (generator->key) {
key 33515 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 33597 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 33601 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 33606 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 33613 Zend/zend_vm_execute.h generator->key = copy;
key 33615 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 33616 Zend/zend_vm_execute.h generator->key = key;
key 33619 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 33620 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 33622 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 33629 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 33630 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 35477 Zend/zend_vm_execute.h if (generator->key) {
key 35478 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 35560 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 35564 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 35569 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 35576 Zend/zend_vm_execute.h generator->key = copy;
key 35578 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 35579 Zend/zend_vm_execute.h generator->key = key;
key 35582 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 35583 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 35585 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 35592 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 35593 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 37821 Zend/zend_vm_execute.h if (generator->key) {
key 37822 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 37904 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 37908 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 37913 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 37920 Zend/zend_vm_execute.h generator->key = copy;
key 37922 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 37923 Zend/zend_vm_execute.h generator->key = key;
key 37926 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 37927 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 37929 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 37937 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 37938 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 38832 Zend/zend_vm_execute.h if (generator->key) {
key 38833 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 38915 Zend/zend_vm_execute.h zval *key = NULL;
key 38919 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 38924 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 38931 Zend/zend_vm_execute.h generator->key = copy;
key 38933 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 38934 Zend/zend_vm_execute.h generator->key = key;
key 38937 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 38938 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 38940 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 38947 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 38948 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 40843 Zend/zend_vm_execute.h if (generator->key) {
key 40844 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 40926 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 40930 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 40935 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 40942 Zend/zend_vm_execute.h generator->key = copy;
key 40944 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 40945 Zend/zend_vm_execute.h generator->key = key;
key 40948 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 40949 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 40951 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 40958 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 40959 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 35 ext/com_dotnet/com_iterator.c ulong key;
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 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 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 1851 ext/curl/interface.c char *key;
key 1859 ext/curl/interface.c key = s;
key 1860 ext/curl/interface.c tmp = memchr(key, '=', 64);
key 1864 ext/curl/interface.c add_assoc_string(hash, key, val, 1);
key 1939 ext/date/php_date.c ZVAL_LONG(key, iterator->current_index);
key 4019 ext/date/php_date.c key = NULL;
key 4025 ext/date/php_date.c retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key 4047 ext/date/php_date.c retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key 4084 ext/date/php_date.c key = NULL;
key 4090 ext/date/php_date.c (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key 4121 ext/date/php_date.c (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key 5012 ext/date/php_date.c zv = std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
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 57 ext/dba/libcdb/cdb.c if (memcmp(buf, key, n))
key 60 ext/dba/libcdb/cdb.c key += n;
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 185 ext/dba/libcdb/cdb.c return cdb_findnext(c, key, len TSRMLS_CC);
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 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 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 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 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 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 425 ext/dba/libinifile/inifile.c switch(inifile_key_cmp(&ln.key, key TSRMLS_CC)) {
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 566 ext/dba/libinifile/inifile.c return inifile_delete_replace_append(dba, key, NULL, 0 TSRMLS_CC);
key 574 ext/dba/libinifile/inifile.c return inifile_delete_replace_append(dba, key, value, 0 TSRMLS_CC);
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 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 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 329 ext/dom/php_dom.c retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 375 ext/dom/php_dom.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 411 ext/dom/php_dom.c std_hnd->write_property(object, member, value, key TSRMLS_CC);
key 459 ext/dom/php_dom.c retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
key 3839 ext/gd/gd.c char * key;
key 3842 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 3850 ext/gd/gd.c if (strcmp("linespacing", key) == 0) {
key 151 ext/gd/gdcache.c int key;
key 158 ext/gd/gdcache.c return (((key_value_t *)map)->key == *(int *)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 161 ext/gd/libgd/gdcache.c return (((key_value_t *) map)->key == *(int *) 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 339 ext/gd/libgd/gdft.c fontkey_t *b = (fontkey_t *) key;
key 347 ext/gd/libgd/gdft.c fontkey_t *b = (fontkey_t *) key;
key 528 ext/gd/libgd/gdft.c tweencolorkey_t *b = (tweencolorkey_t *) key;
key 545 ext/gd/libgd/gdft.c tweencolorkey_t *b = (tweencolorkey_t *) key;
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 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 750 ext/hash/hash.c if (hash->key) {
key 751 ext/hash/hash.c memset(hash->key, 0, hash->ops->block_size);
key 752 ext/hash/hash.c efree(hash->key);
key 926 ext/hash/hash.c char *key, *digest;
key 935 ext/hash/hash.c key = ecalloc(1, times * block_size);
key 947 ext/hash/hash.c memcpy( &key[i*block_size], digest, block_size);
key 950 ext/hash/hash.c RETVAL_STRINGL(key, bytes, 1);
key 951 ext/hash/hash.c memset(key, 0, bytes);
key 954 ext/hash/hash.c efree(key);
key 41 ext/hash/hash_gost.c round(key[0], key[1]) \
key 42 ext/hash/hash_gost.c round(key[2], key[3]) \
key 43 ext/hash/hash_gost.c round(key[4], key[5]) \
key 44 ext/hash/hash_gost.c round(key[6], key[7]) \
key 45 ext/hash/hash_gost.c round(key[0], key[1]) \
key 46 ext/hash/hash_gost.c round(key[2], key[3]) \
key 47 ext/hash/hash_gost.c round(key[4], key[5]) \
key 48 ext/hash/hash_gost.c round(key[6], key[7]) \
key 49 ext/hash/hash_gost.c round(key[0], key[1]) \
key 50 ext/hash/hash_gost.c round(key[2], key[3]) \
key 51 ext/hash/hash_gost.c round(key[4], key[5]) \
key 52 ext/hash/hash_gost.c round(key[6], key[7]) \
key 53 ext/hash/hash_gost.c round(key[7], key[6]) \
key 54 ext/hash/hash_gost.c round(key[5], key[4]) \
key 55 ext/hash/hash_gost.c round(key[3], key[2]) \
key 56 ext/hash/hash_gost.c round(key[1], key[0]) \
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(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 = state, *m = data;
key 54 ext/hash/php_hash.h unsigned char *key;
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 145 ext/intl/breakiterator/breakiterator_iterators.cpp ZVAL_LONG(key, iter->index);
key 260 ext/intl/breakiterator/breakiterator_iterators.cpp if (key == NULL) {
key 267 ext/intl/breakiterator/breakiterator_iterators.cpp key = &local_literal;
key 270 ext/intl/breakiterator/breakiterator_iterators.cpp if ((key->hash_value & 0xFFFFFFFF) == 0xA2B486A1 /* hash of getrulestatus\0 */
key 272 ext/intl/breakiterator/breakiterator_iterators.cpp && memcmp("getrulestatus", Z_STRVAL(key->constant), method_len) == 0) {
key 279 ext/intl/breakiterator/breakiterator_iterators.cpp method, method_len, key TSRMLS_CC);
key 285 ext/intl/breakiterator/breakiterator_iterators.cpp method, method_len, key TSRMLS_CC);
key 288 ext/intl/breakiterator/breakiterator_iterators.cpp if (key == &local_literal) {
key 144 ext/intl/calendar/calendar_methods.cpp char *key,
key 152 ext/intl/calendar/calendar_methods.cpp &key, &key_len, &locale, &locale_len, &commonly_used) == FAILURE) {
key 160 ext/intl/calendar/calendar_methods.cpp StringEnumeration *se = Calendar::getKeywordValuesForLocale(key,
key 170 ext/intl/calendar/calendar_methods.cpp key, locale, !!commonly_used, &status);
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 315 ext/intl/common/common_enum.cpp PHP_ME(IntlIterator, key, ainfo_se_void, ZEND_ACC_PUBLIC)
key 113 ext/intl/locale/locale_methods.c if (strcmp(key, *list) == 0) {
key 406 ext/intl/msgformat/msgformat_helpers.cpp UnicodeString& key = farg_names[argNum];
key 421 ext/intl/msgformat/msgformat_helpers.cpp key.append(temp, len);
key 425 ext/intl/msgformat/msgformat_helpers.cpp intl_stringFromChar(key, str_index, str_len-1, &err.code);
key 436 ext/intl/msgformat/msgformat_helpers.cpp zend_hash_find(types, (char*)key.getBuffer(), key.length(),
key 552 ext/intl/msgformat/msgformat_helpers.cpp if (intl_charFromString(key, &key_char, &key_len,
key 595 ext/intl/msgformat/msgformat_helpers.cpp if (intl_charFromString(key, &key_char, &key_len,
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 268 ext/intl/transliterator/transliterator_class.c retval = std_object_handlers.get_property_ptr_ptr( object, member, type, key TSRMLS_CC );
key 302 ext/intl/transliterator/transliterator_class.c retval = std_object_handlers.read_property( object, member, type, key TSRMLS_CC );
key 334 ext/intl/transliterator/transliterator_class.c std_object_handlers.write_property( object, member, value, key TSRMLS_CC );
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 179 ext/json/json.c char *key;
key 187 ext/json/json.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 262 ext/json/json.c char *key;
key 271 ext/json/json.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 293 ext/json/json.c if (key[0] == '\0' && Z_TYPE_PP(val) == IS_OBJECT) {
key 310 ext/json/json.c json_escape_string(buf, key, key_len - 1, options & ~PHP_JSON_NUMERIC_CHECK TSRMLS_CC);
key 1513 ext/ldap/ldap.c if (zend_hash_find(Z_ARRVAL_P(hashTbl), key, strlen(key)+1, (void **) &fetched) == SUCCESS) {
key 357 ext/mbstring/oniguruma/regparse.c st_str_end_key key;
key 359 ext/mbstring/oniguruma/regparse.c key.s = (UChar* )str_key;
key 360 ext/mbstring/oniguruma/regparse.c key.end = (UChar* )end_key;
key 362 ext/mbstring/oniguruma/regparse.c return onig_st_lookup(table, (st_data_t )(&key), value);
key 369 ext/mbstring/oniguruma/regparse.c st_str_end_key* key;
key 372 ext/mbstring/oniguruma/regparse.c key = (st_str_end_key* )xmalloc(sizeof(st_str_end_key));
key 373 ext/mbstring/oniguruma/regparse.c key->s = (UChar* )str_key;
key 374 ext/mbstring/oniguruma/regparse.c key->end = (UChar* )end_key;
key 375 ext/mbstring/oniguruma/regparse.c result = onig_st_insert(table, (st_data_t )key, value);
key 377 ext/mbstring/oniguruma/regparse.c xfree(key);
key 447 ext/mbstring/oniguruma/regparse.c xfree(key);
key 4872 ext/mbstring/oniguruma/regparse.c p = (UChar* )&(key->enc);
key 4873 ext/mbstring/oniguruma/regparse.c for (i = 0; i < (int )sizeof(key->enc); i++) {
key 4877 ext/mbstring/oniguruma/regparse.c p = (UChar* )(&key->type);
key 4878 ext/mbstring/oniguruma/regparse.c for (i = 0; i < (int )sizeof(key->type); i++) {
key 4882 ext/mbstring/oniguruma/regparse.c val += key->not;
key 4903 ext/mbstring/oniguruma/regparse.c if (IS_NOT_NULL(key)) xfree(key);
key 5198 ext/mbstring/oniguruma/regparse.c type_cclass_key key;
key 5201 ext/mbstring/oniguruma/regparse.c key.enc = env->enc;
key 5202 ext/mbstring/oniguruma/regparse.c key.not = tok->u.prop.not;
key 5203 ext/mbstring/oniguruma/regparse.c key.type = tok->u.prop.ctype;
key 5216 ext/mbstring/oniguruma/regparse.c if (onig_st_lookup(OnigTypeCClassTable, (st_data_t )&key,
key 5233 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 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 248 ext/mbstring/oniguruma/st.c hash_val = do_hash(key, table);
key 271 ext/mbstring/oniguruma/st.c entry->key = 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 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 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 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 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 369 ext/mcrypt/mcrypt.c &cipher, &cipher_len, &key, &key_len, &data, &data_len, &mode, &iv, &iv_len) == FAILURE) { \
key 596 ext/mcrypt/mcrypt.c char *key, *iv;
key 604 ext/mcrypt/mcrypt.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &mcryptind, &key, &key_len, &iv, &iv_len) == FAILURE) {
key 629 ext/mcrypt/mcrypt.c memcpy(key_s, key, key_len);
key 1211 ext/mcrypt/mcrypt.c memcpy(key_s, key, use_key_length);
key 1215 ext/mcrypt/mcrypt.c memcpy(key_s, key, MIN(key_len, key_length_sizes[0]));
key 1228 ext/mcrypt/mcrypt.c memcpy(key_s, key, MIN(key_len, use_key_length));
key 1295 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1302 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, Z_STRVAL_PP(mode), iv, iv_len, ZEND_NUM_ARGS(), MCRYPT_ENCRYPT, return_value TSRMLS_CC);
key 1311 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1318 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, Z_STRVAL_PP(mode), iv, iv_len, ZEND_NUM_ARGS(), MCRYPT_DECRYPT, return_value TSRMLS_CC);
key 1327 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1334 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ecb", iv, iv_len, ZEND_NUM_ARGS(), Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1343 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1350 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cbc", iv, iv_len, ZEND_NUM_ARGS(), Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1359 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1366 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cfb", iv, iv_len, ZEND_NUM_ARGS(), Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1375 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1382 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ofb", iv, iv_len, ZEND_NUM_ARGS(), 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 353 ext/mysqli/mysqli.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 392 ext/mysqli/mysqli.c std_hnd->write_property(object, member, value, key TSRMLS_CC);
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 157 ext/mysqli/mysqli_result_iterator.c ZVAL_LONG(key, iterator->row_num);
key 1591 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, ssl_set)(MYSQLND_CONN_DATA * const conn, const char * key, const char * const cert,
key 1600 ext/mysqlnd/mysqlnd.c ret = (PASS == net->data->m.set_client_option(net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) &&
key 2489 ext/mysqlnd/mysqlnd.c const char * const key,
key 2511 ext/mysqlnd/mysqlnd.c DBG_INF_FMT("Adding [%s][%s]", key, value);
key 2517 ext/mysqlnd/mysqlnd.c zend_hash_update(conn->options->connect_attr, key, strlen(key), ©v, sizeof(char *), NULL);
key 166 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 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 808 ext/mysqlnd/mysqlnd_result.c hash_key->key,
key 812 ext/mysqlnd/mysqlnd_result.c hash_key->key,
key 1049 ext/mysqlnd/mysqlnd_result.c hash_key->key,
key 1053 ext/mysqlnd/mysqlnd_result.c hash_key->key,
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 950 ext/mysqlnd/mysqlnd_structs.h unsigned long key;
key 221 ext/opcache/ZendAccelerator.c char *key;
key 223 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 224 ext/opcache/ZendAccelerator.c if (key) {
key 225 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 226 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 227 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 228 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 968 ext/opcache/ZendAccelerator.c char *key;
key 970 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 971 ext/opcache/ZendAccelerator.c if (key) {
key 972 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 973 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 974 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 975 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 1011 ext/opcache/ZendAccelerator.c if ((size_t)key_length >= sizeof(ZCG(key))) {
key 1015 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), cwd, cwd_len);
key 1016 ext/opcache/ZendAccelerator.c ZCG(key)[cwd_len] = ':';
key 1018 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cwd_len + 1, file_handle->filename, path_length);
key 1020 ext/opcache/ZendAccelerator.c ZCG(key)[cwd_len + 1 + path_length] = ':';
key 1025 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cur_len, parent_script, parent_script_len);
key 1027 ext/opcache/ZendAccelerator.c ZCG(key)[cur_len] = ':';
key 1030 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cur_len, include_path, include_path_len);
key 1031 ext/opcache/ZendAccelerator.c ZCG(key)[key_length] = '\0';
key 1035 ext/opcache/ZendAccelerator.c if ((size_t)key_length >= sizeof(ZCG(key))) {
key 1039 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), file_handle->filename, key_length + 1);
key 1043 ext/opcache/ZendAccelerator.c return ZCG(key);
key 1107 ext/opcache/ZendAccelerator.c if (!zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) {
key 1115 ext/opcache/ZendAccelerator.c memcpy(new_key, key, key_length + 1);
key 1162 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1170 ext/opcache/ZendAccelerator.c memory_used = zend_accel_script_persist_calc(new_persistent_script, key, key_length TSRMLS_CC);
key 1185 ext/opcache/ZendAccelerator.c new_persistent_script = zend_accel_script_persist(new_persistent_script, &key, key_length TSRMLS_CC);
key 1206 ext/opcache/ZendAccelerator.c memcmp(key, "phar://", sizeof("phar://") - 1) != 0 &&
key 1208 ext/opcache/ZendAccelerator.c memcmp(new_persistent_script->full_path, key, key_length) != 0)) {
key 1210 ext/opcache/ZendAccelerator.c if (zend_accel_hash_update(&ZCSG(hash), key, key_length + 1, 1, bucket)) {
key 1211 ext/opcache/ZendAccelerator.c zend_accel_error(ACCEL_LOG_INFO, "Added key '%s'", key);
key 1296 ext/opcache/ZendAccelerator.c if (key == ZCG(key)) {
key 1448 ext/opcache/ZendAccelerator.c return cache_script_in_shared_memory(new_persistent_script, key, key_length, from_shared_memory TSRMLS_CC);
key 1455 ext/opcache/ZendAccelerator.c char *key = NULL;
key 1502 ext/opcache/ZendAccelerator.c key = ZCG(key);
key 1506 ext/opcache/ZendAccelerator.c if ((key = accel_make_persistent_key(file_handle, &key_length TSRMLS_CC)) == NULL) {
key 1509 ext/opcache/ZendAccelerator.c persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key 1546 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1625 ext/opcache/ZendAccelerator.c persistent_script = compile_and_cache_file(file_handle, type, key, key_length, &op_array, &from_shared_memory TSRMLS_CC);
key 1815 ext/opcache/ZendAccelerator.c char *key = NULL;
key 1838 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 1846 ext/opcache/ZendAccelerator.c key = accel_make_persistent_key_ex(handle, filename_len, &key_length TSRMLS_CC);
key 1848 ext/opcache/ZendAccelerator.c key &&
key 1849 ext/opcache/ZendAccelerator.c (persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key 1870 ext/opcache/ZendAccelerator.c if (key && !ZCG(accel_directives).revalidate_path) {
key 1874 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1946 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 1985 ext/opcache/ZendAccelerator.c char *key = NULL;
key 1997 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 2009 ext/opcache/ZendAccelerator.c key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC);
key 2011 ext/opcache/ZendAccelerator.c key &&
key 2012 ext/opcache/ZendAccelerator.c (persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key 2030 ext/opcache/ZendAccelerator.c if (key && !ZCG(accel_directives).revalidate_path) {
key 2034 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 2038 ext/opcache/ZendAccelerator.c ZCG(cache_opline) = (EG(opline_ptr) && key) ? *EG(opline_ptr): NULL;
key 2039 ext/opcache/ZendAccelerator.c ZCG(cache_persistent_script) = key ? persistent_script : NULL;
key 2118 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 2618 ext/opcache/ZendAccelerator.c char *key;
key 2621 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 2622 ext/opcache/ZendAccelerator.c if (key) {
key 2623 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 2624 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 2625 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 2626 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 273 ext/opcache/ZendAccelerator.h char key[MAXPATHLEN * 8];
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 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 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 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 311 ext/opcache/zend_accelerator_module.c char *key;
key 328 ext/opcache/zend_accelerator_module.c if ((key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC)) != NULL) {
key 329 ext/opcache/zend_accelerator_module.c persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key 538 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 674 ext/opcache/zend_persist.c *key = zend_accel_memdup(*key, key_length + 1);
key 340 ext/opcache/zend_persist_calc.c ADD_DUP_SIZE(key, key_length + 1);
key 590 ext/openssl/openssl.c if (key != NULL) {
key 637 ext/openssl/openssl.c if (key != NULL) {
key 638 ext/openssl/openssl.c zend_hash_update(HASH_OF(val), key, strlen(key) + 1, (void *)&subitem, sizeof(subitem), NULL);
key 645 ext/openssl/openssl.c add_assoc_stringl(val, key, (char *)str->data, str->length, 1);
key 797 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 803 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 1405 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 1417 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zkey, 0, "", 1, &keyresource TSRMLS_CC);
key 1418 ext/openssl/openssl.c if (key) {
key 1419 ext/openssl/openssl.c RETVAL_BOOL(X509_check_private_key(cert, key));
key 1422 ext/openssl/openssl.c if (keyresource == -1 && key) {
key 1423 ext/openssl/openssl.c EVP_PKEY_free(key);
key 2500 ext/openssl/openssl.c EVP_PKEY * key = NULL, *priv_key = NULL;
key 2537 ext/openssl/openssl.c key = X509_REQ_get_pubkey(csr);
key 2538 ext/openssl/openssl.c if (key == NULL) {
key 2542 ext/openssl/openssl.c i = X509_REQ_verify(csr, key);
key 2576 ext/openssl/openssl.c i = X509_set_pubkey(new_cert, key);
key 2610 ext/openssl/openssl.c if (key) {
key 2611 ext/openssl/openssl.c EVP_PKEY_free(key);
key 2780 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 2893 ext/openssl/openssl.c key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key 2912 ext/openssl/openssl.c key = PEM_read_bio_PrivateKey(in, NULL,NULL, passphrase);
key 2917 ext/openssl/openssl.c if (public_key && cert && key == NULL) {
key 2919 ext/openssl/openssl.c key = (EVP_PKEY *) X509_get_pubkey(cert);
key 2925 ext/openssl/openssl.c if (key && makeresource && resourceval) {
key 2926 ext/openssl/openssl.c *resourceval = ZEND_REGISTER_RESOURCE(NULL, key, le_key);
key 2931 ext/openssl/openssl.c return key;
key 3201 ext/openssl/openssl.c EVP_PKEY * key;
key 3210 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key 3212 ext/openssl/openssl.c if (key == NULL) {
key 3235 ext/openssl/openssl.c if (PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL)) {
key 3243 ext/openssl/openssl.c if (key_resource == -1 && key) {
key 3244 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3260 ext/openssl/openssl.c EVP_PKEY * key;
key 3269 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key 3271 ext/openssl/openssl.c if (key == NULL) {
key 3290 ext/openssl/openssl.c if (PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL)) {
key 3305 ext/openssl/openssl.c if (key_resource == -1 && key) {
key 3306 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3338 ext/openssl/openssl.c zval *key;
key 3341 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key 3344 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key 3345 ext/openssl/openssl.c zend_list_delete(Z_LVAL_P(key));
key 3376 ext/openssl/openssl.c zval *key;
key 3383 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key 3386 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key 3892 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 3912 ext/openssl/openssl.c key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &keyresval TSRMLS_CC);
key 3913 ext/openssl/openssl.c if (key == NULL) {
key 3936 ext/openssl/openssl.c if (PKCS7_decrypt(p7, key, cert, out, PKCS7_DETACHED)) {
key 3947 ext/openssl/openssl.c if (key && keyresval == -1) {
key 3948 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3959 ext/openssl/openssl.c zval **key, *crypted;
key 3969 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 3974 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4017 ext/openssl/openssl.c zval **key, *crypted;
key 4028 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 4033 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4083 ext/openssl/openssl.c zval **key, *crypted;
key 4093 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
key 4098 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 4141 ext/openssl/openssl.c zval **key, *crypted;
key 4152 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 4157 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 4229 ext/openssl/openssl.c zval **key, *signature;
key 4241 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
key 4244 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4291 ext/openssl/openssl.c zval **key;
key 4302 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 4322 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 4748 ext/openssl/openssl.c EVP_PKEY *key = NULL;
key 4753 ext/openssl/openssl.c key = X509_get_pubkey(cert);
key 4754 ext/openssl/openssl.c EVP_PKEY_copy_parameters(key, SSL_get_privatekey(tmpssl));
key 4755 ext/openssl/openssl.c EVP_PKEY_free(key);
key 4914 ext/openssl/openssl.c unsigned char *outbuf, *key;
key 4928 ext/openssl/openssl.c key = emalloc(keylen);
key 4929 ext/openssl/openssl.c memset(key, 0, keylen);
key 4930 ext/openssl/openssl.c memcpy(key, password, password_len);
key 4932 ext/openssl/openssl.c key = (unsigned char*)password;
key 4948 ext/openssl/openssl.c EVP_EncryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key 4973 ext/openssl/openssl.c if (key != (unsigned char*)password) {
key 4974 ext/openssl/openssl.c efree(key);
key 4993 ext/openssl/openssl.c unsigned char *outbuf, *key;
key 5025 ext/openssl/openssl.c key = emalloc(keylen);
key 5026 ext/openssl/openssl.c memset(key, 0, keylen);
key 5027 ext/openssl/openssl.c memcpy(key, password, password_len);
key 5029 ext/openssl/openssl.c key = (unsigned char*)password;
key 5041 ext/openssl/openssl.c EVP_DecryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key 5055 ext/openssl/openssl.c if (key != (unsigned char*)password) {
key 5056 ext/openssl/openssl.c efree(key);
key 5099 ext/openssl/openssl.c zval *key;
key 5107 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr", &pub_str, &pub_len, &key) == FAILURE) {
key 5110 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
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 1375 ext/pdo/pdo_dbh.c if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len, key TSRMLS_CC)) == NULL) {
key 2238 ext/pdo/pdo_stmt.c std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key 2251 ext/pdo/pdo_stmt.c std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key 2454 ext/pdo/pdo_stmt.c ulong key;
key 2497 ext/pdo/pdo_stmt.c if (I->key == (ulong)-1) {
key 2498 ext/pdo/pdo_stmt.c ZVAL_NULL(key);
key 2500 ext/pdo/pdo_stmt.c ZVAL_LONG(key, I->key);
key 2520 ext/pdo/pdo_stmt.c I->key = (ulong)-1;
key 2527 ext/pdo/pdo_stmt.c I->key++;
key 2558 ext/pdo/pdo_stmt.c I->key = (ulong)-1;
key 2602 ext/pdo/pdo_stmt.c return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key 317 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 97 ext/phar/dirstream.c phar_zstr key;
key 106 ext/phar/dirstream.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(data, &key, &keylen, &unused, 0, NULL)) {
key 110 ext/phar/dirstream.c PHAR_STR(key, str_key);
key 192 ext/phar/dirstream.c phar_zstr key;
key 210 ext/phar/dirstream.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(manifest, &key, &keylen, &unused, 0, NULL)) {
key 214 ext/phar/dirstream.c PHAR_STR(key, str_key);
key 323 ext/phar/dirstream.c phar_zstr key;
key 404 ext/phar/dirstream.c &phar->manifest, &key, &keylen, &unused, 0, NULL)) {
key 405 ext/phar/dirstream.c PHAR_STR(key, str_key);
key 571 ext/phar/dirstream.c phar_zstr key;
key 636 ext/phar/dirstream.c HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->manifest, &key, &key_len, &unused, 0, NULL);
key 639 ext/phar/dirstream.c PHAR_STR(key, str_key);
key 657 ext/phar/dirstream.c HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->virtual_dirs, &key, &key_len, &unused, 0, NULL);
key 660 ext/phar/dirstream.c PHAR_STR(key, str_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 1955 ext/phar/phar.c phar_zstr key;
key 1963 ext/phar/phar.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(&(PHAR_GLOBALS->phar_fname_map), &key, &keylen, &unused, 0, NULL)) {
key 1967 ext/phar/phar.c PHAR_STR(key, str_key);
key 1993 ext/phar/phar.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(&cached_phars, &key, &keylen, &unused, 0, NULL)) {
key 1997 ext/phar/phar.c PHAR_STR(key, str_key);
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 3032 ext/phar/phar_object.c char *error, *key = NULL;
key 3043 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 3064 ext/phar/phar_object.c PHAR_G(openssl_privatekey) = key;
key 630 ext/phar/stream.c phar_zstr key;
key 638 ext/phar/stream.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &keylen, &unused, 0, &pos)) {
key 641 ext/phar/stream.c PHAR_STR(key, str_key);
key 913 ext/phar/stream.c phar_zstr key, new_key;
key 921 ext/phar/stream.c HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->manifest, &key, &key_len, &unused, 0, NULL)) &&
key 925 ext/phar/stream.c PHAR_STR(key, str_key);
key 951 ext/phar/stream.c HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->virtual_dirs, &key, &key_len, &unused, 0, NULL));
key 954 ext/phar/stream.c PHAR_STR(key, str_key);
key 974 ext/phar/stream.c HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &key_len, &unused, 0, NULL)) &&
key 978 ext/phar/stream.c PHAR_STR(key, str_key);
key 1302 ext/phar/util.c phar_zstr key;
key 1309 ext/phar/util.c if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &keylen, &unused, 0, NULL)) {
key 1313 ext/phar/util.c PHAR_STR(key, str_key);
key 1421 ext/phar/util.c ZVAL_STRINGL(zkey, key, key_len, 1);
key 1534 ext/phar/util.c EVP_PKEY *key;
key 1602 ext/phar/util.c key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key 1606 ext/phar/util.c if (NULL == key) {
key 1633 ext/phar/util.c if (EVP_VerifyFinal(&md_ctx, (unsigned char *)sig, sig_len, key) != 1) {
key 1859 ext/phar/util.c EVP_PKEY *key;
key 1871 ext/phar/util.c key = PEM_read_bio_PrivateKey(in, NULL,NULL, "");
key 1874 ext/phar/util.c if (!key) {
key 1883 ext/phar/util.c siglen = EVP_PKEY_size(key);
key 1904 ext/phar/util.c if (!EVP_SignFinal (md_ctx, sigbuf,(unsigned int *)&siglen, key)) {
key 437 ext/reflection/php_reflection.c char *key;
key 444 ext/reflection/php_reflection.c zend_hash_get_current_key_ex(&ce->constants_table, &key, &key_len, &num_index, 0, &pos);
key 446 ext/reflection/php_reflection.c _const_string(str, key, *value, indent TSRMLS_CC);
key 607 ext/reflection/php_reflection.c char *key;
key 615 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 616 ext/reflection/php_reflection.c || zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0)
key 792 ext/reflection/php_reflection.c char *key;
key 813 ext/reflection/php_reflection.c zend_hash_get_current_key_ex(static_variables, &key, &key_len, &num_index, 0, &pos);
key 814 ext/reflection/php_reflection.c string_printf(str, "%s Variable #%d [ $%s ]\n", indent, i++, key);
key 3354 ext/reflection/php_reflection.c char *key;
key 3360 ext/reflection/php_reflection.c zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key 3394 ext/reflection/php_reflection.c add_assoc_zval(return_value, key, prop_copy);
key 6094 ext/reflection/php_reflection.c zend_std_obj_handlers->write_property(object, member, value, key TSRMLS_CC);
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 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 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 406 ext/session/mod_files.c ps_files_open(data, key TSRMLS_CC);
key 441 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 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 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 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 255 ext/session/php_session.h char *key; \
key 265 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 272 ext/session/php_session.h if (php_get_session_var(key, key_length, &struc TSRMLS_CC) == SUCCESS) { \
key 445 ext/session/session.c for (p = key; (c = *p); p++) {
key 457 ext/session/session.c len = p - key;
key 893 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 898 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 974 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 975 ext/session/session.c if (memchr(key, PS_DELIMITER, key_length) || memchr(key, PS_UNDEF_MARKER, key_length)) {
key 985 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 2551 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 2588 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 2598 ext/session/session.c zend_hash_del(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1);
key 2630 ext/session/session.c if (Z_TYPE(progress->sid) && progress->key.c) {
key 2649 ext/session/session.c smart_str_free(&progress->key);
key 2650 ext/session/session.c smart_str_appendl(&progress->key, PS(rfc1867_prefix).c, PS(rfc1867_prefix).len);
key 2651 ext/session/session.c smart_str_appendl(&progress->key, *data->value, value_len);
key 2652 ext/session/session.c smart_str_0(&progress->key);
key 2665 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2727 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2740 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2758 ext/session/session.c if (Z_TYPE(progress->sid) && progress->key.c) {
key 2773 ext/session/session.c smart_str_free(&progress->key);
key 44 ext/shmop/php_shmop.h key_t 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 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 180 ext/simplexml/sxe.c PHP_ME(ce_SimpleXMLIterator, key, arginfo_simplexmliterator__void, ZEND_ACC_PUBLIC)
key 2008 ext/snmp/snmp.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 2047 ext/snmp/snmp.c std_hnd->write_property(object, member, value, key TSRMLS_CC);
key 2069 ext/snmp/snmp.c zval *value = php_snmp_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key 2079 ext/snmp/snmp.c zval *value = php_snmp_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
key 2092 ext/snmp/snmp.c ret = std_hnd->has_property(object, member, has_set_exists, key TSRMLS_CC);
key 2106 ext/snmp/snmp.c char *key;
key 2117 ext/snmp/snmp.c zend_hash_get_current_key_ex(&php_snmp_properties, &key, &key_len, &num_key, 0, &pos);
key 2122 ext/snmp/snmp.c zend_hash_update(props, key, key_len, (void *)&val, sizeof(zval *), NULL);
key 2351 ext/soap/php_encoding.c zval key;
key 2352 ext/soap/php_encoding.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 2356 ext/soap/php_encoding.c array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val);
key 2358 ext/soap/php_encoding.c zval_dtor(&key);
key 2794 ext/soap/php_encoding.c xmlNodePtr key;
key 2802 ext/soap/php_encoding.c key = xmlNewNode(NULL, BAD_CAST("key"));
key 2803 ext/soap/php_encoding.c xmlAddChild(item,key);
key 2806 ext/soap/php_encoding.c set_xsi_type(key, "xsd:string");
key 2808 ext/soap/php_encoding.c xmlNodeSetContent(key, BAD_CAST(key_val));
key 2815 ext/soap/php_encoding.c set_xsi_type(key, "xsd:int");
key 2817 ext/soap/php_encoding.c xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len);
key 2837 ext/soap/php_encoding.c zval *ret, *key, *value;
key 2859 ext/soap/php_encoding.c key = master_to_zval(NULL, xmlKey TSRMLS_CC);
key 2862 ext/soap/php_encoding.c if (Z_TYPE_P(key) == IS_STRING) {
key 2863 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 2864 ext/soap/php_encoding.c } else if (Z_TYPE_P(key) == IS_LONG) {
key 2865 ext/soap/php_encoding.c zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key 2869 ext/soap/php_encoding.c zval_ptr_dtor(&key);
key 815 ext/soap/php_http.c char *key;
key 825 ext/soap/php_http.c int res = zend_hash_get_current_key(Z_ARRVAL_PP(cookies), &key, &numindx, FALSE);
key 841 ext/soap/php_http.c smart_str_appendl(&soap_headers, key, strlen(key));
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 1802 ext/soap/php_sdl.c char *key;
key 1806 ext/soap/php_sdl.c if (zend_hash_get_current_key_ex(ht, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key 1808 ext/soap/php_sdl.c WSDL_CACHE_PUT_N(key, key_len, out);
key 2446 ext/soap/php_sdl.c char *key;
key 2482 ext/soap/php_sdl.c if (zend_hash_get_current_key_ex(headers, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key 2483 ext/soap/php_sdl.c zend_hash_add(pheaders, key, key_len, (void*)&pheader, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL);
key 2514 ext/soap/php_sdl.c char *key;
key 2543 ext/soap/php_sdl.c if (zend_hash_get_current_key_ex(params, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key 2544 ext/soap/php_sdl.c zend_hash_add(pparams, key, key_len, (void*)&pparam, sizeof(sdlParamPtr), NULL);
key 2561 ext/soap/php_sdl.c char *key;
key 2592 ext/soap/php_sdl.c if (zend_hash_get_current_key_ex(faults, &key, &key_len, &index, 0, NULL) == HASH_KEY_IS_STRING) {
key 2593 ext/soap/php_sdl.c zend_hash_add(pfaults, key, key_len, (void*)&pfault, sizeof(sdlParamPtr), NULL);
key 2610 ext/soap/php_sdl.c char *key;
key 2647 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 2658 ext/soap/php_sdl.c zend_hash_add(pattr->extraAttributes, key, key_len, (void*)&pextra, sizeof(sdlExtraAttributePtr), NULL);
key 2722 ext/soap/php_sdl.c char *key;
key 2809 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 2810 ext/soap/php_sdl.c zend_hash_add(ptype->elements, key, key_len, (void*)&pelem, sizeof(sdlTypePtr), NULL);
key 2828 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 2829 ext/soap/php_sdl.c zend_hash_add(ptype->attributes, key, key_len, (void*)&pattr, sizeof(sdlAttributePtr), NULL);
key 2956 ext/soap/php_sdl.c char *key;
key 2983 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 2984 ext/soap/php_sdl.c zend_hash_add(psdl->groups, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key 3003 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 3004 ext/soap/php_sdl.c zend_hash_add(psdl->types, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key 3023 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 3024 ext/soap/php_sdl.c zend_hash_add(psdl->elements, key, key_len, (void*)&ptype, sizeof(sdlTypePtr), NULL);
key 3043 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 3044 ext/soap/php_sdl.c zend_hash_add(psdl->encoders, key, key_len, (void*)&penc, sizeof(encodePtr), NULL);
key 3090 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 3091 ext/soap/php_sdl.c zend_hash_add(psdl->bindings, key, key_len, (void*)&pbind, sizeof(sdlBindingPtr), NULL);
key 3108 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 3109 ext/soap/php_sdl.c zend_hash_add(&psdl->functions, key, key_len, (void*)&pfunc, sizeof(sdlFunctionPtr), NULL);
key 3131 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 3132 ext/soap/php_sdl.c zend_hash_add(psdl->requests, key, key_len, (void*)&preq, sizeof(sdlFunctionPtr), NULL);
key 3198 ext/soap/php_sdl.c char* key = NULL;
key 3240 ext/soap/php_sdl.c key = emalloc(len+sizeof("/wsdl-")-1+user_len+sizeof(md5str));
key 3241 ext/soap/php_sdl.c memcpy(key,SOAP_GLOBAL(cache_dir),len);
key 3242 ext/soap/php_sdl.c memcpy(key+len,"/wsdl-",sizeof("/wsdl-")-1);
key 3245 ext/soap/php_sdl.c memcpy(key+len, user, user_len-1);
key 3247 ext/soap/php_sdl.c key[len++] = '-';
key 3249 ext/soap/php_sdl.c memcpy(key+len,md5str,sizeof(md5str));
key 3251 ext/soap/php_sdl.c if ((sdl = get_sdl_from_cache(key, uri, t-SOAP_GLOBAL(cache_ttl), &cached TSRMLS_CC)) != NULL) {
key 3253 ext/soap/php_sdl.c efree(key);
key 3357 ext/soap/php_sdl.c if ((cache_wsdl & WSDL_CACHE_DISK) && key) {
key 3359 ext/soap/php_sdl.c add_sdl_to_cache(key, uri, t, sdl TSRMLS_CC);
key 3361 ext/soap/php_sdl.c efree(key);
key 3379 ext/soap/php_sdl.c char *key = NULL;
key 3388 ext/soap/php_sdl.c zend_hash_get_current_key_ex(SOAP_GLOBAL(mem_cache), &key, &key_len, &idx, 0, &pos);
key 3391 ext/soap/php_sdl.c if (key) {
key 3392 ext/soap/php_sdl.c zend_hash_del(SOAP_GLOBAL(mem_cache), key, key_len);
key 1421 ext/soap/soap.c char *key;
key 1431 ext/soap/soap.c key = emalloc(key_len + 1);
key 1432 ext/soap/soap.c zend_str_tolower_copy(key, Z_STRVAL_PP(tmp_function), key_len);
key 1434 ext/soap/soap.c if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key 1441 ext/soap/soap.c zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key 1443 ext/soap/soap.c efree(key);
key 1448 ext/soap/soap.c char *key;
key 1453 ext/soap/soap.c key = emalloc(key_len + 1);
key 1454 ext/soap/soap.c zend_str_tolower_copy(key, Z_STRVAL_P(function_name), key_len);
key 1456 ext/soap/soap.c if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key 1468 ext/soap/soap.c zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key 1469 ext/soap/soap.c efree(key);
key 3662 ext/soap/soap.c smart_str key = {0};
key 3665 ext/soap/soap.c smart_str_appends(&key, (char*)hdr_func->ns->href);
key 3666 ext/soap/soap.c smart_str_appendc(&key, ':');
key 3668 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL(h->function_name), Z_STRLEN(h->function_name));
key 3669 ext/soap/soap.c smart_str_0(&key);
key 3670 ext/soap/soap.c if (zend_hash_find(fnb->input.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 3673 ext/soap/soap.c smart_str_free(&key);
key 3910 ext/soap/soap.c smart_str key = {0};
key 3914 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 3915 ext/soap/soap.c smart_str_appendc(&key, ':');
key 3920 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 3923 ext/soap/soap.c smart_str_0(&key);
key 3925 ext/soap/soap.c zend_hash_find(headers->hdr->headerfaults, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 3929 ext/soap/soap.c smart_str_free(&key);
key 4132 ext/soap/soap.c smart_str key = {0};
key 4137 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 4138 ext/soap/soap.c smart_str_appendc(&key, ':');
key 4143 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 4146 ext/soap/soap.c smart_str_0(&key);
key 4151 ext/soap/soap.c zend_hash_find(fnb->output.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 4156 ext/soap/soap.c smart_str_free(&key);
key 4365 ext/soap/soap.c smart_str key = {0};
key 4368 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(ns), Z_STRLEN_PP(ns));
key 4369 ext/soap/soap.c smart_str_appendc(&key, ':');
key 4370 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
key 4371 ext/soap/soap.c smart_str_0(&key);
key 4372 ext/soap/soap.c if (zend_hash_find(hdrs, key.c, key.len+1,(void**)&hdr) == SUCCESS) {
key 4379 ext/soap/soap.c smart_str_free(&key);
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 119 ext/sockets/multicast.c if (zend_hash_find(ht, key, strlen(key) + 1, (void **)&val) == FAILURE) {
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 84 ext/spl/examples/class_tree.php $result = parent::key();
key 44 ext/spl/examples/nocvsdir.php return new NoCvsDirectory($this->key());
key 750 ext/spl/php_spl.c char *key;
key 753 ext/spl/php_spl.c zend_hash_get_current_key_ex(SPL_G(autoload_functions), &key, &len, &dummy, 0, &function_pos);
key 754 ext/spl/php_spl.c add_next_index_stringl(return_value, key, len - 1, 1);
key 839 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 842 ext/spl/spl_array.c return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key 850 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 854 ext/spl/spl_array.c std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key 862 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 865 ext/spl/spl_array.c return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 873 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 876 ext/spl/spl_array.c return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
key 884 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 889 ext/spl/spl_array.c std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key 1035 ext/spl/spl_array.c zend_user_it_get_current_key(iter, key TSRMLS_CC);
key 1038 ext/spl/spl_array.c ZVAL_NULL(key);
key 1040 ext/spl/spl_array.c zend_hash_get_current_key_zval_ex(aht, key, &object->pos);
key 1931 ext/spl/spl_array.c SPL_ME(Array, key, arginfo_array_void, ZEND_ACC_PUBLIC)
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 1714 ext/spl/spl_directory.c ZVAL_LONG(key, object->u.dir.index);
key 1793 ext/spl/spl_directory.c ZVAL_STRING(key, object->u.dir.entry.d_name, 1);
key 1796 ext/spl/spl_directory.c ZVAL_STRINGL(key, object->file_name, object->file_name_len, 1);
key 2004 ext/spl/spl_directory.c SPL_ME(DirectoryIterator, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key 2029 ext/spl/spl_directory.c SPL_ME(FilesystemIterator, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key 3019 ext/spl/spl_directory.c SPL_ME(SplFileObject, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
key 1033 ext/spl/spl_dllist.c ZVAL_LONG(key, iterator->traverse_position);
key 1389 ext/spl/spl_dllist.c SPL_ME(SplDoublyLinkedList, key, arginfo_dllist_void, ZEND_ACC_PUBLIC)
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 1131 ext/spl/spl_fixedarray.c SPL_ME(SplFixedArray, key, arginfo_splfixedarray_void, ZEND_ACC_PUBLIC)
key 957 ext/spl/spl_heap.c ZVAL_LONG(key, iterator->object->heap->count - 1);
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 200 ext/spl/spl_iterators.c sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC);
key 202 ext/spl/spl_iterators.c ZVAL_LONG(key, iter->index);
key 844 ext/spl/spl_iterators.c function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 849 ext/spl/spl_iterators.c function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 959 ext/spl/spl_iterators.c SPL_ME(RecursiveIteratorIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 1181 ext/spl/spl_iterators.c zval prefix, key, postfix, key_copy;
key 1190 ext/spl/spl_iterators.c iterator->funcs->get_current_key(iterator, &key TSRMLS_CC);
key 1192 ext/spl/spl_iterators.c ZVAL_NULL(&key);
key 1196 ext/spl/spl_iterators.c zval *key_ptr = &key;
key 1198 ext/spl/spl_iterators.c zval_dtor(&key);
key 1202 ext/spl/spl_iterators.c if (Z_TYPE(key) != IS_STRING) {
key 1204 ext/spl/spl_iterators.c zend_make_printable_zval(&key, &key_copy, &use_copy);
key 1206 ext/spl/spl_iterators.c key = key_copy;
key 1213 ext/spl/spl_iterators.c str_len = Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix);
key 1219 ext/spl/spl_iterators.c memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key));
key 1220 ext/spl/spl_iterators.c ptr += Z_STRLEN(key);
key 1226 ext/spl/spl_iterators.c zval_dtor(&key);
key 1248 ext/spl/spl_iterators.c SPL_ME(RecursiveTreeIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 1289 ext/spl/spl_iterators.c function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 1294 ext/spl/spl_iterators.c function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 1597 ext/spl/spl_iterators.c if (intern->current.key) {
key 1598 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 1599 ext/spl/spl_iterators.c intern->current.key = NULL;
key 1643 ext/spl/spl_iterators.c MAKE_STD_ZVAL(intern->current.key);
key 1645 ext/spl/spl_iterators.c intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, intern->current.key TSRMLS_CC);
key 1647 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 1648 ext/spl/spl_iterators.c intern->current.key = NULL;
key 1651 ext/spl/spl_iterators.c ZVAL_LONG(intern->current.key, intern->current.pos);
key 1723 ext/spl/spl_iterators.c if (intern->current.key) {
key 1724 ext/spl/spl_iterators.c RETURN_ZVAL(intern->current.key, 1, 0);
key 1941 ext/spl/spl_iterators.c if (intern->current.data == NULL || intern->current.key == NULL) {
key 1946 ext/spl/spl_iterators.c params[1] = &intern->current.key;
key 1987 ext/spl/spl_iterators.c subject_ptr = intern->current.key;
key 2045 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 2046 ext/spl/spl_iterators.c MAKE_STD_ZVAL(intern->current.key);
key 2047 ext/spl/spl_iterators.c ZVAL_STRINGL(intern->current.key, result, result_len, 0);
key 2360 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 2601 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 2627 ext/spl/spl_iterators.c zval *key = intern->current.key;
key 2632 ext/spl/spl_iterators.c array_set_zval_key(HASH_OF(intern->u.caching.zcache), key, zcacheval);
key 2792 ext/spl/spl_iterators.c MAKE_COPY_ZVAL(&intern->current.key, return_value);
key 3020 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3105 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3202 ext/spl/spl_iterators.c SPL_ME(NoRewindIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3296 ext/spl/spl_iterators.c SPL_ME(EmptyIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3471 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3533 ext/spl/spl_iterators.c zval key;
key 3534 ext/spl/spl_iterators.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 3538 ext/spl/spl_iterators.c array_set_zval_key(Z_ARRVAL_P(return_value), &key, *data);
key 3539 ext/spl/spl_iterators.c zval_dtor(&key);
key 136 ext/spl/spl_iterators.h zval *key;
key 965 ext/spl/spl_observer.c SPL_ME(SplObjectStorage, key, arginfo_splobject_void,0)
key 1289 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 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 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 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 1045 ext/standard/array.c *key=NULL; /* Entry key */
key 1048 ext/standard/array.c args[1] = &key;
key 1090 ext/standard/array.c MAKE_STD_ZVAL(key);
key 1091 ext/standard/array.c zend_hash_get_current_key_zval(target_hash, key);
key 1099 ext/standard/array.c if (key) {
key 1100 ext/standard/array.c zval_ptr_dtor(&key);
key 1101 ext/standard/array.c key = NULL;
key 1107 ext/standard/array.c if (key) {
key 1108 ext/standard/array.c zval_ptr_dtor(&key);
key 1109 ext/standard/array.c key = NULL;
key 1565 ext/standard/array.c zval key, *key_ptr = *entry;
key 1568 ext/standard/array.c key = **entry;
key 1569 ext/standard/array.c zval_copy_ctor(&key);
key 1570 ext/standard/array.c convert_to_string(&key);
key 1571 ext/standard/array.c key_ptr = &key;
key 1578 ext/standard/array.c zval_dtor(&key);
key 1939 ext/standard/array.c char *key = NULL;
key 1961 ext/standard/array.c zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &key_len, &index, 0, NULL);
key 1962 ext/standard/array.c if (key && Z_ARRVAL_P(stack) == &EG(symbol_table)) {
key 1963 ext/standard/array.c zend_delete_global_variable(key, key_len - 1 TSRMLS_CC);
key 1965 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 4406 ext/standard/array.c zval *key; /* key to check for */
key 4409 ext/standard/array.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zH", &key, &array) == FAILURE) {
key 4413 ext/standard/array.c switch (Z_TYPE_P(key)) {
key 4415 ext/standard/array.c if (zend_symtable_exists(array, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1)) {
key 4420 ext/standard/array.c if (zend_hash_index_exists(array, Z_LVAL_P(key))) {
key 4547 ext/standard/array.c zval key, *key_ptr = *entry_keys;
key 4550 ext/standard/array.c key = **entry_keys;
key 4551 ext/standard/array.c zval_copy_ctor(&key);
key 4552 ext/standard/array.c convert_to_string(&key);
key 4553 ext/standard/array.c key_ptr = &key;
key 4560 ext/standard/array.c zval_dtor(&key);
key 3308 ext/standard/basic_functions.c PHP_FE(key, arginfo_key)
key 3429 ext/standard/basic_functions.c SetEnvironmentVariable(pe->key, "bugbug");
key 3437 ext/standard/basic_functions.c unsetenv(pe->key);
key 3439 ext/standard/basic_functions.c SetEnvironmentVariable(pe->key, NULL);
key 3441 ext/standard/basic_functions.c _putenv_s(pe->key, "");
key 3447 ext/standard/basic_functions.c if (!strncmp(*env, pe->key, pe->key_len) && (*env)[pe->key_len] == '=') { /* found it */
key 3457 ext/standard/basic_functions.c if (!strncmp(pe->key, "TZ", pe->key_len)) {
key 3463 ext/standard/basic_functions.c efree(pe->key);
key 4097 ext/standard/basic_functions.c pe.key = estrndup(setting, setting_len);
key 4098 ext/standard/basic_functions.c if ((p = strchr(pe.key, '='))) { /* nullify the '=' if there is one */
key 4105 ext/standard/basic_functions.c pe.key_len = strlen(pe.key);
key 4117 ext/standard/basic_functions.c zend_hash_del(&BG(putenv_ht), pe.key, pe.key_len+1);
key 4122 ext/standard/basic_functions.c if (!strncmp(*env, pe.key, pe.key_len) && (*env)[pe.key_len] == '=') { /* found it */
key 4142 ext/standard/basic_functions.c error_code = SetEnvironmentVariable(pe.key, value);
key 4151 ext/standard/basic_functions.c && _putenv_s(pe.key, value ? value : "") == 0
key 4156 ext/standard/basic_functions.c zend_hash_add(&BG(putenv_ht), pe.key, pe.key_len + 1, (void **) &pe, sizeof(putenv_entry), NULL);
key 4158 ext/standard/basic_functions.c if (!strncmp(pe.key, "TZ", pe.key_len)) {
key 4165 ext/standard/basic_functions.c efree(pe.key);
key 5903 ext/standard/basic_functions.c ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1));
key 5904 ext/standard/basic_functions.c if (zend_hash_index_find(Z_ARRVAL_P(arr), key, (void **) &find_hash) == FAILURE) {
key 5909 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 551 ext/standard/crypt_blowfish.c const char *ptr = key;
key 611 ext/standard/crypt_blowfish.c ptr = key;
key 700 ext/standard/crypt_blowfish.c BF_set_key(key, data.expanded_key, data.ctx.P,
key 840 ext/standard/crypt_blowfish.c retval = BF_crypt(key, setting, output, size, 16);
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 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 741 ext/standard/crypt_freesec.c return _crypt_extended_r(key, setting, &data);
key 390 ext/standard/crypt_sha256.c key_len = strlen(key);
key 392 ext/standard/crypt_sha256.c if ((key - (char *) 0) % __alignof__ (uint32_t) != 0) {
key 394 ext/standard/crypt_sha256.c key = copied_key = memcpy(tmp + __alignof__(uint32_t) - (tmp - (char *) 0) % __alignof__(uint32_t), key, key_len);
key 408 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &ctx);
key 421 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 427 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 445 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &ctx);
key 457 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 622 ext/standard/crypt_sha256.c return php_sha256_crypt_r(key, salt, buffer, buflen);
key 424 ext/standard/crypt_sha512.c key_len = strlen(key);
key 426 ext/standard/crypt_sha512.c if ((key - (char *) 0) % __alignof__ (uint64_t) != 0) {
key 428 ext/standard/crypt_sha512.c key = copied_key =
key 429 ext/standard/crypt_sha512.c memcpy(tmp + __alignof__(uint64_t) - (tmp - (char *) 0) % __alignof__(uint64_t), key, key_len);
key 442 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &ctx);
key 455 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 461 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 479 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &ctx);
key 491 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 668 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 1542 ext/standard/html.c char key[9] = ""; /* two unicode code points in UTF-8 */
key 1546 ext/standard/html.c written_k1 = write_octet_sequence(key, charset, orig_cp);
key 1552 ext/standard/html.c add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key 1562 ext/standard/html.c add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key 1581 ext/standard/html.c written_k2 = write_octet_sequence(&key[written_k1], charset, spe_cp);
key 1585 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 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 301 ext/standard/iptc.c unsigned char *buffer, recnum, dataset, key[ 16 ];
key 347 ext/standard/iptc.c snprintf(key, sizeof(key), "%d#%03d", (unsigned int) dataset, (unsigned int) recnum);
key 353 ext/standard/iptc.c if (zend_hash_find(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void **) &element) == FAILURE) {
key 357 ext/standard/iptc.c zend_hash_update(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void *) &values, sizeof(zval*), (void **) &element);
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 664 ext/standard/streamsfuncs.c char *key;
key 674 ext/standard/streamsfuncs.c &key, &key_len, &num_ind, 0, NULL);
key 697 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 852 ext/standard/var.c char *key;
key 860 ext/standard/var.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 864 ext/standard/var.c if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
key 873 ext/standard/var.c php_var_serialize_string(buf, key, key_len - 1);
key 300 ext/standard/var_unserializer.c zval *key, *data, **old_data;
key 302 ext/standard/var_unserializer.c ALLOC_INIT_ZVAL(key);
key 304 ext/standard/var_unserializer.c if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
key 305 ext/standard/var_unserializer.c zval_dtor(key);
key 306 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 310 ext/standard/var_unserializer.c if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
key 311 ext/standard/var_unserializer.c zval_dtor(key);
key 312 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 319 ext/standard/var_unserializer.c zval_dtor(key);
key 320 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 326 ext/standard/var_unserializer.c switch (Z_TYPE_P(key)) {
key 328 ext/standard/var_unserializer.c if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
key 331 ext/standard/var_unserializer.c zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
key 334 ext/standard/var_unserializer.c if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key 337 ext/standard/var_unserializer.c zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
key 342 ext/standard/var_unserializer.c convert_to_string(key);
key 343 ext/standard/var_unserializer.c if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key 346 ext/standard/var_unserializer.c zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,
key 351 ext/standard/var_unserializer.c zval_dtor(key);
key 352 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 54 ext/sysvmsg/php_sysvmsg.h key_t 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 190 ext/sysvsem/sysvsem.c long key, max_acquire = 1, perm = 0666, auto_release = 1;
key 196 ext/sysvsem/sysvsem.c if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|lll", &key, &max_acquire, &perm, &auto_release)) {
key 206 ext/sysvsem/sysvsem.c semid = semget(key, 3, perm|IPC_CREAT);
key 208 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 240 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 248 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 259 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 264 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 269 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 281 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 287 ext/sysvsem/sysvsem.c sem_ptr->key = key;
key 311 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 321 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 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 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 400 ext/sysvshm/sysvshm.c if (shm_var->key == key) {
key 275 ext/wddx/wddx.c php_wddx_serialize_var(packet, *struc, key, key_length TSRMLS_CC);
key 297 ext/wddx/wddx.c char *key;
key 315 ext/wddx/wddx.c hash_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(retval), &key, &key_length, &idx, 0, NULL);
key 320 ext/wddx/wddx.c key = tmp;
key 323 ext/wddx/wddx.c php_set_session_var(key, key_length-1, *ent, NULL TSRMLS_CC);
key 324 ext/wddx/wddx.c PS_ADD_VAR(key);
key 460 ext/wddx/wddx.c const char *key;
key 531 ext/wddx/wddx.c if (zend_hash_get_current_key_ex(objhash, &key, &key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
key 534 ext/wddx/wddx.c zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
key 558 ext/wddx/wddx.c char *key;
key 574 ext/wddx/wddx.c type = zend_hash_get_current_key(target_hash, &key, &idx, 0);
key 604 ext/wddx/wddx.c ent_type = zend_hash_get_current_key_ex(target_hash, &key, &key_len, &idx, 0, NULL);
key 607 ext/wddx/wddx.c php_wddx_serialize_var(packet, *ent, key, key_len TSRMLS_CC);
key 851 ext/wddx/wddx.c char *key;
key 857 ext/wddx/wddx.c key = estrndup(p1, p2 - p1);
key 860 ext/wddx/wddx.c add_assoc_zval_ex(ent.data, key, p2 - p1 + 1, tmp);
key 862 ext/wddx/wddx.c efree(key);
key 139 ext/xmlreader/php_xmlreader.c retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 182 ext/xmlreader/php_xmlreader.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 218 ext/xmlreader/php_xmlreader.c std_hnd->write_property(object, member, value, key TSRMLS_CC);
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 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 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 533 ext/xmlrpc/xmlrpc-epi-php.c XMLRPC_SetValueID(xReturn, key, 0);
key 535 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
key 540 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL_P(val));
key 544 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
key 548 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueInt(key, Z_LVAL_P(val));
key 552 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL_P(val));
key 556 ext/xmlrpc/xmlrpc-epi-php.c xReturn = XMLRPC_CreateValueString(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
key 578 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 93 ext/zip/lib/zip_source_pkware.c ctx->key[0] = KEY0;
key 94 ext/zip/lib/zip_source_pkware.c ctx->key[1] = KEY1;
key 95 ext/zip/lib/zip_source_pkware.c ctx->key[2] = KEY2;
key 121 ext/zip/lib/zip_source_pkware.c tmp = ctx->key[2] | 2;
key 131 ext/zip/lib/zip_source_pkware.c ctx->key[0] = CRC32(ctx->key[0], b);
key 132 ext/zip/lib/zip_source_pkware.c ctx->key[1] = (ctx->key[1] + (ctx->key[0] & 0xff)) * 134775813 + 1;
key 133 ext/zip/lib/zip_source_pkware.c b = ctx->key[1] >> 24;
key 134 ext/zip/lib/zip_source_pkware.c ctx->key[2] = CRC32(ctx->key[2], b);
key 887 ext/zip/php_zip.c key = NULL;
key 894 ext/zip/php_zip.c if (key) {
key 895 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 904 ext/zip/php_zip.c retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 928 ext/zip/php_zip.c key = NULL;
key 935 ext/zip/php_zip.c if (key) {
key 936 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 952 ext/zip/php_zip.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 975 ext/zip/php_zip.c key = NULL;
key 982 ext/zip/php_zip.c if (key) {
key 983 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 1008 ext/zip/php_zip.c retval = std_hnd->has_property(object, member, type, key TSRMLS_CC);
key 1025 ext/zip/php_zip.c char *key;
key 1039 ext/zip/php_zip.c zend_hash_get_current_key_ex(obj->prop_handler, &key, &key_len, &num_key, 0, &pos);
key 1045 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 228 main/rfc1867.c char *key;
key 372 main/rfc1867.c if (h->key) {
key 373 main/rfc1867.c efree(h->key);
key 404 main/rfc1867.c char *key = NULL;
key 428 main/rfc1867.c if(buf_value.c && key) {
key 431 main/rfc1867.c entry.key = key;
key 435 main/rfc1867.c key = NULL;
key 441 main/rfc1867.c key = estrdup(line);
key 449 main/rfc1867.c if(buf_value.c && key) {
key 452 main/rfc1867.c entry.key = key;
key 464 main/rfc1867.c if (key == NULL) {
key 470 main/rfc1867.c if (!strcasecmp(entry->key, key)) {
key 804 main/rfc1867.c char *key = NULL, *word = pair;
key 811 main/rfc1867.c key = getword(mbuff->input_encoding, &pair, '=' TSRMLS_CC);
key 813 main/rfc1867.c if (!strcasecmp(key, "name")) {
key 826 main/rfc1867.c } else if (!strcasecmp(key, "filename")) {
key 841 main/rfc1867.c if (key) {
key 842 main/rfc1867.c efree(key);
key 613 main/streams/memory.c char *comma, *semi, *sep, *key;
key 684 main/streams/memory.c key = estrndup(path, plen);
key 685 main/streams/memory.c add_assoc_stringl_ex(meta, key, plen + 1, sep + 1, vlen, 1);
key 686 main/streams/memory.c efree(key);
key 2219 run-tests.php reset($old1); $k1 = key($old1); $l1 = -2;
key 2220 run-tests.php reset($old2); $k2 = key($old2); $l2 = -2;
key 2227 run-tests.php $k1 = next($old1) ? key($old1) : null;
key 2231 run-tests.php $k2 = next($old2) ? key($old2) : null;
key 2235 run-tests.php $k1 = next($old1) ? key($old1) : null;
key 2239 run-tests.php $k2 = next($old2) ? key($old2) : null;
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 70 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 229 sapi/apache2filter/sapi_apache2.c char *key, *val;
key 232 sapi/apache2filter/sapi_apache2.c APR_ARRAY_FOREACH_OPEN(arr, key, val)
key 236 sapi/apache2filter/sapi_apache2.c if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len TSRMLS_CC)) {
key 237 sapi/apache2filter/sapi_apache2.c php_register_variable_safe(key, val, new_val_len, track_vars_array TSRMLS_CC);
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 484 sapi/cli/php_cli_server.c char *key;
key 500 sapi/cli/php_cli_server.c zend_hash_get_current_key_ex(headers, &key, &key_len, NULL, 0, &pos);
key 501 sapi/cli/php_cli_server.c add_assoc_string_ex(return_value, key, key_len, *value_pointer, 1);
key 716 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 717 sapi/cli/php_cli_server.c php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array TSRMLS_CC);
key 724 sapi/cli/php_cli_server.c char *real_key, *key;
key 726 sapi/cli/php_cli_server.c key = estrndup(hash_key->arKey, hash_key->nKeyLength);
key 728 sapi/cli/php_cli_server.c if (key[i] == '-') {
key 729 sapi/cli/php_cli_server.c key[i] = '_';
key 731 sapi/cli/php_cli_server.c key[i] = toupper(key[i]);
key 734 sapi/cli/php_cli_server.c spprintf(&real_key, 0, "%s_%s", "HTTP", key);
key 736 sapi/cli/php_cli_server.c efree(key);
key 552 sapi/fpm/fpm/fpm_conf.c kv->key = strdup(Z_STRVAL_P(key));
key 554 sapi/fpm/fpm/fpm_conf.c if (!kv->key) {
key 562 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 575 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 652 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 658 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 664 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 1066 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, *p)) {
key 1072 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, "error_log") && !strcasecmp(kv->value, "syslog")) {
key 1076 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, *p)) {
key 1395 sapi/fpm/fpm/fpm_conf.c if (!Z_STRVAL_P(key) || !Z_STRVAL_P(value) || !*Z_STRVAL_P(key)) {
key 1413 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1417 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1421 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1425 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 1);
key 1429 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 1);
key 1438 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 1613 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_NOTICE, "\tenv[%s] = %s", kv->key, kv->value);
key 1617 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_NOTICE, "\tphp_value[%s] = %s", kv->key, kv->value);
key 1621 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 1426 sapi/fpm/fpm/fpm_main.c char *key;
key 1437 sapi/fpm/fpm/fpm_main.c key = Z_STRVAL_P(arg1);
key 1439 sapi/fpm/fpm/fpm_main.c if (!key || strlen(key) < 1) {
key 1449 sapi/fpm/fpm/fpm_main.c zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: empty value for key '%s'", key);
key 1453 sapi/fpm/fpm/fpm_main.c kv.key = key;
key 1457 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 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 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 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 403 sapi/fpm/fpm/fpm_sockets.c unlink(ls->key);
key 405 sapi/fpm/fpm/fpm_sockets.c free(ls->key);
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) {