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 177 Zend/zend.c char key[25];
key 178 Zend/zend.c snprintf(key, sizeof(key), "%ld", num_key);
key 179 Zend/zend.c ZEND_PUTS_EX(key);
key 1231 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1242 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1253 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1264 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1275 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1286 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1297 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
key 1303 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
key 1480 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key 1491 Zend/zend_API.c return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
key 1543 Zend/zend_API.c switch (Z_TYPE_P(key)) {
key 1545 Zend/zend_API.c result = zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
key 1551 Zend/zend_API.c zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(key), Z_LVAL_P(key));
key 1555 Zend/zend_API.c result = zend_hash_index_update(ht, Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key 1558 Zend/zend_API.c result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), &value, sizeof(zval *), NULL);
key 1582 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1600 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1618 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1636 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1654 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1672 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1690 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 1704 Zend/zend_API.c ZVAL_STRINGL(z_key, key, key_len-1, 1);
key 530 Zend/zend_API.h #define add_method(arg, key, method) add_assoc_function((arg), (key), (method))
key 912 Zend/zend_builtin_functions.c char *key;
key 918 Zend/zend_builtin_functions.c zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key 953 Zend/zend_builtin_functions.c zend_hash_update(Z_ARRVAL_P(return_value), key, key_len, &prop_copy, sizeof(zval*), NULL);
key 991 Zend/zend_builtin_functions.c char *key;
key 1018 Zend/zend_builtin_functions.c if (zend_hash_get_current_key_ex(properties, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
key 1019 Zend/zend_builtin_functions.c if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
key 1020 Zend/zend_builtin_functions.c zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
key 1023 Zend/zend_builtin_functions.c if (IS_INTERNED(key) && prop_name != key) {
key 1041 Zend/zend_builtin_functions.c int ret = memcmp(lcname, key, name_len) == 0;
key 1086 Zend/zend_builtin_functions.c char *key;
key 1092 Zend/zend_builtin_functions.c if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING) {
key 1098 Zend/zend_builtin_functions.c zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0) {
key 1103 Zend/zend_builtin_functions.c !same_name(key, mptr->common.function_name, len))) {
key 1105 Zend/zend_builtin_functions.c ZVAL_STRINGL(method_name, zend_find_alias_name(mptr->common.scope, key, key_len - 1), key_len - 1, 1);
key 193 Zend/zend_closures.c return std_object_handlers.get_method(object_ptr, method_name, method_len, key TSRMLS_CC);
key 1711 Zend/zend_compile.c zval key;
key 1743 Zend/zend_compile.c build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC);
key 1744 Zend/zend_compile.c opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key 1750 Zend/zend_compile.c zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
key 2898 Zend/zend_compile.c if (key) {
key 2899 Zend/zend_compile.c SET_NODE(opline->op2, key);
key 3890 Zend/zend_compile.c do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
key 5128 Zend/zend_compile.c zval **ns_name, key;
key 5200 Zend/zend_compile.c build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);
key 5201 Zend/zend_compile.c opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
key 5221 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 6432 Zend/zend_compile.c if (key->op_type != IS_UNUSED) {
key 6436 Zend/zend_compile.c tmp = key;
key 6437 Zend/zend_compile.c key = value;
key 6444 Zend/zend_compile.c if ((key->op_type != IS_UNUSED)) {
key 6445 Zend/zend_compile.c if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
key 6448 Zend/zend_compile.c if (key->EA & ZEND_PARSED_LIST_EXPR) {
key 6497 Zend/zend_compile.c if (key->op_type != IS_UNUSED) {
key 6505 Zend/zend_compile.c zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
key 442 Zend/zend_constants.c if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
key 443 Zend/zend_constants.c key++;
key 444 Zend/zend_constants.c if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
key 447 Zend/zend_constants.c key++;
key 448 Zend/zend_constants.c if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
key 449 Zend/zend_constants.c key++;
key 450 Zend/zend_constants.c if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
key 453 Zend/zend_constants.c key--;
key 454 Zend/zend_constants.c if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key 460 Zend/zend_constants.c key--;
key 461 Zend/zend_constants.c if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
key 354 Zend/zend_exceptions.c if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \
key 356 Zend/zend_exceptions.c zend_error(E_WARNING, "Value for %s is no string", key); \
key 769 Zend/zend_execute.c Z_OBJ_HT_P(object)->write_property(object, property_name, value, key TSRMLS_CC);
key 1426 Zend/zend_execute.c zval **ptr_ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, key TSRMLS_CC);
key 1431 Zend/zend_execute.c (ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC)) != NULL) {
key 1442 Zend/zend_execute.c zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC);
key 918 Zend/zend_execute_API.c if (key) {
key 919 Zend/zend_execute_API.c lc_name = Z_STRVAL(key->constant);
key 920 Zend/zend_execute_API.c lc_length = Z_STRLEN(key->constant) + 1;
key 921 Zend/zend_execute_API.c hash = key->hash_value;
key 940 Zend/zend_execute_API.c if (!key) {
key 950 Zend/zend_execute_API.c if (!key) {
key 958 Zend/zend_execute_API.c if (!key) {
key 970 Zend/zend_execute_API.c if (!key) {
key 1021 Zend/zend_execute_API.c if (!key) {
key 1415 Zend/zend_execute_API.c if (zend_lookup_class_ex(class_name, class_name_len, key, use_autoload, &pce TSRMLS_CC) == FAILURE) {
key 106 Zend/zend_generators.c if (generator->key) {
key 107 Zend/zend_generators.c zval_ptr_dtor(&generator->key);
key 108 Zend/zend_generators.c generator->key = NULL;
key 249 Zend/zend_generators.c zend_hash_quick_update(target, key->arKey, key->nKeyLength, key->h, var, sizeof(zval *), NULL);
key 492 Zend/zend_generators.c if (generator->key) {
key 493 Zend/zend_generators.c RETURN_ZVAL_FAST(generator->key);
key 647 Zend/zend_generators.c if (generator->key) {
key 648 Zend/zend_generators.c ZVAL_ZVAL(key, generator->key, 1, 0);
key 650 Zend/zend_generators.c ZVAL_NULL(key);
key 727 Zend/zend_generators.c ZEND_ME(Generator, key, arginfo_generator_void, ZEND_ACC_PUBLIC)
key 50 Zend/zend_generators.h zval *key;
key 1103 Zend/zend_hash.c Z_TYPE_P(key) = IS_NULL;
key 1105 Zend/zend_hash.c Z_TYPE_P(key) = IS_STRING;
key 1106 Zend/zend_hash.c Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
key 1107 Zend/zend_hash.c Z_STRLEN_P(key) = p->nKeyLength - 1;
key 1109 Zend/zend_hash.c Z_TYPE_P(key) = IS_LONG;
key 1110 Zend/zend_hash.c Z_LVAL_P(key) = p->h;
key 204 Zend/zend_hash.h zend_hash_get_current_key_zval_ex(ht, key, NULL)
key 316 Zend/zend_hash.h register const char *tmp = key; \
key 322 Zend/zend_hash.h const char *end = key + length - 1; \
key 337 Zend/zend_hash.h if (*key == '-') { \
key 353 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 309 Zend/zend_object_handlers.c if (key && (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) != NULL) {
key 324 Zend/zend_object_handlers.c h = key ? key->hash_value : zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
key 341 Zend/zend_object_handlers.c if (key) {
key 342 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 357 Zend/zend_object_handlers.c if (key) {
key 358 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, scope_property_info);
key 370 Zend/zend_object_handlers.c if (key) {
key 371 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 473 Zend/zend_object_handlers.c key = NULL;
key 481 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, silent || (zobj->ce->__get != NULL), key TSRMLS_CC);
key 571 Zend/zend_object_handlers.c key = NULL;
key 574 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__set != NULL), key TSRMLS_CC);
key 763 Zend/zend_object_handlers.c key = NULL;
key 770 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__get != NULL), key TSRMLS_CC);
key 841 Zend/zend_object_handlers.c key = NULL;
key 844 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__unset != NULL), key TSRMLS_CC);
key 1046 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1047 Zend/zend_object_handlers.c lc_method_name = Z_STRVAL(key->constant);
key 1048 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1057 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1113 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1186 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1187 Zend/zend_object_handlers.c lc_function_name = Z_STRVAL(key->constant);
key 1188 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1208 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1260 Zend/zend_object_handlers.c if (UNEXPECTED(!key)) {
key 1273 Zend/zend_object_handlers.c if (UNEXPECTED(!key) ||
key 1274 Zend/zend_object_handlers.c (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {
key 1275 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1276 Zend/zend_object_handlers.c hash_value = key->hash_value;
key 1308 Zend/zend_object_handlers.c if (EXPECTED(key != NULL)) {
key 1309 Zend/zend_object_handlers.c CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
key 1446 Zend/zend_object_handlers.c key = NULL;
key 1453 Zend/zend_object_handlers.c property_info = zend_get_property_info_quick(zobj->ce, member, 1, key TSRMLS_CC);
key 210 Zend/zend_variables.c if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
key 214 Zend/zend_variables.c zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
key 217 Zend/zend_variables.c zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
key 236 Zend/zend_variables.c if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), NULL) == SUCCESS) {
key 640 Zend/zend_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key 642 Zend/zend_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len);
key 644 Zend/zend_virtual_cwd.c unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 648 Zend/zend_virtual_cwd.c if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key 689 Zend/zend_virtual_cwd.c bucket->key = realpath_cache_key(path, path_len TSRMLS_CC);
key 691 Zend/zend_virtual_cwd.c bucket->key = realpath_cache_key(path, path_len);
key 711 Zend/zend_virtual_cwd.c n = bucket->key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 722 Zend/zend_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC);
key 724 Zend/zend_virtual_cwd.c unsigned long key = realpath_cache_key(path, path_len);
key 727 Zend/zend_virtual_cwd.c unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
key 742 Zend/zend_virtual_cwd.c } else if (key == (*bucket)->key && path_len == (*bucket)->path_len &&
key 214 Zend/zend_virtual_cwd.h unsigned long key;
key 3322 Zend/zend_vm_def.h zval key;
key 3323 Zend/zend_vm_def.h iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 3328 Zend/zend_vm_def.h if (Z_TYPE(key) == IS_STRING) {
key 3331 Zend/zend_vm_def.h zval_dtor(&key);
key 3335 Zend/zend_vm_def.h zval_dtor(&key);
key 4462 Zend/zend_vm_def.h zval *key = NULL;
key 4464 Zend/zend_vm_def.h key = &EX_T((opline+1)->result.var).tmp_var;
key 4495 Zend/zend_vm_def.h if (key) {
key 4497 Zend/zend_vm_def.h ZVAL_LONG(key, int_key);
key 4504 Zend/zend_vm_def.h ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key 4519 Zend/zend_vm_def.h if (key) {
key 4520 Zend/zend_vm_def.h zend_hash_get_current_key_zval(fe_ht, key);
key 4555 Zend/zend_vm_def.h if (key) {
key 4557 Zend/zend_vm_def.h iter->funcs->get_current_key(iter, key TSRMLS_CC);
key 4563 Zend/zend_vm_def.h ZVAL_LONG(key, iter->index);
key 5488 Zend/zend_vm_def.h if (generator->key) {
key 5489 Zend/zend_vm_def.h zval_ptr_dtor(&generator->key);
key 5574 Zend/zend_vm_def.h zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
key 5578 Zend/zend_vm_def.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 5583 Zend/zend_vm_def.h INIT_PZVAL_COPY(copy, key);
key 5590 Zend/zend_vm_def.h generator->key = copy;
key 5592 Zend/zend_vm_def.h Z_ADDREF_P(key);
key 5593 Zend/zend_vm_def.h generator->key = key;
key 5596 Zend/zend_vm_def.h if (Z_TYPE_P(generator->key) == IS_LONG
key 5597 Zend/zend_vm_def.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 5599 Zend/zend_vm_def.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 5607 Zend/zend_vm_def.h ALLOC_INIT_ZVAL(generator->key);
key 5608 Zend/zend_vm_def.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 799 Zend/zend_vm_execute.h zval key;
key 800 Zend/zend_vm_execute.h iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 805 Zend/zend_vm_execute.h if (Z_TYPE(key) == IS_STRING) {
key 808 Zend/zend_vm_execute.h zval_dtor(&key);
key 812 Zend/zend_vm_execute.h zval_dtor(&key);
key 4368 Zend/zend_vm_execute.h if (generator->key) {
key 4369 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 4453 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 4457 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 4462 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 4469 Zend/zend_vm_execute.h generator->key = copy;
key 4471 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 4472 Zend/zend_vm_execute.h generator->key = key;
key 4475 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 4476 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 4478 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 4485 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 4486 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 5070 Zend/zend_vm_execute.h if (generator->key) {
key 5071 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 5155 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 5159 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 5164 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 5171 Zend/zend_vm_execute.h generator->key = copy;
key 5173 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 5174 Zend/zend_vm_execute.h generator->key = key;
key 5177 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 5178 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 5180 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 5187 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 5188 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 6097 Zend/zend_vm_execute.h if (generator->key) {
key 6098 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 6182 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 6186 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 6191 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 6198 Zend/zend_vm_execute.h generator->key = copy;
key 6200 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 6201 Zend/zend_vm_execute.h generator->key = key;
key 6204 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 6205 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 6207 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 6215 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 6216 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 6841 Zend/zend_vm_execute.h if (generator->key) {
key 6842 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 6926 Zend/zend_vm_execute.h zval *key = NULL;
key 6930 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 6935 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 6942 Zend/zend_vm_execute.h generator->key = copy;
key 6944 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 6945 Zend/zend_vm_execute.h generator->key = key;
key 6948 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 6949 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 6951 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 6958 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 6959 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 7587 Zend/zend_vm_execute.h if (generator->key) {
key 7588 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 7672 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 7676 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 7681 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 7688 Zend/zend_vm_execute.h generator->key = copy;
key 7690 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 7691 Zend/zend_vm_execute.h generator->key = key;
key 7694 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 7695 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 7697 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 7704 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 7705 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 9650 Zend/zend_vm_execute.h if (generator->key) {
key 9651 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 9735 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 9739 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 9744 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 9751 Zend/zend_vm_execute.h generator->key = copy;
key 9753 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 9754 Zend/zend_vm_execute.h generator->key = key;
key 9757 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 9758 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 9760 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 9767 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 9768 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 10354 Zend/zend_vm_execute.h if (generator->key) {
key 10355 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 10439 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 10443 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 10448 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 10455 Zend/zend_vm_execute.h generator->key = copy;
key 10457 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 10458 Zend/zend_vm_execute.h generator->key = key;
key 10461 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 10462 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 10464 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 10471 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 10472 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 11383 Zend/zend_vm_execute.h if (generator->key) {
key 11384 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 11468 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 11472 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 11477 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 11484 Zend/zend_vm_execute.h generator->key = copy;
key 11486 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 11487 Zend/zend_vm_execute.h generator->key = key;
key 11490 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 11491 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 11493 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 11501 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 11502 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 11978 Zend/zend_vm_execute.h if (generator->key) {
key 11979 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 12063 Zend/zend_vm_execute.h zval *key = NULL;
key 12067 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 12072 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 12079 Zend/zend_vm_execute.h generator->key = copy;
key 12081 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 12082 Zend/zend_vm_execute.h generator->key = key;
key 12085 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 12086 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 12088 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 12095 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 12096 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 12664 Zend/zend_vm_execute.h if (generator->key) {
key 12665 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 12749 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 12753 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 12758 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 12765 Zend/zend_vm_execute.h generator->key = copy;
key 12767 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 12768 Zend/zend_vm_execute.h generator->key = key;
key 12771 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 12772 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 12774 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 12781 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 12782 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 13955 Zend/zend_vm_execute.h zval *key = NULL;
key 13957 Zend/zend_vm_execute.h key = &EX_T((opline+1)->result.var).tmp_var;
key 13988 Zend/zend_vm_execute.h if (key) {
key 13990 Zend/zend_vm_execute.h ZVAL_LONG(key, int_key);
key 13997 Zend/zend_vm_execute.h ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
key 14012 Zend/zend_vm_execute.h if (key) {
key 14013 Zend/zend_vm_execute.h zend_hash_get_current_key_zval(fe_ht, key);
key 14048 Zend/zend_vm_execute.h if (key) {
key 14050 Zend/zend_vm_execute.h iter->funcs->get_current_key(iter, key TSRMLS_CC);
key 14056 Zend/zend_vm_execute.h ZVAL_LONG(key, iter->index);
key 16577 Zend/zend_vm_execute.h if (generator->key) {
key 16578 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 16663 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 16667 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 16672 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 16679 Zend/zend_vm_execute.h generator->key = copy;
key 16681 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 16682 Zend/zend_vm_execute.h generator->key = key;
key 16685 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 16686 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 16688 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 16695 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 16696 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 18677 Zend/zend_vm_execute.h if (generator->key) {
key 18678 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 18763 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 18767 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 18772 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 18779 Zend/zend_vm_execute.h generator->key = copy;
key 18781 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 18782 Zend/zend_vm_execute.h generator->key = key;
key 18785 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 18786 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 18788 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 18795 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 18796 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 21157 Zend/zend_vm_execute.h if (generator->key) {
key 21158 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 21243 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 21247 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 21252 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 21259 Zend/zend_vm_execute.h generator->key = copy;
key 21261 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 21262 Zend/zend_vm_execute.h generator->key = key;
key 21265 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 21266 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 21268 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 21276 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 21277 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 22327 Zend/zend_vm_execute.h if (generator->key) {
key 22328 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 22413 Zend/zend_vm_execute.h zval *key = NULL;
key 22417 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 22422 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 22429 Zend/zend_vm_execute.h generator->key = copy;
key 22431 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 22432 Zend/zend_vm_execute.h generator->key = key;
key 22435 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 22436 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 22438 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 22445 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 22446 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 24461 Zend/zend_vm_execute.h if (generator->key) {
key 24462 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 24547 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 24551 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 24556 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 24563 Zend/zend_vm_execute.h generator->key = copy;
key 24565 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 24566 Zend/zend_vm_execute.h generator->key = key;
key 24569 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 24570 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 24572 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 24579 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 24580 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 25978 Zend/zend_vm_execute.h if (generator->key) {
key 25979 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 26063 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 26067 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 26072 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 26079 Zend/zend_vm_execute.h generator->key = copy;
key 26081 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 26082 Zend/zend_vm_execute.h generator->key = key;
key 26085 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 26086 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 26088 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 26095 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 26096 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 27300 Zend/zend_vm_execute.h if (generator->key) {
key 27301 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 27385 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 27389 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 27394 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 27401 Zend/zend_vm_execute.h generator->key = copy;
key 27403 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 27404 Zend/zend_vm_execute.h generator->key = key;
key 27407 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 27408 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 27410 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 27417 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 27418 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 28622 Zend/zend_vm_execute.h if (generator->key) {
key 28623 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 28707 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 28711 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 28716 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 28723 Zend/zend_vm_execute.h generator->key = copy;
key 28725 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 28726 Zend/zend_vm_execute.h generator->key = key;
key 28729 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 28730 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 28732 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 28740 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 28741 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 29054 Zend/zend_vm_execute.h if (generator->key) {
key 29055 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 29139 Zend/zend_vm_execute.h zval *key = NULL;
key 29143 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 29148 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 29155 Zend/zend_vm_execute.h generator->key = copy;
key 29157 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 29158 Zend/zend_vm_execute.h generator->key = key;
key 29161 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 29162 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 29164 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 29171 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 29172 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 30373 Zend/zend_vm_execute.h if (generator->key) {
key 30374 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 30458 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 30462 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 30467 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 30474 Zend/zend_vm_execute.h generator->key = copy;
key 30476 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 30477 Zend/zend_vm_execute.h generator->key = key;
key 30480 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 30481 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 30483 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 30490 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 30491 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 33882 Zend/zend_vm_execute.h if (generator->key) {
key 33883 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 33967 Zend/zend_vm_execute.h zval *key = opline->op2.zv;
key 33971 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 33976 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 33983 Zend/zend_vm_execute.h generator->key = copy;
key 33985 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 33986 Zend/zend_vm_execute.h generator->key = key;
key 33989 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 33990 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 33992 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 33999 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 34000 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 35845 Zend/zend_vm_execute.h if (generator->key) {
key 35846 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 35930 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 35934 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 35939 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 35946 Zend/zend_vm_execute.h generator->key = copy;
key 35948 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 35949 Zend/zend_vm_execute.h generator->key = key;
key 35952 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 35953 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 35955 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 35962 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 35963 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 38187 Zend/zend_vm_execute.h if (generator->key) {
key 38188 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 38272 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
key 38276 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 38281 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 38288 Zend/zend_vm_execute.h generator->key = copy;
key 38290 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 38291 Zend/zend_vm_execute.h generator->key = key;
key 38294 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 38295 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 38297 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 38305 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 38306 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 39208 Zend/zend_vm_execute.h if (generator->key) {
key 39209 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 39293 Zend/zend_vm_execute.h zval *key = NULL;
key 39297 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 39302 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 39309 Zend/zend_vm_execute.h generator->key = copy;
key 39311 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 39312 Zend/zend_vm_execute.h generator->key = key;
key 39315 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 39316 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 39318 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 39325 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 39326 Zend/zend_vm_execute.h ZVAL_LONG(generator->key, generator->largest_used_integer_key);
key 41204 Zend/zend_vm_execute.h if (generator->key) {
key 41205 Zend/zend_vm_execute.h zval_ptr_dtor(&generator->key);
key 41289 Zend/zend_vm_execute.h zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
key 41293 Zend/zend_vm_execute.h || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
key 41298 Zend/zend_vm_execute.h INIT_PZVAL_COPY(copy, key);
key 41305 Zend/zend_vm_execute.h generator->key = copy;
key 41307 Zend/zend_vm_execute.h Z_ADDREF_P(key);
key 41308 Zend/zend_vm_execute.h generator->key = key;
key 41311 Zend/zend_vm_execute.h if (Z_TYPE_P(generator->key) == IS_LONG
key 41312 Zend/zend_vm_execute.h && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
key 41314 Zend/zend_vm_execute.h generator->largest_used_integer_key = Z_LVAL_P(generator->key);
key 41321 Zend/zend_vm_execute.h ALLOC_INIT_ZVAL(generator->key);
key 41322 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 1843 ext/curl/interface.c char *key;
key 1851 ext/curl/interface.c key = s;
key 1852 ext/curl/interface.c tmp = memchr(key, '=', 64);
key 1856 ext/curl/interface.c add_assoc_string(hash, key, val, 1);
key 1947 ext/date/php_date.c ZVAL_LONG(key, iterator->current_index);
key 4047 ext/date/php_date.c key = NULL;
key 4053 ext/date/php_date.c retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key 4075 ext/date/php_date.c retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
key 4112 ext/date/php_date.c key = NULL;
key 4118 ext/date/php_date.c (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key 4149 ext/date/php_date.c (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
key 5109 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 330 ext/dom/php_dom.c retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 376 ext/dom/php_dom.c retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
key 412 ext/dom/php_dom.c std_hnd->write_property(object, member, value, key TSRMLS_CC);
key 460 ext/dom/php_dom.c retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
key 3854 ext/gd/gd.c char * key;
key 3857 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 3865 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 340 ext/gd/libgd/gdft.c fontkey_t *b = (fontkey_t *) key;
key 367 ext/gd/libgd/gdft.c fontkey_t *b = (fontkey_t *) key;
key 562 ext/gd/libgd/gdft.c tweencolorkey_t *b = (tweencolorkey_t *) key;
key 579 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 790 ext/hash/hash.c if (hash->key) {
key 791 ext/hash/hash.c memset(hash->key, 0, hash->ops->block_size);
key 792 ext/hash/hash.c efree(hash->key);
key 966 ext/hash/hash.c char *key, *digest;
key 975 ext/hash/hash.c key = ecalloc(1, times * block_size);
key 987 ext/hash/hash.c memcpy( &key[i*block_size], digest, block_size);
key 990 ext/hash/hash.c RETVAL_STRINGL(key, bytes, 1);
key 991 ext/hash/hash.c memset(key, 0, bytes);
key 994 ext/hash/hash.c efree(key);
key 41 ext/hash/hash_gost.c round(tables, key[0], key[1]) \
key 42 ext/hash/hash_gost.c round(tables, key[2], key[3]) \
key 43 ext/hash/hash_gost.c round(tables, key[4], key[5]) \
key 44 ext/hash/hash_gost.c round(tables, key[6], key[7]) \
key 45 ext/hash/hash_gost.c round(tables, key[0], key[1]) \
key 46 ext/hash/hash_gost.c round(tables, key[2], key[3]) \
key 47 ext/hash/hash_gost.c round(tables, key[4], key[5]) \
key 48 ext/hash/hash_gost.c round(tables, key[6], key[7]) \
key 49 ext/hash/hash_gost.c round(tables, key[0], key[1]) \
key 50 ext/hash/hash_gost.c round(tables, key[2], key[3]) \
key 51 ext/hash/hash_gost.c round(tables, key[4], key[5]) \
key 52 ext/hash/hash_gost.c round(tables, key[6], key[7]) \
key 53 ext/hash/hash_gost.c round(tables, key[7], key[6]) \
key 54 ext/hash/hash_gost.c round(tables, key[5], key[4]) \
key 55 ext/hash/hash_gost.c round(tables, key[3], key[2]) \
key 56 ext/hash/hash_gost.c round(tables, key[1], key[0]) \
key 72 ext/hash/hash_gost.c key[0] = (w[0] & 0x000000ff) | ((w[2] & 0x000000ff) << 8) | \
key 74 ext/hash/hash_gost.c key[1] = ((w[0] & 0x0000ff00) >> 8) | (w[2] & 0x0000ff00) | \
key 76 ext/hash/hash_gost.c key[2] = ((w[0] & 0x00ff0000) >> 16) | ((w[2] & 0x00ff0000) >> 8) | \
key 78 ext/hash/hash_gost.c key[3] = ((w[0] & 0xff000000) >> 24) | ((w[2] & 0xff000000) >> 16) | \
key 80 ext/hash/hash_gost.c key[4] = (w[1] & 0x000000ff) | ((w[3] & 0x000000ff) << 8) | \
key 82 ext/hash/hash_gost.c key[5] = ((w[1] & 0x0000ff00) >> 8) | (w[3] & 0x0000ff00) | \
key 84 ext/hash/hash_gost.c key[6] = ((w[1] & 0x00ff0000) >> 16) | ((w[3] & 0x00ff0000) >> 8) | \
key 86 ext/hash/hash_gost.c key[7] = ((w[1] & 0xff000000) >> 24) | ((w[3] & 0xff000000) >> 16) | \
key 199 ext/hash/hash_gost.c P(key, w); \
key 200 ext/hash/hash_gost.c R((tables), key, h, i, t, l, r); \
key 213 ext/hash/hash_gost.c php_hash_uint32 l, r, t, key[8], u[8], v[8], w[8], s[8], *h = context->state, *m = data;
key 59 ext/hash/php_hash.h unsigned char *key;
key 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 188 ext/json/json.c char *key;
key 196 ext/json/json.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 271 ext/json/json.c char *key;
key 280 ext/json/json.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 302 ext/json/json.c if (key[0] == '\0' && Z_TYPE_PP(val) == IS_OBJECT) {
key 319 ext/json/json.c json_escape_string(buf, key, key_len - 1, options & ~PHP_JSON_NUMERIC_CHECK TSRMLS_CC);
key 1572 ext/ldap/ldap.c if (zend_hash_find(Z_ARRVAL_P(hashTbl), key, strlen(key)+1, (void **) &fetched) == SUCCESS) {
key 365 ext/mbstring/oniguruma/regparse.c st_str_end_key key;
key 367 ext/mbstring/oniguruma/regparse.c key.s = (UChar* )str_key;
key 368 ext/mbstring/oniguruma/regparse.c key.end = (UChar* )end_key;
key 370 ext/mbstring/oniguruma/regparse.c return onig_st_lookup(table, (st_data_t )(&key), value);
key 377 ext/mbstring/oniguruma/regparse.c st_str_end_key* key;
key 380 ext/mbstring/oniguruma/regparse.c key = (st_str_end_key* )xmalloc(sizeof(st_str_end_key));
key 381 ext/mbstring/oniguruma/regparse.c key->s = (UChar* )str_key;
key 382 ext/mbstring/oniguruma/regparse.c key->end = (UChar* )end_key;
key 383 ext/mbstring/oniguruma/regparse.c result = onig_st_insert(table, (st_data_t )key, value);
key 385 ext/mbstring/oniguruma/regparse.c xfree(key);
key 455 ext/mbstring/oniguruma/regparse.c xfree(key);
key 4874 ext/mbstring/oniguruma/regparse.c p = (UChar* )&(key->enc);
key 4875 ext/mbstring/oniguruma/regparse.c for (i = 0; i < (int )sizeof(key->enc); i++) {
key 4879 ext/mbstring/oniguruma/regparse.c p = (UChar* )(&key->type);
key 4880 ext/mbstring/oniguruma/regparse.c for (i = 0; i < (int )sizeof(key->type); i++) {
key 4884 ext/mbstring/oniguruma/regparse.c val += key->not;
key 4905 ext/mbstring/oniguruma/regparse.c if (IS_NOT_NULL(key)) xfree(key);
key 5200 ext/mbstring/oniguruma/regparse.c type_cclass_key key;
key 5203 ext/mbstring/oniguruma/regparse.c key.enc = env->enc;
key 5204 ext/mbstring/oniguruma/regparse.c key.not = tok->u.prop.not;
key 5205 ext/mbstring/oniguruma/regparse.c key.type = tok->u.prop.ctype;
key 5218 ext/mbstring/oniguruma/regparse.c if (onig_st_lookup(OnigTypeCClassTable, (st_data_t )&key,
key 5235 ext/mbstring/oniguruma/regparse.c xmemcpy(new_key, &key, sizeof(type_cclass_key));
key 20 ext/mbstring/oniguruma/st.c st_data_t key;
key 59 ext/mbstring/oniguruma/st.c #define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key))
key 60 ext/mbstring/oniguruma/st.c #define do_hash_bin(key,table) (do_hash(key, table)%(table)->num_bins)
key 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 334 ext/mcrypt/mcrypt.c &cipher, &cipher_len, &key, &key_len, &data, &data_len, &mode, &iv, &iv_len) == FAILURE) { \
key 555 ext/mcrypt/mcrypt.c char *key, *iv;
key 563 ext/mcrypt/mcrypt.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &mcryptind, &key, &key_len, &iv, &iv_len) == FAILURE) {
key 588 ext/mcrypt/mcrypt.c memcpy(key_s, key, key_len);
key 1290 ext/mcrypt/mcrypt.c if (mcrypt_generic_init(td, (void *) key, key_len, (void *) iv) < 0) {
key 1314 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *mode, *iv = NULL;
key 1318 ext/mcrypt/mcrypt.c &key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key 1322 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_ENCRYPT, return_value TSRMLS_CC);
key 1330 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *mode, *iv = NULL;
key 1334 ext/mcrypt/mcrypt.c &key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
key 1338 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_DECRYPT, return_value TSRMLS_CC);
key 1347 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1354 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ecb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1363 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1370 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cbc", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1379 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1386 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "cfb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 1395 ext/mcrypt/mcrypt.c char *cipher, *key, *data, *iv = NULL;
key 1402 ext/mcrypt/mcrypt.c php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, "ofb", iv, iv_len, Z_LVAL_PP(mode), return_value TSRMLS_CC);
key 158 ext/mcrypt/mcrypt_filter.c char *iv = NULL, *key = NULL;
key 203 ext/mcrypt/mcrypt_filter.c key = Z_STRVAL_PP(tmpzval);
key 236 ext/mcrypt/mcrypt_filter.c result = mcrypt_generic_init(mcrypt_module, key, key_len, iv);
key 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 1617 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, ssl_set)(MYSQLND_CONN_DATA * const conn, const char * key, const char * const cert,
key 1626 ext/mysqlnd/mysqlnd.c ret = (PASS == net->data->m.set_client_option(net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) &&
key 2518 ext/mysqlnd/mysqlnd.c const char * const key,
key 2540 ext/mysqlnd/mysqlnd.c DBG_INF_FMT("Adding [%s][%s]", key, value);
key 2546 ext/mysqlnd/mysqlnd.c zend_hash_update(conn->options->connect_attr, key, strlen(key), ©v, sizeof(char *), NULL);
key 167 ext/mysqlnd/mysqlnd.h #define mysqlnd_ssl_set(conn, key, cert, ca, capath, cipher) ((conn)->data)->m->ssl_set((conn)->data, (key), (cert), (ca), (capath), (cipher) TSRMLS_CC)
key 45 ext/mysqlnd/mysqlnd_bt.c if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \
key 82 ext/mysqlnd/mysqlnd_libmysql_compat.h #define mysql_ssl_set(c,key,cert,ca,capath,cipher) mysqlnd_ssl_set((c), (key), (cert), (ca), (capath), (cipher))
key 954 ext/mysqlnd/mysqlnd_result.c meta->zend_hash_keys[i].key,
key 957 ext/mysqlnd/mysqlnd_result.c zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, (void *) &data, sizeof(zval *), NULL);
key 1209 ext/mysqlnd/mysqlnd_result.c meta->zend_hash_keys[i].key,
key 1213 ext/mysqlnd/mysqlnd_result.c meta->zend_hash_keys[i].key,
key 1310 ext/mysqlnd/mysqlnd_result.c meta->zend_hash_keys[i].key,
key 1314 ext/mysqlnd/mysqlnd_result.c meta->zend_hash_keys[i].key,
key 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 990 ext/mysqlnd/mysqlnd_structs.h unsigned long key;
key 100 ext/opcache/Optimizer/compact_literals.c char *key;
key 359 ext/opcache/Optimizer/compact_literals.c key = emalloc(key_len);
key 360 ext/opcache/Optimizer/compact_literals.c key_len = snprintf(key, key_len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i].constant));
key 364 ext/opcache/Optimizer/compact_literals.c key = emalloc(key_len);
key 365 ext/opcache/Optimizer/compact_literals.c memcpy(key, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
key 366 ext/opcache/Optimizer/compact_literals.c memcpy(key + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
key 367 ext/opcache/Optimizer/compact_literals.c memcpy(key + Z_STRLEN_P(class_name) + sizeof("::") - 1,
key 371 ext/opcache/Optimizer/compact_literals.c key = Z_STRVAL(op_array->literals[i].constant);
key 374 ext/opcache/Optimizer/compact_literals.c h = zend_hash_func(key, key_len);
key 378 ext/opcache/Optimizer/compact_literals.c zend_hash_quick_find(&hash, key, key_len, h, (void**)&pos) == SUCCESS &&
key 383 ext/opcache/Optimizer/compact_literals.c efree(key);
key 396 ext/opcache/Optimizer/compact_literals.c zend_hash_quick_add(&hash, key, key_len, h, (void**)&j, sizeof(int), NULL);
key 398 ext/opcache/Optimizer/compact_literals.c efree(key);
key 225 ext/opcache/ZendAccelerator.c char *key;
key 227 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 228 ext/opcache/ZendAccelerator.c if (key) {
key 229 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 230 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 231 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 232 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 977 ext/opcache/ZendAccelerator.c char *key;
key 979 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 980 ext/opcache/ZendAccelerator.c if (key) {
key 981 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 982 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 983 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 984 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 1020 ext/opcache/ZendAccelerator.c if ((size_t)key_length >= sizeof(ZCG(key))) {
key 1024 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), cwd, cwd_len);
key 1025 ext/opcache/ZendAccelerator.c ZCG(key)[cwd_len] = ':';
key 1027 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cwd_len + 1, file_handle->filename, path_length);
key 1029 ext/opcache/ZendAccelerator.c ZCG(key)[cwd_len + 1 + path_length] = ':';
key 1034 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cur_len, parent_script, parent_script_len);
key 1036 ext/opcache/ZendAccelerator.c ZCG(key)[cur_len] = ':';
key 1039 ext/opcache/ZendAccelerator.c memcpy(ZCG(key) + cur_len, include_path, include_path_len);
key 1040 ext/opcache/ZendAccelerator.c ZCG(key)[key_length] = '\0';
key 1044 ext/opcache/ZendAccelerator.c if ((size_t)key_length >= sizeof(ZCG(key))) {
key 1048 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), file_handle->filename, key_length + 1);
key 1052 ext/opcache/ZendAccelerator.c return ZCG(key);
key 1116 ext/opcache/ZendAccelerator.c if (!zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) {
key 1124 ext/opcache/ZendAccelerator.c memcpy(new_key, key, key_length + 1);
key 1175 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1183 ext/opcache/ZendAccelerator.c memory_used = zend_accel_script_persist_calc(new_persistent_script, key, key_length TSRMLS_CC);
key 1198 ext/opcache/ZendAccelerator.c new_persistent_script = zend_accel_script_persist(new_persistent_script, &key, key_length TSRMLS_CC);
key 1219 ext/opcache/ZendAccelerator.c memcmp(key, "phar://", sizeof("phar://") - 1) != 0 &&
key 1221 ext/opcache/ZendAccelerator.c memcmp(new_persistent_script->full_path, key, key_length) != 0)) {
key 1223 ext/opcache/ZendAccelerator.c if (zend_accel_hash_update(&ZCSG(hash), key, key_length + 1, 1, bucket)) {
key 1224 ext/opcache/ZendAccelerator.c zend_accel_error(ACCEL_LOG_INFO, "Added key '%s'", key);
key 1309 ext/opcache/ZendAccelerator.c if (key == ZCG(key)) {
key 1461 ext/opcache/ZendAccelerator.c return cache_script_in_shared_memory(new_persistent_script, key, key_length, from_shared_memory TSRMLS_CC);
key 1468 ext/opcache/ZendAccelerator.c char *key = NULL;
key 1515 ext/opcache/ZendAccelerator.c key = ZCG(key);
key 1519 ext/opcache/ZendAccelerator.c if ((key = accel_make_persistent_key(file_handle, &key_length TSRMLS_CC)) == NULL) {
key 1522 ext/opcache/ZendAccelerator.c persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key 1559 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1638 ext/opcache/ZendAccelerator.c persistent_script = compile_and_cache_file(file_handle, type, key, key_length, &op_array, &from_shared_memory TSRMLS_CC);
key 1850 ext/opcache/ZendAccelerator.c char *key = NULL;
key 1873 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 1881 ext/opcache/ZendAccelerator.c key = accel_make_persistent_key_ex(handle, filename_len, &key_length TSRMLS_CC);
key 1883 ext/opcache/ZendAccelerator.c key &&
key 1884 ext/opcache/ZendAccelerator.c (persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key 1905 ext/opcache/ZendAccelerator.c if (key && !ZCG(accel_directives).revalidate_path) {
key 1909 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 1981 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 2020 ext/opcache/ZendAccelerator.c char *key = NULL;
key 2032 ext/opcache/ZendAccelerator.c memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
key 2044 ext/opcache/ZendAccelerator.c key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC);
key 2046 ext/opcache/ZendAccelerator.c key &&
key 2047 ext/opcache/ZendAccelerator.c (persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1)) != NULL &&
key 2065 ext/opcache/ZendAccelerator.c if (key && !ZCG(accel_directives).revalidate_path) {
key 2069 ext/opcache/ZendAccelerator.c zend_accel_add_key(key, key_length, bucket TSRMLS_CC);
key 2073 ext/opcache/ZendAccelerator.c ZCG(cache_opline) = (EG(opline_ptr) && key) ? *EG(opline_ptr): NULL;
key 2074 ext/opcache/ZendAccelerator.c ZCG(cache_persistent_script) = key ? persistent_script : NULL;
key 2153 ext/opcache/ZendAccelerator.c ZCSG(include_paths).hash_table[zend_inline_hash_func(ZCSG(include_paths).hash_entries[0].key, ZCSG(include_paths).hash_entries[0].key_length) % ZCSG(include_paths).max_num_entries] = &ZCSG(include_paths).hash_entries[0];
key 2655 ext/opcache/ZendAccelerator.c char *key;
key 2658 ext/opcache/ZendAccelerator.c key = zend_shared_alloc(ZCG(include_path_len) + 2);
key 2659 ext/opcache/ZendAccelerator.c if (key) {
key 2660 ext/opcache/ZendAccelerator.c memcpy(key, ZCG(include_path), ZCG(include_path_len) + 1);
key 2661 ext/opcache/ZendAccelerator.c key[ZCG(include_path_len) + 1] = 'A' + ZCSG(include_paths).num_entries;
key 2662 ext/opcache/ZendAccelerator.c ZCG(include_path_key) = key + ZCG(include_path_len) + 1;
key 2663 ext/opcache/ZendAccelerator.c zend_accel_hash_update(&ZCSG(include_paths), key, ZCG(include_path_len) + 1, 0, ZCG(include_path_key));
key 274 ext/opcache/ZendAccelerator.h char key[MAXPATHLEN * 8];
key 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 315 ext/opcache/zend_accelerator_module.c char *key;
key 332 ext/opcache/zend_accelerator_module.c if ((key = accel_make_persistent_key_ex(&handle, filename_len, &key_length TSRMLS_CC)) != NULL) {
key 333 ext/opcache/zend_accelerator_module.c persistent_script = zend_accel_hash_find(&ZCSG(hash), key, key_length + 1);
key 542 ext/opcache/zend_accelerator_module.c zend_hash_update(return_value->value.ht, cache_entry->key, cache_entry->key_length, &persistent_script_report, sizeof(zval *), NULL);
key 711 ext/opcache/zend_persist.c *key = zend_accel_memdup(*key, key_length + 1);
key 369 ext/opcache/zend_persist_calc.c ADD_DUP_SIZE(key, key_length + 1);
key 637 ext/openssl/openssl.c if (key != NULL) {
key 684 ext/openssl/openssl.c if (key != NULL) {
key 685 ext/openssl/openssl.c zend_hash_update(HASH_OF(val), key, strlen(key) + 1, (void *)&subitem, sizeof(subitem), NULL);
key 692 ext/openssl/openssl.c add_assoc_stringl(val, key, (char *)str->data, str->length, 1);
key 844 ext/openssl/openssl.c if (optional_args && zend_hash_find(Z_ARRVAL_P(optional_args), key, sizeof(key), (void**)&item) == SUCCESS && Z_TYPE_PP(item) == IS_STRING) \
key 850 ext/openssl/openssl.c if (optional_args && zend_hash_find(Z_ARRVAL_P(optional_args), key, sizeof(key), (void**)&item) == SUCCESS && Z_TYPE_PP(item) == IS_LONG) \
key 1831 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 1843 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zkey, 0, "", 1, &keyresource TSRMLS_CC);
key 1844 ext/openssl/openssl.c if (key) {
key 1845 ext/openssl/openssl.c RETVAL_BOOL(X509_check_private_key(cert, key));
key 1848 ext/openssl/openssl.c if (keyresource == -1 && key) {
key 1849 ext/openssl/openssl.c EVP_PKEY_free(key);
key 2926 ext/openssl/openssl.c EVP_PKEY * key = NULL, *priv_key = NULL;
key 2963 ext/openssl/openssl.c key = X509_REQ_get_pubkey(csr);
key 2964 ext/openssl/openssl.c if (key == NULL) {
key 2968 ext/openssl/openssl.c i = X509_REQ_verify(csr, key);
key 3002 ext/openssl/openssl.c i = X509_set_pubkey(new_cert, key);
key 3036 ext/openssl/openssl.c if (key) {
key 3037 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3206 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 3319 ext/openssl/openssl.c key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key 3338 ext/openssl/openssl.c key = PEM_read_bio_PrivateKey(in, NULL,NULL, passphrase);
key 3343 ext/openssl/openssl.c if (public_key && cert && key == NULL) {
key 3345 ext/openssl/openssl.c key = (EVP_PKEY *) X509_get_pubkey(cert);
key 3351 ext/openssl/openssl.c if (key && makeresource && resourceval) {
key 3352 ext/openssl/openssl.c *resourceval = ZEND_REGISTER_RESOURCE(NULL, key, le_key);
key 3357 ext/openssl/openssl.c return key;
key 3630 ext/openssl/openssl.c EVP_PKEY * key;
key 3639 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key 3641 ext/openssl/openssl.c if (key == NULL) {
key 3665 ext/openssl/openssl.c switch (EVP_PKEY_type(key->type)) {
key 3668 ext/openssl/openssl.c pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key 3672 ext/openssl/openssl.c pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key 3684 ext/openssl/openssl.c if (key_resource == -1 && key) {
key 3685 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3703 ext/openssl/openssl.c EVP_PKEY * key;
key 3712 ext/openssl/openssl.c key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
key 3714 ext/openssl/openssl.c if (key == NULL) {
key 3734 ext/openssl/openssl.c switch (EVP_PKEY_type(key->type)) {
key 3737 ext/openssl/openssl.c pem_write = PEM_write_bio_ECPrivateKey(bio_out, EVP_PKEY_get1_EC_KEY(key), cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key 3741 ext/openssl/openssl.c pem_write = PEM_write_bio_PrivateKey(bio_out, key, cipher, (unsigned char *)passphrase, passphrase_len, NULL, NULL);
key 3760 ext/openssl/openssl.c if (key_resource == -1 && key) {
key 3761 ext/openssl/openssl.c EVP_PKEY_free(key);
key 3793 ext/openssl/openssl.c zval *key;
key 3796 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key 3799 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key 3800 ext/openssl/openssl.c zend_list_delete(Z_LVAL_P(key));
key 3831 ext/openssl/openssl.c zval *key;
key 3838 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &key) == FAILURE) {
key 3841 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key 4381 ext/openssl/openssl.c EVP_PKEY * key = NULL;
key 4401 ext/openssl/openssl.c key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &keyresval TSRMLS_CC);
key 4402 ext/openssl/openssl.c if (key == NULL) {
key 4425 ext/openssl/openssl.c if (PKCS7_decrypt(p7, key, cert, out, PKCS7_DETACHED)) {
key 4436 ext/openssl/openssl.c if (key && keyresval == -1) {
key 4437 ext/openssl/openssl.c EVP_PKEY_free(key);
key 4448 ext/openssl/openssl.c zval **key, *crypted;
key 4458 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 4463 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4506 ext/openssl/openssl.c zval **key, *crypted;
key 4517 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 4522 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4572 ext/openssl/openssl.c zval **key, *crypted;
key 4582 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
key 4587 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 4630 ext/openssl/openssl.c zval **key, *crypted;
key 4641 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
key 4646 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 4718 ext/openssl/openssl.c zval **key, *signature;
key 4730 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szZ|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
key 4733 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
key 4780 ext/openssl/openssl.c zval **key;
key 4791 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 4811 ext/openssl/openssl.c pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
key 5155 ext/openssl/openssl.c unsigned char *outbuf, *key;
key 5169 ext/openssl/openssl.c key = emalloc(keylen);
key 5170 ext/openssl/openssl.c memset(key, 0, keylen);
key 5171 ext/openssl/openssl.c memcpy(key, password, password_len);
key 5173 ext/openssl/openssl.c key = (unsigned char*)password;
key 5189 ext/openssl/openssl.c EVP_EncryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key 5214 ext/openssl/openssl.c if (key != (unsigned char*)password) {
key 5215 ext/openssl/openssl.c efree(key);
key 5234 ext/openssl/openssl.c unsigned char *outbuf, *key;
key 5266 ext/openssl/openssl.c key = emalloc(keylen);
key 5267 ext/openssl/openssl.c memset(key, 0, keylen);
key 5268 ext/openssl/openssl.c memcpy(key, password, password_len);
key 5270 ext/openssl/openssl.c key = (unsigned char*)password;
key 5282 ext/openssl/openssl.c EVP_DecryptInit_ex(&cipher_ctx, NULL, NULL, key, (unsigned char *)iv);
key 5296 ext/openssl/openssl.c if (key != (unsigned char*)password) {
key 5297 ext/openssl/openssl.c efree(key);
key 5340 ext/openssl/openssl.c zval *key;
key 5348 ext/openssl/openssl.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr", &pub_str, &pub_len, &key) == FAILURE) {
key 5351 ext/openssl/openssl.c ZEND_FETCH_RESOURCE(pkey, EVP_PKEY *, &key, -1, "OpenSSL key", le_key);
key 305 ext/openssl/xp_ssl.c char *key;
key 318 ext/openssl/xp_ssl.c int key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(val), &key, &key_len, &key_index, 0, &pos);
key 324 ext/openssl/xp_ssl.c if (php_x509_fingerprint_cmp(peer, key, Z_STRVAL_PP(current) TSRMLS_CC) != 0) {
key 913 ext/openssl/xp_ssl.c EVP_PKEY *key = NULL;
key 918 ext/openssl/xp_ssl.c key = X509_get_pubkey(cert);
key 919 ext/openssl/xp_ssl.c EVP_PKEY_copy_parameters(key, SSL_get_privatekey(tmpssl));
key 920 ext/openssl/xp_ssl.c EVP_PKEY_free(key);
key 1321 ext/openssl/xp_ssl.c char *key;
key 1363 ext/openssl/xp_ssl.c key_type = zend_hash_get_current_key_ex(Z_ARRVAL_PP(val), &key, &key_len, &key_index, 0, &pos);
key 1393 ext/openssl/xp_ssl.c sslsock->sni_certs[i].name = pestrdup(key, php_stream_is_persistent(stream));
key 752 ext/pcntl/pcntl.c char *key;
key 792 ext/pcntl/pcntl.c switch (return_val = zend_hash_get_current_key_ex(envs_hash, &key, &key_length, &key_num, 0, NULL)) {
key 794 ext/pcntl/pcntl.c key = emalloc(101);
key 795 ext/pcntl/pcntl.c snprintf(key, 100, "%ld", key_num);
key 796 ext/pcntl/pcntl.c key_length = strlen(key);
key 808 ext/pcntl/pcntl.c strlcpy(*pair, key, key_length);
key 813 ext/pcntl/pcntl.c if (return_val == HASH_KEY_IS_LONG) efree(key);
key 10049 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c struct tilegx_spr key;
key 10051 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c key.number = num;
key 10052 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c result = bsearch((const void *) &key, (const void *) tilegx_sprs,
key 1359 ext/pdo/pdo_dbh.c if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len, key TSRMLS_CC)) == NULL) {
key 2226 ext/pdo/pdo_stmt.c std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key 2239 ext/pdo/pdo_stmt.c std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key 2442 ext/pdo/pdo_stmt.c ulong key;
key 2485 ext/pdo/pdo_stmt.c if (I->key == (ulong)-1) {
key 2486 ext/pdo/pdo_stmt.c ZVAL_NULL(key);
key 2488 ext/pdo/pdo_stmt.c ZVAL_LONG(key, I->key);
key 2508 ext/pdo/pdo_stmt.c I->key = (ulong)-1;
key 2515 ext/pdo/pdo_stmt.c I->key++;
key 2546 ext/pdo/pdo_stmt.c I->key = (ulong)-1;
key 2590 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 103 ext/phar/phar.c char *key, *lasts, *end;
key 133 ext/phar/phar.c for (key = php_strtok_r(tmp, ds, &lasts);
key 134 ext/phar/phar.c key;
key 135 ext/phar/phar.c key = php_strtok_r(NULL, ds, &lasts)) {
key 136 ext/phar/phar.c end = strchr(key, DEFAULT_DIR_SEPARATOR);
key 139 ext/phar/phar.c if (SUCCESS == phar_open_from_filename(key, end - key, NULL, 0, 0, &phar, NULL TSRMLS_CC)) {
key 162 ext/phar/phar.c if (SUCCESS == phar_open_from_filename(key, strlen(key), NULL, 0, 0, &phar, NULL TSRMLS_CC)) {
key 1457 ext/phar/phar_object.c zval key;
key 1458 ext/phar/phar_object.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 1464 ext/phar/phar_object.c if (Z_TYPE(key) != IS_STRING) {
key 1465 ext/phar/phar_object.c zval_dtor(&key);
key 1470 ext/phar/phar_object.c str_key_len = Z_STRLEN(key);
key 1471 ext/phar/phar_object.c str_key = estrndup(Z_STRVAL(key), str_key_len);
key 1474 ext/phar/phar_object.c zval_dtor(&key);
key 1585 ext/phar/phar_object.c zval key;
key 1586 ext/phar/phar_object.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 1592 ext/phar/phar_object.c if (Z_TYPE(key) != IS_STRING) {
key 1593 ext/phar/phar_object.c zval_dtor(&key);
key 1598 ext/phar/phar_object.c str_key_len = Z_STRLEN(key);
key 1599 ext/phar/phar_object.c str_key = estrndup(Z_STRVAL(key), str_key_len);
key 1602 ext/phar/phar_object.c zval_dtor(&key);
key 3034 ext/phar/phar_object.c char *error, *key = NULL;
key 3045 ext/phar/phar_object.c if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &algo, &key, &key_len) != SUCCESS) {
key 3066 ext/phar/phar_object.c PHAR_G(openssl_privatekey) = key;
key 1414 ext/phar/util.c ZVAL_STRINGL(zkey, key, key_len, 1);
key 1527 ext/phar/util.c EVP_PKEY *key;
key 1595 ext/phar/util.c key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
key 1599 ext/phar/util.c if (NULL == key) {
key 1626 ext/phar/util.c if (EVP_VerifyFinal(&md_ctx, (unsigned char *)sig, sig_len, key) != 1) {
key 1852 ext/phar/util.c EVP_PKEY *key;
key 1864 ext/phar/util.c key = PEM_read_bio_PrivateKey(in, NULL,NULL, "");
key 1867 ext/phar/util.c if (!key) {
key 1876 ext/phar/util.c siglen = EVP_PKEY_size(key);
key 1897 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 800 ext/reflection/php_reflection.c char *key;
key 821 ext/reflection/php_reflection.c zend_hash_get_current_key_ex(static_variables, &key, &key_len, &num_index, 0, &pos);
key 822 ext/reflection/php_reflection.c string_printf(str, "%s Variable #%d [ $%s ]\n", indent, i++, key);
key 3389 ext/reflection/php_reflection.c char *key;
key 3395 ext/reflection/php_reflection.c zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
key 3429 ext/reflection/php_reflection.c add_assoc_zval(return_value, key, prop_copy);
key 6131 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 256 ext/session/php_session.h char *key; \
key 266 ext/session/php_session.h (key_type = zend_hash_get_current_key_ex(_ht, &key, &key_length, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTENT; \
key 273 ext/session/php_session.h if (php_get_session_var(key, key_length, &struc TSRMLS_CC) == SUCCESS) { \
key 445 ext/session/session.c for (p = key; (c = *p); p++) {
key 457 ext/session/session.c len = p - key;
key 894 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 899 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 975 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 976 ext/session/session.c if (memchr(key, PS_DELIMITER, key_length) || memchr(key, PS_UNDEF_MARKER, key_length)) {
key 986 ext/session/session.c smart_str_appendl(&buf, key, key_length);
key 2589 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 2626 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 2636 ext/session/session.c zend_hash_del(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1);
key 2668 ext/session/session.c if (Z_TYPE(progress->sid) && progress->key.c) {
key 2687 ext/session/session.c smart_str_free(&progress->key);
key 2688 ext/session/session.c smart_str_appendl(&progress->key, PS(rfc1867_prefix).c, PS(rfc1867_prefix).len);
key 2689 ext/session/session.c smart_str_appendl(&progress->key, *data->value, value_len);
key 2690 ext/session/session.c smart_str_0(&progress->key);
key 2703 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2765 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2778 ext/session/session.c if (!Z_TYPE(progress->sid) || !progress->key.c) {
key 2796 ext/session/session.c if (Z_TYPE(progress->sid) && progress->key.c) {
key 2811 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 2349 ext/soap/php_encoding.c zval key;
key 2350 ext/soap/php_encoding.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 2354 ext/soap/php_encoding.c array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val);
key 2356 ext/soap/php_encoding.c zval_dtor(&key);
key 2792 ext/soap/php_encoding.c xmlNodePtr key;
key 2800 ext/soap/php_encoding.c key = xmlNewNode(NULL, BAD_CAST("key"));
key 2801 ext/soap/php_encoding.c xmlAddChild(item,key);
key 2804 ext/soap/php_encoding.c set_xsi_type(key, "xsd:string");
key 2806 ext/soap/php_encoding.c xmlNodeSetContent(key, BAD_CAST(key_val));
key 2813 ext/soap/php_encoding.c set_xsi_type(key, "xsd:int");
key 2815 ext/soap/php_encoding.c xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len);
key 2835 ext/soap/php_encoding.c zval *ret, *key, *value;
key 2857 ext/soap/php_encoding.c key = master_to_zval(NULL, xmlKey TSRMLS_CC);
key 2860 ext/soap/php_encoding.c if (Z_TYPE_P(key) == IS_STRING) {
key 2861 ext/soap/php_encoding.c zend_symtable_update(Z_ARRVAL_P(ret), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
key 2862 ext/soap/php_encoding.c } else if (Z_TYPE_P(key) == IS_LONG) {
key 2863 ext/soap/php_encoding.c zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL);
key 2867 ext/soap/php_encoding.c zval_ptr_dtor(&key);
key 815 ext/soap/php_http.c char *key;
key 826 ext/soap/php_http.c zend_hash_get_current_key_ex(Z_ARRVAL_PP(cookies), &key, &key_len, NULL, 0, NULL);
key 839 ext/soap/php_http.c smart_str_appendl(&soap_headers, key, key_len-1);
key 403 ext/soap/php_packet_soap.c smart_str key = {0};
key 407 ext/soap/php_packet_soap.c smart_str_appends(&key, (char*)trav->ns->href);
key 408 ext/soap/php_packet_soap.c smart_str_appendc(&key,':');
key 410 ext/soap/php_packet_soap.c smart_str_appends(&key, (char*)trav->name);
key 411 ext/soap/php_packet_soap.c smart_str_0(&key);
key 412 ext/soap/php_packet_soap.c if (zend_hash_find(hdrs, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 415 ext/soap/php_packet_soap.c smart_str_free(&key);
key 1074 ext/soap/php_schema.c smart_str key = {0};
key 1083 ext/soap/php_schema.c smart_str_appends(&key, (char*)nsptr->href);
key 1090 ext/soap/php_schema.c smart_str_appends(&key, (char*)ns->children->content);
key 1093 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1094 ext/soap/php_schema.c smart_str_appends(&key, type);
key 1095 ext/soap/php_schema.c smart_str_0(&key);
key 1099 ext/soap/php_schema.c newModel->u.group_ref = estrdup(key.c);
key 1109 ext/soap/php_schema.c smart_str_appends(&key, (char*)ns->children->content);
key 1110 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1111 ext/soap/php_schema.c smart_str_appends(&key, (char*)name->children->content);
key 1112 ext/soap/php_schema.c smart_str_0(&key);
key 1125 ext/soap/php_schema.c if (zend_hash_add(sdl->groups, key.c, key.len+1, (void**)&newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key 1126 ext/soap/php_schema.c soap_error1(E_ERROR, "Parsing Schema: group '%s' already defined", key.c);
key 1131 ext/soap/php_schema.c smart_str_free(&key);
key 1505 ext/soap/php_schema.c smart_str key = {0};
key 1550 ext/soap/php_schema.c smart_str_appends(&key, newType->namens);
key 1551 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1552 ext/soap/php_schema.c smart_str_appends(&key, newType->name);
key 1559 ext/soap/php_schema.c smart_str_appends(&key, newType->name);
key 1562 ext/soap/php_schema.c smart_str_0(&key);
key 1563 ext/soap/php_schema.c if (zend_hash_add(addHash, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key 1565 ext/soap/php_schema.c soap_error1(E_ERROR, "Parsing Schema: element '%s' already defined", key.c);
key 1570 ext/soap/php_schema.c smart_str_free(&key);
key 1740 ext/soap/php_schema.c smart_str key = {0};
key 1752 ext/soap/php_schema.c smart_str_appends(&key, (char*)nsptr->href);
key 1760 ext/soap/php_schema.c smart_str_appends(&key, (char*)ns->children->content);
key 1763 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1764 ext/soap/php_schema.c smart_str_appends(&key, attr_name);
key 1765 ext/soap/php_schema.c smart_str_0(&key);
key 1766 ext/soap/php_schema.c newAttr->ref = estrdup(key.c);
key 1777 ext/soap/php_schema.c smart_str_appends(&key, (char*)ns->children->content);
key 1778 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1781 ext/soap/php_schema.c smart_str_appends(&key, (char*)name->children->content);
key 1782 ext/soap/php_schema.c smart_str_0(&key);
key 1795 ext/soap/php_schema.c if (zend_hash_add(addHash, key.c, key.len + 1, &newAttr, sizeof(sdlAttributePtr), NULL) != SUCCESS) {
key 1796 ext/soap/php_schema.c soap_error1(E_ERROR, "Parsing Schema: attribute '%s' already defined", key.c);
key 1798 ext/soap/php_schema.c smart_str_free(&key);
key 1959 ext/soap/php_schema.c smart_str key = {0};
key 1970 ext/soap/php_schema.c smart_str_appends(&key, newType->namens);
key 1971 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1972 ext/soap/php_schema.c smart_str_appends(&key, newType->name);
key 1973 ext/soap/php_schema.c smart_str_0(&key);
key 1975 ext/soap/php_schema.c if (zend_hash_add(ctx->attributeGroups, key.c, key.len + 1, &newType, sizeof(sdlTypePtr), NULL) != SUCCESS) {
key 1976 ext/soap/php_schema.c soap_error1(E_ERROR, "Parsing Schema: attributeGroup '%s' already defined", key.c);
key 1979 ext/soap/php_schema.c smart_str_free(&key);
key 1983 ext/soap/php_schema.c smart_str key = {0};
key 1996 ext/soap/php_schema.c smart_str_appends(&key, (char*)nsptr->href);
key 1998 ext/soap/php_schema.c smart_str_appendc(&key, ':');
key 1999 ext/soap/php_schema.c smart_str_appends(&key, group_name);
key 2000 ext/soap/php_schema.c smart_str_0(&key);
key 2001 ext/soap/php_schema.c newAttr->ref = estrdup(key.c);
key 2004 ext/soap/php_schema.c smart_str_free(&key);
key 2143 ext/soap/php_schema.c char* key;
key 2163 ext/soap/php_schema.c zend_hash_get_current_key_ex((*tmp)->attributes, &key, &key_len, NULL, 0, NULL);
key 2164 ext/soap/php_schema.c zend_hash_add(ht, key, key_len, &newAttr, sizeof(sdlAttributePtr), NULL);
key 201 ext/soap/php_sdl.c smart_str key = {0};
key 203 ext/soap/php_sdl.c smart_str_appends(&key, ns);
key 204 ext/soap/php_sdl.c smart_str_appendc(&key, ':');
key 205 ext/soap/php_sdl.c smart_str_appends(&key, name);
key 206 ext/soap/php_sdl.c smart_str_0(&key);
key 208 ext/soap/php_sdl.c zend_hash_find(sdl->bindings, key.c, key.len, (void **)&binding);
key 210 ext/soap/php_sdl.c smart_str_free(&key);
key 535 ext/soap/php_sdl.c smart_str key = {0};
key 543 ext/soap/php_sdl.c smart_str_appends(&key,hf->ns);
key 544 ext/soap/php_sdl.c smart_str_appendc(&key,':');
key 546 ext/soap/php_sdl.c smart_str_appends(&key,hf->name);
key 547 ext/soap/php_sdl.c smart_str_0(&key);
key 548 ext/soap/php_sdl.c if (zend_hash_add(h->headerfaults, key.c, key.len+1, (void**)&hf, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
key 551 ext/soap/php_sdl.c smart_str_free(&key);
key 640 ext/soap/php_sdl.c smart_str key = {0};
key 648 ext/soap/php_sdl.c smart_str_appends(&key,h->ns);
key 649 ext/soap/php_sdl.c smart_str_appendc(&key,':');
key 651 ext/soap/php_sdl.c smart_str_appends(&key,h->name);
key 652 ext/soap/php_sdl.c smart_str_0(&key);
key 653 ext/soap/php_sdl.c if (zend_hash_add(binding->headers, key.c, key.len+1, (void**)&h, sizeof(sdlSoapBindingFunctionHeaderPtr), NULL) != SUCCESS) {
key 656 ext/soap/php_sdl.c smart_str_free(&key);
key 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 1423 ext/soap/soap.c char *key;
key 1433 ext/soap/soap.c key = emalloc(key_len + 1);
key 1434 ext/soap/soap.c zend_str_tolower_copy(key, Z_STRVAL_PP(tmp_function), key_len);
key 1436 ext/soap/soap.c if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key 1443 ext/soap/soap.c zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key 1445 ext/soap/soap.c efree(key);
key 1450 ext/soap/soap.c char *key;
key 1455 ext/soap/soap.c key = emalloc(key_len + 1);
key 1456 ext/soap/soap.c zend_str_tolower_copy(key, Z_STRVAL_P(function_name), key_len);
key 1458 ext/soap/soap.c if (zend_hash_find(EG(function_table), key, key_len+1, (void**)&f) == FAILURE) {
key 1470 ext/soap/soap.c zend_hash_update(service->soap_functions.ft, key, key_len+1, &function_copy, sizeof(zval *), NULL);
key 1471 ext/soap/soap.c efree(key);
key 3661 ext/soap/soap.c smart_str key = {0};
key 3664 ext/soap/soap.c smart_str_appends(&key, (char*)hdr_func->ns->href);
key 3665 ext/soap/soap.c smart_str_appendc(&key, ':');
key 3667 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL(h->function_name), Z_STRLEN(h->function_name));
key 3668 ext/soap/soap.c smart_str_0(&key);
key 3669 ext/soap/soap.c if (zend_hash_find(fnb->input.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 3672 ext/soap/soap.c smart_str_free(&key);
key 3909 ext/soap/soap.c smart_str key = {0};
key 3913 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 3914 ext/soap/soap.c smart_str_appendc(&key, ':');
key 3919 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 3922 ext/soap/soap.c smart_str_0(&key);
key 3924 ext/soap/soap.c zend_hash_find(headers->hdr->headerfaults, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 3928 ext/soap/soap.c smart_str_free(&key);
key 4131 ext/soap/soap.c smart_str key = {0};
key 4136 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 4137 ext/soap/soap.c smart_str_appendc(&key, ':');
key 4142 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
key 4145 ext/soap/soap.c smart_str_0(&key);
key 4150 ext/soap/soap.c zend_hash_find(fnb->output.headers, key.c, key.len+1, (void**)&hdr) == SUCCESS) {
key 4155 ext/soap/soap.c smart_str_free(&key);
key 4364 ext/soap/soap.c smart_str key = {0};
key 4367 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(ns), Z_STRLEN_PP(ns));
key 4368 ext/soap/soap.c smart_str_appendc(&key, ':');
key 4369 ext/soap/soap.c smart_str_appendl(&key, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
key 4370 ext/soap/soap.c smart_str_0(&key);
key 4371 ext/soap/soap.c if (zend_hash_find(hdrs, key.c, key.len+1,(void**)&hdr) == SUCCESS) {
key 4378 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 848 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 851 ext/spl/spl_array.c return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
key 859 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 863 ext/spl/spl_array.c std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
key 871 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 874 ext/spl/spl_array.c return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
key 882 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 885 ext/spl/spl_array.c return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
key 893 ext/spl/spl_array.c && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
key 898 ext/spl/spl_array.c std_object_handlers.unset_property(object, member, key TSRMLS_CC);
key 1044 ext/spl/spl_array.c zend_user_it_get_current_key(iter, key TSRMLS_CC);
key 1047 ext/spl/spl_array.c ZVAL_NULL(key);
key 1049 ext/spl/spl_array.c zend_hash_get_current_key_zval_ex(aht, key, &object->pos);
key 1932 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 3105 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 1387 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 216 ext/spl/spl_iterators.c sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC);
key 218 ext/spl/spl_iterators.c ZVAL_LONG(key, iter->index);
key 884 ext/spl/spl_iterators.c function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 889 ext/spl/spl_iterators.c function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 999 ext/spl/spl_iterators.c SPL_ME(RecursiveIteratorIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 1247 ext/spl/spl_iterators.c zval prefix, key, postfix, key_copy;
key 1258 ext/spl/spl_iterators.c iterator->funcs->get_current_key(iterator, &key TSRMLS_CC);
key 1260 ext/spl/spl_iterators.c ZVAL_NULL(&key);
key 1264 ext/spl/spl_iterators.c zval *key_ptr = &key;
key 1266 ext/spl/spl_iterators.c zval_dtor(&key);
key 1270 ext/spl/spl_iterators.c if (Z_TYPE(key) != IS_STRING) {
key 1272 ext/spl/spl_iterators.c zend_make_printable_zval(&key, &key_copy, &use_copy);
key 1274 ext/spl/spl_iterators.c key = key_copy;
key 1281 ext/spl/spl_iterators.c str_len = Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix);
key 1287 ext/spl/spl_iterators.c memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key));
key 1288 ext/spl/spl_iterators.c ptr += Z_STRLEN(key);
key 1294 ext/spl/spl_iterators.c zval_dtor(&key);
key 1316 ext/spl/spl_iterators.c SPL_ME(RecursiveTreeIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 1357 ext/spl/spl_iterators.c function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 1362 ext/spl/spl_iterators.c function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
key 1665 ext/spl/spl_iterators.c if (intern->current.key) {
key 1666 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 1667 ext/spl/spl_iterators.c intern->current.key = NULL;
key 1711 ext/spl/spl_iterators.c MAKE_STD_ZVAL(intern->current.key);
key 1713 ext/spl/spl_iterators.c intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, intern->current.key TSRMLS_CC);
key 1715 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 1716 ext/spl/spl_iterators.c intern->current.key = NULL;
key 1719 ext/spl/spl_iterators.c ZVAL_LONG(intern->current.key, intern->current.pos);
key 1791 ext/spl/spl_iterators.c if (intern->current.key) {
key 1792 ext/spl/spl_iterators.c RETURN_ZVAL(intern->current.key, 1, 0);
key 2009 ext/spl/spl_iterators.c if (intern->current.data == NULL || intern->current.key == NULL) {
key 2014 ext/spl/spl_iterators.c params[1] = &intern->current.key;
key 2055 ext/spl/spl_iterators.c subject_ptr = intern->current.key;
key 2113 ext/spl/spl_iterators.c zval_ptr_dtor(&intern->current.key);
key 2114 ext/spl/spl_iterators.c MAKE_STD_ZVAL(intern->current.key);
key 2115 ext/spl/spl_iterators.c ZVAL_STRINGL(intern->current.key, result, result_len, 0);
key 2428 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 2669 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 2695 ext/spl/spl_iterators.c zval *key = intern->current.key;
key 2700 ext/spl/spl_iterators.c array_set_zval_key(HASH_OF(intern->u.caching.zcache), key, zcacheval);
key 2860 ext/spl/spl_iterators.c MAKE_COPY_ZVAL(&intern->current.key, return_value);
key 3088 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3173 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3270 ext/spl/spl_iterators.c SPL_ME(NoRewindIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3364 ext/spl/spl_iterators.c SPL_ME(EmptyIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3539 ext/spl/spl_iterators.c SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
key 3601 ext/spl/spl_iterators.c zval key;
key 3602 ext/spl/spl_iterators.c iter->funcs->get_current_key(iter, &key TSRMLS_CC);
key 3606 ext/spl/spl_iterators.c array_set_zval_key(Z_ARRVAL_P(return_value), &key, *data);
key 3607 ext/spl/spl_iterators.c zval_dtor(&key);
key 136 ext/spl/spl_iterators.h zval *key;
key 979 ext/spl/spl_observer.c SPL_ME(SplObjectStorage, key, arginfo_splobject_void,0)
key 1303 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 1046 ext/standard/array.c *key=NULL; /* Entry key */
key 1049 ext/standard/array.c args[1] = &key;
key 1091 ext/standard/array.c MAKE_STD_ZVAL(key);
key 1092 ext/standard/array.c zend_hash_get_current_key_zval(target_hash, key);
key 1100 ext/standard/array.c if (key) {
key 1101 ext/standard/array.c zval_ptr_dtor(&key);
key 1102 ext/standard/array.c key = NULL;
key 1108 ext/standard/array.c if (key) {
key 1109 ext/standard/array.c zval_ptr_dtor(&key);
key 1110 ext/standard/array.c key = NULL;
key 1570 ext/standard/array.c zval key, *key_ptr = *entry;
key 1573 ext/standard/array.c key = **entry;
key 1574 ext/standard/array.c zval_copy_ctor(&key);
key 1575 ext/standard/array.c convert_to_string(&key);
key 1576 ext/standard/array.c key_ptr = &key;
key 1583 ext/standard/array.c zval_dtor(&key);
key 1860 ext/standard/array.c char *key = NULL;
key 1882 ext/standard/array.c zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &key_len, &index, 0, NULL);
key 1883 ext/standard/array.c if (key && Z_ARRVAL_P(stack) == &EG(symbol_table)) {
key 1884 ext/standard/array.c zend_delete_global_variable(key, key_len - 1 TSRMLS_CC);
key 1886 ext/standard/array.c zend_hash_del_key_or_index(Z_ARRVAL_P(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
key 4070 ext/standard/array.c zval *key = NULL;
key 4096 ext/standard/array.c args[1] = &key;
key 4100 ext/standard/array.c args[0] = &key;
key 4113 ext/standard/array.c MAKE_STD_ZVAL(key);
key 4117 ext/standard/array.c Z_TYPE_P(key) = IS_LONG;
key 4118 ext/standard/array.c Z_LVAL_P(key) = num_key;
key 4122 ext/standard/array.c ZVAL_STRINGL(key, string_key, string_key_len - 1, 1);
key 4137 ext/standard/array.c zval_ptr_dtor(&key);
key 4300 ext/standard/array.c zval *key; /* key to check for */
key 4303 ext/standard/array.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zH", &key, &array) == FAILURE) {
key 4307 ext/standard/array.c switch (Z_TYPE_P(key)) {
key 4309 ext/standard/array.c if (zend_symtable_exists(array, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1)) {
key 4314 ext/standard/array.c if (zend_hash_index_exists(array, Z_LVAL_P(key))) {
key 4441 ext/standard/array.c zval key, *key_ptr = *entry_keys;
key 4444 ext/standard/array.c key = **entry_keys;
key 4445 ext/standard/array.c zval_copy_ctor(&key);
key 4446 ext/standard/array.c convert_to_string(&key);
key 4447 ext/standard/array.c key_ptr = &key;
key 4454 ext/standard/array.c zval_dtor(&key);
key 3279 ext/standard/basic_functions.c PHP_FE(key, arginfo_key)
key 3400 ext/standard/basic_functions.c SetEnvironmentVariable(pe->key, "bugbug");
key 3408 ext/standard/basic_functions.c unsetenv(pe->key);
key 3410 ext/standard/basic_functions.c SetEnvironmentVariable(pe->key, NULL);
key 3412 ext/standard/basic_functions.c _putenv_s(pe->key, "");
key 3418 ext/standard/basic_functions.c if (!strncmp(*env, pe->key, pe->key_len) && (*env)[pe->key_len] == '=') { /* found it */
key 3428 ext/standard/basic_functions.c if (!strncmp(pe->key, "TZ", pe->key_len)) {
key 3434 ext/standard/basic_functions.c efree(pe->key);
key 4069 ext/standard/basic_functions.c pe.key = estrndup(setting, setting_len);
key 4070 ext/standard/basic_functions.c if ((p = strchr(pe.key, '='))) { /* nullify the '=' if there is one */
key 4077 ext/standard/basic_functions.c pe.key_len = strlen(pe.key);
key 4089 ext/standard/basic_functions.c zend_hash_del(&BG(putenv_ht), pe.key, pe.key_len+1);
key 4094 ext/standard/basic_functions.c if (!strncmp(*env, pe.key, pe.key_len) && (*env)[pe.key_len] == '=') { /* found it */
key 4114 ext/standard/basic_functions.c error_code = SetEnvironmentVariable(pe.key, value);
key 4123 ext/standard/basic_functions.c && _putenv_s(pe.key, value ? value : "") == 0
key 4128 ext/standard/basic_functions.c zend_hash_add(&BG(putenv_ht), pe.key, pe.key_len + 1, (void **) &pe, sizeof(putenv_entry), NULL);
key 4130 ext/standard/basic_functions.c if (!strncmp(pe.key, "TZ", pe.key_len)) {
key 4137 ext/standard/basic_functions.c efree(pe.key);
key 5875 ext/standard/basic_functions.c ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1));
key 5876 ext/standard/basic_functions.c if (zend_hash_index_find(Z_ARRVAL_P(arr), key, (void **) &find_hash) == FAILURE) {
key 5881 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 384 ext/standard/crypt_sha256.c key_len = strlen(key);
key 386 ext/standard/crypt_sha256.c if ((key - (char *) 0) % __alignof__ (uint32_t) != 0) {
key 388 ext/standard/crypt_sha256.c key = copied_key = memcpy(tmp + __alignof__(uint32_t) - (tmp - (char *) 0) % __alignof__(uint32_t), key, key_len);
key 402 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &ctx);
key 415 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 421 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 439 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &ctx);
key 451 ext/standard/crypt_sha256.c sha256_process_bytes(key, key_len, &alt_ctx);
key 616 ext/standard/crypt_sha256.c return php_sha256_crypt_r(key, salt, buffer, buflen);
key 418 ext/standard/crypt_sha512.c key_len = strlen(key);
key 420 ext/standard/crypt_sha512.c if ((key - (char *) 0) % __alignof__ (uint64_t) != 0) {
key 422 ext/standard/crypt_sha512.c key = copied_key =
key 423 ext/standard/crypt_sha512.c memcpy(tmp + __alignof__(uint64_t) - (tmp - (char *) 0) % __alignof__(uint64_t), key, key_len);
key 436 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &ctx);
key 449 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 455 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 473 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &ctx);
key 485 ext/standard/crypt_sha512.c sha512_process_bytes(key, key_len, &alt_ctx);
key 662 ext/standard/crypt_sha512.c return php_sha512_crypt_r (key, salt, buffer, buflen);
key 1212 ext/standard/filestat.c if (LONG_MAX >= bucket->key) {
key 1213 ext/standard/filestat.c add_assoc_long(entry, "key", bucket->key);
key 1215 ext/standard/filestat.c add_assoc_double(entry, "key", (double)bucket->key);
key 1562 ext/standard/html.c char key[9] = ""; /* two unicode code points in UTF-8 */
key 1566 ext/standard/html.c written_k1 = write_octet_sequence(key, charset, orig_cp);
key 1572 ext/standard/html.c add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key 1582 ext/standard/html.c add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
key 1601 ext/standard/html.c written_k2 = write_octet_sequence(&key[written_k1], charset, spe_cp);
key 1605 ext/standard/html.c add_assoc_stringl_ex(arr, key, written_k1 + written_k2 + 1, entity, l + 1, 1);
key 34 ext/standard/http.c char *key = NULL;
key 59 ext/standard/http.c (key_type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL)) != HASH_KEY_NON_EXISTENT;
key 62 ext/standard/http.c if (key_type == HASH_KEY_IS_STRING && key_len && key[key_len-1] == '\0') {
key 68 ext/standard/http.c if (key && *key == '\0' && type != NULL) {
key 72 ext/standard/http.c if (zend_check_property_access(zobj, key, key_len TSRMLS_CC) != SUCCESS) {
key 76 ext/standard/http.c zend_unmangle_property_name_ex(key, key_len, &tmp, (const char**)&key, &key_len);
key 86 ext/standard/http.c ekey = php_raw_url_encode(key, key_len, &ekey_len);
key 88 ext/standard/http.c ekey = php_url_encode(key, key_len, &ekey_len);
key 154 ext/standard/http.c ekey = php_raw_url_encode(key, key_len, &ekey_len);
key 156 ext/standard/http.c ekey = php_url_encode(key, key_len, &ekey_len);
key 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 661 ext/standard/streamsfuncs.c char *key;
key 668 ext/standard/streamsfuncs.c &key, &key_len, &num_ind, 0, NULL);
key 688 ext/standard/streamsfuncs.c zend_hash_update(new_hash, key, key_len, (void *)elem, sizeof(zval *), (void **)&dest_elem);
key 379 ext/standard/url.c long key = -1;
key 381 ext/standard/url.c if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &key) == FAILURE) {
key 391 ext/standard/url.c if (key > -1) {
key 392 ext/standard/url.c switch (key) {
key 418 ext/standard/url.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid URL component identifier %ld", key);
key 49 ext/standard/url_scanner_ex.c char *key;
key 68 ext/standard/url_scanner_ex.c for (key = php_strtok_r(tmp, ",", &lasts);
key 69 ext/standard/url_scanner_ex.c key;
key 70 ext/standard/url_scanner_ex.c key = php_strtok_r(NULL, ",", &lasts)) {
key 73 ext/standard/url_scanner_ex.c val = strchr(key, '=');
key 79 ext/standard/url_scanner_ex.c for (q = key; *q; q++)
key 81 ext/standard/url_scanner_ex.c keylen = q - key;
key 84 ext/standard/url_scanner_ex.c zend_hash_add(ctx->tags, key, keylen, val, strlen(val)+1, NULL);
key 358 ext/standard/var.c char *key, *tmp_str;
key 360 ext/standard/var.c key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
key 361 ext/standard/var.c tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
key 369 ext/standard/var.c efree(key);
key 634 ext/standard/var.c char *key;
key 648 ext/standard/var.c i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);
key 654 ext/standard/var.c if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
key 849 ext/standard/var.c char *key;
key 857 ext/standard/var.c i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
key 861 ext/standard/var.c if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
key 870 ext/standard/var.c php_var_serialize_string(buf, key, key_len - 1);
key 299 ext/standard/var_unserializer.c zval *key, *data, **old_data;
key 301 ext/standard/var_unserializer.c ALLOC_INIT_ZVAL(key);
key 303 ext/standard/var_unserializer.c if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
key 304 ext/standard/var_unserializer.c zval_dtor(key);
key 305 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 309 ext/standard/var_unserializer.c if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
key 310 ext/standard/var_unserializer.c zval_dtor(key);
key 311 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 318 ext/standard/var_unserializer.c zval_dtor(key);
key 319 ext/standard/var_unserializer.c FREE_ZVAL(key);
key 325 ext/standard/var_unserializer.c switch (Z_TYPE_P(key)) {
key 327 ext/standard/var_unserializer.c if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
key 330 ext/standard/var_unserializer.c zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
key 333 ext/standard/var_unserializer.c if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key 336 ext/standard/var_unserializer.c zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
key 341 ext/standard/var_unserializer.c convert_to_string(key);
key 342 ext/standard/var_unserializer.c if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
key 345 ext/standard/var_unserializer.c zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,
key 350 ext/standard/var_unserializer.c zval_dtor(key);
key 351 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 191 ext/sysvsem/sysvsem.c long key, max_acquire = 1, perm = 0666, auto_release = 1;
key 197 ext/sysvsem/sysvsem.c if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|lll", &key, &max_acquire, &perm, &auto_release)) {
key 207 ext/sysvsem/sysvsem.c semid = semget(key, 3, perm|IPC_CREAT);
key 209 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 241 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed acquiring SYSVSEM_SETVAL for key 0x%lx: %s", key, strerror(errno));
key 249 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 260 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 265 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 270 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed for key 0x%lx: %s", key, strerror(errno));
key 282 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed releasing SYSVSEM_SETVAL for key 0x%lx: %s", key, strerror(errno));
key 288 ext/sysvsem/sysvsem.c sem_ptr->key = key;
key 319 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "SysV semaphore %ld (key 0x%x) is not currently acquired", Z_LVAL_P(arg_id), sem_ptr->key);
key 330 ext/sysvsem/sysvsem.c php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to %s key 0x%x: %s", acquire ? "acquire" : "release", sem_ptr->key, strerror(errno));
key 41 ext/sysvshm/php_sysvshm.h long key;
key 56 ext/sysvshm/php_sysvshm.h key_t key; /* key set by user */
key 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 273 ext/wddx/wddx.c php_wddx_serialize_var(packet, *struc, key, key_length TSRMLS_CC);
key 295 ext/wddx/wddx.c char *key;
key 313 ext/wddx/wddx.c hash_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(retval), &key, &key_length, &idx, 0, NULL);
key 318 ext/wddx/wddx.c key = tmp;
key 321 ext/wddx/wddx.c php_set_session_var(key, key_length-1, *ent, NULL TSRMLS_CC);
key 322 ext/wddx/wddx.c PS_ADD_VAR(key);
key 458 ext/wddx/wddx.c const char *key;
key 529 ext/wddx/wddx.c if (zend_hash_get_current_key_ex(objhash, &key, &key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
key 532 ext/wddx/wddx.c zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
key 556 ext/wddx/wddx.c char *key;
key 572 ext/wddx/wddx.c type = zend_hash_get_current_key(target_hash, &key, &idx, 0);
key 602 ext/wddx/wddx.c ent_type = zend_hash_get_current_key_ex(target_hash, &key, &key_len, &idx, 0, NULL);
key 605 ext/wddx/wddx.c php_wddx_serialize_var(packet, *ent, key, key_len TSRMLS_CC);
key 849 ext/wddx/wddx.c char *key;
key 855 ext/wddx/wddx.c key = estrndup(p1, p2 - p1);
key 858 ext/wddx/wddx.c add_assoc_zval_ex(ent.data, key, p2 - p1 + 1, tmp);
key 860 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 86 ext/zip/lib/zip_source_pkware.c ctx->key[0] = KEY0;
key 87 ext/zip/lib/zip_source_pkware.c ctx->key[1] = KEY1;
key 88 ext/zip/lib/zip_source_pkware.c ctx->key[2] = KEY2;
key 114 ext/zip/lib/zip_source_pkware.c tmp = (zip_uint16_t)(ctx->key[2] | 2);
key 124 ext/zip/lib/zip_source_pkware.c ctx->key[0] = (zip_uint32_t)crc32(ctx->key[0] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key 125 ext/zip/lib/zip_source_pkware.c ctx->key[1] = (ctx->key[1] + (ctx->key[0] & 0xff)) * 134775813 + 1;
key 126 ext/zip/lib/zip_source_pkware.c b = ctx->key[1] >> 24;
key 127 ext/zip/lib/zip_source_pkware.c ctx->key[2] = (zip_uint32_t)crc32(ctx->key[2] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;
key 60 ext/zip/php_zip.c #define KEY_ARG_DC , const zend_literal *key
key 61 ext/zip/php_zip.c #define KEY_ARG_CC , key
key 903 ext/zip/php_zip.c key = NULL;
key 912 ext/zip/php_zip.c if (key) {
key 913 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 947 ext/zip/php_zip.c key = NULL;
key 956 ext/zip/php_zip.c if (key) {
key 957 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 997 ext/zip/php_zip.c key = NULL;
key 1006 ext/zip/php_zip.c if (key) {
key 1007 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 1053 ext/zip/php_zip.c char *key;
key 1067 ext/zip/php_zip.c zend_hash_get_current_key_ex(obj->prop_handler, &key, &key_len, &num_key, 0, &pos);
key 1073 ext/zip/php_zip.c zend_hash_update(props, key, key_len, (void *)&val, sizeof(zval *), NULL);
key 282 main/php_ini.c char *key = NULL;
key 287 main/php_ini.c key = Z_STRVAL_P(arg1);
key 288 main/php_ini.c key = key + sizeof("PATH") - 1;
key 294 main/php_ini.c TRANSLATE_SLASHES_LOWER(key);
key 298 main/php_ini.c key = Z_STRVAL_P(arg1);
key 299 main/php_ini.c key = key + sizeof("HOST") - 1;
key 303 main/php_ini.c zend_str_tolower(key, key_len); /* host names are case-insensitive. */
key 309 main/php_ini.c if (key && key_len > 0) {
key 311 main/php_ini.c while (key_len > 0 && (key[key_len - 1] == '/' || key[key_len - 1] == '\\')) {
key 313 main/php_ini.c key[key_len] = 0;
key 317 main/php_ini.c while (*key && (
key 318 main/php_ini.c *key == '=' ||
key 319 main/php_ini.c *key == ' ' ||
key 320 main/php_ini.c *key == '\t'
key 322 main/php_ini.c key++;
key 327 main/php_ini.c if (zend_hash_find(target_hash, key, key_len + 1, (void **) &entry) == FAILURE) {
key 335 main/php_ini.c zend_hash_update(target_hash, key, key_len + 1, section_arr, sizeof(zval), (void **) &entry);
key 233 main/rfc1867.c char *key;
key 377 main/rfc1867.c if (h->key) {
key 378 main/rfc1867.c efree(h->key);
key 409 main/rfc1867.c char *key = NULL;
key 433 main/rfc1867.c if(buf_value.c && key) {
key 436 main/rfc1867.c entry.key = key;
key 440 main/rfc1867.c key = NULL;
key 446 main/rfc1867.c key = estrdup(line);
key 454 main/rfc1867.c if(buf_value.c && key) {
key 457 main/rfc1867.c entry.key = key;
key 469 main/rfc1867.c if (key == NULL) {
key 475 main/rfc1867.c if (!strcasecmp(entry->key, key)) {
key 810 main/rfc1867.c char *key = NULL, *word = pair;
key 817 main/rfc1867.c key = getword(mbuff->input_encoding, &pair, '=' TSRMLS_CC);
key 819 main/rfc1867.c if (!strcasecmp(key, "name")) {
key 832 main/rfc1867.c } else if (!strcasecmp(key, "filename")) {
key 847 main/rfc1867.c if (key) {
key 848 main/rfc1867.c efree(key);
key 628 main/streams/memory.c char *comma, *semi, *sep, *key;
key 699 main/streams/memory.c key = estrndup(path, plen);
key 700 main/streams/memory.c add_assoc_stringl_ex(meta, key, plen + 1, sep + 1, vlen, 1);
key 701 main/streams/memory.c efree(key);
key 2223 run-tests.php reset($old1); $k1 = key($old1); $l1 = -2;
key 2224 run-tests.php reset($old2); $k2 = key($old2); $l2 = -2;
key 2231 run-tests.php $k1 = next($old1) ? key($old1) : null;
key 2235 run-tests.php $k2 = next($old2) ? key($old2) : null;
key 2239 run-tests.php $k1 = next($old1) ? key($old1) : null;
key 2243 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 66 sapi/apache2filter/php_apache.h key = elts[i].key; \
key 157 sapi/apache2filter/php_functions.c char *key, *val;
key 164 sapi/apache2filter/php_functions.c APR_ARRAY_FOREACH_OPEN(arr, key, val)
key 166 sapi/apache2filter/php_functions.c add_assoc_string(return_value, key, val, 1);
key 177 sapi/apache2filter/php_functions.c char *key, *val;
key 184 sapi/apache2filter/php_functions.c APR_ARRAY_FOREACH_OPEN(arr, key, val)
key 186 sapi/apache2filter/php_functions.c add_assoc_string(return_value, key, val, 1);
key 232 sapi/apache2filter/sapi_apache2.c char *key, *val;
key 235 sapi/apache2filter/sapi_apache2.c APR_ARRAY_FOREACH_OPEN(arr, key, val)
key 239 sapi/apache2filter/sapi_apache2.c if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len TSRMLS_CC)) {
key 240 sapi/apache2filter/sapi_apache2.c php_register_variable_safe(key, val, new_val_len, track_vars_array TSRMLS_CC);
key 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 559 sapi/fpm/fpm/fpm_conf.c kv->key = strdup(Z_STRVAL_P(key));
key 561 sapi/fpm/fpm/fpm_conf.c if (!kv->key) {
key 569 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 577 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 584 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 664 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 670 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 676 sapi/fpm/fpm/fpm_conf.c free(kv->key);
key 1078 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, *p)) {
key 1084 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, "error_log") && !strcasecmp(kv->value, "syslog")) {
key 1088 sapi/fpm/fpm/fpm_conf.c if (!strcasecmp(kv->key, *p)) {
key 1407 sapi/fpm/fpm/fpm_conf.c if (!Z_STRVAL_P(key) || !Z_STRVAL_P(value) || !*Z_STRVAL_P(key)) {
key 1425 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1429 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1433 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 0);
key 1437 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 1);
key 1441 sapi/fpm/fpm/fpm_conf.c err = fpm_conf_set_array(key, value, &config, 1);
key 1450 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_ERROR, "[%s:%d] error while parsing '%s[%s]' : %s", ini_filename, ini_lineno, Z_STRVAL_P(name), Z_STRVAL_P(key), err);
key 1629 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_NOTICE, "\tenv[%s] = %s", kv->key, kv->value);
key 1633 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_NOTICE, "\tphp_value[%s] = %s", kv->key, kv->value);
key 1637 sapi/fpm/fpm/fpm_conf.c zlog(ZLOG_NOTICE, "\tphp_admin_value[%s] = %s", kv->key, kv->value);
key 19 sapi/fpm/fpm/fpm_conf.h char *key;
key 151 sapi/fpm/fpm/fpm_env.c setenv(kv->key, kv->value, 1);
key 184 sapi/fpm/fpm/fpm_env.c if (!strcmp(kv->key, "USER")) {
key 189 sapi/fpm/fpm/fpm_env.c if (!strcmp(kv->key, "HOME")) {
key 1432 sapi/fpm/fpm/fpm_main.c char *key;
key 1443 sapi/fpm/fpm/fpm_main.c key = Z_STRVAL_P(arg1);
key 1445 sapi/fpm/fpm/fpm_main.c if (!key || strlen(key) < 1) {
key 1455 sapi/fpm/fpm/fpm_main.c zlog(ZLOG_ERROR, "Passing INI directive through FastCGI: empty value for key '%s'", key);
key 1459 sapi/fpm/fpm/fpm_main.c kv.key = key;
key 1463 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 401 sapi/fpm/fpm/fpm_sockets.c unlink(ls->key);
key 403 sapi/fpm/fpm/fpm_sockets.c free(ls->key);
key 1094 sapi/phpdbg/phpdbg_bp.c char *key;
key 1131 sapi/phpdbg/phpdbg_bp.c (*table), &key, &klen, &idx, 0, &position)) {
key 1134 sapi/phpdbg/phpdbg_bp.c zend_hash_del((*table), key, klen);
key 156 sapi/phpdbg/phpdbg_help.c for (p = phpdbg_help_text; p->key; p++) {
key 157 sapi/phpdbg/phpdbg_help.c if (!strcmp(p->key, key)) {
key 184 sapi/phpdbg/phpdbg_help.c if (c->alias == key[0]) {
key 193 sapi/phpdbg/phpdbg_help.c if (!strncmp(c->name, key, len)) {
key 43 sapi/phpdbg/phpdbg_help.h char *key;
key 135 sapi/phpdbg/phpdbg_utils.h Z_TYPE_P(key) = IS_NULL;
key 137 sapi/phpdbg/phpdbg_utils.h Z_TYPE_P(key) = IS_STRING;
key 138 sapi/phpdbg/phpdbg_utils.h Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
key 139 sapi/phpdbg/phpdbg_utils.h Z_STRLEN_P(key) = p->nKeyLength - 1;
key 141 sapi/phpdbg/phpdbg_utils.h Z_TYPE_P(key) = IS_LONG;
key 142 sapi/phpdbg/phpdbg_utils.h Z_LVAL_P(key) = p->h;
key 142 sapi/phpdbg/phpdbg_watch.c if (*key != 0) {
key 143 sapi/phpdbg/phpdbg_watch.c return key;
key 145 sapi/phpdbg/phpdbg_watch.c return strchr(key + 1, 0) + 1;
key 172 sapi/phpdbg/phpdbg_watch.c zval key;
key 183 sapi/phpdbg/phpdbg_watch.c zend_hash_get_current_key_zval_ex(ht, &key, &position);
key 184 sapi/phpdbg/phpdbg_watch.c if (Z_TYPE(key) == IS_STRING) {
key 185 sapi/phpdbg/phpdbg_watch.c new_watch->name_in_parent = zend_strndup(Z_STRVAL(key), Z_STRLEN(key));
key 186 sapi/phpdbg/phpdbg_watch.c new_watch->name_in_parent_len = Z_STRLEN(key);
key 189 sapi/phpdbg/phpdbg_watch.c new_watch->name_in_parent_len = asprintf(&new_watch->name_in_parent, "%ld", Z_LVAL(key));
key 226 sapi/phpdbg/phpdbg_watch.c zval key;
key 236 sapi/phpdbg/phpdbg_watch.c zend_hash_get_current_key_zval_ex(ht, &key, &position);
key 238 sapi/phpdbg/phpdbg_watch.c if (Z_TYPE(key) == IS_STRING) {
key 239 sapi/phpdbg/phpdbg_watch.c str_len = asprintf(&str, "%.*s%s%s%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", phpdbg_get_property_key(Z_STRVAL(key)), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
key 241 sapi/phpdbg/phpdbg_watch.c str_len = asprintf(&str, "%.*s%s%li%s", (int)watch->parent->str_len, watch->parent->str, Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"[":"->", Z_LVAL(key), Z_TYPE_P(watch->parent->addr.zv) == IS_ARRAY?"]":"");
key 336 sapi/phpdbg/phpdbg_watch.c zval *key = emalloc(sizeof(zval));
key 339 sapi/phpdbg/phpdbg_watch.c zend_hash_get_current_key_zval_ex(parent, key, &position);
key 340 sapi/phpdbg/phpdbg_watch.c convert_to_string(key);
key 341 sapi/phpdbg/phpdbg_watch.c watch->str = malloc(i + Z_STRLEN_P(key) + 2);
key 342 sapi/phpdbg/phpdbg_watch.c watch->str_len = sprintf(watch->str, "%.*s%s%s", (int)i, input, phpdbg_get_property_key(Z_STRVAL_P(key)), input[len - 1] == ']'?"]":"");
key 343 sapi/phpdbg/phpdbg_watch.c efree(key);
key 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) {