type              168 TSRM/TSRM.h    #define TSRMG(id, type, element)	(TSRMG_BULK(id, type)->element)
type              169 TSRM/TSRM.h    #define TSRMG_BULK(id, type)	((type) (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(id)])
type              171 TSRM/TSRM.h    #define TSRMG_STATIC(id, type, element)	(TSRMG_BULK_STATIC(id, type)->element)
type              172 TSRM/TSRM.h    #define TSRMG_BULK_STATIC(id, type)	((type) (*((void ***) TSRMLS_CACHE))[TSRM_UNSHUFFLE_RSRC_ID(id)])
type              199 TSRM/TSRM.h    #define TSRMG_STATIC(id, type, element)
type               53 TSRM/tsrm_nw.c TSRM_API FILE* popen(const char *commandline, const char *type)
type               73 TSRM/tsrm_nw.c 	if (!commandline || !type)
type               82 TSRM/tsrm_nw.c 	if (strcmp(type, "r") == 0)
type               88 TSRM/tsrm_nw.c 	else if (strcmp(type, "w") == 0)
type              202 TSRM/tsrm_nw.c 		stream = fdopen(pipe_handle, type);
type               26 TSRM/tsrm_nw.h TSRM_API FILE* popen(const char *command, const char *type);
type              215 TSRM/tsrm_win32.c 		DWORD type;
type              216 TSRM/tsrm_win32.c 		return GetBinaryType(pathname, &type) ? 0 : -1;
type              452 TSRM/tsrm_win32.c TSRM_API FILE *popen(const char *command, const char *type)
type              455 TSRM/tsrm_win32.c 	return popen_ex(command, type, NULL, NULL);
type              458 TSRM/tsrm_win32.c TSRM_API FILE *popen_ex(const char *command, const char *type, const char *cwd, char *env)
type              471 TSRM/tsrm_win32.c 	char *ptype = (char *)type;
type              476 TSRM/tsrm_win32.c 	if (!type) {
type              481 TSRM/tsrm_win32.c 	type_len = (int)strlen(type);
type              508 TSRM/tsrm_win32.c 	read = (type[0] == 'r') ? TRUE : FALSE;
type              509 TSRM/tsrm_win32.c 	mode = ((type_len == 2) && (type[1] == 'b')) ? O_BINARY : O_TEXT;
type              565 TSRM/tsrm_win32.c 	stream = _fdopen(fno, type);
type              102 TSRM/tsrm_win32.h TSRM_API FILE *popen_ex(const char *command, const char *type, const char *cwd, char *env);
type              103 TSRM/tsrm_win32.h TSRM_API FILE *popen(const char *command, const char *type);
type               56 Zend/zend.c    ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
type              825 Zend/zend.c    			if (func->type == ZEND_USER_FUNCTION) {
type              830 Zend/zend.c    			if (ce->type == ZEND_USER_CLASS) {
type             1032 Zend/zend.c    ZEND_API ZEND_COLD void zend_error(int type, const char *format, ...) /* {{{ */
type             1034 Zend/zend.c    static ZEND_COLD void zend_error_va_list(int type, const char *format, va_list args)
type             1059 Zend/zend.c    		switch (type) {
type             1068 Zend/zend.c    				while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type             1087 Zend/zend.c    	switch (type) {
type             1152 Zend/zend.c    		|| !(EG(user_error_handler_error_reporting) & type)
type             1154 Zend/zend.c    		zend_error_cb(type, error_filename, error_lineno, format, args);
type             1155 Zend/zend.c    	} else switch (type) {
type             1163 Zend/zend.c    			zend_error_cb(type, error_filename, error_lineno, format, args);
type             1186 Zend/zend.c    			ZVAL_LONG(&params[0], type);
type             1225 Zend/zend.c    						zend_error_cb(type, error_filename, error_lineno, format, args);
type             1231 Zend/zend.c    				zend_error_cb(type, error_filename, error_lineno, format, args);
type             1259 Zend/zend.c    	if (type == E_PARSE) {
type             1263 Zend/zend.c    			ZEND_USER_CODE(EG(current_execute_data)->func->type) &&
type             1274 Zend/zend.c    ZEND_COLD void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((alias("zend_error"),noreturn));
type             1276 Zend/zend.c    ZEND_API ZEND_COLD void zend_error(int type, const char *format, ...) /* {{{ */
type             1281 Zend/zend.c    	zend_error_va_list(type, format, va);
type             1285 Zend/zend.c    ZEND_API ZEND_COLD ZEND_NORETURN void zend_error_noreturn(int type, const char *format, ...)
type             1290 Zend/zend.c    	zend_error_va_list(type, format, va);
type             1407 Zend/zend.c    ZEND_API int zend_execute_scripts(int type, zval *retval, int file_count, ...) /* {{{ */
type             1421 Zend/zend.c    		op_array = zend_compile_file(file_handle, type);
type             1435 Zend/zend.c    		} else if (type==ZEND_REQUIRE) {
type               63 Zend/zend.h    	 !ZEND_USER_CODE(EX(prev_execute_data)->func->common.type) || \
type               84 Zend/zend.h    ZEND_COLD void zend_error_noreturn(int type, const char *format, ...) ZEND_NORETURN;
type               86 Zend/zend.h    ZEND_API ZEND_COLD ZEND_NORETURN void zend_error_noreturn(int type, const char *format, ...);
type              132 Zend/zend.h    	char type;
type              196 Zend/zend.h    	void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
type              281 Zend/zend.h    extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
type              289 Zend/zend.h    ZEND_API ZEND_COLD void zend_error(int type, const char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
type              164 Zend/zend_API.c ZEND_API char *zend_get_type_by_const(int type) /* {{{ */
type              166 Zend/zend_API.c 	switch(type) {
type              329 Zend/zend_API.c 		int type;
type              331 Zend/zend_API.c 		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), dest, &d)) != IS_LONG)) {
type              332 Zend/zend_API.c 			if (EXPECTED(type != 0)) {
type              378 Zend/zend_API.c 		int type;
type              380 Zend/zend_API.c 		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), dest, &d)) != IS_LONG)) {
type              381 Zend/zend_API.c 			if (EXPECTED(type != 0)) {
type              420 Zend/zend_API.c 		int type;
type              422 Zend/zend_API.c 		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, dest)) != IS_DOUBLE)) {
type              423 Zend/zend_API.c 			if (EXPECTED(type != 0)) {
type             1817 Zend/zend_API.c 			if (dep->type == MODULE_DEP_REQUIRED) {
type             1849 Zend/zend_API.c 		if (module->module_startup_func(module->type, module->module_number)==FAILURE) {
type             1882 Zend/zend_API.c 				if (dep->type == MODULE_DEP_REQUIRED || dep->type == MODULE_DEP_OPTIONAL) {
type             1950 Zend/zend_API.c 		if (ce->type == ZEND_INTERNAL_CLASS &&
type             1963 Zend/zend_API.c 			if (ce->type == ZEND_INTERNAL_CLASS &&
type             2007 Zend/zend_API.c 			if (dep->type == MODULE_DEP_CONFLICTS) {
type             2037 Zend/zend_API.c 	if (module->functions && zend_register_functions(NULL, module->functions, NULL, module->type)==FAILURE) {
type             2051 Zend/zend_API.c 	module->type = MODULE_PERSISTENT;
type             2121 Zend/zend_API.c ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type) /* {{{ */
type             2135 Zend/zend_API.c 	if (type==MODULE_PERSISTENT) {
type             2144 Zend/zend_API.c 	internal_function->type = ZEND_INTERNAL_FUNCTION;
type             2478 Zend/zend_API.c 	if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module->module_number == module_number) {
type             2495 Zend/zend_API.c 	if (module->type == MODULE_TEMPORARY) {
type             2505 Zend/zend_API.c 		module->module_shutdown_func(module->type, module->module_number);
type             2543 Zend/zend_API.c 		if (module->request_startup_func(module->type, module->module_number)==FAILURE) {
type             2561 Zend/zend_API.c 		module->request_shutdown_func(module->type, module->module_number);
type             2580 Zend/zend_API.c 				module->request_shutdown_func(module->type, module->module_number);
type             2601 Zend/zend_API.c 	return (module->type == MODULE_TEMPORARY) ? ZEND_HASH_APPLY_REMOVE : ZEND_HASH_APPLY_STOP;
type             2653 Zend/zend_API.c 	class_entry->type = ZEND_INTERNAL_CLASS;
type             2882 Zend/zend_API.c 		while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type             3070 Zend/zend_API.c 							if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
type             3238 Zend/zend_API.c 			     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
type             3239 Zend/zend_API.c 			     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
type             3240 Zend/zend_API.c 				if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
type             3325 Zend/zend_API.c 					     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
type             3326 Zend/zend_API.c 					     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
type             3327 Zend/zend_API.c 						if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
type             3400 Zend/zend_API.c 		     fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
type             3401 Zend/zend_API.c 		     fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
type             3402 Zend/zend_API.c 			if (fcc.function_handler->type != ZEND_OVERLOADED_FUNCTION) {
type             3611 Zend/zend_API.c 	if (ce->type == ZEND_INTERNAL_CLASS) {
type             3634 Zend/zend_API.c 			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval) * ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
type             3637 Zend/zend_API.c 		if (ce->type == ZEND_USER_CLASS) {
type             3649 Zend/zend_API.c 			ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
type             3653 Zend/zend_API.c 	if (ce->type & ZEND_INTERNAL_CLASS) {
type             3667 Zend/zend_API.c 		property_info->name = zend_mangle_property_name(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
type             3670 Zend/zend_API.c 		property_info->name = zend_mangle_property_name("*", 1, ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
type             3685 Zend/zend_API.c 	zend_string *key = zend_string_init(name, name_length, ce->type & ZEND_INTERNAL_CLASS);
type             3732 Zend/zend_API.c 	ZVAL_NEW_STR(&property, zend_string_init(value, strlen(value), ce->type & ZEND_INTERNAL_CLASS));
type             3741 Zend/zend_API.c 	ZVAL_NEW_STR(&property, zend_string_init(value, value_len, ce->type & ZEND_INTERNAL_CLASS));
type             3796 Zend/zend_API.c 	ZVAL_NEW_STR(&constant, zend_string_init(value, value_length, ce->type & ZEND_INTERNAL_CLASS));
type             4125 Zend/zend_API.c 	if (f->common.type != ZEND_USER_FUNCTION ||
type              111 Zend/zend_API.h #define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, class_name, allow_null) \
type              113 Zend/zend_API.h 	   	{ (const char*)(zend_uintptr_t)(required_num_args), class_name, type, return_reference, allow_null, 0 },
type              114 Zend/zend_API.h #define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO(name, type, class_name, allow_null) \
type              115 Zend/zend_API.h 	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, 0, -1, type, class_name, allow_null)
type              238 Zend/zend_API.h #	define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members_table:CG(static_members_table)[(zend_intptr_t)(ce)->static_members_table])
type              278 Zend/zend_API.h ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type);
type              359 Zend/zend_API.h ZEND_API char *zend_get_type_by_const(int type);
type              267 Zend/zend_ast.h static zend_always_inline zend_ast *zend_ast_create_cast(uint32_t type, zend_ast *op0) {
type              268 Zend/zend_ast.h 	return zend_ast_create_ex(ZEND_AST_CAST, type, op0);
type              226 Zend/zend_builtin_functions.c 	ZEND_ARG_INFO(0, type)
type              363 Zend/zend_builtin_functions.c 	zend_builtin_module.type = MODULE_PERSISTENT;
type             1284 Zend/zend_builtin_functions.c 				if (mptr->type == ZEND_USER_FUNCTION &&
type             1566 Zend/zend_builtin_functions.c 	RETURN_BOOL(func && (func->type != ZEND_INTERNAL_FUNCTION ||
type             1588 Zend/zend_builtin_functions.c 		if (ce->type == ZEND_USER_CLASS) {
type             1917 Zend/zend_builtin_functions.c 	if (func->type == ZEND_INTERNAL_FUNCTION) {
type             1919 Zend/zend_builtin_functions.c 	} else if (func->type == ZEND_USER_FUNCTION) {
type             2082 Zend/zend_builtin_functions.c 	zend_string *type = NULL;
type             2087 Zend/zend_builtin_functions.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|S", &type) == FAILURE) {
type             2091 Zend/zend_builtin_functions.c 	if (!type) {
type             2099 Zend/zend_builtin_functions.c 	} else if (zend_string_equals_literal(type, "Unknown")) {
type             2108 Zend/zend_builtin_functions.c 		int id = zend_fetch_list_dtor_id(ZSTR_VAL(type));
type             2111 Zend/zend_builtin_functions.c 			zend_error(E_WARNING, "get_resources():  Unknown resource type '%s'", ZSTR_VAL(type));
type             2254 Zend/zend_builtin_functions.c 			if (call->func->type == ZEND_USER_FUNCTION) {
type             2342 Zend/zend_builtin_functions.c 		if ((!skip->func || !ZEND_USER_CODE(skip->func->common.type)) &&
type             2345 Zend/zend_builtin_functions.c 		    ZEND_USER_CODE(skip->prev_execute_data->func->common.type) &&
type             2354 Zend/zend_builtin_functions.c 		if (skip->func && ZEND_USER_CODE(skip->func->common.type)) {
type             2402 Zend/zend_builtin_functions.c 			if (func->type != ZEND_EVAL_CODE) {
type             2411 Zend/zend_builtin_functions.c 			if (!ptr->func || !ZEND_USER_CODE(ptr->func->common.type) || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
type             2466 Zend/zend_builtin_functions.c 					!ZEND_USER_CODE(prev_call->func->common.type)) {
type             2470 Zend/zend_builtin_functions.c 				if (prev->func && ZEND_USER_CODE(prev->func->common.type)) {
type             2507 Zend/zend_builtin_functions.c 	if (!ptr->func || !ZEND_USER_CODE(ptr->func->common.type)) {
type             2519 Zend/zend_builtin_functions.c 			if (ptr->func && ZEND_USER_CODE(ptr->func->common.type) && (ptr->opline->opcode == ZEND_NEW)) {
type             2538 Zend/zend_builtin_functions.c 		if ((!skip->func || !ZEND_USER_CODE(skip->func->common.type)) &&
type             2541 Zend/zend_builtin_functions.c 		    ZEND_USER_CODE(skip->prev_execute_data->func->common.type) &&
type             2550 Zend/zend_builtin_functions.c 		if (skip->func && ZEND_USER_CODE(skip->func->common.type)) {
type             2574 Zend/zend_builtin_functions.c 					!ZEND_USER_CODE(prev_call->func->common.type) &&
type             2578 Zend/zend_builtin_functions.c 				if (prev->func && ZEND_USER_CODE(prev->func->common.type)) {
type             2628 Zend/zend_builtin_functions.c 				func->type != ZEND_EVAL_CODE) {
type             2639 Zend/zend_builtin_functions.c 			if (!ptr->func || !ZEND_USER_CODE(ptr->func->common.type) || ptr->opline->opcode != ZEND_INCLUDE_OR_EVAL) {
type             2765 Zend/zend_builtin_functions.c 		if (zif->common.type == ZEND_INTERNAL_FUNCTION
type               86 Zend/zend_closures.c 		if (func->type == ZEND_INTERNAL_FUNCTION && func->common.scope &&
type               96 Zend/zend_closures.c 			&& func->type == ZEND_INTERNAL_FUNCTION) {
type              101 Zend/zend_closures.c 	if (scope && scope != func->common.scope && scope->type == ZEND_INTERNAL_CLASS) {
type              161 Zend/zend_closures.c 		memcpy(&my_function, fci_cache.function_handler, fci_cache.function_handler->type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function));
type              167 Zend/zend_closures.c 		if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) {
type              180 Zend/zend_closures.c 	} else if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) {
type              234 Zend/zend_closures.c 	if (ZEND_USER_CODE(closure->func.type) && (closure->func.common.scope != new_closure->func.common.scope || (closure->func.op_array.fn_flags & ZEND_ACC_NO_RT_ARENA))) {
type              269 Zend/zend_closures.c 	invoke->type = ZEND_INTERNAL_FUNCTION;
type              272 Zend/zend_closures.c 	if (closure->func.type != ZEND_INTERNAL_FUNCTION || (closure->func.common.fn_flags & ZEND_ACC_USER_ARG_INFO)) {
type              312 Zend/zend_closures.c static zval *zend_closure_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
type              325 Zend/zend_closures.c static zval *zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              353 Zend/zend_closures.c 	if (closure->func.type == ZEND_USER_FUNCTION) {
type              427 Zend/zend_closures.c 	if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) {
type              479 Zend/zend_closures.c 	return (closure->func.type == ZEND_USER_FUNCTION) ?
type              568 Zend/zend_closures.c 	if (func->type == ZEND_USER_FUNCTION) {
type               81 Zend/zend_compile.c ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type);
type              189 Zend/zend_compile.c 	const zend_uchar type;
type              209 Zend/zend_compile.c 			return info->type;
type              755 Zend/zend_compile.c 	zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
type              766 Zend/zend_compile.c 	if (type == ZEND_NAME_FQ) {
type              771 Zend/zend_compile.c 	if (type == ZEND_NAME_RELATIVE) {
type              811 Zend/zend_compile.c zend_string *zend_resolve_function_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */
type              814 Zend/zend_compile.c 		name, type, is_fully_qualified, 0, FC(imports_function));
type              818 Zend/zend_compile.c zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */ {
type              820 Zend/zend_compile.c 		name, type, is_fully_qualified, 1, FC(imports_const));
type              824 Zend/zend_compile.c zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */
type              828 Zend/zend_compile.c 	if (type == ZEND_NAME_RELATIVE) {
type              832 Zend/zend_compile.c 	if (type == ZEND_NAME_FQ || ZSTR_VAL(name)[0] == '\\') {
type              918 Zend/zend_compile.c 	if (function->type == ZEND_USER_FUNCTION) {
type              930 Zend/zend_compile.c 	} else if (function->type == ZEND_INTERNAL_FUNCTION) {
type              959 Zend/zend_compile.c 			&& old_function->type == ZEND_USER_FUNCTION
type             1090 Zend/zend_compile.c 				     (ce->type == ZEND_INTERNAL_CLASS))) {
type             1605 Zend/zend_compile.c 	zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
type             1621 Zend/zend_compile.c 	if (ce->type == ZEND_INTERNAL_CLASS) {
type             1671 Zend/zend_compile.c 		if (ce->type == ZEND_INTERNAL_CLASS) {
type             1808 Zend/zend_compile.c static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) /* {{{ */
type             1810 Zend/zend_compile.c 	switch (type & BP_VAR_MASK) {
type             1825 Zend/zend_compile.c 			opline->extended_value |= type >> BP_VAR_SHIFT;
type             2143 Zend/zend_compile.c 			uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
type             2146 Zend/zend_compile.c 				zend_resolve_class_name(name, type));
type             2188 Zend/zend_compile.c static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
type             2224 Zend/zend_compile.c static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
type             2227 Zend/zend_compile.c 		zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type, delayed);
type             2228 Zend/zend_compile.c 		zend_adjust_for_fetch_type(opline, type);
type             2233 Zend/zend_compile.c static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, uint32_t type) /* {{{ */
type             2235 Zend/zend_compile.c 	if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) {
type             2247 Zend/zend_compile.c void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type);
type             2265 Zend/zend_compile.c static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2272 Zend/zend_compile.c 	zend_delayed_compile_var(&var_node, var_ast, type);
type             2273 Zend/zend_compile.c 	zend_separate_if_call_and_write(&var_node, var_ast, type);
type             2276 Zend/zend_compile.c 		if (type == BP_VAR_R || type == BP_VAR_IS) {
type             2279 Zend/zend_compile.c 		if (type == BP_VAR_UNSET) {
type             2292 Zend/zend_compile.c static inline zend_op *zend_compile_dim_common(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2295 Zend/zend_compile.c 	zend_delayed_compile_dim(result, ast, type);
type             2300 Zend/zend_compile.c void zend_compile_dim(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2302 Zend/zend_compile.c 	zend_op *opline = zend_compile_dim_common(result, ast, type);
type             2303 Zend/zend_compile.c 	zend_adjust_for_fetch_type(opline, type);
type             2318 Zend/zend_compile.c static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2329 Zend/zend_compile.c 		zend_delayed_compile_var(&obj_node, obj_ast, type);
type             2330 Zend/zend_compile.c 		zend_separate_if_call_and_write(&obj_node, obj_ast, type);
type             2344 Zend/zend_compile.c static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2347 Zend/zend_compile.c 	zend_delayed_compile_prop(result, ast, type);
type             2352 Zend/zend_compile.c void zend_compile_prop(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             2354 Zend/zend_compile.c 	zend_op *opline = zend_compile_prop_common(result, ast, type);
type             2355 Zend/zend_compile.c 	zend_adjust_for_fetch_type(opline, type);
type             2359 Zend/zend_compile.c zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
type             2398 Zend/zend_compile.c void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
type             2400 Zend/zend_compile.c 	zend_op *opline = zend_compile_static_prop_common(result, ast, type, delayed);
type             2401 Zend/zend_compile.c 	zend_adjust_for_fetch_type(opline, type);
type             2787 Zend/zend_compile.c 		if (fbc->type == ZEND_INTERNAL_FUNCTION) {
type             2929 Zend/zend_compile.c int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type) /* {{{ */
type             2940 Zend/zend_compile.c 	opline->extended_value = type;
type             2991 Zend/zend_compile.c 	 || (fbc->type == ZEND_INTERNAL_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
type             2992 Zend/zend_compile.c 	 || (fbc->type == ZEND_USER_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS))
type             3196 Zend/zend_compile.c void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             3231 Zend/zend_compile.c 		 || (fbc->type == ZEND_INTERNAL_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
type             3232 Zend/zend_compile.c 		 || (fbc->type == ZEND_USER_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS))
type             3258 Zend/zend_compile.c void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             3299 Zend/zend_compile.c void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             4394 Zend/zend_compile.c 		zend_uchar type = zend_lookup_builtin_type_by_name(class_name);
type             4396 Zend/zend_compile.c 		if (type != 0) {
type             4402 Zend/zend_compile.c 			arg_info->type_hint = type;
type             5232 Zend/zend_compile.c 	ce->type = ZEND_USER_CLASS;
type             5385 Zend/zend_compile.c static HashTable *zend_get_import_ht(uint32_t type) /* {{{ */
type             5387 Zend/zend_compile.c 	switch (type) {
type             5413 Zend/zend_compile.c static char *zend_get_use_type_str(uint32_t type) /* {{{ */
type             5415 Zend/zend_compile.c 	switch (type) {
type             5429 Zend/zend_compile.c static void zend_check_already_in_use(uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name) /* {{{ */
type             5436 Zend/zend_compile.c 		"is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name));
type             5445 Zend/zend_compile.c 	uint32_t type = ast->attr;
type             5446 Zend/zend_compile.c 	HashTable *current_import = zend_get_import_ht(type);
type             5447 Zend/zend_compile.c 	zend_bool case_sensitive = type == T_CONST;
type             5468 Zend/zend_compile.c 					if (type == T_CLASS && zend_string_equals_literal(new_name, "strict")) {
type             5485 Zend/zend_compile.c 		if (type == T_CLASS && zend_is_reserved_class_name(new_name)) {
type             5497 Zend/zend_compile.c 				zend_check_already_in_use(type, old_name, new_name, ns_name);
type             5502 Zend/zend_compile.c 			switch (type) {
type             5506 Zend/zend_compile.c 					if (ce && ce->type == ZEND_USER_CLASS
type             5509 Zend/zend_compile.c 						zend_check_already_in_use(type, old_name, new_name, lookup_name);
type             5516 Zend/zend_compile.c 					if (fn && fn->type == ZEND_USER_FUNCTION
type             5519 Zend/zend_compile.c 						zend_check_already_in_use(type, old_name, new_name, lookup_name);
type             5527 Zend/zend_compile.c 						zend_check_already_in_use(type, old_name, new_name, lookup_name);
type             5538 Zend/zend_compile.c 				"is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name));
type             7232 Zend/zend_compile.c void zend_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             7236 Zend/zend_compile.c 			zend_compile_simple_var(result, ast, type, 0);
type             7239 Zend/zend_compile.c 			zend_compile_dim(result, ast, type);
type             7242 Zend/zend_compile.c 			zend_compile_prop(result, ast, type);
type             7245 Zend/zend_compile.c 			zend_compile_static_prop(result, ast, type, 0);
type             7248 Zend/zend_compile.c 			zend_compile_call(result, ast, type);
type             7251 Zend/zend_compile.c 			zend_compile_method_call(result, ast, type);
type             7254 Zend/zend_compile.c 			zend_compile_static_call(result, ast, type);
type             7260 Zend/zend_compile.c 			if (type == BP_VAR_W || type == BP_VAR_REF
type             7261 Zend/zend_compile.c 				|| type == BP_VAR_RW || type == BP_VAR_UNSET
type             7273 Zend/zend_compile.c void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
type             7278 Zend/zend_compile.c 			zend_compile_simple_var(result, ast, type, 1);
type             7281 Zend/zend_compile.c 			opline = zend_delayed_compile_dim(result, ast, type);
type             7282 Zend/zend_compile.c 			zend_adjust_for_fetch_type(opline, type);
type             7285 Zend/zend_compile.c 			opline = zend_delayed_compile_prop(result, ast, type);
type             7286 Zend/zend_compile.c 			zend_adjust_for_fetch_type(opline, type);
type             7289 Zend/zend_compile.c 			zend_compile_static_prop(result, ast, type, 1);
type             7292 Zend/zend_compile.c 			zend_compile_var(result, ast, type);
type              149 Zend/zend_compile.h void zend_compile_var(znode *node, zend_ast *ast, uint32_t type);
type              335 Zend/zend_compile.h 	zend_uchar type;
type              386 Zend/zend_compile.h 	zend_uchar type;
type              405 Zend/zend_compile.h 	zend_uchar type;	/* MUST be the first element of this struct! */
type              408 Zend/zend_compile.h 		zend_uchar type;  /* never used */
type              670 Zend/zend_compile.h extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type);
type              725 Zend/zend_compile.h ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type);
type              727 Zend/zend_compile.h ZEND_API zend_op_array *compile_filename(int type, zval *filename);
type              729 Zend/zend_compile.h ZEND_API int zend_execute_scripts(int type, zval *retval, int file_count, ...);
type              731 Zend/zend_compile.h ZEND_API void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size);
type              846 Zend/zend_compile.h #define ZEND_USER_CODE(type) ((type & 1) == 0)
type              918 Zend/zend_compile.h 		*(uint32_t*)&(zf)->type |= ((mask) << ((arg_num) - 1) * 2); \
type              921 Zend/zend_compile.h 	(((*((uint32_t*)&((zf)->type))) >> (((arg_num) - 1) * 2)) & (mask))
type              924 Zend/zend_compile.h 		*(uint32_t*)&(zf)->type |= (((mask) << 6) << (arg_num) * 2); \
type              927 Zend/zend_compile.h 	(((*(uint32_t*)&(zf)->type) >> (((arg_num) + 3) * 2)) & (mask))
type               27 Zend/zend_dtrace.c ZEND_API zend_op_array *(*zend_dtrace_compile_file)(zend_file_handle *file_handle, int type);
type               36 Zend/zend_dtrace.c 	while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type               46 Zend/zend_dtrace.c ZEND_API zend_op_array *dtrace_compile_file(zend_file_handle *file_handle, int type)
type               50 Zend/zend_dtrace.c 	res = compile_file(file_handle, type);
type               33 Zend/zend_dtrace.h ZEND_API extern zend_op_array *(*zend_dtrace_compile_file)(zend_file_handle *file_handle, int type);
type               37 Zend/zend_dtrace.h ZEND_API zend_op_array *dtrace_compile_file(zend_file_handle *file_handle, int type);
type              167 Zend/zend_exceptions.c 	    !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) ||
type              293 Zend/zend_exceptions.c #define CHECK_EXC_TYPE(name, type) \
type              296 Zend/zend_exceptions.c 	if(Z_TYPE_P(pvalue) != IS_UNDEF && Z_TYPE_P(pvalue) != type) { \
type              972 Zend/zend_exceptions.c static void zend_error_va(int type, const char *file, uint lineno, const char *format, ...) /* {{{ */
type              977 Zend/zend_exceptions.c 	zend_error_cb(type, file, lineno, format, args);
type              982 Zend/zend_exceptions.c static void zend_error_helper(int type, const char *filename, const uint lineno, const char *format, ...)
type              987 Zend/zend_exceptions.c 	zend_error_cb(type, filename, lineno, format, va);
type               55 Zend/zend_execute.c #define get_zval_ptr(op_type, node, ex, should_free, type) _get_zval_ptr(op_type, node, ex, should_free, type)
type               56 Zend/zend_execute.c #define get_zval_ptr_deref(op_type, node, ex, should_free, type) _get_zval_ptr_deref(op_type, node, ex, should_free, type)
type               59 Zend/zend_execute.c #define get_zval_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_undef(op_type, node, ex, should_free, type)
type               60 Zend/zend_execute.c #define get_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
type               61 Zend/zend_execute.c #define get_zval_ptr_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
type               62 Zend/zend_execute.c #define get_obj_zval_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr(op_type, node, ex, should_free, type)
type               63 Zend/zend_execute.c #define get_obj_zval_ptr_undef(op_type, node, ex, should_free, type) _get_obj_zval_ptr_undef(op_type, node, ex, should_free, type)
type               64 Zend/zend_execute.c #define get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type)
type              112 Zend/zend_execute.c #define FREE_UNFETCHED_OP(type, var) \
type              113 Zend/zend_execute.c 	if ((type) & (IS_TMP_VAR|IS_VAR)) { \
type              234 Zend/zend_execute.c static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int type, const zend_execute_data *execute_data)
type              236 Zend/zend_execute.c 	switch (type) {
type              279 Zend/zend_execute.c static zend_always_inline zval *_get_zval_ptr_cv(const zend_execute_data *execute_data, uint32_t var, int type)
type              284 Zend/zend_execute.c 		return _get_zval_cv_lookup(ret, var, type, execute_data);
type              294 Zend/zend_execute.c static zend_always_inline zval *_get_zval_ptr_cv_deref(const zend_execute_data *execute_data, uint32_t var, int type)
type              299 Zend/zend_execute.c 		return _get_zval_cv_lookup(ret, var, type, execute_data);
type              414 Zend/zend_execute.c static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              428 Zend/zend_execute.c 			return _get_zval_ptr_cv(execute_data, node.var, type);
type              456 Zend/zend_execute.c static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              470 Zend/zend_execute.c 			return _get_zval_ptr_cv_deref(execute_data, node.var, type);
type              498 Zend/zend_execute.c static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              532 Zend/zend_execute.c static inline zval *_get_zval_ptr_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              536 Zend/zend_execute.c 		return _get_zval_ptr_cv(execute_data, node.var, type);
type              548 Zend/zend_execute.c static inline zval *_get_obj_zval_ptr(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              554 Zend/zend_execute.c 	return get_zval_ptr(op_type, op, execute_data, should_free, type);
type              557 Zend/zend_execute.c static inline zval *_get_obj_zval_ptr_undef(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              563 Zend/zend_execute.c 	return get_zval_ptr_undef(op_type, op, execute_data, should_free, type);
type              566 Zend/zend_execute.c static inline zval *_get_obj_zval_ptr_ptr(int op_type, znode_op node, zend_execute_data *execute_data, zend_free_op *should_free, int type)
type              572 Zend/zend_execute.c 	return get_zval_ptr_ptr(op_type, node, execute_data, should_free, type);
type              645 Zend/zend_execute.c 	if (zf->common.type == ZEND_USER_FUNCTION) {
type              646 Zend/zend_execute.c 		if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) {
type              905 Zend/zend_execute.c 		if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) {
type             1536 Zend/zend_execute.c static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type)
type             1548 Zend/zend_execute.c 			switch (type) {
type             1579 Zend/zend_execute.c 					switch (type) {
type             1597 Zend/zend_execute.c 			switch (type) {
type             1637 Zend/zend_execute.c 				retval = (type == BP_VAR_W || type == BP_VAR_RW) ?
type             1644 Zend/zend_execute.c static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type)
type             1655 Zend/zend_execute.c 				if (type != BP_VAR_UNSET) {
type             1681 Zend/zend_execute.c static zend_always_inline zend_long zend_fetch_string_offset(zval *container, zval *dim, int type)
type             1683 Zend/zend_execute.c 	zend_long offset = zend_check_string_offset(dim, type);
type             1695 Zend/zend_execute.c static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type)
type             1710 Zend/zend_execute.c 			retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
type             1721 Zend/zend_execute.c 		if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRLEN_P(container) == 0)) {
type             1733 Zend/zend_execute.c 			zend_check_string_offset(dim, type);
type             1741 Zend/zend_execute.c 			retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result);
type             1778 Zend/zend_execute.c 		} else if (type != BP_VAR_UNSET) {
type             1785 Zend/zend_execute.c 		if (type == BP_VAR_UNSET) {
type             1810 Zend/zend_execute.c static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type)
type             1816 Zend/zend_execute.c 		retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
type             1836 Zend/zend_execute.c 					if (type == BP_VAR_IS) {
type             1846 Zend/zend_execute.c 					if (type != BP_VAR_IS) {
type             1864 Zend/zend_execute.c 			if (type != BP_VAR_IS) {
type             1884 Zend/zend_execute.c 			retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result);
type             1915 Zend/zend_execute.c static zend_always_inline void zend_fetch_property_address(zval *result, zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, void **cache_slot, int type)
type             1932 Zend/zend_execute.c 			if (type != BP_VAR_UNSET &&
type             1971 Zend/zend_execute.c 		zval *ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, cache_slot);
type             1974 Zend/zend_execute.c 				ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result);
type             1988 Zend/zend_execute.c 		zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result);
type             2711 Zend/zend_execute.c #define GET_OP1_UNDEF_CV(ptr, type) \
type             2712 Zend/zend_execute.c 	_get_zval_cv_lookup_ ## type(ptr, opline->op1.var, execute_data)
type             2713 Zend/zend_execute.c #define GET_OP2_UNDEF_CV(ptr, type) \
type             2714 Zend/zend_execute.c 	_get_zval_cv_lookup_ ## type(ptr, opline->op2.var, execute_data)
type             2738 Zend/zend_execute.c ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
type             2740 Zend/zend_execute.c 	return get_zval_ptr(op_type, *node, execute_data, should_free, type);
type              197 Zend/zend_execute.h 	if (EXPECTED(ZEND_USER_CODE(func->type))) {
type              316 Zend/zend_execute.h ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type);
type              103 Zend/zend_execute_API.c 	return (function->type == ZEND_INTERNAL_FUNCTION) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
type              110 Zend/zend_execute_API.c 	return (function->type == ZEND_INTERNAL_FUNCTION) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
type              117 Zend/zend_execute_API.c 	return (ce->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
type              124 Zend/zend_execute_API.c 	return (ce->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
type              314 Zend/zend_execute_API.c 				if (func->type == ZEND_USER_FUNCTION) {
type              319 Zend/zend_execute_API.c 				if (ce->type == ZEND_USER_CLASS) {
type              327 Zend/zend_execute_API.c 				if (func->type != ZEND_USER_FUNCTION) {
type              333 Zend/zend_execute_API.c 				if (ce->type != ZEND_USER_CLASS) {
type              428 Zend/zend_execute_API.c 	switch (func->type) {
type              456 Zend/zend_execute_API.c 	switch (func->type) {
type              480 Zend/zend_execute_API.c 	while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type              495 Zend/zend_execute_API.c 	while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type              510 Zend/zend_execute_API.c 	while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type              727 Zend/zend_execute_API.c 	           ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
type              857 Zend/zend_execute_API.c 	if (func->type == ZEND_USER_FUNCTION) {
type              871 Zend/zend_execute_API.c 	} else if (func->type == ZEND_INTERNAL_FUNCTION) {
type              919 Zend/zend_execute_API.c 		if (func->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
type             1075 Zend/zend_execute_API.c 			if (ex->func->type != ZEND_INTERNAL_FUNCTION || ex->func->common.scope) {
type             1091 Zend/zend_execute_API.c 			if (ex->func->type != ZEND_INTERNAL_FUNCTION || ex->func->common.scope) {
type             1478 Zend/zend_execute_API.c 	while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->common.type))) {
type             1583 Zend/zend_execute_API.c 	while (execute_data && (!execute_data->func || !ZEND_USER_CODE(execute_data->func->common.type))) {
type             1625 Zend/zend_execute_API.c 	while (execute_data && (!execute_data->func || !ZEND_USER_CODE(execute_data->func->common.type))) {
type               61 Zend/zend_inheritance.c 	if (UNEXPECTED(func->type == ZEND_INTERNAL_FUNCTION)) {
type               62 Zend/zend_inheritance.c 		if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
type              181 Zend/zend_inheritance.c 		if (fe->type == ZEND_INTERNAL_FUNCTION) {
type              198 Zend/zend_inheritance.c 		if (proto->type == ZEND_INTERNAL_FUNCTION) {
type              216 Zend/zend_inheritance.c 			if (fe->common.type != ZEND_USER_FUNCTION) {
type              228 Zend/zend_inheritance.c 						fe_ce->type == ZEND_INTERNAL_CLASS ||
type              229 Zend/zend_inheritance.c 						proto_ce->type == ZEND_INTERNAL_CLASS ||
type              258 Zend/zend_inheritance.c 	if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) {
type              350 Zend/zend_inheritance.c 		if (fptr->type == ZEND_INTERNAL_FUNCTION) {
type              426 Zend/zend_inheritance.c 				if (fptr->type == ZEND_INTERNAL_FUNCTION) {
type              438 Zend/zend_inheritance.c 				if (fptr->type == ZEND_USER_FUNCTION) {
type              593 Zend/zend_inheritance.c 		    func->type == ZEND_USER_FUNCTION &&
type              647 Zend/zend_inheritance.c 			if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
type              655 Zend/zend_inheritance.c 			if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
type              688 Zend/zend_inheritance.c 	if (ce->type == ZEND_INTERNAL_CLASS) {
type              718 Zend/zend_inheritance.c 			if (parent_ce->type == ZEND_INTERNAL_CLASS) {
type              769 Zend/zend_inheritance.c 			zval *table = pemalloc(sizeof(zval) * (ce->default_properties_count + parent_ce->default_properties_count), ce->type == ZEND_INTERNAL_CLASS);
type              779 Zend/zend_inheritance.c 			pefree(src, ce->type == ZEND_INTERNAL_CLASS);
type              782 Zend/zend_inheritance.c 			end = pemalloc(sizeof(zval) * parent_ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
type              791 Zend/zend_inheritance.c 			if (parent_ce->type != ce->type) {
type              812 Zend/zend_inheritance.c 			zval *table = pemalloc(sizeof(zval) * (ce->default_static_members_count + parent_ce->default_static_members_count), ce->type == ZEND_INTERNAL_CLASS);
type              822 Zend/zend_inheritance.c 			pefree(src, ce->type == ZEND_INTERNAL_CLASS);
type              825 Zend/zend_inheritance.c 			end = pemalloc(sizeof(zval) * parent_ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
type              833 Zend/zend_inheritance.c 			if (parent_ce->type == ZEND_INTERNAL_CLASS) {
type              847 Zend/zend_inheritance.c 		if (ce->type == ZEND_USER_CLASS) {
type              900 Zend/zend_inheritance.c 	if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) {
type              930 Zend/zend_inheritance.c 			if (iface->type == ZEND_INTERNAL_CLASS) {
type              973 Zend/zend_inheritance.c 			if (ce->type == ZEND_INTERNAL_CLASS) {
type             1017 Zend/zend_inheritance.c 			if (ce->type == ZEND_INTERNAL_CLASS) {
type             1172 Zend/zend_inheritance.c 		if (fn->type == ZEND_USER_FUNCTION && fn->op_array.static_variables) {
type             1219 Zend/zend_inheritance.c 		memcpy(&fn_copy, fn, fn->type == ZEND_USER_FUNCTION? sizeof(zend_op_array) : sizeof(zend_internal_function));
type              403 Zend/zend_ini.c ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
type              495 Zend/zend_ini.c static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
type              498 Zend/zend_ini.c 		ini_entry->displayer(ini_entry, type);
type              503 Zend/zend_ini.c 		if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type              539 Zend/zend_ini.c 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type              573 Zend/zend_ini.c 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type              600 Zend/zend_ini.c 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type               31 Zend/zend_ini.h #define ZEND_INI_DISP(name) void name(zend_ini_entry *ini_entry, int type)
type               40 Zend/zend_ini.h 	void (*displayer)(zend_ini_entry *ini_entry, int type);
type               55 Zend/zend_ini.h 	void (*displayer)(zend_ini_entry *ini_entry, int type);
type               89 Zend/zend_ini.h ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type));
type               51 Zend/zend_ini_parser.y static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
type               67 Zend/zend_ini_parser.y 	switch (type) {
type              145 Zend/zend_ini_scanner.c #define RETURN_TOKEN(type, str, len) {                       \
type              147 Zend/zend_ini_scanner.c 		zend_ini_copy_typed_value(ini_lval, type, str, len); \
type              151 Zend/zend_ini_scanner.c 	return type;                                             \
type              156 Zend/zend_ini_scanner.c 	zend_uchar type;
type              161 Zend/zend_ini_scanner.c 	if ((type = is_numeric_string_ex(str, str_len, &lval, &dval, 0, &overflow)) != 0) {
type              162 Zend/zend_ini_scanner.c 		if (type == IS_LONG) {
type              165 Zend/zend_ini_scanner.c 		} else if (type == IS_DOUBLE && !overflow) {
type              174 Zend/zend_ini_scanner.c static void zend_ini_copy_typed_value(zval *retval, const int type, const char *str, int len)
type              176 Zend/zend_ini_scanner.c 	switch (type) {
type              179 Zend/zend_ini_scanner.c 			ZVAL_BOOL(retval, type == BOOL_TRUE);
type              335 Zend/zend_interfaces.c 		if (class_type->type == ZEND_INTERNAL_CLASS) {
type              369 Zend/zend_interfaces.c 		if (class_type->type == ZEND_INTERNAL_CLASS) {
type              253 Zend/zend_language_parser.y %type <ast> assignment_list isset_variable type return_type
type              640 Zend/zend_language_parser.y 	|	type		{ $$ = $1; }
type              643 Zend/zend_language_parser.y type:
type              651 Zend/zend_language_parser.y 	|	':' type	{ $$ = $2; }
type              504 Zend/zend_language_scanner.c 	if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {
type              574 Zend/zend_language_scanner.c ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)
type              581 Zend/zend_language_scanner.c 		if (type==ZEND_REQUIRE) {
type              630 Zend/zend_language_scanner.c zend_op_array *compile_filename(int type, zval *filename)
type              645 Zend/zend_language_scanner.c 	file_handle.type = ZEND_HANDLE_FILENAME;
type              649 Zend/zend_language_scanner.c 	retval = zend_compile_file(&file_handle, type);
type              802 Zend/zend_language_scanner.c 	file_handle.type = ZEND_HANDLE_FILENAME;
type               34 Zend/zend_list.c ZEND_API zval *zend_list_insert(void *ptr, int type)
type               43 Zend/zend_list.c 	ZVAL_NEW_RES(&zv, index, ptr, type);
type               70 Zend/zend_list.c 	res->type = -1;
type               73 Zend/zend_list.c 	ld = zend_hash_index_find_ptr(&list_destructors, r.type);
type               79 Zend/zend_list.c 		zend_error(E_WARNING, "Unknown list entry type (%d)", r.type);
type               88 Zend/zend_list.c 	} else if (res->type >= 0) {
type              106 Zend/zend_list.c 		if (resource_type1 == res->type) {
type              110 Zend/zend_list.c 		if (resource_type2 == res->type) {
type              126 Zend/zend_list.c 	if (resource_type == res->type) {
type              186 Zend/zend_list.c 	if (res->type >= 0) {
type              196 Zend/zend_list.c 	if (res->type >= 0) {
type              199 Zend/zend_list.c 		ld = zend_hash_index_find_ptr(&list_destructors, res->type);
type              205 Zend/zend_list.c 			zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
type              229 Zend/zend_list.c 	if (res->type >= 0) {
type              332 Zend/zend_list.c 	lde = zend_hash_index_find_ptr(&list_destructors, res->type);
type               57 Zend/zend_list.h ZEND_API zval *zend_list_insert(void *ptr, int type);
type               29 Zend/zend_modules.h #define INIT_FUNC_ARGS		int type, int module_number
type               30 Zend/zend_modules.h #define INIT_FUNC_ARGS_PASSTHRU	type, module_number
type               31 Zend/zend_modules.h #define SHUTDOWN_FUNC_ARGS	int type, int module_number
type               32 Zend/zend_modules.h #define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number
type               98 Zend/zend_modules.h 	unsigned char type;
type              122 Zend/zend_modules.h 	unsigned char type;		/* dependency type */
type              517 Zend/zend_object_handlers.c zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
type              538 Zend/zend_object_handlers.c 	property_offset = zend_get_property_offset(zobj->ce, Z_STR_P(member), (type == BP_VAR_IS) || (zobj->ce->__get != NULL), cache_slot);
type              570 Zend/zend_object_handlers.c 				    (type == BP_VAR_W || type == BP_VAR_RW  || type == BP_VAR_UNSET)) {
type              595 Zend/zend_object_handlers.c 	if ((type != BP_VAR_IS)) {
type              707 Zend/zend_object_handlers.c zval *zend_std_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
type              789 Zend/zend_object_handlers.c static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              818 Zend/zend_object_handlers.c 					if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
type              849 Zend/zend_object_handlers.c 				if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
type             1044 Zend/zend_object_handlers.c 	func->type = ZEND_USER_FUNCTION;
type             1058 Zend/zend_object_handlers.c 	func->T = (fbc->type == ZEND_USER_FUNCTION)? MAX(fbc->op_array.last_var + fbc->op_array.T, 2) : 2;
type             1059 Zend/zend_object_handlers.c 	func->filename = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.filename : ZSTR_EMPTY_ALLOC();
type             1060 Zend/zend_object_handlers.c 	func->line_start = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_start : 0;
type             1061 Zend/zend_object_handlers.c 	func->line_end = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_end : 0;
type             1520 Zend/zend_object_handlers.c ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type) /* {{{ */
type             1525 Zend/zend_object_handlers.c 	switch (type) {
type               38 Zend/zend_object_handlers.h typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, void **cache_slot, zval *rv);
type               41 Zend/zend_object_handlers.h typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int type, zval *rv);
type               57 Zend/zend_object_handlers.h typedef zval *(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, void **cache_slot);
type              112 Zend/zend_object_handlers.h typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type);
type              171 Zend/zend_object_handlers.h ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type);
type               52 Zend/zend_opcode.c void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size)
type               54 Zend/zend_opcode.c 	op_array->type = type;
type              109 Zend/zend_opcode.c 	if (function->type == ZEND_USER_FUNCTION) {
type              112 Zend/zend_opcode.c 		ZEND_ASSERT(function->type == ZEND_INTERNAL_FUNCTION);
type              122 Zend/zend_opcode.c 	if (function->type == ZEND_USER_FUNCTION) {
type              127 Zend/zend_opcode.c 		ZEND_ASSERT(function->type == ZEND_INTERNAL_FUNCTION);
type              153 Zend/zend_opcode.c 			if (func->type == ZEND_USER_FUNCTION) {
type              257 Zend/zend_opcode.c 	switch (ce->type) {
type              581 Zend/zend_opcode.c 	if (!ZEND_USER_CODE(op_array->type)) {
type             2758 Zend/zend_operators.c 	zend_uchar type;
type             2794 Zend/zend_operators.c 		for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) {
type             2824 Zend/zend_operators.c 		type = IS_DOUBLE;
type             2847 Zend/zend_operators.c 	if (type == IS_LONG) {
type              372 Zend/zend_operators.h #define convert_to_explicit_type(pzv, type)		\
type              374 Zend/zend_operators.h 		switch (type) {							\
type              199 Zend/zend_portability.h # define ZEND_ATTRIBUTE_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
type              201 Zend/zend_portability.h # define ZEND_ATTRIBUTE_FORMAT(type, idx, first)
type              205 Zend/zend_portability.h # define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
type              207 Zend/zend_portability.h # define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first)
type              105 Zend/zend_stack.c ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element))
type              109 Zend/zend_stack.c 	switch (type) {
type              128 Zend/zend_stack.c ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
type              132 Zend/zend_stack.c 	switch (type) {
type               43 Zend/zend_stack.h ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element));
type               44 Zend/zend_stack.h ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg);
type              103 Zend/zend_stream.c 	return file_handle->type == ZEND_HANDLE_MAPPED;
type              113 Zend/zend_stream.c 	if (file_handle->type == ZEND_HANDLE_STREAM || file_handle->type == ZEND_HANDLE_MAPPED) {
type              133 Zend/zend_stream.c 	handle->type = ZEND_HANDLE_FP;
type              185 Zend/zend_stream.c 	if (file_handle->type == ZEND_HANDLE_FILENAME) {
type              191 Zend/zend_stream.c 	switch (file_handle->type) {
type              193 Zend/zend_stream.c 			file_handle->type = ZEND_HANDLE_FP;
type              226 Zend/zend_stream.c 	old_type = file_handle->type;
type              227 Zend/zend_stream.c 	file_handle->type = ZEND_HANDLE_STREAM;  /* we might still be _FP but we need fsize() work */
type              289 Zend/zend_stream.c 	file_handle->type = ZEND_HANDLE_MAPPED;
type              304 Zend/zend_stream.c 	switch (fh->type) {
type              337 Zend/zend_stream.c 	if (fh1->type != fh2->type) {
type              340 Zend/zend_stream.c 	switch (fh1->type) {
type               73 Zend/zend_stream.h 	zend_stream_type  type;
type              126 Zend/zend_types.h 				zend_uchar    type,			/* active type */
type              149 Zend/zend_types.h 				zend_uchar    type,
type              287 Zend/zend_types.h 	int               type;
type              327 Zend/zend_types.h 	return pz->u1.v.type;
type              372 Zend/zend_types.h #define GC_TYPE(p)					(p)->gc.u.v.type
type              557 Zend/zend_types.h #define Z_RES_TYPE(zval)			Z_RES(zval)->type
type              698 Zend/zend_types.h 		_res->type = (t);										\
type              712 Zend/zend_types.h 		_res->type = (t);										\
type             1818 Zend/zend_virtual_cwd.c CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
type             1820 Zend/zend_virtual_cwd.c 	return popen_ex(command, type, CWDG(cwd).cwd, NULL);
type             1827 Zend/zend_virtual_cwd.c CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
type             1843 Zend/zend_virtual_cwd.c 	retval = popen(command, type);
type             1854 Zend/zend_virtual_cwd.c CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
type             1906 Zend/zend_virtual_cwd.c 	retval = popen(command_line, type);
type              173 Zend/zend_virtual_cwd.h CWD_API FILE *virtual_popen(const char *command, const char *type);
type              277 Zend/zend_virtual_cwd.h #define VCWD_POPEN(command, type) virtual_popen(command, type)
type              313 Zend/zend_virtual_cwd.h #define VCWD_POPEN(command, type) popen(command, type)
type             1473 Zend/zend_vm_def.h ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int type)
type             1555 Zend/zend_vm_def.h 			switch (type) {
type             1576 Zend/zend_vm_def.h 				switch (type) {
type             1612 Zend/zend_vm_def.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             1625 Zend/zend_vm_def.h 	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
type             1630 Zend/zend_vm_def.h 	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
type             1635 Zend/zend_vm_def.h 	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
type             1643 Zend/zend_vm_def.h 		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
type             1645 Zend/zend_vm_def.h 		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
type             1651 Zend/zend_vm_def.h 	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
type             1656 Zend/zend_vm_def.h 	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
type             2428 Zend/zend_vm_def.h 				if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) {
type             2986 Zend/zend_vm_def.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             3088 Zend/zend_vm_def.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             3597 Zend/zend_vm_def.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type             3625 Zend/zend_vm_def.h 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
type             3718 Zend/zend_vm_def.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type             3750 Zend/zend_vm_def.h 	} else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) {
type             3818 Zend/zend_vm_def.h 			if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
type             3839 Zend/zend_vm_def.h 		if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
type             5141 Zend/zend_vm_def.h 		if (ce->type == ZEND_INTERNAL_CLASS) {
type             7269 Zend/zend_vm_def.h 	ZEND_ASSERT(zfunc != NULL && Z_FUNC_P(zfunc)->type == ZEND_USER_FUNCTION);
type             7889 Zend/zend_vm_def.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type             7906 Zend/zend_vm_def.h 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
type             7963 Zend/zend_vm_def.h 	if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
type              546 Zend/zend_vm_execute.h 				if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) {
type              650 Zend/zend_vm_execute.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type              678 Zend/zend_vm_execute.h 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
type              771 Zend/zend_vm_execute.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type              803 Zend/zend_vm_execute.h 	} else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) {
type              871 Zend/zend_vm_execute.h 			if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
type              892 Zend/zend_vm_execute.h 		if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
type             1759 Zend/zend_vm_execute.h 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
type             1776 Zend/zend_vm_execute.h 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
type             1833 Zend/zend_vm_execute.h 	if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
type             4936 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             5017 Zend/zend_vm_execute.h 			switch (type) {
type             5038 Zend/zend_vm_execute.h 				switch (type) {
type             5074 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             5582 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             5682 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             5975 Zend/zend_vm_execute.h 		if (ce->type == ZEND_INTERNAL_CLASS) {
type             6870 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             6951 Zend/zend_vm_execute.h 			switch (type) {
type             6972 Zend/zend_vm_execute.h 				switch (type) {
type             7008 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             7376 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             7457 Zend/zend_vm_execute.h 			switch (type) {
type             7478 Zend/zend_vm_execute.h 				switch (type) {
type             7514 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             7678 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             8119 Zend/zend_vm_execute.h 	ZEND_ASSERT(zfunc != NULL && Z_FUNC_P(zfunc)->type == ZEND_USER_FUNCTION);
type             9328 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             9428 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             11150 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             11251 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             17603 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             17764 Zend/zend_vm_execute.h 		if (ce->type == ZEND_INTERNAL_CLASS) {
type             19238 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             20866 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             22443 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             23858 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             23978 Zend/zend_vm_execute.h 		if (ce->type == ZEND_INTERNAL_CLASS) {
type             26273 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             27765 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             31054 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             31135 Zend/zend_vm_execute.h 			switch (type) {
type             31156 Zend/zend_vm_execute.h 				switch (type) {
type             31192 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             32023 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             33273 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             33354 Zend/zend_vm_execute.h 			switch (type) {
type             33375 Zend/zend_vm_execute.h 				switch (type) {
type             33411 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             34220 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             34301 Zend/zend_vm_execute.h 			switch (type) {
type             34322 Zend/zend_vm_execute.h 				switch (type) {
type             34358 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             37107 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             39687 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             41431 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             41513 Zend/zend_vm_execute.h 			switch (type) {
type             41534 Zend/zend_vm_execute.h 				switch (type) {
type             41570 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             41922 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             42430 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             42512 Zend/zend_vm_execute.h 			switch (type) {
type             42533 Zend/zend_vm_execute.h 				switch (type) {
type             42569 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             42841 Zend/zend_vm_execute.h static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
type             42923 Zend/zend_vm_execute.h 			switch (type) {
type             42944 Zend/zend_vm_execute.h 				switch (type) {
type             42980 Zend/zend_vm_execute.h 	if (type == BP_VAR_R || type == BP_VAR_IS) {
type             44070 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type             45216 Zend/zend_vm_execute.h 		    EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
type              161 ext/com_dotnet/com_extension.c 	ZEND_ARG_INFO(0, type)
type              166 ext/com_dotnet/com_extension.c 	ZEND_ARG_INFO(0, type)
type               32 ext/com_dotnet/com_handlers.c static zval *com_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
type               83 ext/com_dotnet/com_handlers.c static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv)
type              275 ext/com_dotnet/com_handlers.c 		f.type = ZEND_OVERLOADED_FUNCTION;
type              401 ext/com_dotnet/com_handlers.c 	f.type = ZEND_INTERNAL_FUNCTION; \
type              467 ext/com_dotnet/com_handlers.c static int com_object_cast(zval *readobj, zval *writeobj, int type)
type              487 ext/com_dotnet/com_handlers.c 	switch(type) {
type              520 ext/com_dotnet/com_handlers.c 	return zend_std_cast_object_tostring(readobj, writeobj, type);
type               74 ext/com_dotnet/com_saproxy.c static zval *saproxy_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
type               88 ext/com_dotnet/com_saproxy.c static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *rv)
type              346 ext/com_dotnet/com_saproxy.c static int saproxy_object_cast(zval *readobj, zval *writeobj, int type)
type              153 ext/com_dotnet/php_com_dotnet_internal.h PHP_COM_DOTNET_API void php_com_variant_from_zval_with_type(VARIANT *v, zval *z, VARTYPE type, int codepage);
type             1615 ext/curl/interface.c static int curl_debug(CURL *cp, curl_infotype type, char *buf, size_t buf_len, void *ctx) /* {{{ */
type             1619 ext/curl/interface.c 	if (type == CURLINFO_HEADER_OUT) {
type             2549 ext/curl/interface.c 						char *type = NULL, *filename = NULL;
type             2563 ext/curl/interface.c 								type = Z_STRVAL_P(prop);
type             2573 ext/curl/interface.c 											CURLFORM_CONTENTTYPE, type ? type : "application/octet-stream",
type             3068 ext/curl/interface.c 				int type = CURLINFO_TYPEMASK & option;
type             3069 ext/curl/interface.c 				switch (type) {
type              168 ext/date/lib/parse_date.c     int         type;
type              558 ext/date/lib/parse_date.c 			*behavior = tp->type;
type              673 ext/date/lib/parse_date.c 			s->time->relative.special.type = relunit->multiplier;
type              709 ext/date/lib/parse_date.c 		if ((fmp->gmtoffset * 60) == gmtoffset && fmp->type == isdst) {
type              732 ext/date/lib/parse_date.c 		*dst = tp->type;
type              733 ext/date/lib/parse_date.c 		value += tp->type * 60;
type             7212 ext/date/lib/parse_date.c 		if (s->time->relative.have_special_relative && s->time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY) {
type             16687 ext/date/lib/parse_date.c 			s->time->relative.special.type = TIMELIB_SPECIAL_DAY_OF_WEEK_IN_MONTH;
type             16690 ext/date/lib/parse_date.c 			s->time->relative.special.type = TIMELIB_SPECIAL_LAST_DAY_OF_WEEK_IN_MONTH;
type              161 ext/date/lib/parse_tz.c 	tz->type = (ttinfo*) timelib_malloc(tz->bit32.typecnt * sizeof(struct ttinfo));
type              162 ext/date/lib/parse_tz.c 	if (!tz->type) {
type              169 ext/date/lib/parse_tz.c 		tz->type[i].offset = (buffer[j] * 16777216) + (buffer[j + 1] * 65536) + (buffer[j + 2] * 256) + buffer[j + 3];
type              170 ext/date/lib/parse_tz.c 		tz->type[i].isdst = buffer[j + 4];
type              171 ext/date/lib/parse_tz.c 		tz->type[i].abbr_idx = buffer[j + 5];
type              211 ext/date/lib/parse_tz.c 			tz->type[i].isstdcnt = buffer[i];
type              225 ext/date/lib/parse_tz.c 			tz->type[i].isgmtcnt = buffer[i];
type              279 ext/date/lib/parse_tz.c 		(long int) tz->type[0].offset,
type              280 ext/date/lib/parse_tz.c 		tz->type[0].isdst,
type              281 ext/date/lib/parse_tz.c 		tz->type[0].abbr_idx,
type              282 ext/date/lib/parse_tz.c 		&tz->timezone_abbr[tz->type[0].abbr_idx],
type              283 ext/date/lib/parse_tz.c 		tz->type[0].isstdcnt,
type              284 ext/date/lib/parse_tz.c 		tz->type[0].isgmtcnt
type              289 ext/date/lib/parse_tz.c 			(long int) tz->type[tz->trans_idx[i]].offset,
type              290 ext/date/lib/parse_tz.c 			tz->type[tz->trans_idx[i]].isdst,
type              291 ext/date/lib/parse_tz.c 			tz->type[tz->trans_idx[i]].abbr_idx,
type              292 ext/date/lib/parse_tz.c 			&tz->timezone_abbr[tz->type[tz->trans_idx[i]].abbr_idx],
type              293 ext/date/lib/parse_tz.c 			tz->type[tz->trans_idx[i]].isstdcnt,
type              294 ext/date/lib/parse_tz.c 			tz->type[tz->trans_idx[i]].isgmtcnt
type              417 ext/date/lib/parse_tz.c 			return &(tz->type[0]);
type              431 ext/date/lib/parse_tz.c 		while (j < tz->bit32.timecnt && tz->type[tz->trans_idx[j]].isdst) {
type              437 ext/date/lib/parse_tz.c 		return &(tz->type[tz->trans_idx[j]]);
type              445 ext/date/lib/parse_tz.c 			return &(tz->type[tz->trans_idx[i - 1]]);
type              449 ext/date/lib/parse_tz.c 	return &(tz->type[tz->trans_idx[tz->bit32.timecnt - 1]]);
type              153 ext/date/lib/timelib.c 	tmp->type = (ttinfo*) timelib_malloc(tz->bit32.typecnt * sizeof(struct ttinfo));
type              154 ext/date/lib/timelib.c 	memcpy(tmp->type, tz->type, tz->bit32.typecnt * sizeof(struct ttinfo));
type              170 ext/date/lib/timelib.c 	TIMELIB_TIME_FREE(tz->type);
type              277 ext/date/lib/timelib.c 				switch (d->relative.special.type) {
type              203 ext/date/lib/timelib_structs.h 	ttinfo  *type;
type              212 ext/date/lib/timelib_structs.h 	unsigned int type;
type              282 ext/date/lib/timelib_structs.h 	int         type;
type              279 ext/date/lib/tm2unixtime.c 		switch (time->relative.special.type) {
type              292 ext/date/lib/tm2unixtime.c 		switch (time->relative.special.type) {
type              648 ext/date/php_date.c zval *date_interval_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv);
type              650 ext/date/php_date.c static zval *date_period_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv);
type             1963 ext/date/php_date.c 	if (implementor->type == ZEND_USER_CLASS &&
type             2242 ext/date/php_date.c 	new_obj->type = old_obj->type;
type             2244 ext/date/php_date.c 	switch (new_obj->type) {
type             2276 ext/date/php_date.c 	ZVAL_LONG(&zv, tzobj->type);
type             2279 ext/date/php_date.c 	switch (tzobj->type) {
type             2376 ext/date/php_date.c 	PHP_DATE_INTERVAL_ADD_PROPERTY("special_type", special.type);
type             2431 ext/date/php_date.c 	if (intern->type == TIMELIB_ZONETYPE_ABBR) {
type             2488 ext/date/php_date.c 	int type = TIMELIB_ZONETYPE_ID, new_dst = 0;
type             2520 ext/date/php_date.c 		switch (tzobj->type) {
type             2533 ext/date/php_date.c 		type = tzobj->type;
type             2541 ext/date/php_date.c 	now->zone_type = type;
type             2542 ext/date/php_date.c 	switch (type) {
type             2756 ext/date/php_date.c 						tzobj->type = TIMELIB_ZONETYPE_ID;
type             2931 ext/date/php_date.c 		if (parsed_time->relative.have_special_relative && (parsed_time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY)) {
type             3215 ext/date/php_date.c        tzobj->type = t->zone_type;
type             3265 ext/date/php_date.c 	switch (tzobj->type) {
type             3745 ext/date/php_date.c 	switch (tzobj->type) {
type             3810 ext/date/php_date.c 	switch (tzobj->type) {
type             3841 ext/date/php_date.c 	if (tzobj->type != TIMELIB_ZONETYPE_ID) {
type             3849 ext/date/php_date.c 		add_assoc_long(&element, "offset", tzobj->tzi.tz->type[0].offset); \
type             3850 ext/date/php_date.c 		add_assoc_bool(&element, "isdst",  tzobj->tzi.tz->type[0].isdst); \
type             3851 ext/date/php_date.c 		add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx]); \
type             3858 ext/date/php_date.c 		add_assoc_long(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \
type             3859 ext/date/php_date.c 		add_assoc_bool(&element, "isdst",  tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \
type             3860 ext/date/php_date.c 		add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx]); \
type             3919 ext/date/php_date.c 	if (tzobj->type != TIMELIB_ZONETYPE_ID) {
type             3967 ext/date/php_date.c zval *date_interval_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type             3985 ext/date/php_date.c 		retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv);
type             4007 ext/date/php_date.c 		retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv);
type             4144 ext/date/php_date.c 	PHP_DATE_INTERVAL_READ_PROPERTY("special_type", special.type, unsigned int, 0);
type             4570 ext/date/php_date.c 		add_assoc_bool_ex(&element, "dst", sizeof("dst") -1, entry->type);
type             5026 ext/date/php_date.c static zval *date_period_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type             5029 ext/date/php_date.c 	if (type != BP_VAR_IS && type != BP_VAR_R) {
type             5035 ext/date/php_date.c 	zv = std_object_handlers.read_property(object, member, type, cache_slot, rv);
type              150 ext/date/php_date.h 	int             type;
type              617 ext/dba/dba.c  		if (le->type == le_db || le->type == le_pdb) {
type              686 ext/dba/dba.c  			if (le->type != le_pdb) {
type             1269 ext/dba/dba.c  		if (le->type == le_db || le->type == le_pdb) {
type               50 ext/dba/dba_db2.c 	DBTYPE type;
type               60 ext/dba/dba_db2.c 	type = info->mode == DBA_READER ? DB_UNKNOWN :
type               79 ext/dba/dba_db2.c 	if (db_open(info->path, type, gmode, filemode, NULL, NULL, &dbp)) {
type               62 ext/dba/dba_db3.c 	DBTYPE type;
type               72 ext/dba/dba_db3.c 	type = info->mode == DBA_READER ? DB_UNKNOWN :
type               99 ext/dba/dba_db3.c 			(err=dbp->open(dbp, 0, info->path, NULL, type, gmode, filemode)) == 0) {
type              101 ext/dba/dba_db3.c 			(err=dbp->open(dbp, info->path, NULL, type, gmode, filemode)) == 0) {
type               76 ext/dba/dba_db4.c 	DBTYPE type;
type               87 ext/dba/dba_db4.c 	type = info->mode == DBA_READER ? DB_UNKNOWN :
type              101 ext/dba/dba_db4.c 	type = info->mode == DBA_READER ? DB_UNKNOWN :
type              128 ext/dba/dba_db4.c 			(err=dbp->open(dbp, 0, info->path, NULL, type, gmode, filemode)) == 0) {
type              130 ext/dba/dba_db4.c 			(err=dbp->open(dbp, info->path, NULL, type, gmode, filemode)) == 0) {
type              991 ext/dom/document.c 	if (nodep->type == XML_HTML_DOCUMENT_NODE || nodep->type == XML_DOCUMENT_NODE
type              992 ext/dom/document.c 		|| nodep->type == XML_DOCUMENT_TYPE_NODE) {
type             1000 ext/dom/document.c 		if ((recursive == 0) && (nodep->type == XML_ELEMENT_NODE)) {
type             1008 ext/dom/document.c 		if ((retnodep->type == XML_ATTRIBUTE_NODE) && (nodep->ns != NULL)) {
type             1691 ext/dom/document.c 		if (cur->type == XML_XINCLUDE_START) {
type             1695 ext/dom/document.c 			while(cur && cur->type != XML_XINCLUDE_END) {
type             1697 ext/dom/document.c 				if (cur->type == XML_ELEMENT_NODE) {
type             1703 ext/dom/document.c 			if (cur && cur->type == XML_XINCLUDE_END) {
type             1707 ext/dom/document.c 			if (cur->type == XML_ELEMENT_NODE) {
type             1745 ext/dom/document.c 	while(root && root->type != XML_ELEMENT_NODE && root->type != XML_XINCLUDE_START) {
type             1795 ext/dom/document.c static void _dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
type             1821 ext/dom/document.c 	switch (type) {
type             1897 ext/dom/document.c static void _dom_document_relaxNG_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
type             1921 ext/dom/document.c 	switch (type) {
type             2184 ext/dom/document.c 		if (node->type == XML_DOCUMENT_FRAG_NODE) {
type               89 ext/dom/documentfragment.c 		if(tree->type == XML_ELEMENT_NODE) {
type               65 ext/dom/dom_iterators.c     ret->type = XML_NOTATION_NODE;
type              215 ext/dom/dom_iterators.c 					if (basenode && (basenode->type == XML_DOCUMENT_NODE ||
type              216 ext/dom/dom_iterators.c 						basenode->type == XML_HTML_DOCUMENT_NODE)) {
type              299 ext/dom/dom_iterators.c 					if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type              173 ext/dom/domimplementation.c 		if (doctype->type == XML_DOCUMENT_TYPE_NODE) {
type              340 ext/dom/element.c 		switch (attr->type) {
type              399 ext/dom/element.c 		switch (attr->type) {
type              456 ext/dom/element.c 	switch (attrp->type) {
type              500 ext/dom/element.c 	if (attrp->type == XML_NAMESPACE_DECL) {
type              514 ext/dom/element.c 		attrp->type = XML_NAMESPACE_DECL;
type              548 ext/dom/element.c 	if (attrp->type != XML_ATTRIBUTE_NODE) {
type              559 ext/dom/element.c 	if (existattrp != NULL && existattrp->type != XML_ATTRIBUTE_DECL) {
type              614 ext/dom/element.c 	if (attrp->type != XML_ATTRIBUTE_NODE || attrp->parent != nodep) {
type              699 ext/dom/element.c 	if ((tree == NULL) || (ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) {
type              771 ext/dom/element.c 			if (nodep != NULL && nodep->type != XML_ATTRIBUTE_DECL) {
type              839 ext/dom/element.c 				if (attr != NULL && attr->type != XML_ATTRIBUTE_DECL) {
type              903 ext/dom/element.c 	if (attrp && attrp->type != XML_ATTRIBUTE_DECL) {
type              974 ext/dom/element.c 	if (attrp->type != XML_ATTRIBUTE_NODE) {
type              991 ext/dom/element.c 	if (existattrp != NULL && existattrp->type != XML_ATTRIBUTE_DECL) {
type             1160 ext/dom/element.c 	if (attrp == NULL || attrp->type == XML_ATTRIBUTE_DECL) {
type             1196 ext/dom/element.c 	if (attrp == NULL || attrp->type == XML_ATTRIBUTE_DECL) {
type              166 ext/dom/node.c 	if (nodep->type == XML_ELEMENT_NODE) {
type              213 ext/dom/node.c 	switch (nodep->type) {
type              297 ext/dom/node.c 	switch (nodep->type) {
type              335 ext/dom/node.c 	switch (nodep->type) {
type              377 ext/dom/node.c 	if (nodep->type == XML_DTD_NODE) {
type              380 ext/dom/node.c 		ZVAL_LONG(retval, nodep->type);
type              576 ext/dom/node.c 	if (nodep->type == XML_ELEMENT_NODE) {
type              604 ext/dom/node.c 	if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type              635 ext/dom/node.c 	switch (nodep->type) {
type              675 ext/dom/node.c 	switch (nodep->type) {
type              713 ext/dom/node.c 	switch (nodep->type) {
type              729 ext/dom/node.c 					(nodep->type == XML_ATTRIBUTE_NODE && !strcmp(prefix, "xmlns") &&
type              731 ext/dom/node.c 					(nodep->type == XML_ATTRIBUTE_NODE && !strcmp((char *) nodep->name, "xmlns"))) {
type              780 ext/dom/node.c 	if (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE || nodep->type == XML_NAMESPACE_DECL) {
type              955 ext/dom/node.c 	if (child->type == XML_DOCUMENT_FRAG_NODE && child->children == NULL) {
type              976 ext/dom/node.c 		if (child->type == XML_TEXT_NODE && (refp->type == XML_TEXT_NODE ||
type              977 ext/dom/node.c 			(refp->prev != NULL && refp->prev->type == XML_TEXT_NODE))) {
type              995 ext/dom/node.c 		} else if (child->type == XML_ATTRIBUTE_NODE) {
type             1002 ext/dom/node.c 			if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
type             1011 ext/dom/node.c 		} else if (child->type == XML_DOCUMENT_FRAG_NODE) {
type             1022 ext/dom/node.c 		if (child->type == XML_TEXT_NODE && parentp->last != NULL && parentp->last->type == XML_TEXT_NODE) {
type             1037 ext/dom/node.c 		} else 	if (child->type == XML_ATTRIBUTE_NODE) {
type             1044 ext/dom/node.c 			if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
type             1053 ext/dom/node.c 		} else if (child->type == XML_DOCUMENT_FRAG_NODE) {
type             1132 ext/dom/node.c 		if (newchild->type == XML_DOCUMENT_FRAG_NODE) {
type             1253 ext/dom/node.c 	if (child->type == XML_DOCUMENT_FRAG_NODE && child->children == NULL) {
type             1267 ext/dom/node.c 	if (child->type == XML_TEXT_NODE && nodep->last != NULL && nodep->last->type == XML_TEXT_NODE) {
type             1282 ext/dom/node.c 	} else 	if (child->type == XML_ATTRIBUTE_NODE) {
type             1289 ext/dom/node.c 		if (lastattr != NULL && lastattr->type != XML_ATTRIBUTE_DECL) {
type             1295 ext/dom/node.c 	} else if (child->type == XML_DOCUMENT_FRAG_NODE) {
type             1367 ext/dom/node.c 	if (n->type == XML_ELEMENT_NODE && recursive == 0) {
type             1461 ext/dom/node.c 	if (nodep->type != XML_ELEMENT_NODE)
type             1528 ext/dom/node.c 		switch (nodep->type) {
type             1577 ext/dom/node.c 	if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type             1610 ext/dom/node.c 	if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type             1707 ext/dom/node.c 		if (nodep->type != XML_DOCUMENT_NODE) {
type             1712 ext/dom/node.c 			if (xpathobjp && xpathobjp->type == XPATH_NODESET) {
type             1756 ext/dom/node.c 		if (xpathobjp && xpathobjp->type == XPATH_NODESET) {
type               82 ext/dom/nodelist.c 						if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type              151 ext/dom/nodelist.c 							if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type              120 ext/dom/php_dom.c 	switch (node->type) {
type              144 ext/dom/php_dom.c 	switch (node->type) {
type              313 ext/dom/php_dom.c static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              321 ext/dom/php_dom.c 		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
type              330 ext/dom/php_dom.c zval *dom_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type              352 ext/dom/php_dom.c 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
type              493 ext/dom/php_dom.c 	if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
type              983 ext/dom/php_dom.c 			if (node->type == XML_ENTITY_REF_NODE)
type              987 ext/dom/php_dom.c 			switch (node->type) {
type             1045 ext/dom/php_dom.c 		if (((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_DOCUMENT_NODE && ((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_HTML_DOCUMENT_NODE) {
type             1078 ext/dom/php_dom.c 	while (base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
type             1208 ext/dom/php_dom.c 	switch (obj->type) {
type             1278 ext/dom/php_dom.c 			php_error_docref(NULL, E_WARNING, "Unsupported node type: %d", obj->type);
type             1346 ext/dom/php_dom.c 		if (nodep->type == XML_ELEMENT_NODE) {
type             1377 ext/dom/php_dom.c 		switch (child->type) {
type             1381 ext/dom/php_dom.c 					if (nextp->type == XML_TEXT_NODE) {
type             1427 ext/dom/php_dom.c 		doc->oldNs->type = XML_LOCAL_NAMESPACE;
type             1538 ext/dom/php_dom.c zval *dom_nodelist_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
type              129 ext/dom/php_dom.h zval *dom_nodelist_read_dimension(zval *object, zval *offset, int type, zval *rv);
type              114 ext/dom/text.c 	while (node->prev && ((node->prev->type == XML_TEXT_NODE) || (node->prev->type == XML_CDATA_SECTION_NODE))) {
type              119 ext/dom/text.c 	while (node && ((node->type == XML_TEXT_NODE) || (node->type == XML_CDATA_SECTION_NODE))) {
type              157 ext/dom/text.c 	if (node->type != XML_TEXT_NODE && node->type != XML_CDATA_SECTION_NODE) {
type              188 ext/dom/text.c 		nnode->type = XML_ELEMENT_NODE;
type              190 ext/dom/text.c 		nnode->type = XML_TEXT_NODE;
type               75 ext/dom/xpath.c static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
type              120 ext/dom/xpath.c 		switch (obj->type) {
type              131 ext/dom/xpath.c 				if (type == 1) {
type              135 ext/dom/xpath.c 				} else if (type == 2) {
type              143 ext/dom/xpath.c 							if (node->type == XML_NAMESPACE_DECL) {
type              157 ext/dom/xpath.c 								node->type = XML_NAMESPACE_DECL;
type              349 ext/dom/xpath.c static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
type              423 ext/dom/xpath.c 	if (type == PHP_DOM_XPATH_QUERY) {
type              426 ext/dom/xpath.c 		xpath_type = xpathobjp->type;
type              438 ext/dom/xpath.c 			if (xpathobjp->type == XPATH_NODESET && NULL != (nodesetp = xpathobjp->nodesetval)) {
type              444 ext/dom/xpath.c 					if (node->type == XML_NAMESPACE_DECL) {
type              458 ext/dom/xpath.c 						node->type = XML_NAMESPACE_DECL;
type             1476 ext/exif/exif.c 	int     type;
type             1558 ext/exif/exif.c static void exif_error_docref(const char *docref EXIFERR_DC, const image_info_type *ImageInfo, int type, const char *format, ...)
type             1568 ext/exif/exif.c 		php_verror(docref, ImageInfo->FileName?ImageInfo->FileName:"", type, buf, args);
type             1572 ext/exif/exif.c 	php_verror(docref, ImageInfo->FileName?ImageInfo->FileName:"", type, format, args);
type             1592 ext/exif/exif.c static int exif_file_sections_add(image_info_type *ImageInfo, int type, size_t size, uchar *data)
type             1599 ext/exif/exif.c 	ImageInfo->file.list[count].type = 0xFFFF;
type             1608 ext/exif/exif.c 	ImageInfo->file.list[count].type = type;
type              113 ext/fileinfo/libmagic/apprentice.c 	int type;
type              181 ext/fileinfo/libmagic/apprentice.c 	const int type;
type              274 ext/fileinfo/libmagic/apprentice.c 	return p->type;
type              280 ext/fileinfo/libmagic/apprentice.c 	int type;
type              286 ext/fileinfo/libmagic/apprentice.c 			type = FILE_BYTE;
type              290 ext/fileinfo/libmagic/apprentice.c 			type = FILE_SHORT;
type              306 ext/fileinfo/libmagic/apprentice.c 			type = FILE_LONG;
type              310 ext/fileinfo/libmagic/apprentice.c 			type = FILE_QUAD;
type              334 ext/fileinfo/libmagic/apprentice.c 			type = FILE_BYTE;
type              337 ext/fileinfo/libmagic/apprentice.c 			type = FILE_SHORT;
type              340 ext/fileinfo/libmagic/apprentice.c 			type = FILE_LONG;
type              343 ext/fileinfo/libmagic/apprentice.c 			type = FILE_QUAD;
type              354 ext/fileinfo/libmagic/apprentice.c 		type = FILE_LONG;
type              359 ext/fileinfo/libmagic/apprentice.c 	return type;
type              373 ext/fileinfo/libmagic/apprentice.c 		assert(p->type < FILE_NAMES_SIZE);
type              374 ext/fileinfo/libmagic/apprentice.c 		file_names[p->type] = p->name;
type              375 ext/fileinfo/libmagic/apprentice.c 		file_formats[p->type] = p->format;
type              718 ext/fileinfo/libmagic/apprentice.c 	switch (m->type) {
type              798 ext/fileinfo/libmagic/apprentice.c 		(void)fprintf(stderr, "Bad type %d\n", m->type);
type              917 ext/fileinfo/libmagic/apprentice.c 	switch (m->type) {
type              997 ext/fileinfo/libmagic/apprentice.c 	size_t i = me->mp->type == FILE_NAME ? 1 : 0;
type             1158 ext/fileinfo/libmagic/apprentice.c 		    me[i].mp->type == FILE_DEFAULT) {
type             1331 ext/fileinfo/libmagic/apprentice.c 		switch(m->type) {
type             1394 ext/fileinfo/libmagic/apprentice.c 				    m->type);
type             1407 ext/fileinfo/libmagic/apprentice.c 	if ((m->type != FILE_REGEX || (m->str_flags & REGEX_LINE_COUNT) == 0) &&
type             1408 ext/fileinfo/libmagic/apprentice.c 	    (m->type != FILE_PSTRING && (m->str_flags & PSTRING_LEN) != 0)) {
type             1413 ext/fileinfo/libmagic/apprentice.c 	switch (m->type) {
type             1454 ext/fileinfo/libmagic/apprentice.c 		    m->type);
type             1641 ext/fileinfo/libmagic/apprentice.c 			if (m->type != FILE_PSTRING)
type             1646 ext/fileinfo/libmagic/apprentice.c 			if (m->type != FILE_PSTRING)
type             1651 ext/fileinfo/libmagic/apprentice.c 			if (m->type != FILE_PSTRING)
type             1656 ext/fileinfo/libmagic/apprentice.c 			if (m->type != FILE_PSTRING)
type             1661 ext/fileinfo/libmagic/apprentice.c 			switch (m->type) {
type             1671 ext/fileinfo/libmagic/apprentice.c 			if (m->type != FILE_PSTRING)
type             1905 ext/fileinfo/libmagic/apprentice.c 		m->type = get_type(type_tbl, l + 1, &l);
type             1906 ext/fileinfo/libmagic/apprentice.c 		if (m->type == FILE_INVALID) {
type             1911 ext/fileinfo/libmagic/apprentice.c 			m->type = get_standard_integer_type(l, &l);
type             1914 ext/fileinfo/libmagic/apprentice.c 		if (m->type != FILE_INVALID)
type             1923 ext/fileinfo/libmagic/apprentice.c 		m->type = get_type(type_tbl, l, &l);
type             1924 ext/fileinfo/libmagic/apprentice.c 		if (m->type == FILE_INVALID) {
type             1931 ext/fileinfo/libmagic/apprentice.c 				m->type = get_standard_integer_type(l, &l);
type             1933 ext/fileinfo/libmagic/apprentice.c 				m->type = FILE_STRING;
type             1939 ext/fileinfo/libmagic/apprentice.c 	if (m->type == FILE_INVALID) {
type             1941 ext/fileinfo/libmagic/apprentice.c 		m->type = get_type(special_tbl, l, &l);
type             1944 ext/fileinfo/libmagic/apprentice.c 	if (m->type == FILE_INVALID) {
type             1955 ext/fileinfo/libmagic/apprentice.c 		if (!IS_LIBMAGIC_STRING(m->type))
type             1962 ext/fileinfo/libmagic/apprentice.c 	m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0;
type             1964 ext/fileinfo/libmagic/apprentice.c 		if (IS_LIBMAGIC_STRING(m->type)) {
type             1975 ext/fileinfo/libmagic/apprentice.c 			if (m->type == FILE_INDIRECT)
type             2091 ext/fileinfo/libmagic/apprentice.c 	if (m->type == FILE_NAME) {
type             2214 ext/fileinfo/libmagic/apprentice.c check_format_type(const char *ptr, int type)
type             2222 ext/fileinfo/libmagic/apprentice.c 	switch (file_formats[type]) {
type             2228 ext/fileinfo/libmagic/apprentice.c 			switch (type) {
type             2402 ext/fileinfo/libmagic/apprentice.c 	if (m->type >= file_nformats) {
type             2407 ext/fileinfo/libmagic/apprentice.c 	if (file_formats[m->type] == FILE_FMT_NONE) {
type             2409 ext/fileinfo/libmagic/apprentice.c 		    "`%s'", m->desc, file_names[m->type]);
type             2414 ext/fileinfo/libmagic/apprentice.c 	if (check_format_type(ptr, m->type) == -1) {
type             2421 ext/fileinfo/libmagic/apprentice.c 		    file_names[m->type], m->desc);
type             2430 ext/fileinfo/libmagic/apprentice.c 			    file_names[m->type], m->desc);
type             2445 ext/fileinfo/libmagic/apprentice.c 	switch (m->type) {
type             2461 ext/fileinfo/libmagic/apprentice.c 		if (m->type == FILE_REGEX) {
type             2555 ext/fileinfo/libmagic/apprentice.c 						    && (m->type != FILE_REGEX ||
type             2666 ext/fileinfo/libmagic/apprentice.c 	if (m->type == FILE_PSTRING)
type             2788 ext/fileinfo/libmagic/apprentice.c 	map->type = MAP_TYPE_USER;
type             3189 ext/fileinfo/libmagic/apprentice.c 	if (IS_LIBMAGIC_STRING(m->type)) {
type             3259 ext/fileinfo/libmagic/apprentice.c 			if (ma[i].type != FILE_NAME)
type               48 ext/fileinfo/libmagic/apptype.c 	APPTYPE         rc, type;
type               80 ext/fileinfo/libmagic/apptype.c 	rc = DosQueryAppType((unsigned char *)path, &type);
type              108 ext/fileinfo/libmagic/apptype.c 	if (type & FAPPTYP_32BIT)
type              111 ext/fileinfo/libmagic/apptype.c 	if (type & FAPPTYP_PHYSDRV) {
type              114 ext/fileinfo/libmagic/apptype.c 	} else if (type & FAPPTYP_VIRTDRV) {
type              117 ext/fileinfo/libmagic/apptype.c 	} else if (type & FAPPTYP_DLL) {
type              118 ext/fileinfo/libmagic/apptype.c 		if (type & FAPPTYP_PROTDLL)
type              123 ext/fileinfo/libmagic/apptype.c 	} else if (type & (FAPPTYP_WINDOWSREAL | FAPPTYP_WINDOWSPROT)) {
type              126 ext/fileinfo/libmagic/apptype.c 	} else if (type & FAPPTYP_DOS) {
type              142 ext/fileinfo/libmagic/apptype.c 	} else if (type & FAPPTYP_BOUND) {
type              145 ext/fileinfo/libmagic/apptype.c 	} else if ((type & 7) == FAPPTYP_WINDOWAPI) {
type              151 ext/fileinfo/libmagic/apptype.c 	switch (type & (FAPPTYP_NOTWINDOWCOMPAT |
type               80 ext/fileinfo/libmagic/ascmagic.c 	const char *type = NULL;
type               89 ext/fileinfo/libmagic/ascmagic.c 	    &type) == 0)
type               93 ext/fileinfo/libmagic/ascmagic.c 						 type, text);
type              103 ext/fileinfo/libmagic/ascmagic.c     const char *type, int text)
type              192 ext/fileinfo/libmagic/ascmagic.c 	if (strcmp(type, "binary") == 0) {
type              238 ext/fileinfo/libmagic/ascmagic.c 		if (file_printf(ms, " %s", type) == -1)
type              775 ext/fileinfo/libmagic/cdf.c cdf_find_stream(const cdf_dir_t *dir, const char *name, int type)
type              780 ext/fileinfo/libmagic/cdf.c 		if (dir->dir_tab[i - 1].d_type == type &&
type              787 ext/fileinfo/libmagic/cdf.c 	DPRINTF(("Cannot find type %d `%s'\n", type, name));
type               34 ext/fileinfo/libmagic/elfclass.h 	type = elf_getu16(swap, elfhdr.e_type);
type               36 ext/fileinfo/libmagic/elfclass.h 	switch (type) {
type               68 ext/fileinfo/libmagic/encoding.c file_encoding(struct magic_set *ms, const unsigned char *buf, size_t nbytes, unichar **ubuf, size_t *ulen, const char **code, const char **code_mime, const char **type)
type               74 ext/fileinfo/libmagic/encoding.c 	*type = "text";
type              134 ext/fileinfo/libmagic/encoding.c 			*type = "binary";
type              178 ext/fileinfo/libmagic/file.h 	uint8_t type;		/* comparison type (FILE_*) */
type              459 ext/fileinfo/libmagic/file.h protected void file_delmagic(struct magic *, int type, size_t entries);
type              174 ext/fileinfo/libmagic/funcs.c 	const char *type = "application/octet-stream";
type              180 ext/fileinfo/libmagic/funcs.c 		type = "application/x-empty";
type              274 ext/fileinfo/libmagic/funcs.c 	    file_printf(ms, "%s", mime ? type : def) == -1) {
type              172 ext/fileinfo/libmagic/softmagic.c 		if (m->type != FILE_NAME)
type              173 ext/fileinfo/libmagic/softmagic.c 		if ((IS_LIBMAGIC_STRING(m->type) &&
type              199 ext/fileinfo/libmagic/softmagic.c 			if (m->type == FILE_INDIRECT)
type              290 ext/fileinfo/libmagic/softmagic.c 				if (m->type == FILE_INDIRECT)
type              308 ext/fileinfo/libmagic/softmagic.c 				if (m->type == FILE_CLEAR)
type              311 ext/fileinfo/libmagic/softmagic.c 					if (m->type == FILE_DEFAULT)
type              412 ext/fileinfo/libmagic/softmagic.c   	switch (m->type) {
type              535 ext/fileinfo/libmagic/softmagic.c 			if (m->type == FILE_PSTRING)
type              673 ext/fileinfo/libmagic/softmagic.c 		file_magerror(ms, "invalid m->type (%d) in mprint()", m->type);
type              682 ext/fileinfo/libmagic/softmagic.c   	switch (m->type) {
type              715 ext/fileinfo/libmagic/softmagic.c 			if (m->type == FILE_PSTRING)
type              776 ext/fileinfo/libmagic/softmagic.c cvt_flip(int type, int flip)
type              779 ext/fileinfo/libmagic/softmagic.c 		return type;
type              780 ext/fileinfo/libmagic/softmagic.c 	switch (type) {
type              822 ext/fileinfo/libmagic/softmagic.c 		return type;
type              918 ext/fileinfo/libmagic/softmagic.c 	uint8_t type;
type              920 ext/fileinfo/libmagic/softmagic.c 	switch (type = cvt_flip(m->type, flip)) {
type             1055 ext/fileinfo/libmagic/softmagic.c 		file_magerror(ms, "invalid type %d in mconvert()", m->type);
type             1071 ext/fileinfo/libmagic/softmagic.c mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
type             1079 ext/fileinfo/libmagic/softmagic.c 		switch (type) {
type             1149 ext/fileinfo/libmagic/softmagic.c 			if (type == FILE_BESTRING16)
type             1161 ext/fileinfo/libmagic/softmagic.c 					if (type == FILE_BESTRING16 ?
type             1224 ext/fileinfo/libmagic/softmagic.c 	if (mcopy(ms, p, m->type, m->flag & INDIR, s, (uint32_t)(offset + o),
type             1232 ext/fileinfo/libmagic/softmagic.c 		    m->type, m->flag, offset, o, nbytes,
type             1597 ext/fileinfo/libmagic/softmagic.c 		if (mcopy(ms, p, m->type, 0, s, offset, nbytes, m) == -1)
type             1608 ext/fileinfo/libmagic/softmagic.c 	switch (m->type) {
type             1852 ext/fileinfo/libmagic/softmagic.c 	switch (m->type) {
type             2080 ext/fileinfo/libmagic/softmagic.c 		file_magerror(ms, "invalid type %d in magiccheck()", m->type);
type               86 ext/filter/filter.c 	ZEND_ARG_INFO(0, type)
type               99 ext/filter/filter.c 	ZEND_ARG_INFO(0, type)
type              114 ext/filter/filter.c 	ZEND_ARG_INFO(0, type)
type              100 ext/ftp/ftp.c  static int		ftp_type(ftpbuf_t *ftp, ftptype_t type);
type              702 ext/ftp/ftp.c  ftp_type(ftpbuf_t *ftp, ftptype_t type)
type              709 ext/ftp/ftp.c  	if (type == ftp->type) {
type              712 ext/ftp/ftp.c  	if (type == FTPTYPE_ASCII) {
type              714 ext/ftp/ftp.c  	} else if (type == FTPTYPE_IMAGE) {
type              725 ext/ftp/ftp.c  	ftp->type = type;
type              828 ext/ftp/ftp.c  ftp_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, zend_long resumepos)
type              837 ext/ftp/ftp.c  	if (!ftp_type(ftp, type)) {
type              873 ext/ftp/ftp.c  		if (type == FTPTYPE_ASCII) {
type              920 ext/ftp/ftp.c  ftp_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, zend_long startpos)
type              931 ext/ftp/ftp.c  	if (!ftp_type(ftp, type)) {
type              971 ext/ftp/ftp.c  		if (ch == '\n' && type == FTPTYPE_ASCII) {
type             1531 ext/ftp/ftp.c  	data->type = ftp->type;
type             1888 ext/ftp/ftp.c  ftp_nb_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, zend_long resumepos)
type             1897 ext/ftp/ftp.c  	if (!ftp_type(ftp, type)) {
type             1948 ext/ftp/ftp.c  	ftptype_t	type;
type             1957 ext/ftp/ftp.c  	type = ftp->type;
type             1965 ext/ftp/ftp.c  		if (type == FTPTYPE_ASCII) {
type             1983 ext/ftp/ftp.c  	if (type == FTPTYPE_ASCII && lastch == '\r') {
type             2005 ext/ftp/ftp.c  ftp_nb_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, zend_long startpos)
type             2013 ext/ftp/ftp.c  	if (!ftp_type(ftp, type)) {
type             2070 ext/ftp/ftp.c  		if (ch == '\n' && ftp->type == FTPTYPE_ASCII) {
type               51 ext/ftp/ftp.h  	ftptype_t	type;			/* transfer type */
type               70 ext/ftp/ftp.h  	ftptype_t	type;			/* current transfer type */
type              174 ext/ftp/ftp.h  int		ftp_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, zend_long resumepos);
type              179 ext/ftp/ftp.h  int		ftp_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, zend_long startpos);
type              199 ext/ftp/ftp.h  int		ftp_nb_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, zend_long resumepos);
type              204 ext/ftp/ftp.h  int		ftp_nb_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, zend_long startpos);
type              401 ext/gd/gd.c    	ZEND_ARG_INFO(0, type)
type              807 ext/gd/gd.c    	ZEND_ARG_INFO(0, type)
type             1021 ext/gd/gd.c    void php_gd_error_method(int type, const char *format, va_list args)
type             1024 ext/gd/gd.c    	php_verror(NULL, "", type, format, args);
type             2501 ext/gd/gd.c    	zend_long quality = 0, type = 0;
type             2513 ext/gd/gd.c    	if (zend_parse_parameters(argc, "r|pll", &imgind, &file, &file_len, &quality, &type) == FAILURE) {
type             2527 ext/gd/gd.c    			t = type;
type             3424 ext/gd/gd.c    			 if (!zv || (Z_RES_P(zv))->type != le_gd_font) {
type             4787 ext/gd/gd.c    	zend_long type;
type             4792 ext/gd/gd.c    	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|z", &type, &options) == FAILURE)  {
type             4796 ext/gd/gd.c    	switch((gdAffineStandardMatrix)type) {
type             4818 ext/gd/gd.c    			if (type == GD_AFFINE_TRANSLATE) {
type             4838 ext/gd/gd.c    			if (type == GD_AFFINE_SHEAR_HORIZONTAL) {
type             4840 ext/gd/gd.c    			} else if (type == GD_AFFINE_SHEAR_VERTICAL) {
type             4849 ext/gd/gd.c    			php_error_docref(NULL, E_WARNING, "Invalid type for element %li", type);
type              101 ext/gd/libgd/gd.c void php_gd_error_ex(int type, const char *format, ...)
type              107 ext/gd/libgd/gd.c 	php_verror(NULL, "", type, format, args);
type               49 ext/gd/libgd/gd.h void php_gd_error_ex(int type, const char *format, ...);
type               70 ext/gd/libgd/gd_topal.c #define METHODDEF(type) static type
type               71 ext/gd/libgd/gd_topal.c #define LOCAL(type)	static type
type              159 ext/gd/libgd/wbmp.c   wbmp->type = getin (in);
type              160 ext/gd/libgd/wbmp.c   if (wbmp->type != 0)
type               29 ext/gd/libgd/wbmp.h     int type;           /* type of the wbmp */
type               37 ext/gd/libgd/xbm.c 	char *type;
type               57 ext/gd/libgd/xbm.c 			if (!(type = strrchr(iname, '_'))) {
type               58 ext/gd/libgd/xbm.c 				type = iname;
type               60 ext/gd/libgd/xbm.c 				type++;
type               63 ext/gd/libgd/xbm.c 			if (!strcmp("width", type)) {
type               66 ext/gd/libgd/xbm.c 			if (!strcmp("height", type)) {
type               84 ext/gd/libgd/xbm.c 				if (!(type = strrchr(iname, '_'))) {
type               85 ext/gd/libgd/xbm.c 					type = iname;
type               87 ext/gd/libgd/xbm.c 					type++;
type               89 ext/gd/libgd/xbm.c 				if (!strcmp("bits[]", type)) {
type              410 ext/gmp/gmp.c  static int gmp_cast_object(zval *readobj, zval *writeobj, int type) /* {{{ */
type              413 ext/gmp/gmp.c  	switch (type) {
type              116 ext/iconv/iconv.c 	ZEND_ARG_INFO(0, type)
type              121 ext/iconv/iconv.c 	ZEND_ARG_INFO(0, type)
type             2479 ext/iconv/iconv.c 	char *type;
type             2484 ext/iconv/iconv.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sS", &type, &type_len, &charset) == FAILURE)
type             2492 ext/iconv/iconv.c 	if(!strcasecmp("input_encoding", type)) {
type             2494 ext/iconv/iconv.c 	} else if(!strcasecmp("output_encoding", type)) {
type             2496 ext/iconv/iconv.c 	} else if(!strcasecmp("internal_encoding", type)) {
type             2517 ext/iconv/iconv.c 	char *type = "all";
type             2520 ext/iconv/iconv.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &type, &type_len) == FAILURE)
type             2523 ext/iconv/iconv.c 	if (!strcasecmp("all", type)) {
type             2528 ext/iconv/iconv.c 	} else if (!strcasecmp("input_encoding", type)) {
type             2530 ext/iconv/iconv.c 	} else if (!strcasecmp("output_encoding", type)) {
type             2532 ext/iconv/iconv.c 	} else if (!strcasecmp("internal_encoding", type)) {
type             3348 ext/imap/php_imap.c 	if (body->type <= TYPEMAX) {
type             3349 ext/imap/php_imap.c 		add_property_long(return_value, "type", body->type);
type             3382 ext/imap/php_imap.c 	if (body->disposition.type) {
type             3384 ext/imap/php_imap.c 		add_property_string(return_value, "disposition", body->disposition.type);
type             3616 ext/imap/php_imap.c 				bod->type = (short) Z_LVAL_P(pvalue);
type             3659 ext/imap/php_imap.c 				bod->disposition.type = (char *) fs_get(Z_STRLEN_P(pvalue) + 1);
type             3660 ext/imap/php_imap.c 				memcpy(bod->disposition.type, Z_STRVAL_P(pvalue), Z_STRLEN_P(pvalue)+1);
type             3700 ext/imap/php_imap.c 			short type = -1;
type             3703 ext/imap/php_imap.c 				type = (short) Z_LVAL_P(pvalue);
type             3717 ext/imap/php_imap.c 			if (type != TYPEMULTIPART) {
type             3718 ext/imap/php_imap.c 				bod->type = type;
type             3763 ext/imap/php_imap.c 				bod->disposition.type = (char *) fs_get(Z_STRLEN_P(pvalue) + 1);
type             3764 ext/imap/php_imap.c 				memcpy(bod->disposition.type, Z_STRVAL_P(pvalue), Z_STRLEN_P(pvalue)+1);
type             3811 ext/imap/php_imap.c 	if (bod && bod->type == TYPEMULTIPART && (!bod->nested.part || !bod->nested.part->next)) {
type             3855 ext/imap/php_imap.c 	if (bod && bod->type == TYPEMULTIPART) {
type             4576 ext/imap/php_imap.c 	if (body->type <= TYPEMAX) {
type             4577 ext/imap/php_imap.c 		add_property_long(arg, "type", body->type);
type             4614 ext/imap/php_imap.c 	if (body->disposition.type) {
type             4616 ext/imap/php_imap.c 		add_property_string(arg, "disposition", body->disposition.type);
type             4659 ext/imap/php_imap.c 	if (body->type == TYPEMULTIPART) {
type             4670 ext/imap/php_imap.c 	if ((body->type == TYPEMESSAGE) && (!strcasecmp(body->subtype, "rfc822"))) {
type              220 ext/interbase/ibase_blobs.c 	ib_blob->type = BLOB_INPUT;
type              265 ext/interbase/ibase_blobs.c 	ib_blob->type = BLOB_OUTPUT;
type              305 ext/interbase/ibase_blobs.c 	if (ib_blob->type != BLOB_INPUT) {
type              332 ext/interbase/ibase_blobs.c 	if (ib_blob->type != BLOB_OUTPUT) {
type               52 ext/interbase/ibase_query.c 	unsigned short type;
type             1185 ext/interbase/ibase_query.c 			result->type = QUERY_RESULT;
type             1295 ext/interbase/ibase_query.c static int _php_ibase_var_zval(zval *val, void *data, int type, int len, /* {{{ */
type             1316 ext/interbase/ibase_query.c 	switch (type & ~1) {
type             1406 ext/interbase/ibase_query.c 				switch (type & ~1) {
type             1838 ext/interbase/ibase_query.c 			result->type = EXECUTE_RESULT;
type             1881 ext/interbase/ibase_query.c 	int type;
type             1890 ext/interbase/ibase_query.c 	type = Z_RES_P(result)->type;
type             1892 ext/interbase/ibase_query.c 	if (type == le_query) {
type             2005 ext/interbase/ibase_query.c 	int type;
type             2014 ext/interbase/ibase_query.c 	type = Z_RES_P(result_arg)->type;
type             2016 ext/interbase/ibase_query.c 	if (type == le_query) {
type              555 ext/interbase/interbase.c 	if (Z_RES_P(link_id)->type == le_trans) {
type              697 ext/interbase/interbase.c 	if ((type == PHP_INI_DISPLAY_ORIG && ini_entry->orig_value)
type              698 ext/interbase/interbase.c 			|| (type == PHP_INI_DISPLAY_ACTIVE && ini_entry->value)) {
type              936 ext/interbase/interbase.c 		if (le->type != le_index_ptr) {
type              941 ext/interbase/interbase.c 		if ((!persistent && xlink->type == le_link) || xlink->type == le_plink) {
type              962 ext/interbase/interbase.c 			if (le->type != le_plink) {
type              999 ext/interbase/interbase.c 			new_le.type = le_plink;
type             1019 ext/interbase/interbase.c 	new_index_ptr.type = le_index_ptr;
type             1338 ext/interbase/interbase.c 		if (Z_RES_P(arg)->type == le_trans) {
type               92 ext/interbase/php_ibase_includes.h 	unsigned short type;
type               36 ext/intl/collator/collator_locale.c 	zend_long   type        = 0;
type               43 ext/intl/collator/collator_locale.c 		&object, Collator_ce_ptr, &type ) == FAILURE )
type               65 ext/intl/collator/collator_locale.c 		co->ucoll, type, COLLATOR_ERROR_CODE_P( co ) );
type               31 ext/intl/common/common_date.h U_CFUNC TimeZone *timezone_convert_datetimezone(int type, void *object, int is_datetime, intl_error *outside_error, const char *func);
type              429 ext/intl/formatter/formatter_attr.c 	zend_long type = ULOC_ACTUAL_LOCALE;
type              435 ext/intl/formatter/formatter_attr.c 		&object, NumberFormatter_ce_ptr, &type ) == FAILURE )
type              446 ext/intl/formatter/formatter_attr.c 	loc = (char *)unum_getLocaleByType(FORMATTER_OBJECT(nfo), type, &INTL_DATA_ERROR_CODE(nfo));
type              105 ext/intl/formatter/formatter_class.c 	ZEND_ARG_INFO(0, type)
type              137 ext/intl/formatter/formatter_class.c 	ZEND_ARG_INFO(0, type)
type              153 ext/intl/formatter/formatter_class.c 	ZEND_ARG_INFO(0, type)
type               36 ext/intl/formatter/formatter_format.c 	zend_long type = FORMAT_TYPE_DEFAULT;
type               44 ext/intl/formatter/formatter_format.c 		&object, NumberFormatter_ce_ptr,  &number, &type ) == FAILURE )
type               55 ext/intl/formatter/formatter_format.c 	if(type == FORMAT_TYPE_DEFAULT) {
type               62 ext/intl/formatter/formatter_format.c 			type = (sizeof(zend_long) == 8)?FORMAT_TYPE_INT64:FORMAT_TYPE_INT32;
type               64 ext/intl/formatter/formatter_format.c 			type = FORMAT_TYPE_DOUBLE;
type               66 ext/intl/formatter/formatter_format.c 			type = FORMAT_TYPE_INT32;
type               74 ext/intl/formatter/formatter_format.c 	switch(type) {
type              122 ext/intl/formatter/formatter_format.c 			php_error_docref(NULL, E_WARNING, "Unsupported format type %pd", type);
type               39 ext/intl/formatter/formatter_parse.c 	zend_long type = FORMAT_TYPE_DOUBLE;
type               54 ext/intl/formatter/formatter_parse.c 		&object, NumberFormatter_ce_ptr,  &str, &str_len, &type, &zposition ) == FAILURE )
type               82 ext/intl/formatter/formatter_parse.c 	switch(type) {
type              100 ext/intl/formatter/formatter_parse.c 			php_error_docref(NULL, E_WARNING, "Unsupported format type %pd", type);
type              165 ext/intl/php_intl.c 	ZEND_ARG_INFO(0, type)
type              258 ext/intl/php_intl.c 	ZEND_ARG_INFO(0, type)
type              291 ext/intl/php_intl.c 	ZEND_ARG_INFO(0, type)
type              224 ext/intl/resourcebundle/resourcebundle_class.c zval *resourcebundle_array_get(zval *object, zval *offset, int type, zval *rv)
type              220 ext/intl/transliterator/transliterator_class.c static zval *Transliterator_get_property_ptr_ptr( zval *object, zval *member, int type, void **cache_slot )
type              233 ext/intl/transliterator/transliterator_class.c 		retval = std_object_handlers.get_property_ptr_ptr( object, member, type, cache_slot );
type              243 ext/intl/transliterator/transliterator_class.c static zval *Transliterator_read_property( zval *object, zval *member, int type, void **cache_slot, zval *rv )
type              249 ext/intl/transliterator/transliterator_class.c 	if( ( type != BP_VAR_R && type != BP_VAR_IS ) &&
type              258 ext/intl/transliterator/transliterator_class.c 		retval = std_object_handlers.read_property( object, member, type, cache_slot, rv );
type              177 ext/intl/uchar/uchar.c                                    UCharCategory type) {
type              187 ext/intl/uchar/uchar.c 	ZVAL_LONG(&args[2], type);
type              291 ext/json/json_encoder.c 		int type;
type              294 ext/json/json_encoder.c 		if ((type = is_numeric_string(s, len, &p, &d, 0)) != 0) {
type              295 ext/json/json_encoder.c 			if (type == IS_LONG) {
type              298 ext/json/json_encoder.c 			} else if (type == IS_DOUBLE && php_json_is_valid_double(d)) {
type              247 ext/ldap/ldap.c 	ldap_module_entry.type = type;
type             2054 ext/ldap/ldap.c 	if (le->type != le_result) {
type              178 ext/libxml/libxml.c 			if (nodeptr->node != NULL && nodeptr->node->type != XML_DOCUMENT_NODE) {
type              194 ext/libxml/libxml.c 		switch (node->type) {
type              220 ext/libxml/libxml.c 				node->type = XML_ELEMENT_NODE;
type              235 ext/libxml/libxml.c 			switch (node->type) {
type             1294 ext/libxml/libxml.c 	switch (node->type) {
type             1299 ext/libxml/libxml.c 			if (node->parent == NULL || node->type == XML_NAMESPACE_DECL) {
type             1301 ext/libxml/libxml.c 				switch (node->type) {
type             3037 ext/mbstring/libmbfl/mbfl/mbfilter.c     int type)
type             3059 ext/mbstring/libmbfl/mbfl/mbfilter.c 	if (type == 0) { /* decimal output */
type             3064 ext/mbstring/libmbfl/mbfl/mbfilter.c 	} else if (type == 2) { /* hex output */
type              282 ext/mbstring/libmbfl/mbfl/mbfilter.h mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type);
type              221 ext/mbstring/mbstring.c 	ZEND_ARG_INFO(0, type)
type              425 ext/mbstring/mbstring.c 	ZEND_ARG_INFO(0, type)
type             1625 ext/mbstring/mbstring.c 		while (p->type > 0) {
type             1626 ext/mbstring/mbstring.c 			if ((MBSTRG(func_overload) & p->type) == p->type &&
type             1635 ext/mbstring/mbstring.c 					ZEND_ASSERT(orig->type == ZEND_INTERNAL_FUNCTION);
type             1686 ext/mbstring/mbstring.c 		while (p->type > 0) {
type             1687 ext/mbstring/mbstring.c 			if ((MBSTRG(func_overload) & p->type) == p->type &&
type             3911 ext/mbstring/mbstring.c php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type)
type             3943 ext/mbstring/mbstring.c 	if (type == 0 && is_hex) {
type             3944 ext/mbstring/mbstring.c 		type = 2; /* output in hex format */
type             3968 ext/mbstring/mbstring.c 	ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type);
type             4505 ext/mbstring/mbstring.c 			while (over_func->type > 0) {
type             4506 ext/mbstring/mbstring.c 				if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
type             4582 ext/mbstring/mbstring.c 				while (over_func->type > 0) {
type             4583 ext/mbstring/mbstring.c 					if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
type              199 ext/mbstring/mbstring.h 	int type;
type             1210 ext/mbstring/oniguruma/regcomp.c   if (node->type == ENCLOSE_OPTION)
type             1220 ext/mbstring/oniguruma/regcomp.c   switch (node->type) {
type             1275 ext/mbstring/oniguruma/regcomp.c   if (node->type == ENCLOSE_OPTION)
type             1278 ext/mbstring/oniguruma/regcomp.c   switch (node->type) {
type             1382 ext/mbstring/oniguruma/regcomp.c   switch (node->type) {
type             1409 ext/mbstring/oniguruma/regcomp.c   switch (node->type) {
type             1491 ext/mbstring/oniguruma/regcomp.c   int len, type, r;
type             1493 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             1494 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             1584 ext/mbstring/oniguruma/regcomp.c   int n, type, len, pos, r = 0;
type             1586 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             1587 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             1778 ext/mbstring/oniguruma/regcomp.c       if (en->type == ENCLOSE_MEMORY) {
type             1994 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             2116 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             2233 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             2355 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             2628 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             2648 ext/mbstring/oniguruma/regcomp.c     if (NANCHOR(node)->type == ANCHOR_PREC_READ)
type             2662 ext/mbstring/oniguruma/regcomp.c   int type, r = 0;
type             2664 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             2665 ext/mbstring/oniguruma/regcomp.c   if ((NTYPE2BIT(type) & type_mask) == 0)
type             2668 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             2685 ext/mbstring/oniguruma/regcomp.c       if ((en->type & enclose_mask) == 0)
type             2693 ext/mbstring/oniguruma/regcomp.c     type = NANCHOR(node)->type;
type             2694 ext/mbstring/oniguruma/regcomp.c     if ((type & anchor_mask) == 0)
type             2716 ext/mbstring/oniguruma/regcomp.c   int type;
type             2719 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             2720 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             2763 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             2800 ext/mbstring/oniguruma/regcomp.c   int type;
type             2803 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             2804 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             2819 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             2872 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             2913 ext/mbstring/oniguruma/regcomp.c   int type;
type             2916 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             2917 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             2941 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             2980 ext/mbstring/oniguruma/regcomp.c   int type;
type             2983 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             2984 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             3067 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             3095 ext/mbstring/oniguruma/regcomp.c   int anc_type = an->type;
type             3144 ext/mbstring/oniguruma/regcomp.c   int type;
type             3147 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             3148 ext/mbstring/oniguruma/regcomp.c   if (type == NT_QTFR) {
type             3178 ext/mbstring/oniguruma/regcomp.c   else if (type == NT_ENCLOSE) {
type             3180 ext/mbstring/oniguruma/regcomp.c     if (en->type == ENCLOSE_MEMORY) {
type             3513 ext/mbstring/oniguruma/regcomp.c   int type;
type             3516 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             3517 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             3555 ext/mbstring/oniguruma/regcomp.c 	      if (en->type == ENCLOSE_MEMORY) {
type             3607 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             3657 ext/mbstring/oniguruma/regcomp.c   int type;
type             3660 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             3661 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             3804 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             3845 ext/mbstring/oniguruma/regcomp.c       switch (an->type) {
type             4540 ext/mbstring/oniguruma/regcomp.c   int type;
type             4546 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             4547 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             4692 ext/mbstring/oniguruma/regcomp.c     switch (NANCHOR(node)->type) {
type             4699 ext/mbstring/oniguruma/regcomp.c       add_opt_anc_info(&opt->anc, NANCHOR(node)->type);
type             4827 ext/mbstring/oniguruma/regcomp.c       switch (en->type) {
type             6117 ext/mbstring/oniguruma/regcomp.c   int i, type;
type             6127 ext/mbstring/oniguruma/regcomp.c   type = NTYPE(node);
type             6128 ext/mbstring/oniguruma/regcomp.c   switch (type) {
type             6138 ext/mbstring/oniguruma/regcomp.c       if (NTYPE(node) != type) {
type             6192 ext/mbstring/oniguruma/regcomp.c     switch (NANCHOR(node)->type) {
type             6249 ext/mbstring/oniguruma/regcomp.c     switch (NENCLOSE(node)->type) {
type             6272 ext/mbstring/oniguruma/regcomp.c   if (type != NT_LIST && type != NT_ALT && type != NT_QTFR &&
type             6273 ext/mbstring/oniguruma/regcomp.c       type != NT_ENCLOSE)
type              480 ext/mbstring/oniguruma/regexec.c   stk->type = (stack_type);\
type              484 ext/mbstring/oniguruma/regexec.c #define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0)
type              499 ext/mbstring/oniguruma/regexec.c   else if ((stk)->type == STK_STATE_CHECK_MARK) { \
type              506 ext/mbstring/oniguruma/regexec.c   stk->type = (stack_type);\
type              515 ext/mbstring/oniguruma/regexec.c   stk->type = (stack_type);\
type              523 ext/mbstring/oniguruma/regexec.c   stk->type = STK_ALT;\
type              534 ext/mbstring/oniguruma/regexec.c     stk->type = STK_STATE_CHECK_MARK;\
type              547 ext/mbstring/oniguruma/regexec.c   stk->type = (stack_type);\
type              555 ext/mbstring/oniguruma/regexec.c   stk->type = (stack_type);\
type              570 ext/mbstring/oniguruma/regexec.c   stk->type = STK_REPEAT;\
type              579 ext/mbstring/oniguruma/regexec.c   stk->type = STK_REPEAT_INC;\
type              586 ext/mbstring/oniguruma/regexec.c   stk->type = STK_MEM_START;\
type              598 ext/mbstring/oniguruma/regexec.c   stk->type = STK_MEM_END;\
type              609 ext/mbstring/oniguruma/regexec.c   stk->type = STK_MEM_END_MARK;\
type              619 ext/mbstring/oniguruma/regexec.c     if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \
type              623 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
type              633 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
type              637 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_MEM_END && k->u.mem.num == (mnum)) {\
type              650 ext/mbstring/oniguruma/regexec.c   stk->type = STK_NULL_CHECK_START;\
type              658 ext/mbstring/oniguruma/regexec.c   stk->type = STK_NULL_CHECK_END;\
type              665 ext/mbstring/oniguruma/regexec.c   stk->type = STK_CALL_FRAME;\
type              672 ext/mbstring/oniguruma/regexec.c   stk->type = STK_RETURN;\
type              698 ext/mbstring/oniguruma/regexec.c       if ((stk->type & STK_MASK_POP_USED) != 0)  break;\
type              706 ext/mbstring/oniguruma/regexec.c       if ((stk->type & STK_MASK_POP_USED) != 0)  break;\
type              707 ext/mbstring/oniguruma/regexec.c       else if (stk->type == STK_MEM_START) {\
type              718 ext/mbstring/oniguruma/regexec.c       if ((stk->type & STK_MASK_POP_USED) != 0)  break;\
type              719 ext/mbstring/oniguruma/regexec.c       else if (stk->type == STK_MEM_START) {\
type              723 ext/mbstring/oniguruma/regexec.c       else if (stk->type == STK_REPEAT_INC) {\
type              726 ext/mbstring/oniguruma/regexec.c       else if (stk->type == STK_MEM_END) {\
type              740 ext/mbstring/oniguruma/regexec.c     if (stk->type == STK_POS_NOT) break;\
type              741 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_MEM_START) {\
type              745 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_REPEAT_INC) {\
type              748 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_MEM_END) {\
type              760 ext/mbstring/oniguruma/regexec.c     if (stk->type == STK_LOOK_BEHIND_NOT) break;\
type              761 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_MEM_START) {\
type              765 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_REPEAT_INC) {\
type              768 ext/mbstring/oniguruma/regexec.c     else if (stk->type == STK_MEM_END) {\
type              782 ext/mbstring/oniguruma/regexec.c       k->type = STK_VOID;\
type              784 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_POS) {\
type              785 ext/mbstring/oniguruma/regexec.c       k->type = STK_VOID;\
type              797 ext/mbstring/oniguruma/regexec.c       k->type = STK_VOID;\
type              799 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_STOP_BT) {\
type              800 ext/mbstring/oniguruma/regexec.c       k->type = STK_VOID;\
type              811 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_NULL_CHECK_START) {\
type              826 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_NULL_CHECK_START) {\
type              835 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_NULL_CHECK_END) {\
type              846 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_NULL_CHECK_START) {\
type              856 ext/mbstring/oniguruma/regexec.c             if (k->type == STK_MEM_START) {\
type              886 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_NULL_CHECK_START) {\
type              897 ext/mbstring/oniguruma/regexec.c               if (k->type == STK_MEM_START) {\
type              922 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_NULL_CHECK_END) {\
type              934 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_REPEAT) {\
type              941 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_CALL_FRAME) level--;\
type              942 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_RETURN)     level++;\
type              952 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_CALL_FRAME) {\
type              959 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_RETURN)\
type             1045 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_MEM_START) {
type             1063 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_MEM_END) {
type             1103 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_CALL_FRAME) {
type             1106 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_RETURN) {
type             1110 ext/mbstring/oniguruma/regexec.c       if (k->type == STK_MEM_START) {
type             1134 ext/mbstring/oniguruma/regexec.c       else if (k->type == STK_MEM_END) {
type             2704 ext/mbstring/oniguruma/regexec.c         stk->type = STK_STATE_CHECK_MARK;
type              217 ext/mbstring/oniguruma/regint.h #define PLATFORM_GET_INC(val,p,type) do{\
type              218 ext/mbstring/oniguruma/regint.h   val  = *(type* )p;\
type              219 ext/mbstring/oniguruma/regint.h   (p) += sizeof(type);\
type              224 ext/mbstring/oniguruma/regint.h #define PLATFORM_GET_INC(val,p,type) do{\
type              225 ext/mbstring/oniguruma/regint.h   xmemcpy(&val, (p), sizeof(type));\
type              226 ext/mbstring/oniguruma/regint.h   (p) += sizeof(type);\
type              683 ext/mbstring/oniguruma/regint.h   int type;
type              702 ext/mbstring/oniguruma/regint.h   unsigned int type;
type             1197 ext/mbstring/oniguruma/regparse.c node_new_ctype(int type, int not)
type             1203 ext/mbstring/oniguruma/regparse.c   NCTYPE(node)->ctype = type;
type             1267 ext/mbstring/oniguruma/regparse.c onig_node_new_anchor(int type)
type             1273 ext/mbstring/oniguruma/regparse.c   NANCHOR(node)->type     = type;
type             1374 ext/mbstring/oniguruma/regparse.c node_new_enclose(int type)
type             1380 ext/mbstring/oniguruma/regparse.c   NENCLOSE(node)->type      = type;
type             1391 ext/mbstring/oniguruma/regparse.c onig_node_new_enclose(int type)
type             1393 ext/mbstring/oniguruma/regparse.c   return node_new_enclose(type);
type             2278 ext/mbstring/oniguruma/regparse.c   enum TokenSyms type;
type             2394 ext/mbstring/oniguruma/regparse.c   tok->type = TK_INTERVAL;
type             2919 ext/mbstring/oniguruma/regparse.c     tok->type = TK_EOT;
type             2920 ext/mbstring/oniguruma/regparse.c     return tok->type;
type             2924 ext/mbstring/oniguruma/regparse.c   tok->type = TK_CHAR;
type             2930 ext/mbstring/oniguruma/regparse.c     tok->type = TK_CC_CLOSE;
type             2933 ext/mbstring/oniguruma/regparse.c     tok->type = TK_CC_RANGE;
type             2946 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2951 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2956 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2961 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2966 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2971 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2977 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2983 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             2994 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_CHAR_PROPERTY;
type             3024 ext/mbstring/oniguruma/regparse.c 	  tok->type   = TK_CODE_POINT;
type             3039 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_RAW_BYTE;
type             3055 ext/mbstring/oniguruma/regparse.c 	tok->type   = TK_CODE_POINT;
type             3071 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_RAW_BYTE;
type             3083 ext/mbstring/oniguruma/regparse.c 	tok->type   = TK_CODE_POINT;
type             3095 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_POSIX_BRACKET_OPEN;
type             3105 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_CC_CC_OPEN;
type             3116 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CC_AND;
type             3122 ext/mbstring/oniguruma/regparse.c   return tok->type;
type             3138 ext/mbstring/oniguruma/regparse.c     tok->type = TK_EOT;
type             3139 ext/mbstring/oniguruma/regparse.c     return tok->type;
type             3142 ext/mbstring/oniguruma/regparse.c   tok->type  = TK_STRING;
type             3158 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3166 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3174 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3188 ext/mbstring/oniguruma/regparse.c 	      tok->type != TK_INTERVAL)  ||
type             3190 ext/mbstring/oniguruma/regparse.c 	      tok->type == TK_INTERVAL))) {
type             3218 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ALT;
type             3223 ext/mbstring/oniguruma/regparse.c       tok->type = TK_SUBEXP_OPEN;
type             3228 ext/mbstring/oniguruma/regparse.c       tok->type = TK_SUBEXP_CLOSE;
type             3233 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3240 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3247 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3253 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3260 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3266 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3273 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3280 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3287 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3294 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3301 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3308 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CHAR_TYPE;
type             3316 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3322 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3329 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3335 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3364 ext/mbstring/oniguruma/regparse.c 	  tok->type   = TK_CODE_POINT;
type             3378 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_RAW_BYTE;
type             3394 ext/mbstring/oniguruma/regparse.c 	tok->type   = TK_CODE_POINT;
type             3416 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_BACKREF;
type             3443 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_RAW_BYTE;
type             3486 ext/mbstring/oniguruma/regparse.c 	    tok->type = TK_BACKREF;
type             3507 ext/mbstring/oniguruma/regparse.c 	    tok->type = TK_BACKREF;
type             3537 ext/mbstring/oniguruma/regparse.c 	  tok->type = TK_CALL;
type             3550 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_QUOTE_OPEN;
type             3559 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_CHAR_PROPERTY;
type             3579 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_CODE_POINT;
type             3604 ext/mbstring/oniguruma/regparse.c 	tok->type = TK_ANYCHAR_ANYTIME;
type             3616 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANYCHAR;
type             3624 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3635 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3646 ext/mbstring/oniguruma/regparse.c       tok->type = TK_OP_REPEAT;
type             3668 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ALT;
type             3693 ext/mbstring/oniguruma/regparse.c       tok->type = TK_SUBEXP_OPEN;
type             3698 ext/mbstring/oniguruma/regparse.c       tok->type = TK_SUBEXP_CLOSE;
type             3703 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3710 ext/mbstring/oniguruma/regparse.c       tok->type = TK_ANCHOR;
type             3717 ext/mbstring/oniguruma/regparse.c       tok->type = TK_CC_OPEN;
type             3752 ext/mbstring/oniguruma/regparse.c   return tok->type;
type             4054 ext/mbstring/oniguruma/regparse.c next_state_class(CClassNode* cc, OnigCodePoint* vs, enum CCVALTYPE* type,
type             4062 ext/mbstring/oniguruma/regparse.c   if (*state == CCS_VALUE && *type != CCV_CLASS) {
type             4063 ext/mbstring/oniguruma/regparse.c     if (*type == CCV_SB)
type             4065 ext/mbstring/oniguruma/regparse.c     else if (*type == CCV_CODE_POINT) {
type             4072 ext/mbstring/oniguruma/regparse.c   *type  = CCV_CLASS;
type             4079 ext/mbstring/oniguruma/regparse.c 	       enum CCVALTYPE intype, enum CCVALTYPE* type,
type             4086 ext/mbstring/oniguruma/regparse.c     if (*type == CCV_SB)
type             4088 ext/mbstring/oniguruma/regparse.c     else if (*type == CCV_CODE_POINT) {
type             4095 ext/mbstring/oniguruma/regparse.c     if (intype == *type) {
type             4115 ext/mbstring/oniguruma/regparse.c       if (intype == CCV_CODE_POINT && *type == CCV_SB) {
type             4147 ext/mbstring/oniguruma/regparse.c   *type     = intype;
type             4207 ext/mbstring/oniguruma/regparse.c     r = tok->type = TK_CHAR;  /* allow []...] */
type             4448 ext/mbstring/oniguruma/regparse.c       r = tok->type;
type             4737 ext/mbstring/oniguruma/regparse.c     if (NENCLOSE(*np)->type == ENCLOSE_MEMORY) {
type             4856 ext/mbstring/oniguruma/regparse.c   int type;
type             4861 ext/mbstring/oniguruma/regparse.c   if (x->type != y->type) return 1;
type             4879 ext/mbstring/oniguruma/regparse.c   p = (UChar* )(&key->type);
type             4880 ext/mbstring/oniguruma/regparse.c   for (i = 0; i < (int )sizeof(key->type); i++) {
type             5045 ext/mbstring/oniguruma/regparse.c   if (tok->type == (enum TokenSyms )term)
type             5048 ext/mbstring/oniguruma/regparse.c   switch (tok->type) {
type             5053 ext/mbstring/oniguruma/regparse.c   return tok->type;
type             5071 ext/mbstring/oniguruma/regparse.c       return tok->type;
type             5205 ext/mbstring/oniguruma/regparse.c             key.type = tok->u.prop.ctype;
type             5494 ext/mbstring/oniguruma/regparse.c     if (tok->type != (enum TokenSyms )term)
type               48 ext/mbstring/oniguruma/regparse.h #define NTYPE2BIT(type)      (1<<(type))
type               62 ext/mbstring/oniguruma/regparse.h #define IS_NODE_TYPE_SIMPLE(type) \
type               63 ext/mbstring/oniguruma/regparse.h   ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\
type               66 ext/mbstring/oniguruma/regparse.h #define NTYPE(node)             ((node)->u.base.type)
type               67 ext/mbstring/oniguruma/regparse.h #define SET_NTYPE(node, ntype)   (node)->u.base.type = (ntype)
type              188 ext/mbstring/oniguruma/regparse.h   int type;
type              236 ext/mbstring/oniguruma/regparse.h   int type;
type              333 ext/mbstring/oniguruma/regparse.h extern Node*  onig_node_new_enclose P_((int type));
type              334 ext/mbstring/oniguruma/regparse.h extern Node*  onig_node_new_anchor P_((int type));
type               54 ext/mbstring/oniguruma/st.c #define alloc(type) (type*)xmalloc((unsigned)sizeof(type))
type               57 ext/mbstring/oniguruma/st.c #define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0)
type               59 ext/mbstring/oniguruma/st.c #define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key))
type              142 ext/mbstring/oniguruma/st.c st_init_table_with_size(type, size)
type              143 ext/mbstring/oniguruma/st.c     struct st_hash_type *type;
type              158 ext/mbstring/oniguruma/st.c     tbl->type = type;
type              167 ext/mbstring/oniguruma/st.c st_init_table(type)
type              168 ext/mbstring/oniguruma/st.c     struct st_hash_type *type;
type              170 ext/mbstring/oniguruma/st.c     return st_init_table_with_size(type, 0);
type               25 ext/mbstring/oniguruma/st.h     struct st_hash_type *type;
type              114 ext/mysqli/mysqli.c void php_free_stmt_bind_buffer(BIND_BUFFER bbuf, int type)
type              125 ext/mysqli/mysqli.c 		if (type == FETCH_RESULT && bbuf.buf[i].val) {
type              142 ext/mysqli/mysqli.c 	if (type == FETCH_RESULT) {
type              144 ext/mysqli/mysqli.c 	} else if (type == FETCH_SIMPLE){
type              299 ext/mysqli/mysqli.c zval *mysqli_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type              325 ext/mysqli/mysqli.c 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
type              454 ext/mysqli/mysqli.c 	while (mysqli_base_class->type != ZEND_INTERNAL_CLASS &&
type              944 ext/mysqli/mysqli.c 	if (le->type == php_le_pmysqli()) {
type             1179 ext/mysqli/mysqli.c 			if (mysql_fetch_field_direct(result, i)->type == MYSQL_TYPE_BIT) {
type              282 ext/mysqli/mysqli_api.c 		zend_uchar type;
type              285 ext/mysqli/mysqli_api.c 				type = MYSQL_TYPE_DOUBLE;
type              289 ext/mysqli/mysqli_api.c 				type = MYSQL_TYPE_LONGLONG;
type              291 ext/mysqli/mysqli_api.c 				type = MYSQL_TYPE_LONG;
type              295 ext/mysqli/mysqli_api.c 				type = MYSQL_TYPE_LONG_BLOB;
type              298 ext/mysqli/mysqli_api.c 				type = MYSQL_TYPE_VAR_STRING;
type              308 ext/mysqli/mysqli_api.c 		params[i].type = type;
type              414 ext/mysqli/mysqli_api.c 		col_type = (stmt->stmt->fields) ? stmt->stmt->fields[ofs].type : MYSQL_TYPE_STRING;
type              418 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_DOUBLE;
type              428 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_DOUBLE;
type              439 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_NULL;
type              456 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_LONG;
type              469 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_STRING;
type              503 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].type = IS_STRING;
type              688 ext/mysqli/mysqli_api.c 			if (le->type == php_le_pmysqli()) {
type              956 ext/mysqli/mysqli_api.c 		if (stmt->result.buf[i].type == IS_STRING) {
type              982 ext/mysqli/mysqli_api.c 				switch (stmt->result.buf[i].type) {
type              984 ext/mysqli/mysqli_api.c 						if ((stmt->stmt->fields[i].type == MYSQL_TYPE_LONG)
type             1177 ext/mysqli/mysqli_api.c 	add_property_long(value, "type", field->type);
type             2537 ext/mysqli/mysqli_api.c 			if (stmt->stmt->fields && (stmt->stmt->fields[i].type == MYSQL_TYPE_BLOB ||
type             2538 ext/mysqli/mysqli_api.c 				stmt->stmt->fields[i].type == MYSQL_TYPE_MEDIUM_BLOB ||
type             2539 ext/mysqli/mysqli_api.c 				stmt->stmt->fields[i].type == MYSQL_TYPE_LONG_BLOB ||
type             2540 ext/mysqli/mysqli_api.c 				stmt->stmt->fields[i].type == MYSQL_TYPE_GEOMETRY))
type              167 ext/mysqli/mysqli_nonapi.c 				if (le->type == php_le_pmysqli()) {
type              196 ext/mysqli/mysqli_nonapi.c 				le.type = php_le_pmysqli();
type               76 ext/mysqli/mysqli_priv.h extern void php_free_stmt_bind_buffer(BIND_BUFFER bbuf, int type);
type              104 ext/mysqli/php_mysqli_structs.h 	zend_ulong		type;
type             1219 ext/mysqlnd/mysqlnd.c 											  enum_mysqlnd_send_query_type type, zval *read_cb, zval *err_cb)
type             1244 ext/mysqlnd/mysqlnd.c MYSQLND_METHOD(mysqlnd_conn_data, reap_query)(MYSQLND_CONN_DATA * conn, enum_mysqlnd_reap_result_type type)
type             1518 ext/mysqlnd/mysqlnd.c 			result->type = MYSQLND_RES_NORMAL;
type               52 ext/mysqlnd/mysqlnd_debug.c 								   unsigned int level, const char * type, const char * message)
type              130 ext/mysqlnd/mysqlnd_debug.c 								pipe_buffer, type? type:"", message);
type              147 ext/mysqlnd/mysqlnd_debug.c 									  unsigned int level, const char * type,
type              231 ext/mysqlnd/mysqlnd_debug.c 								pipe_buffer, type? type:"", buffer);
type               34 ext/mysqlnd/mysqlnd_debug.h 							unsigned int level, const char * type, const char *message);
type               36 ext/mysqlnd/mysqlnd_debug.h 							   unsigned int level, const char * type, const char *format, ...);
type               89 ext/mysqlnd/mysqlnd_ps.c 	result->type			= MYSQLND_RES_PS_BUF;
type              104 ext/mysqlnd/mysqlnd_ps.c 		if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_ZVAL) {
type              122 ext/mysqlnd/mysqlnd_ps.c 		} else if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_ZVAL) {
type              196 ext/mysqlnd/mysqlnd_ps.c 			result->type = MYSQLND_RES_PS_BUF;
type              450 ext/mysqlnd/mysqlnd_ps.c 		result->type = MYSQLND_RES_PS_BUF;
type              492 ext/mysqlnd/mysqlnd_ps.c mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const s, enum_mysqlnd_parse_exec_response_type type)
type              532 ext/mysqlnd/mysqlnd_ps.c 		stmt->result->type = MYSQLND_RES_PS_BUF;
type              626 ext/mysqlnd/mysqlnd_ps.c MYSQLND_METHOD(mysqlnd_stmt, send_execute)(MYSQLND_STMT * const s, enum_mysqlnd_send_execute_type type, zval * read_cb, zval * err_cb)
type              763 ext/mysqlnd/mysqlnd_ps.c 	if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_ZVAL) {
type              841 ext/mysqlnd/mysqlnd_ps.c 	} else if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_C) {
type             1357 ext/mysqlnd/mysqlnd_ps.c 	if (stmt->param_bind[param_no].type != MYSQL_TYPE_LONG_BLOB) {
type             1483 ext/mysqlnd/mysqlnd_ps.c 			DBG_INF_FMT("%u is of type %u", i, stmt->param_bind[i].type);
type             1488 ext/mysqlnd/mysqlnd_ps.c 			if (stmt->param_bind[i].type == MYSQL_TYPE_LONG_BLOB) {
type             1503 ext/mysqlnd/mysqlnd_ps.c 												 zval * const zv, zend_uchar type)
type             1510 ext/mysqlnd/mysqlnd_ps.c 	DBG_INF_FMT("stmt=%lu param_no=%u param_count=%u type=%u", stmt->stmt_id, param_no, stmt->param_count, type);
type             1540 ext/mysqlnd/mysqlnd_ps.c 		if (type == MYSQL_TYPE_LONG_BLOB) {
type             1545 ext/mysqlnd/mysqlnd_ps.c 		stmt->param_bind[param_no].type = type;
type             1851 ext/mysqlnd/mysqlnd_ps.c 		result->type = MYSQLND_RES_NORMAL;
type               63 ext/mysqlnd/mysqlnd_ps_codec.c 	zend_bool is_bit = field->type == MYSQL_TYPE_BIT;
type              581 ext/mysqlnd/mysqlnd_ps_codec.c 		short current_type = stmt->param_bind[i].type;
type              637 ext/mysqlnd/mysqlnd_ps_codec.c 		short current_type = stmt->param_bind[i].type;
type              688 ext/mysqlnd/mysqlnd_ps_codec.c 		if ((stmt->param_bind[i].type != MYSQL_TYPE_LONG_BLOB && Z_TYPE_P(the_var) == IS_NULL)) {
type              707 ext/mysqlnd/mysqlnd_ps_codec.c 		switch (stmt->param_bind[i].type) {
type              780 ext/mysqlnd/mysqlnd_ps_codec.c 			switch (stmt->param_bind[i].type) {
type              259 ext/mysqlnd/mysqlnd_result.c 	if (set->type == MYSQLND_BUFFERED_TYPE_ZVAL) {
type              261 ext/mysqlnd/mysqlnd_result.c 	} if (set->type == MYSQLND_BUFFERED_TYPE_C) {
type              931 ext/mysqlnd/mysqlnd_result.c 		result->type			= MYSQLND_RES_NORMAL;
type              933 ext/mysqlnd/mysqlnd_result.c 		result->type			= MYSQLND_RES_PS_UNBUF;
type              976 ext/mysqlnd/mysqlnd_result.c 	if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_ZVAL) {
type             1044 ext/mysqlnd/mysqlnd_result.c 	} else if (result->stored_data->type == MYSQLND_BUFFERED_TYPE_C) {
type             1408 ext/mysqlnd/mysqlnd_result.c 	result->type = MYSQLND_RES_NORMAL;
type             1488 ext/mysqlnd/mysqlnd_result.c 									result->type == MYSQLND_RES_NORMAL? STAT_FLUSHED_NORMAL_SETS:
type             1984 ext/mysqlnd/mysqlnd_result.c 	ret->type = MYSQLND_BUFFERED_TYPE_ZVAL;
type             2027 ext/mysqlnd/mysqlnd_result.c 	ret->type = MYSQLND_BUFFERED_TYPE_C;
type               92 ext/mysqlnd/mysqlnd_result_meta.c 		if (mysqlnd_ps_fetch_functions[meta->fields[i].type].func == NULL) {
type               94 ext/mysqlnd/mysqlnd_result_meta.c 						meta->fields[i].type);
type               98 ext/mysqlnd/mysqlnd_result_meta.c 							 meta->fields[i].type);
type              102 ext/mysqlnd/mysqlnd_result_meta.c 		if (meta->fields[i].type == MYSQL_TYPE_BIT) {
type               95 ext/mysqlnd/mysqlnd_structs.h 	enum mysqlnd_field_types type;	/* Type of field. See mysql_com.h for types */
type              427 ext/mysqlnd/mysqlnd_structs.h typedef enum_func_status	(*func_mysqlnd_conn_data__send_query)(MYSQLND_CONN_DATA * conn, const char *query, unsigned int query_len, enum_mysqlnd_send_query_type type, zval *read_cb, zval *err_cb);
type              428 ext/mysqlnd/mysqlnd_structs.h typedef enum_func_status	(*func_mysqlnd_conn_data__reap_query)(MYSQLND_CONN_DATA * conn, enum_mysqlnd_reap_result_type type);
type             1300 ext/mysqlnd/mysqlnd_wireprotocol.c 	meta->type = uint1korr(p);
type             1318 ext/mysqlnd/mysqlnd_wireprotocol.c 		(meta->type <= MYSQL_TYPE_INT24 &&
type             1319 ext/mysqlnd/mysqlnd_wireprotocol.c 			(meta->type != MYSQL_TYPE_TIMESTAMP || meta->length == 14 || meta->length == 8)
type             1320 ext/mysqlnd/mysqlnd_wireprotocol.c 		) || meta->type == MYSQL_TYPE_YEAR)
type             1542 ext/mysqlnd/mysqlnd_wireprotocol.c 			fields_metadata[i].db, fields_metadata[i].table, fields_metadata[i].name, fields_metadata[i].type,
type             1543 ext/mysqlnd/mysqlnd_wireprotocol.c 			fields_metadata[i].flags & UNSIGNED_FLAG, fields_metadata[i].flags, fields_metadata[i].type == MYSQL_TYPE_BIT);
type             1549 ext/mysqlnd/mysqlnd_wireprotocol.c 			enum_mysqlnd_field_types type = fields_metadata[i].type;
type             1550 ext/mysqlnd/mysqlnd_wireprotocol.c 			mysqlnd_ps_fetch_functions[type].func(current_field, &fields_metadata[i], 0, &p);
type             1553 ext/mysqlnd/mysqlnd_wireprotocol.c 				switch (fields_metadata[i].type) {
type             1631 ext/mysqlnd/mysqlnd_wireprotocol.c 					mysqlnd_ps_fetch_functions[fields_metadata[i].type];
type             1635 ext/mysqlnd/mysqlnd_wireprotocol.c 				switch (fields_metadata[i].type) {
type             1715 ext/mysqlnd/mysqlnd_wireprotocol.c 			if (fields_metadata[i].type == MYSQL_TYPE_BIT) {
type              154 ext/oci8/oci8.c 	ZEND_ARG_INFO(0, type)
type              162 ext/oci8/oci8.c 	ZEND_ARG_INFO(0, type)
type              171 ext/oci8/oci8.c 	ZEND_ARG_INFO(0, type)
type              276 ext/oci8/oci8.c 	ZEND_ARG_INFO(0, type)
type              602 ext/oci8/oci8.c 	ZEND_ARG_INFO(0, type)
type             1454 ext/oci8/oci8.c 			if (le != NULL && le->type == le_pconnection && le->ptr == connection) {
type             1609 ext/oci8/oci8.c 	if (descriptor && descriptor->buffering == PHP_OCI_LOB_BUFFER_USED && (descriptor->type == OCI_DTYPE_LOB || descriptor->type == OCI_DTYPE_FILE)) {
type             1938 ext/oci8/oci8.c 			if (le->type == le_pconnection) {
type             1944 ext/oci8/oci8.c 			if (le->type == le_index_ptr) {
type             1948 ext/oci8/oci8.c 				if (ptr && (ptr->type == le_connection)) {
type             2176 ext/oci8/oci8.c 		new_le.type = le_pconnection;
type             2193 ext/oci8/oci8.c 		new_le.type = le_index_ptr;
type             2829 ext/oci8/oci8.c 	if (le->type == le_pconnection) {
type             3041 ext/oci8/oci8.c 		spool_le.type = le_psessionpool;
type             3044 ext/oci8/oci8.c 	} else if (spool_out_le->type == le_psessionpool &&
type               55 ext/oci8/oci8_interface.c 	zend_long type = 0;
type               60 ext/oci8/oci8_interface.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz/|l", &stmt, &name, &name_len, &var, &type) == FAILURE) {
type               95 ext/oci8/oci8_interface.c 	define->type = (ub4) type;
type              109 ext/oci8/oci8_interface.c 	zend_long maxlen = -1, type = 0;
type              115 ext/oci8/oci8_interface.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz/|ll", &z_statement, &name, &name_len, &bind_var, &maxlen, &type) == FAILURE) {
type              119 ext/oci8/oci8_interface.c 	if (type) {
type              120 ext/oci8/oci8_interface.c 		bind_type = (ub2) type;
type              139 ext/oci8/oci8_interface.c 	zend_long type = SQLT_AFC;
type              145 ext/oci8/oci8_interface.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz/l|ll", &z_statement, &name, &name_len, &bind_var, &max_array_len, &max_item_len, &type) == FAILURE) {
type              160 ext/oci8/oci8_interface.c 	if (php_oci_bind_array_by_name(statement, name, (sb4) name_len, bind_var, max_array_len, max_item_len, type)) {
type             1034 ext/oci8/oci8_interface.c 	zend_long type = OCI_TEMP_CLOB;
type             1037 ext/oci8/oci8_interface.c 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &data, &data_len, &type) == FAILURE) {
type             1042 ext/oci8/oci8_interface.c 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "Os|l", &z_descriptor, oci_lob_class_entry_ptr, &data, &data_len, &type) == FAILURE) {
type             1054 ext/oci8/oci8_interface.c 	if (php_oci_lob_write_tmp(descriptor, type, data, (int) data_len)) {
type             1095 ext/oci8/oci8_interface.c 	zend_long type = OCI_DTYPE_LOB;
type             1097 ext/oci8/oci8_interface.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &z_connection, &type) == FAILURE) {
type             1104 ext/oci8/oci8_interface.c 	descriptor = php_oci_lob_create(connection, type);	
type             2121 ext/oci8/oci8_interface.c 	ub2 type;
type             2129 ext/oci8/oci8_interface.c 	if (php_oci_statement_get_type(statement, &type)) {
type             2133 ext/oci8/oci8_interface.c 	switch (type) {
type               54 ext/oci8/oci8_lob.c php_oci_descriptor *php_oci_lob_create (php_oci_connection *connection, zend_long type)
type               59 ext/oci8/oci8_lob.c 	switch (type) {
type               66 ext/oci8/oci8_lob.c 			php_error_docref(NULL, E_WARNING, "Unknown descriptor type %pd", type);
type               72 ext/oci8/oci8_lob.c 	descriptor->type = (ub4) type;
type               76 ext/oci8/oci8_lob.c 	PHP_OCI_CALL_RETURN(errstatus, OCIDescriptorAlloc, (connection->env, (dvoid*)&(descriptor->descriptor), descriptor->type, (size_t) 0, (dvoid **) 0));
type               97 ext/oci8/oci8_lob.c 	if (descriptor->type == OCI_DTYPE_LOB || descriptor->type == OCI_DTYPE_FILE) {
type              132 ext/oci8/oci8_lob.c 		if (descriptor->type == OCI_DTYPE_FILE) {
type              151 ext/oci8/oci8_lob.c 		if (descriptor->type == OCI_DTYPE_FILE) {
type              218 ext/oci8/oci8_lob.c 	if (descriptor->type == OCI_DTYPE_FILE) {
type              291 ext/oci8/oci8_lob.c 	if (descriptor->type == OCI_DTYPE_FILE) {
type              381 ext/oci8/oci8_lob.c 	if (descriptor->type == OCI_DTYPE_FILE) {
type              692 ext/oci8/oci8_lob.c 	if ((descriptor->type == OCI_DTYPE_FILE || descriptor->type == OCI_DTYPE_LOB) && descriptor->buffering == PHP_OCI_LOB_BUFFER_USED) {
type              696 ext/oci8/oci8_lob.c 	if (descriptor->type == OCI_DTYPE_LOB) {
type              700 ext/oci8/oci8_lob.c 	PHP_OCI_CALL(OCIDescriptorFree, (descriptor->descriptor, descriptor->type));
type              904 ext/oci8/oci8_lob.c int php_oci_lob_write_tmp (php_oci_descriptor *descriptor, zend_long type, char *data, int data_len)
type              911 ext/oci8/oci8_lob.c 	switch (type) {
type              917 ext/oci8/oci8_lob.c 			php_error_docref(NULL, E_WARNING, "Invalid temporary lob type: %pd", type);
type              933 ext/oci8/oci8_lob.c 			 (ub1)type,
type              687 ext/oci8/oci8_statement.c 					if (outcol->define->type) {
type              688 ext/oci8/oci8_statement.c 						outcol->data_type = outcol->define->type;
type              919 ext/oci8/oci8_statement.c 	switch (bind->type) {
type              996 ext/oci8/oci8_statement.c 		switch (bind->array.type) {
type             1087 ext/oci8/oci8_statement.c int php_oci_bind_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long maxlength, ub2 type)
type             1101 ext/oci8/oci8_statement.c 	switch (type) {
type             1175 ext/oci8/oci8_statement.c 				if (type == SQLT_LNG) {
type             1226 ext/oci8/oci8_statement.c 			php_error_docref(NULL, E_WARNING, "Unknown or unsupported datatype given: %d", (int)type);
type             1250 ext/oci8/oci8_statement.c 	bindp->type = type;
type             1267 ext/oci8/oci8_statement.c 			type,							 /* in/out data type */
type             1302 ext/oci8/oci8_statement.c 	if (type == SQLT_NTY) {
type             1521 ext/oci8/oci8_statement.c int php_oci_statement_get_type(php_oci_statement *statement, ub2 *type)
type             1526 ext/oci8/oci8_statement.c 	*type = 0;
type             1536 ext/oci8/oci8_statement.c 	*type = statement_type;
type             1567 ext/oci8/oci8_statement.c int php_oci_bind_array_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long max_table_length, zend_long maxlength, zend_long type)
type             1580 ext/oci8/oci8_statement.c 	switch(type) {
type             1607 ext/oci8/oci8_statement.c 			php_error_docref(NULL, E_WARNING, "Unknown or unsupported datatype given: %pd", type);
type             1622 ext/oci8/oci8_statement.c 	bind->array.type = type;
type             1624 ext/oci8/oci8_statement.c 	bind->type = 0; 			/* not used for array binds */
type             1636 ext/oci8/oci8_statement.c 								(ub2)type,
type              178 ext/oci8/php_oci8_int.h 	ub4					 type;					/* descriptor type (FILE/LOB) */
type              215 ext/oci8/php_oci8_int.h 	ub4			 type;			/* define type */
type              251 ext/oci8/php_oci8_int.h 	ub2 type;						/* bind type */
type              259 ext/oci8/php_oci8_int.h 		zend_long	 type;
type              390 ext/oci8/php_oci8_int.h #define PHP_OCI_FETCH_RESOURCE_EX(zval, var, type, name, resource_type)						 \
type              392 ext/oci8/php_oci8_int.h 		var = (type) zend_fetch_resource(Z_RES_P(zval), name, resource_type);                \
type              440 ext/oci8/php_oci8_int.h php_oci_descriptor *php_oci_lob_create(php_oci_connection *connection, zend_long type);
type              450 ext/oci8/php_oci8_int.h int php_oci_lob_write_tmp(php_oci_descriptor *descriptor, zend_long type, char *data, int data_len);
type              495 ext/oci8/php_oci8_int.h int php_oci_bind_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long maxlength, ub2 type);
type              500 ext/oci8/php_oci8_int.h int php_oci_statement_get_type(php_oci_statement *statement, ub2 *type);
type              502 ext/oci8/php_oci8_int.h int php_oci_bind_array_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long max_table_length, zend_long maxlength, zend_long type);
type              241 ext/odbc/birdstep.c 	int type;
type              243 ext/odbc/birdstep.c 	conn = zend_list_find(ind,&type);
type              244 ext/odbc/birdstep.c 	if ( !conn || type != php_birdstep_module.le_link ) {
type              269 ext/odbc/birdstep.c 	int type;
type              271 ext/odbc/birdstep.c 	res = zend_list_find(ind,&type);
type              272 ext/odbc/birdstep.c 	if ( !res || type != php_birdstep_module.le_result ) {
type              291 ext/odbc/php_odbc.c 	ZEND_ARG_INFO(0, type)
type              482 ext/odbc/php_odbc.c 		if (p->ptr && (p->type == le_result)) {
type              507 ext/odbc/php_odbc.c 		if (p->ptr && (p->type == le_result)) {
type              531 ext/odbc/php_odbc.c 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
type              555 ext/odbc/php_odbc.c 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
type              585 ext/odbc/php_odbc.c 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
type              615 ext/odbc/php_odbc.c 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
type              640 ext/odbc/php_odbc.c 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
type              722 ext/odbc/php_odbc.c 	odbc_module_entry.type = type;
type             1047 ext/odbc/php_odbc.c void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type)
type             1061 ext/odbc/php_odbc.c 	rc = SQLTransact(conn->henv, conn->hdbc, (SQLUSMALLINT)((type)?SQL_COMMIT:SQL_ROLLBACK));
type             1074 ext/odbc/php_odbc.c 	if (le->type == le_pconn && (((odbc_connection *)(le->ptr))->res == res)){
type             1083 ext/odbc/php_odbc.c void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type)
type             1123 ext/odbc/php_odbc.c 	PHP_ODBC_SQLCOLATTRIBUTE(result->stmt, (SQLUSMALLINT)pv_num, (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), NULL, 0, NULL, &len);
type             1143 ext/odbc/php_odbc.c 		if (p->ptr && (p->type == le_result)) {
type             1151 ext/odbc/php_odbc.c 			if (p->type == le_conn){
type             1153 ext/odbc/php_odbc.c 			} else if (p->type == le_pconn){
type             2632 ext/odbc/php_odbc.c 			new_le.type = le_pconn;
type             2646 ext/odbc/php_odbc.c 			if (le->type != le_pconn) {
type             2688 ext/odbc/php_odbc.c 			if (index_ptr->type != le_index_ptr) {
type             2694 ext/odbc/php_odbc.c 			if (p && p->ptr && (p->type == le_conn || p->type == le_pconn)) {
type             2716 ext/odbc/php_odbc.c 		new_index_ptr.type = le_index_ptr;
type             2745 ext/odbc/php_odbc.c 	if (Z_RES_P(pv_conn)->type == le_pconn) {
type             2750 ext/odbc/php_odbc.c 		if (p->ptr && (p->type == le_result)) {
type             3163 ext/odbc/php_odbc.c 	char *cat = NULL, *schema = NULL, *table = NULL, *type = NULL;
type             3168 ext/odbc/php_odbc.c 		&table, &table_len, &type, &type_len) == FAILURE) {
type             3200 ext/odbc/php_odbc.c 			type, SAFE_SQL_NTS(type));
type             3713 ext/odbc/php_odbc.c 	SQLUSMALLINT type, scope, nullable;
type             3721 ext/odbc/php_odbc.c 	type = (SQLUSMALLINT) vtype;
type             3745 ext/odbc/php_odbc.c 			type,
type              111 ext/opcache/Optimizer/pass1_5.c 				zend_uchar type = opline->result_type;
type              134 ext/opcache/Optimizer/pass1_5.c 				if (zend_optimizer_replace_by_const(op_array, opline + 1, type, tv, &res)) {
type              306 ext/opcache/Optimizer/pass1_5.c 								(ce->type == ZEND_INTERNAL_CLASS &&
type              307 ext/opcache/Optimizer/pass1_5.c 								 ce->info.internal.module->type != MODULE_PERSISTENT) ||
type              308 ext/opcache/Optimizer/pass1_5.c 								(ce->type == ZEND_USER_CLASS &&
type              450 ext/opcache/Optimizer/pass1_5.c 						 && func->type == ZEND_INTERNAL_FUNCTION
type              451 ext/opcache/Optimizer/pass1_5.c 						 && func->module->type == MODULE_PERSISTENT
type              492 ext/opcache/Optimizer/pass1_5.c 						if (m->type == MODULE_PERSISTENT
type              123 ext/opcache/Optimizer/zend_optimizer.c 	return (fbc && fbc->type == ZEND_INTERNAL_FUNCTION &&
type              364 ext/opcache/Optimizer/zend_optimizer.c                                     zend_uchar     type,
type              371 ext/opcache/Optimizer/zend_optimizer.c 		if (ZEND_OP1_TYPE(opline) == type &&
type              436 ext/opcache/Optimizer/zend_optimizer.c 						if (ZEND_OP1_TYPE(m) == type &&
type              475 ext/opcache/Optimizer/zend_optimizer.c 		if (ZEND_OP2_TYPE(opline) == type &&
type              488 ext/opcache/Optimizer/zend_optimizer.c 	if (op_array->type == ZEND_EVAL_CODE) {
type              700 ext/opcache/Optimizer/zend_optimizer.c 			} else if (op_array->type == ZEND_USER_FUNCTION) {
type              731 ext/opcache/Optimizer/zend_optimizer.c 				} else if (op_array->type == ZEND_USER_FUNCTION) {
type              129 ext/opcache/Optimizer/zend_optimizer_internal.h                                      zend_uchar     type,
type              115 ext/opcache/ZendAccelerator.c static zend_op_array *(*accelerator_orig_compile_file)(zend_file_handle *file_handle, int type);
type              782 ext/opcache/ZendAccelerator.c 	switch (file_handle->type) {
type              899 ext/opcache/ZendAccelerator.c 	ps_handle.type = ZEND_HANDLE_FILENAME;
type             1107 ext/opcache/ZendAccelerator.c 		file_handle.type = ZEND_HANDLE_FILENAME;
type             1401 ext/opcache/ZendAccelerator.c static zend_persistent_script *opcache_compile_file(zend_file_handle *file_handle, int type, char *key, unsigned int key_length, zend_op_array **op_array_p)
type             1413 ext/opcache/ZendAccelerator.c     if (file_handle->type == ZEND_HANDLE_FILENAME) {
type             1421 ext/opcache/ZendAccelerator.c 			if (type == ZEND_REQUIRE) {
type             1434 ext/opcache/ZendAccelerator.c 		*op_array_p = accelerator_orig_compile_file(file_handle, type);
type             1452 ext/opcache/ZendAccelerator.c 			*op_array_p = accelerator_orig_compile_file(file_handle, type);
type             1459 ext/opcache/ZendAccelerator.c 			*op_array_p = accelerator_orig_compile_file(file_handle, type);
type             1465 ext/opcache/ZendAccelerator.c 			*op_array_p = accelerator_orig_compile_file(file_handle, type);
type             1489 ext/opcache/ZendAccelerator.c 		op_array = *op_array_p = accelerator_orig_compile_file(file_handle, type);
type             1550 ext/opcache/ZendAccelerator.c zend_op_array *file_cache_compile_file(zend_file_handle *file_handle, int type)
type             1558 ext/opcache/ZendAccelerator.c 		return accelerator_orig_compile_file(file_handle, type);
type             1562 ext/opcache/ZendAccelerator.c 		if (file_handle->type == ZEND_HANDLE_FILENAME &&
type             1564 ext/opcache/ZendAccelerator.c 			if (type == ZEND_REQUIRE) {
type             1582 ext/opcache/ZendAccelerator.c 			    !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) ||
type             1609 ext/opcache/ZendAccelerator.c 	persistent_script = opcache_compile_file(file_handle, type, NULL, 0, &op_array);
type             1622 ext/opcache/ZendAccelerator.c zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
type             1631 ext/opcache/ZendAccelerator.c 		return accelerator_orig_compile_file(file_handle, type);
type             1634 ext/opcache/ZendAccelerator.c 		return file_cache_compile_file(file_handle, type);
type             1640 ext/opcache/ZendAccelerator.c 			return file_cache_compile_file(file_handle, type);
type             1643 ext/opcache/ZendAccelerator.c 		return accelerator_orig_compile_file(file_handle, type);
type             1655 ext/opcache/ZendAccelerator.c 	      ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
type             1669 ext/opcache/ZendAccelerator.c 				return accelerator_orig_compile_file(file_handle, type);
type             1678 ext/opcache/ZendAccelerator.c 		    if (file_handle->type == ZEND_HANDLE_FILENAME &&
type             1680 ext/opcache/ZendAccelerator.c 				if (type == ZEND_REQUIRE) {
type             1723 ext/opcache/ZendAccelerator.c 				return file_cache_compile_file(file_handle, type);
type             1726 ext/opcache/ZendAccelerator.c 			return accelerator_orig_compile_file(file_handle, type);
type             1795 ext/opcache/ZendAccelerator.c 			return accelerator_orig_compile_file(file_handle, type);
type             1802 ext/opcache/ZendAccelerator.c 		persistent_script = opcache_compile_file(file_handle, type, key, key ? key_length : 0, &op_array);
type             1840 ext/opcache/ZendAccelerator.c 			    !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) ||
type             1884 ext/opcache/ZendAccelerator.c 		     ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
type             1891 ext/opcache/ZendAccelerator.c 			handle->type = ZEND_HANDLE_FILENAME;
type             1912 ext/opcache/ZendAccelerator.c 		     ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
type             2202 ext/opcache/ZendAccelerator.c 			if (func->type == ZEND_INTERNAL_FUNCTION) {
type             2219 ext/opcache/ZendAccelerator.c 			if (ce->type == ZEND_INTERNAL_CLASS) {
type             2226 ext/opcache/ZendAccelerator.c 						if (func->type == ZEND_USER_FUNCTION) {
type             2261 ext/opcache/ZendAccelerator.c 			if (func->type == ZEND_INTERNAL_FUNCTION) {
type             2271 ext/opcache/ZendAccelerator.c 			if (ce->type == ZEND_INTERNAL_CLASS) {
type             2767 ext/opcache/ZendAccelerator.c 	    func->type == ZEND_INTERNAL_FUNCTION) {
type              103 ext/opcache/ZendAccelerator.h #  define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              104 ext/opcache/ZendAccelerator.h 		struct flock name = {start, len, -1, type, whence}
type              106 ext/opcache/ZendAccelerator.h #  define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              107 ext/opcache/ZendAccelerator.h 		struct flock name = {type, whence, start, len}
type              109 ext/opcache/ZendAccelerator.h #  define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              110 ext/opcache/ZendAccelerator.h 		struct flock name = {type, whence, start, len, 0}
type              113 ext/opcache/ZendAccelerator.h #   define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              114 ext/opcache/ZendAccelerator.h 		struct flock name = {type, whence, 0, 0, 0, start, len }
type              116 ext/opcache/ZendAccelerator.h #   define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              117 ext/opcache/ZendAccelerator.h 		struct flock name = {type, whence, start, len}
type              120 ext/opcache/ZendAccelerator.h #  define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              121 ext/opcache/ZendAccelerator.h 		struct flock name = {start, len, -1, type, whence}
type              123 ext/opcache/ZendAccelerator.h #  define FLOCK_STRUCTURE(name, type, whence, start, len) \
type              124 ext/opcache/ZendAccelerator.h 		struct flock name = {type, whence, start, len}
type              332 ext/opcache/ZendAccelerator.h zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type);
type               40 ext/opcache/shared_alloc_win32.c static void zend_win_error_message(int type, char *msg, int err)
type               74 ext/opcache/shared_alloc_win32.c 	zend_accel_error(type, msg);
type               31 ext/opcache/zend_accelerator_debug.c void zend_accel_error(int type, const char *format, ...)
type               38 ext/opcache/zend_accelerator_debug.c 	if (type > ZCG(accel_directives).log_verbosity_level) {
type               64 ext/opcache/zend_accelerator_debug.c 	switch (type) {
type               86 ext/opcache/zend_accelerator_debug.c 	switch (type) {
type               31 ext/opcache/zend_accelerator_debug.h void zend_accel_error(int type, const char *format, ...);
type              331 ext/opcache/zend_accelerator_module.c 			handle.type = ZEND_HANDLE_FILENAME;
type              386 ext/opcache/zend_accelerator_module.c 	(void)type; /* keep the compiler happy */
type              421 ext/opcache/zend_accelerator_module.c 	(void)type; /* keep the compiler happy */
type              801 ext/opcache/zend_accelerator_module.c 	handle.type = ZEND_HANDLE_FILENAME;
type               49 ext/opcache/zend_accelerator_util_funcs.c 	if (function->type == ZEND_USER_FUNCTION) {
type              108 ext/opcache/zend_accelerator_util_funcs.c 	return(function->type != ZEND_INTERNAL_FUNCTION);
type              130 ext/opcache/zend_accelerator_util_funcs.c 		if (EXPECTED(function->type == ZEND_USER_FUNCTION)) {
type              143 ext/opcache/zend_accelerator_util_funcs.c 	if (function->type == ZEND_INTERNAL_FUNCTION) {
type              556 ext/opcache/zend_accelerator_util_funcs.c 	if (function2->type == ZEND_USER_FUNCTION
type              600 ext/opcache/zend_accelerator_util_funcs.c 	if (function2->type == ZEND_USER_FUNCTION
type               82 ext/opcache/zend_file_cache.c static int zend_file_cache_flock(int fd, int type)
type              446 ext/opcache/zend_persist.c 	if (op_array->type != ZEND_USER_FUNCTION) {
type              723 ext/opcache/zend_persist.c 	if (ce->type == ZEND_USER_CLASS) {
type              162 ext/opcache/zend_persist_calc.c 	if (op_array->type != ZEND_USER_FUNCTION) {
type              267 ext/opcache/zend_persist_calc.c 	if (op_array->type == ZEND_USER_FUNCTION/* &&
type              301 ext/opcache/zend_persist_calc.c 	if (ce->type == ZEND_USER_CLASS) {
type             1937 ext/openssl/openssl.c 		switch (name->type) {
type             2686 ext/openssl/openssl.c 		char * type;
type             2724 ext/openssl/openssl.c 			type = v->name;
type             2726 ext/openssl/openssl.c 			len = (int)strlen(type);
type             2731 ext/openssl/openssl.c 			if (strcmp("_default", type + len) != 0) {
type             2737 ext/openssl/openssl.c 			memcpy(buffer, type, len);
type             2739 ext/openssl/openssl.c 			type = buffer;
type             2743 ext/openssl/openssl.c 			for (str = type; *str; str++) {
type             2747 ext/openssl/openssl.c 						type = str;
type             2753 ext/openssl/openssl.c 			nid = OBJ_txt2nid(type);
type             2757 ext/openssl/openssl.c 			if (!X509_NAME_add_entry_by_txt(subj, type, MBSTRING_UTF8, (unsigned char*)v->value, -1, -1, 0)) {
type             2758 ext/openssl/openssl.c 				php_error_docref(NULL, E_WARNING, "add_entry_by_txt %s -> %s (failed)", type, v->value);
type             3286 ext/openssl/openssl.c 		if (res->type == le_x509) {
type             3290 ext/openssl/openssl.c 		} else if (res->type == le_key) {
type             3496 ext/openssl/openssl.c 	switch (pkey->type) {
type             3718 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
type             3788 ext/openssl/openssl.c 		switch (EVP_PKEY_type(key->type)) {
type             3911 ext/openssl/openssl.c 	switch (EVP_PKEY_type(pkey->type)) {
type             4526 ext/openssl/openssl.c 	switch (pkey->type) {
type             4586 ext/openssl/openssl.c 	switch (pkey->type) {
type             4652 ext/openssl/openssl.c 	switch (pkey->type) {
type             4713 ext/openssl/openssl.c 	switch (pkey->type) {
type             5448 ext/openssl/openssl.c 	if (EVP_PKEY_type(pkey->type) != EVP_PKEY_DH || !pkey->pkey.dh) {
type              414 ext/openssl/xp_ssl.c 		if (san->type == GEN_DNS) {
type              433 ext/openssl/xp_ssl.c 		} else if (san->type == GEN_IPADD) {
type             1565 ext/pcre/pcrelib/pcre_compile.c     *ptypeptr = PRIV(utt)[i].type;
type             2651 ext/pcre/pcrelib/pcre_internal.h   pcre_uint16 type;
type              525 ext/pcre/pcrelib/pcre_jit_compile.c #define JUMP(type) \
type              526 ext/pcre/pcrelib/pcre_jit_compile.c   sljit_emit_jump(compiler, (type))
type              527 ext/pcre/pcrelib/pcre_jit_compile.c #define JUMPTO(type, label) \
type              528 ext/pcre/pcrelib/pcre_jit_compile.c   sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
type              533 ext/pcre/pcrelib/pcre_jit_compile.c #define CMP(type, src1, src1w, src2, src2w) \
type              534 ext/pcre/pcrelib/pcre_jit_compile.c   sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
type              535 ext/pcre/pcrelib/pcre_jit_compile.c #define CMPTO(type, src1, src1w, src2, src2w, label) \
type              536 ext/pcre/pcrelib/pcre_jit_compile.c   sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
type              537 ext/pcre/pcrelib/pcre_jit_compile.c #define OP_FLAGS(op, dst, dstw, src, srcw, type) \
type              538 ext/pcre/pcrelib/pcre_jit_compile.c   sljit_emit_op_flags(compiler, (op), (dst), (dstw), (src), (srcw), (type))
type              929 ext/pcre/pcrelib/pcre_jit_compile.c pcre_uchar type;
type              961 ext/pcre/pcrelib/pcre_jit_compile.c   type = *next;
type              964 ext/pcre/pcrelib/pcre_jit_compile.c     if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
type              973 ext/pcre/pcrelib/pcre_jit_compile.c   if (next[0] == type && next[1] == *begin && max >= 1)
type              985 ext/pcre/pcrelib/pcre_jit_compile.c         common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
type             5285 ext/pcre/pcrelib/pcre_jit_compile.c static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
type             5300 ext/pcre/pcrelib/pcre_jit_compile.c switch(type)
type             5317 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_NOT_ZERO : SLJIT_ZERO));
type             5326 ext/pcre/pcrelib/pcre_jit_compile.c     read_char7_type(common, type == OP_NOT_DIGIT);
type             5329 ext/pcre/pcrelib/pcre_jit_compile.c     read_char8_type(common, type == OP_NOT_DIGIT);
type             5332 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_ZERO : SLJIT_NOT_ZERO));
type             5340 ext/pcre/pcrelib/pcre_jit_compile.c     read_char7_type(common, type == OP_NOT_WHITESPACE);
type             5343 ext/pcre/pcrelib/pcre_jit_compile.c     read_char8_type(common, type == OP_NOT_WHITESPACE);
type             5345 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_ZERO : SLJIT_NOT_ZERO));
type             5353 ext/pcre/pcrelib/pcre_jit_compile.c     read_char7_type(common, type == OP_NOT_WORDCHAR);
type             5356 ext/pcre/pcrelib/pcre_jit_compile.c     read_char8_type(common, type == OP_NOT_WORDCHAR);
type             5358 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_ZERO : SLJIT_NOT_ZERO));
type             5420 ext/pcre/pcrelib/pcre_jit_compile.c   propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
type             5453 ext/pcre/pcrelib/pcre_jit_compile.c   read_char_range(common, 0x9, 0x3000, type == OP_NOT_HSPACE);
type             5455 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
type             5461 ext/pcre/pcrelib/pcre_jit_compile.c   read_char_range(common, 0xa, 0x2029, type == OP_NOT_VSPACE);
type             5463 ext/pcre/pcrelib/pcre_jit_compile.c   add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
type             5671 ext/pcre/pcrelib/pcre_jit_compile.c   if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
type             5681 ext/pcre/pcrelib/pcre_jit_compile.c     return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
type             5694 ext/pcre/pcrelib/pcre_jit_compile.c   if (type == OP_CHAR || !char_has_othercase(common, cc))
type             5726 ext/pcre/pcrelib/pcre_jit_compile.c       if (type == OP_NOT || !char_has_othercase(common, cc))
type             5752 ext/pcre/pcrelib/pcre_jit_compile.c   if (type == OP_NOT || !char_has_othercase(common, cc))
type             5780 ext/pcre/pcrelib/pcre_jit_compile.c   bit = (common->utf && is_char7_bitset((const pcre_uint8 *)cc, type == OP_NCLASS)) ? 127 : 255;
type             5781 ext/pcre/pcrelib/pcre_jit_compile.c   read_char_range(common, 0, bit, type == OP_NCLASS);
type             5783 ext/pcre/pcrelib/pcre_jit_compile.c   read_char_range(common, 0, 255, type == OP_NCLASS);
type             5786 ext/pcre/pcrelib/pcre_jit_compile.c   if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, FALSE, backtracks))
type             5794 ext/pcre/pcrelib/pcre_jit_compile.c     if (type == OP_CLASS)
type             5802 ext/pcre/pcrelib/pcre_jit_compile.c   if (type == OP_CLASS)
type             5955 ext/pcre/pcrelib/pcre_jit_compile.c #define BACKTRACK_AS(type) ((type *)backtrack)
type             6088 ext/pcre/pcrelib/pcre_jit_compile.c pcre_uchar type;
type             6103 ext/pcre/pcrelib/pcre_jit_compile.c type = cc[1 + IMM2_SIZE];
type             6106 ext/pcre/pcrelib/pcre_jit_compile.c minimize = (type & 0x1) != 0;
type             6107 ext/pcre/pcrelib/pcre_jit_compile.c switch(type)
type             6227 ext/pcre/pcrelib/pcre_jit_compile.c if (type != OP_CRMINSTAR)
type             7805 ext/pcre/pcrelib/pcre_jit_compile.c static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *max, int *min, pcre_uchar **end)
type             7813 ext/pcre/pcrelib/pcre_jit_compile.c   *type = OP_CHAR;
type             7818 ext/pcre/pcrelib/pcre_jit_compile.c   *type = OP_CHARI;
type             7824 ext/pcre/pcrelib/pcre_jit_compile.c   *type = OP_NOT;
type             7830 ext/pcre/pcrelib/pcre_jit_compile.c   *type = OP_NOTI;
type             7837 ext/pcre/pcrelib/pcre_jit_compile.c   *type = 0;
type             7842 ext/pcre/pcrelib/pcre_jit_compile.c   *type = *opcode;
type             7844 ext/pcre/pcrelib/pcre_jit_compile.c   class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
type             7884 ext/pcre/pcrelib/pcre_jit_compile.c if (*type == 0)
type             7886 ext/pcre/pcrelib/pcre_jit_compile.c   *type = *cc;
type             7908 ext/pcre/pcrelib/pcre_jit_compile.c pcre_uchar type;
type             7922 ext/pcre/pcrelib/pcre_jit_compile.c cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, &end);
type             7924 ext/pcre/pcrelib/pcre_jit_compile.c switch(type)
type             7969 ext/pcre/pcrelib/pcre_jit_compile.c   if (type == OP_ANYNL || type == OP_EXTUNI)
type             7988 ext/pcre/pcrelib/pcre_jit_compile.c     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8010 ext/pcre/pcrelib/pcre_jit_compile.c       compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8019 ext/pcre/pcrelib/pcre_jit_compile.c     compile_char1_matchingpath(common, type, cc, &nomatch);
type             8046 ext/pcre/pcrelib/pcre_jit_compile.c     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8070 ext/pcre/pcrelib/pcre_jit_compile.c     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8077 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8086 ext/pcre/pcrelib/pcre_jit_compile.c     compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8091 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &nomatch);
type             8106 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &nomatch);
type             8116 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);
type             8127 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &nomatch);
type             8596 ext/pcre/pcrelib/pcre_jit_compile.c #define CURRENT_AS(type) ((type *)current)
type             8603 ext/pcre/pcrelib/pcre_jit_compile.c pcre_uchar type;
type             8613 ext/pcre/pcrelib/pcre_jit_compile.c cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, NULL);
type             8621 ext/pcre/pcrelib/pcre_jit_compile.c   if (type == OP_ANYNL || type == OP_EXTUNI)
type             8661 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &jumplist);
type             8679 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &jumplist);
type             8717 ext/pcre/pcrelib/pcre_jit_compile.c   compile_char1_matchingpath(common, type, cc, &jumplist);
type             8747 ext/pcre/pcrelib/pcre_jit_compile.c pcre_uchar type;
type             8749 ext/pcre/pcrelib/pcre_jit_compile.c type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
type             8751 ext/pcre/pcrelib/pcre_jit_compile.c if ((type & 0x1) == 0)
type               74 ext/pcre/pcrelib/pcre_newline.c PRIV(is_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR endptr, int *lenptr,
type               90 ext/pcre/pcrelib/pcre_newline.c if (type == NLTYPE_ANYCRLF) switch(c)
type              149 ext/pcre/pcrelib/pcre_newline.c PRIV(was_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR startptr, int *lenptr,
type              167 ext/pcre/pcrelib/pcre_newline.c if (type == NLTYPE_ANYCRLF) switch(c)
type              240 ext/pcre/pcrelib/pcre_printint.c   if (ptype == PRIV(utt)[i].type && pvalue == PRIV(utt)[i].value) break;
type              876 ext/pcre/pcrelib/sljit/sljitLir.c #define JUMP_PREFIX(type) \
type              877 ext/pcre/pcrelib/sljit/sljitLir.c 	((type & 0xff) <= SLJIT_MUL_NOT_OVERFLOW ? ((type & SLJIT_INT_OP) ? "i_" : "") \
type              878 ext/pcre/pcrelib/sljit/sljitLir.c 	: ((type & 0xff) <= SLJIT_D_ORDERED ? ((type & SLJIT_SINGLE_OP) ? "s_" : "d_") : ""))
type             1323 ext/pcre/pcrelib/sljit/sljitLir.c static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1331 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_INT_OP)));
type             1332 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_CALL3);
type             1333 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) < SLJIT_JUMP || !(type & SLJIT_INT_OP));
type             1334 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) <= SLJIT_CALL0 || ((type & 0xff) - SLJIT_CALL0) <= compiler->scratches);
type             1338 ext/pcre/pcrelib/sljit/sljitLir.c 		fprintf(compiler->verbose, "  jump%s.%s%s\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
type             1339 ext/pcre/pcrelib/sljit/sljitLir.c 			JUMP_PREFIX(type), jump_names[type & 0xff]);
type             1344 ext/pcre/pcrelib/sljit/sljitLir.c static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
type             1349 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_INT_OP)));
type             1350 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_SIG_LESS_EQUAL);
type             1356 ext/pcre/pcrelib/sljit/sljitLir.c 		fprintf(compiler->verbose, "  cmp%s.%s%s ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
type             1357 ext/pcre/pcrelib/sljit/sljitLir.c 			(type & SLJIT_INT_OP) ? "i_" : "", jump_names[type & 0xff]);
type             1367 ext/pcre/pcrelib/sljit/sljitLir.c static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
type             1373 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_SINGLE_OP)));
type             1374 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) >= SLJIT_D_EQUAL && (type & 0xff) <= SLJIT_D_ORDERED);
type             1380 ext/pcre/pcrelib/sljit/sljitLir.c 		fprintf(compiler->verbose, "  fcmp%s.%s%s ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
type             1381 ext/pcre/pcrelib/sljit/sljitLir.c 			(type & SLJIT_SINGLE_OP) ? "s_" : "d_", jump_names[type & 0xff]);
type             1391 ext/pcre/pcrelib/sljit/sljitLir.c static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1399 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
type             1400 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(type <= SLJIT_CALL0 || (type - SLJIT_CALL0) <= compiler->scratches);
type             1405 ext/pcre/pcrelib/sljit/sljitLir.c 		fprintf(compiler->verbose, "  ijump.%s ", jump_names[type]);
type             1416 ext/pcre/pcrelib/sljit/sljitLir.c 	sljit_si type)
type             1419 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_INT_OP)));
type             1420 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_D_ORDERED);
type             1442 ext/pcre/pcrelib/sljit/sljitLir.c 		fprintf(compiler->verbose, ", %s%s\n", JUMP_PREFIX(type), jump_names[type & 0xff]);
type             1579 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
type             1588 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_PTR(check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w));
type             1590 ext/pcre/pcrelib/sljit/sljitLir.c 	condition = type & 0xff;
type             1600 ext/pcre/pcrelib/sljit/sljitLir.c 			return emit_cmp_to0(compiler, type, src1, src1w);
type             1632 ext/pcre/pcrelib/sljit/sljitLir.c 		type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));
type             1652 ext/pcre/pcrelib/sljit/sljitLir.c 	PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),
type             1658 ext/pcre/pcrelib/sljit/sljitLir.c 	return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
type             1661 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
type             1668 ext/pcre/pcrelib/sljit/sljitLir.c 	CHECK_PTR(check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w));
type             1670 ext/pcre/pcrelib/sljit/sljitLir.c 	condition = type & 0xff;
type             1672 ext/pcre/pcrelib/sljit/sljitLir.c 	if (type & SLJIT_SINGLE_OP)
type             1685 ext/pcre/pcrelib/sljit/sljitLir.c 	return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
type             1919 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1922 ext/pcre/pcrelib/sljit/sljitLir.c 	SLJIT_UNUSED_ARG(type);
type             1927 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
type             1932 ext/pcre/pcrelib/sljit/sljitLir.c 	SLJIT_UNUSED_ARG(type);
type             1941 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
type             1946 ext/pcre/pcrelib/sljit/sljitLir.c 	SLJIT_UNUSED_ARG(type);
type             1969 ext/pcre/pcrelib/sljit/sljitLir.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1972 ext/pcre/pcrelib/sljit/sljitLir.c 	SLJIT_UNUSED_ARG(type);
type             1982 ext/pcre/pcrelib/sljit/sljitLir.c 	sljit_si type)
type             1990 ext/pcre/pcrelib/sljit/sljitLir.c 	SLJIT_UNUSED_ARG(type);
type             1017 ext/pcre/pcrelib/sljit/sljitLir.h SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type);
type             1027 ext/pcre/pcrelib/sljit/sljitLir.h SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
type             1041 ext/pcre/pcrelib/sljit/sljitLir.h SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
type             1056 ext/pcre/pcrelib/sljit/sljitLir.h SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw);
type             1076 ext/pcre/pcrelib/sljit/sljitLir.h 	sljit_si type);
type             1243 ext/pcre/pcrelib/sljit/sljitLir.h 	sljit_si type,
type              940 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c #define EMIT_DATA_TRANSFER(type, add, wb, target, base1, base2) \
type              941 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	(data_transfer_insts[(type) >> 4] | ((add) << 23) | ((wb) << 21) | (reg_map[target] << 12) | (reg_map[base1] << 16) | (base2))
type              944 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c #define IS_TYPE1_TRANSFER(type) \
type              945 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	(data_transfer_insts[(type) >> 4] & 0x04000000)
type             2329 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c static sljit_uw get_cc(sljit_si type)
type             2331 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	switch (type) {
type             2379 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
type             2400 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             2405 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             2409 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             2410 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	type &= 0xff;
type             2414 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	if (type >= SLJIT_FAST_CALL)
type             2417 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		type <= SLJIT_JUMP ? TMP_PC : TMP_REG1, TMP_PC, 0)) & ~COND_MASK) | get_cc(type), 0));
type             2424 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	if (type >= SLJIT_FAST_CALL) {
type             2432 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	if (type >= SLJIT_FAST_CALL)
type             2435 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	PTR_FAIL_IF(push_inst(compiler, (((type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG1)) & ~COND_MASK) | get_cc(type)));
type             2441 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             2446 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             2452 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 			return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(src));
type             2456 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG2));
type             2461 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
type             2465 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	if (type >= SLJIT_FAST_CALL)
type             2467 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	FAIL_IF(push_inst_with_unique_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, type <= SLJIT_JUMP ? TMP_PC : TMP_REG1, TMP_PC, 0), 0));
type             2468 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	if (type >= SLJIT_FAST_CALL)
type             2472 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	FAIL_IF(push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG1)));
type             2481 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	sljit_si type)
type             2487 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             2495 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	cc = get_cc(type & 0xff);
type             1809 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c static sljit_uw get_cc(sljit_si type)
type             1811 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	switch (type) {
type             1880 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1885 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             1889 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1890 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	type &= 0xff;
type             1892 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	if (type < SLJIT_JUMP) {
type             1894 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 		PTR_FAIL_IF(push_inst(compiler, B_CC | (6 << 5) | get_cc(type)));
type             1896 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	else if (type >= SLJIT_FAST_CALL)
type             1901 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	PTR_FAIL_IF(push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1)));
type             1906 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c static SLJIT_INLINE struct sljit_jump* emit_cmp_to0(struct sljit_compiler *compiler, sljit_si type,
type             1910 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	sljit_ins inv_bits = (type & SLJIT_INT_OP) ? (1 << 31) : 0;
type             1912 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	SLJIT_ASSERT((type & 0xff) == SLJIT_EQUAL || (type & 0xff) == SLJIT_NOT_EQUAL);
type             1917 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1930 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	if ((type & 0xff) == SLJIT_EQUAL)
type             1940 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1945 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             1954 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 		return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(src));
type             1959 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
type             1964 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1));
type             1970 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	sljit_si type)
type             1976 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             1983 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	cc = get_cc(type & 0xff);
type              281 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	sljit_si type = (jump->flags >> 4) & 0xf;
type              286 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	if (SLJIT_UNLIKELY(type == 0)) {
type              299 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	switch (type) {
type              315 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		type = 5;
type              334 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	if (type == 5) /* Encoding T4 of 'B' instruction */
type              336 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	else if (type == 6) /* Encoding T1 of 'BL' instruction */
type             1843 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c static sljit_uw get_cc(sljit_si type)
type             1845 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	switch (type) {
type             1914 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1920 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             1924 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1925 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	type &= 0xff;
type             1929 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	if (type < SLJIT_JUMP) {
type             1931 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		cc = get_cc(type);
type             1937 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	if (type <= SLJIT_JUMP)
type             1947 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1952 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             1958 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 			return push_inst16(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RN3(src));
type             1960 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		FAIL_IF(emit_op_mem(compiler, WORD_SIZE, type <= SLJIT_JUMP ? TMP_PC : TMP_REG1, src, srcw));
type             1961 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		if (type >= SLJIT_FAST_CALL)
type             1967 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
type             1972 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	return push_inst16(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RN3(TMP_REG1));
type             1978 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	sljit_si type)
type             1984 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             1992 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	cc = get_cc(type & 0xff);
type             1620 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1628 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             1632 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1633 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	type &= 0xff;
type             1635 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	switch (type) {
type             1700 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	if (type <= SLJIT_JUMP) {
type             1707 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		jump->flags |= IS_JAL | (type >= SLJIT_CALL0 ? IS_CALL : 0);
type             1736 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
type             1745 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	CHECK_PTR(check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w));
type             1751 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	flags = ((type & SLJIT_INT_OP) ? INT_DATA : WORD_DATA) | LOAD_DATA;
type             1763 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1764 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	type &= 0xff;
type             1766 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	if (type <= SLJIT_NOT_EQUAL) {
type             1772 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		PTR_FAIL_IF(push_inst(compiler, (type == SLJIT_EQUAL ? BNE : BEQ) | S(src1) | T(src2) | JUMP_LENGTH, UNMOVABLE_INS));
type             1774 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	else if (type >= SLJIT_SIG_LESS && (((src1 & SLJIT_IMM) && (src1w == 0)) || ((src2 & SLJIT_IMM) && (src2w == 0)))) {
type             1778 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 			switch (type) {
type             1800 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 			switch (type) {
type             1822 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		if (type == SLJIT_LESS || type == SLJIT_GREATER_EQUAL || type == SLJIT_SIG_LESS || type == SLJIT_SIG_GREATER_EQUAL) {
type             1825 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 				PTR_FAIL_IF(push_inst(compiler, (type <= SLJIT_LESS_EQUAL ? SLTIU : SLTI) | S(src1) | T(TMP_REG1) | IMM(src2w), DR(TMP_REG1)));
type             1828 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 				PTR_FAIL_IF(push_inst(compiler, (type <= SLJIT_LESS_EQUAL ? SLTU : SLT) | S(src1) | T(src2) | D(TMP_REG1), DR(TMP_REG1)));
type             1830 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 			type = (type == SLJIT_LESS || type == SLJIT_SIG_LESS) ? SLJIT_NOT_EQUAL : SLJIT_EQUAL;
type             1835 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 				PTR_FAIL_IF(push_inst(compiler, (type <= SLJIT_LESS_EQUAL ? SLTIU : SLTI) | S(src2) | T(TMP_REG1) | IMM(src1w), DR(TMP_REG1)));
type             1838 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 				PTR_FAIL_IF(push_inst(compiler, (type <= SLJIT_LESS_EQUAL ? SLTU : SLT) | S(src2) | T(src1) | D(TMP_REG1), DR(TMP_REG1)));
type             1840 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 			type = (type == SLJIT_GREATER || type == SLJIT_SIG_GREATER) ? SLJIT_NOT_EQUAL : SLJIT_EQUAL;
type             1844 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		PTR_FAIL_IF(push_inst(compiler, (type == SLJIT_EQUAL ? BNE : BEQ) | S(TMP_REG1) | TA(0) | JUMP_LENGTH, UNMOVABLE_INS));
type             1857 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
type             1866 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	CHECK_PTR(check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w));
type             1872 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		PTR_FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(type) | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));
type             1879 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		PTR_FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(type) | LOAD_DATA, TMP_FREG2, src2, src2w, 0, 0));
type             1887 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1890 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	switch (type & 0xff) {
type             1927 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	PTR_FAIL_IF(push_inst(compiler, inst | FMT(type) | FT(src2) | FS(src1), UNMOVABLE_INS));
type             1946 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1952 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             1962 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	if (type >= SLJIT_CALL0) {
type             1977 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		if (type >= SLJIT_CALL1)
type             1986 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_JAL : 0));
type             2007 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	sljit_si type)
type             2018 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             2040 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	switch (type & 0xff) {
type             2074 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		type ^= 0x1; /* Flip type bit for the XORI below. */
type             2095 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 	if (type & 0x1) {
type               38 ext/pcre/pcrelib/sljit/sljitNativePPC_64.c #define RLDI(dst, src, sh, mb, type) \
type               39 ext/pcre/pcrelib/sljit/sljitNativePPC_64.c 	(HI(30) | S(src) | A(dst) | ((type) << 2) | (((sh) & 0x1f) << 11) | (((sh) & 0x20) >> 4) | (((mb) & 0x1f) << 6) | ((mb) & 0x20))
type             1293 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c #define EMIT_MOV(type, type_flags, type_cast) \
type             1294 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	emit_op(compiler, (src & SLJIT_IMM) ? SLJIT_MOV : type, flags | (type_flags), dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? type_cast srcw : srcw)
type             2068 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c static sljit_ins get_bo_bi_flags(sljit_si type)
type             2070 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	switch (type) {
type             2126 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
type             2131 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             2137 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             2139 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	bo_bi_flags = get_bo_bi_flags(type & 0xff);
type             2145 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             2146 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	type &= 0xff;
type             2149 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	if (type < SLJIT_JUMP)
type             2152 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	if (type >= SLJIT_CALL0)
type             2159 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	PTR_FAIL_IF(push_inst(compiler, BCCTR | bo_bi_flags | (type >= SLJIT_FAST_CALL ? 1 : 0)));
type             2163 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             2169 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             2174 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		if (type >= SLJIT_CALL0) {
type             2189 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		if (type >= SLJIT_CALL0)
type             2203 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	return push_inst(compiler, BCCTR | (20 << 21) | (type >= SLJIT_FAST_CALL ? 1 : 0));
type             2217 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	sljit_si type)
type             2224 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             2247 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 	switch (type & 0xff) {
type             1234 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c static sljit_ins get_cc(sljit_si type)
type             1236 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	switch (type) {
type             1289 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             1294 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             1298 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             1299 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	type &= 0xff;
type             1301 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	if (type < SLJIT_D_EQUAL) {
type             1306 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		PTR_FAIL_IF(push_inst(compiler, BICC | get_cc(type ^ 1) | 5, UNMOVABLE_INS));
type             1311 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	else if (type < SLJIT_JUMP) {
type             1316 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		PTR_FAIL_IF(push_inst(compiler, FBFCC | get_cc(type ^ 1) | 5, UNMOVABLE_INS));
type             1323 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		if (type >= SLJIT_FAST_CALL)
type             1328 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	PTR_FAIL_IF(push_inst(compiler, JMPL | D(type >= SLJIT_FAST_CALL ? TMP_LINK : 0) | S1(TMP_REG2) | IMM(0), UNMOVABLE_INS));
type             1335 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             1341 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             1353 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		if (type >= SLJIT_FAST_CALL)
type             1364 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	FAIL_IF(push_inst(compiler, JMPL | D(type >= SLJIT_FAST_CALL ? TMP_LINK : 0) | S1(src_r) | IMM(0), UNMOVABLE_INS));
type             1373 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	sljit_si type)
type             1378 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             1397 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	type &= 0xff;
type             1398 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 	if (type < SLJIT_D_EQUAL)
type             1399 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		FAIL_IF(push_inst(compiler, BICC | get_cc(type) | 3, UNMOVABLE_INS));
type             1401 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		FAIL_IF(push_inst(compiler, FBFCC | get_cc(type) | 3, UNMOVABLE_INS));
type              245 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c   tilegx_operand_type type;
type             9568 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c       if (op->type == TILEGX_OP_TYPE_ADDRESS)
type             10133 ext/pcre/pcrelib/sljit/sljitNativeTILEGX-encoder.c       switch (op->type)
type             2085 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src, sljit_sw srcw, sljit_si type)
type             2092 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             2112 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	switch (type & 0xff) {
type             2142 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		type ^= 0x1; /* Flip type bit for the XORI below. */
type             2151 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	if (type & 0x1) {
type             2315 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             2323 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             2333 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	if (type >= SLJIT_CALL0) {
type             2353 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		if (type >= SLJIT_CALL1)
type             2368 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_JAL : 0));
type             2372 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		if (type >= SLJIT_FAST_CALL) {
type             2404 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             2413 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             2417 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             2418 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	type &= 0xff;
type             2420 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	switch (type) {
type             2468 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		inst = inst | ((type <= SLJIT_JUMP) ? BOFF_X1(5) : BOFF_X1(6));
type             2473 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	if (type <= SLJIT_JUMP) {
type             2479 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		jump->flags |= IS_JAL | (type >= SLJIT_CALL0 ? SLJIT_REWRITABLE_JUMP : 0);
type               41 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_si type)
type               43 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	if (type == SLJIT_JUMP) {
type               47 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	else if (type >= SLJIT_FAST_CALL) {
type               53 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 		*code_ptr++ = get_jump_code(type);
type              441 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c static SLJIT_INLINE sljit_si call_with_args(struct sljit_compiler *compiler, sljit_si type)
type              446 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	inst = (sljit_ub*)ensure_buf(compiler, type >= SLJIT_CALL3 ? 1 + 2 + 1 : 1 + 2);
type              448 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	INC_SIZE(type >= SLJIT_CALL3 ? 2 + 1 : 2);
type              450 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	if (type >= SLJIT_CALL3)
type              455 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	inst = (sljit_ub*)ensure_buf(compiler, 1 + 4 * (type - SLJIT_CALL0));
type              457 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	INC_SIZE(4 * (type - SLJIT_CALL0));
type              463 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	if (type >= SLJIT_CALL2) {
type              469 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 	if (type >= SLJIT_CALL3) {
type               42 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_si type)
type               44 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	if (type < SLJIT_JUMP) {
type               46 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 		*code_ptr++ = get_jump_code(type ^ 0x1) - 0x10;
type               63 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	*code_ptr++ = (type >= SLJIT_FAST_CALL) ? (MOD_REG | CALL_rm | 1) : (MOD_REG | JMP_rm | 1);
type               68 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_sw addr, sljit_si type)
type               73 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 		*code_ptr++ = (type == 2) ? CALL_i32 : JMP_i32;
type               84 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 		*code_ptr++ = (type == 2) ? (MOD_REG | CALL_rm | 1) : (MOD_REG | JMP_rm | 1);
type              556 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c static SLJIT_INLINE sljit_si call_with_args(struct sljit_compiler *compiler, sljit_si type)
type              563 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	inst = (sljit_ub*)ensure_buf(compiler, 1 + ((type < SLJIT_CALL3) ? 3 : 6));
type              565 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	INC_SIZE((type < SLJIT_CALL3) ? 3 : 6);
type              566 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	if (type >= SLJIT_CALL3) {
type              577 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	inst = (sljit_ub*)ensure_buf(compiler, 1 + ((type < SLJIT_CALL3) ? 3 : 6));
type              579 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	INC_SIZE((type < SLJIT_CALL3) ? 3 : 6);
type              580 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 	if (type >= SLJIT_CALL3) {
type              333 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c static sljit_ub get_jump_code(sljit_si type)
type              335 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	switch (type) {
type              389 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_si type);
type              392 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_sw addr, sljit_si type);
type              395 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c static sljit_ub* generate_near_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_ub *code, sljit_si type)
type              408 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		return generate_far_jump_code(jump, code_ptr, type);
type              411 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	if (type == SLJIT_JUMP) {
type              418 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	else if (type >= SLJIT_FAST_CALL) {
type              424 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		*code_ptr++ = get_jump_code(type) - 0x10;
type              429 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		*code_ptr++ = get_jump_code(type);
type             2554 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
type             2560 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
type             2563 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		if ((type & 0xff) <= SLJIT_JUMP)
type             2570 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
type             2571 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	type &= 0xff;
type             2573 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	if (type >= SLJIT_CALL1)
type             2574 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		PTR_FAIL_IF(call_with_args(compiler, type));
type             2578 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	compiler->size += (type >= SLJIT_JUMP) ? 5 : 6;
type             2580 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	compiler->size += (type >= SLJIT_JUMP) ? (10 + 3) : (2 + 10 + 3);
type             2587 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	*inst++ = type + 4;
type             2591 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
type             2597 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
type             2603 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		if (type <= SLJIT_JUMP)
type             2608 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	if (type >= SLJIT_CALL1) {
type             2615 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		if (src == SLJIT_MEM1(SLJIT_SP) && type >= SLJIT_CALL3)
type             2625 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		FAIL_IF(call_with_args(compiler, type));
type             2645 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		*inst++ = type + 4;
type             2655 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		*inst |= (type >= SLJIT_FAST_CALL) ? CALL_rm : JMP_rm;
type             2663 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	sljit_si type)
type             2676 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
type             2687 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	type &= 0xff;
type             2689 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	cond_set = get_jump_code(type) + 0x10;
type             2959 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	sljit_si type,
type             2968 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_INT_OP)));
type             2969 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_D_ORDERED);
type             2977 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 			JUMP_PREFIX(type), jump_names[type & 0xff]);
type             3002 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 	*inst = get_jump_code(type & 0xff) - 0x40;
type              294 ext/pdo/pdo_dbh.c 				if (le->type == php_pdo_list_entry()) {
type              364 ext/pdo/pdo_dbh.c 			le.type = php_pdo_list_entry();
type             1299 ext/pdo/pdo_dbh.c 		func.type = ZEND_INTERNAL_FUNCTION;
type               72 ext/pdo/pdo_stmt.c 	ZEND_ARG_INFO(0, type)
type               78 ext/pdo/pdo_stmt.c 	ZEND_ARG_INFO(0, type)
type               86 ext/pdo/pdo_stmt.c 	ZEND_ARG_INFO(0, type)
type              550 ext/pdo/pdo_stmt.c 	int type, new_type;
type              553 ext/pdo/pdo_stmt.c 	type = PDO_PARAM_TYPE(col->param_type);
type              554 ext/pdo/pdo_stmt.c 	new_type =  type_override ? PDO_PARAM_TYPE(*type_override) : type;
type              561 ext/pdo/pdo_stmt.c 	switch (type) {
type              570 ext/pdo/pdo_stmt.c 				type = new_type;
type              640 ext/pdo/pdo_stmt.c 	if (type != new_type) {
type             2481 ext/pdo/pdo_stmt.c static zval *row_prop_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type             2514 ext/pdo/pdo_stmt.c 				return std_object_handlers.read_property(&zobj, member, type, cache_slot, rv);
type             2522 ext/pdo/pdo_stmt.c static zval *row_dim_read(zval *object, zval *member, int type, zval *rv)
type             2524 ext/pdo/pdo_stmt.c 	return row_prop_read(object, member, type, NULL, rv);
type             2634 ext/pdo/pdo_stmt.c 	ctor.type = ZEND_INTERNAL_FUNCTION;
type               42 ext/pdo_dblib/dblib_stmt.c static char *pdo_dblib_get_field_name(int type)
type               52 ext/pdo_dblib/dblib_stmt.c 	switch (type) {
type              215 ext/pdo_firebird/firebird_statement.c #define FETCH_BUF(buf,type,len,lenvar) ((buf) = (buf) ? (buf) : \
type              216 ext/pdo_firebird/firebird_statement.c 	emalloc((len) ? (len * sizeof(type)) : ((*(unsigned long*)lenvar) = sizeof(type))))
type              207 ext/pdo_mysql/mysql_statement.c 				if (calc_max_length && S->fields[i].type == FIELD_TYPE_BLOB) {
type              212 ext/pdo_mysql/mysql_statement.c 				switch (S->fields[i].type) {
type              776 ext/pdo_mysql/mysql_statement.c static char *type_to_name_native(int type) /* {{{ */
type              780 ext/pdo_mysql/mysql_statement.c     switch (type) {
type              865 ext/pdo_mysql/mysql_statement.c 	str = type_to_name_native(F->type);
type              871 ext/pdo_mysql/mysql_statement.c 	switch (F->type) {
type             1000 ext/pgsql/pgsql.c 	if (rsrc->type != le_plink)
type             1365 ext/pgsql/pgsql.c 			new_le.type = le_plink;
type             1373 ext/pgsql/pgsql.c 			if (le->type != le_plink) {
type             1424 ext/pgsql/pgsql.c 			if (index_ptr->type != le_index_ptr) {
type             1429 ext/pgsql/pgsql.c 			if (link->ptr && (link->type == le_link || link->type == le_plink)) {
type             1478 ext/pgsql/pgsql.c 		new_index_ptr.type = le_index_ptr;
type             2379 ext/pgsql/pgsql.c 			new_oid_entry.type = le_string;
type             2473 ext/pgsql/pgsql.c 		new_field_table.type = le_string;
type             5804 ext/pgsql/pgsql.c 	zval meta, *def, *type, *not_null, *has_default, *is_enum, *val, new_val;
type             5837 ext/pgsql/pgsql.c 		if (!err && (type = zend_hash_str_find(Z_ARRVAL_P(def), "type", sizeof("type") - 1)) == NULL) {
type             5866 ext/pgsql/pgsql.c 			data_type = php_pgsql_get_data_type(Z_STRVAL_P(type), Z_STRLEN_P(type));
type             5893 ext/pgsql/pgsql.c 								php_error_docref(NULL, E_NOTICE, "Detected invalid value (%s) for PostgreSQL %s field (%s)", Z_STRVAL_P(val), Z_STRVAL_P(type), ZSTR_VAL(field));
type             5925 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects string, null, long or boolelan value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             5967 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for pgsql '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6013 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6076 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6118 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6150 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6183 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6214 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6245 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6324 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6372 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6403 ext/pgsql/pgsql.c 					php_error_docref(NULL, E_NOTICE, "Expects NULL or string for PostgreSQL %s field (%s)", Z_STRVAL_P(type), ZSTR_VAL(field));
type             6409 ext/pgsql/pgsql.c 				php_error_docref(NULL, E_NOTICE, "Unknown or system data type '%s' for '%s'. Report error", Z_STRVAL_P(type), ZSTR_VAL(field));
type              435 ext/phar/func_interceptors.c #define IS_ACCESS_CHECK(__t) (IS_ABLE_CHECK(type) || (__t) == FS_EXISTS)
type              439 ext/phar/func_interceptors.c static void phar_fancy_stat(zend_stat_t *stat_sb, int type, zval *return_value)
type              450 ext/phar/func_interceptors.c 	if (type >= FS_IS_W && type <= FS_IS_X) {
type              481 ext/phar/func_interceptors.c 	switch (type) {
type              608 ext/phar/func_interceptors.c static void phar_file_stat(const char *filename, php_stat_len filename_length, int type, void (*orig_stat_func)(INTERNAL_FUNCTION_PARAMETERS), INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
type              666 ext/phar/func_interceptors.c 				if (IS_EXISTS_CHECK(type)) {
type              701 ext/phar/func_interceptors.c 					if (IS_EXISTS_CHECK(type)) {
type              712 ext/phar/func_interceptors.c 					if (IS_EXISTS_CHECK(type)) {
type              734 ext/phar/func_interceptors.c 				if (!IS_EXISTS_CHECK(type)) {
type              735 ext/phar/func_interceptors.c 					php_error_docref(NULL, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
type              795 ext/phar/func_interceptors.c 			phar_fancy_stat(&sb, type, return_value);
type             3265 ext/phar/phar.c zend_op_array *(*phar_orig_compile_file)(zend_file_handle *file_handle, int type);
type             3273 ext/phar/phar.c static zend_op_array *phar_compile_file(zend_file_handle *file_handle, int type) /* {{{ */
type             3281 ext/phar/phar.c 		return phar_orig_compile_file(file_handle, type);
type             3304 ext/phar/phar.c 				file_handle->type = ZEND_HANDLE_STREAM;
type             3322 ext/phar/phar.c 		res = phar_orig_compile_file(file_handle, type);
type             3363 ext/phar/phar.c 		mime.type = ret; \
type              416 ext/phar/phar_internal.h static inline void phar_set_fp_type(phar_entry_info *entry, enum phar_fp_type type, zend_off_t offset)
type              421 ext/phar/phar_internal.h 		entry->fp_type = type;
type              426 ext/phar/phar_internal.h 	data->fp_type = type;
type              459 ext/phar/phar_internal.h 	char type;
type               55 ext/phar/phar_object.c 	return mime->type;
type              233 ext/phar/phar_object.c 			file_handle.type = ZEND_HANDLE_FILENAME;
type             1477 ext/phar/phar_object.c 				switch (intern->type) {
type             1933 ext/phar/phar_object.c 	zend_long type;
type             1936 ext/phar/phar_object.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &type) == FAILURE) {
type             1940 ext/phar/phar_object.c 	switch (type) {
type              232 ext/pspell/pspell.c 	if (res == NULL || Z_RES_P(res)->type != le_pspell_config) { \
type              241 ext/pspell/pspell.c 	if (res == NULL || Z_RES_P(res)->type != le_pspell) { \
type              599 ext/readline/readline_cli.c 		prepend_file.type = ZEND_HANDLE_FILENAME;
type              385 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
type              401 ext/reflection/php_reflection.c 	string_printf(str, (ce->type == ZEND_USER_CLASS) ? "<user" : "<internal");
type              402 ext/reflection/php_reflection.c 	if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module) {
type              442 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_CLASS) {
type              620 ext/reflection/php_reflection.c 	char *type = zend_zval_type_name(value);
type              624 ext/reflection/php_reflection.c 					indent, type, name, ZSTR_VAL(value_str));
type              660 ext/reflection/php_reflection.c 			(fptr->type == ZEND_INTERNAL_FUNCTION &&
type              681 ext/reflection/php_reflection.c 			(fptr->type == ZEND_INTERNAL_FUNCTION &&
type              688 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION && offset >= required) {
type              760 ext/reflection/php_reflection.c 	if (fptr->type != ZEND_USER_FUNCTION || !fptr->op_array.static_variables) {
type              793 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
type              799 ext/reflection/php_reflection.c 	string_printf(str, (fptr->type == ZEND_USER_FUNCTION) ? "<user" : "<internal");
type              803 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_INTERNAL_FUNCTION && ((zend_internal_function*)fptr)->module) {
type              869 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION) {
type              886 ext/reflection/php_reflection.c 				(fptr->type == ZEND_INTERNAL_FUNCTION &&
type              991 ext/reflection/php_reflection.c 	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) {
type             1022 ext/reflection/php_reflection.c 	if (module->type == MODULE_PERSISTENT) {
type             1025 ext/reflection/php_reflection.c 	if (module->type == MODULE_TEMPORARY) {
type             1040 ext/reflection/php_reflection.c 			switch(dep->type) {
type             1098 ext/reflection/php_reflection.c 			if (fptr->common.type==ZEND_INTERNAL_FUNCTION
type             1220 ext/reflection/php_reflection.c 		if (fptr->type == ZEND_INTERNAL_FUNCTION &&
type             1470 ext/reflection/php_reflection.c 	if (param->fptr->type != ZEND_USER_FUNCTION) {
type             1772 ext/reflection/php_reflection.c 	RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION);
type             1787 ext/reflection/php_reflection.c 	RETURN_BOOL(fptr->type == ZEND_USER_FUNCTION);
type             1800 ext/reflection/php_reflection.c 	RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.handler == zif_display_disabled_function);
type             1815 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION) {
type             1833 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION) {
type             1851 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION) {
type             1869 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
type             1891 ext/reflection/php_reflection.c 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.static_variables != NULL) {
type             2111 ext/reflection/php_reflection.c 	if (fptr->type != ZEND_INTERNAL_FUNCTION) {
type             2135 ext/reflection/php_reflection.c 	if (fptr->type != ZEND_INTERNAL_FUNCTION) {
type             2437 ext/reflection/php_reflection.c 				if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
type             2453 ext/reflection/php_reflection.c 		if (fptr->type == ZEND_INTERNAL_FUNCTION &&
type             2476 ext/reflection/php_reflection.c 				if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
type             2490 ext/reflection/php_reflection.c 		if (fptr->type == ZEND_INTERNAL_FUNCTION &&
type             2613 ext/reflection/php_reflection.c 		if (param->fptr->type == ZEND_INTERNAL_FUNCTION &&
type             2642 ext/reflection/php_reflection.c 			if (param->fptr->type == ZEND_INTERNAL_FUNCTION &&
type             2689 ext/reflection/php_reflection.c 	if (((param->fptr->type == ZEND_INTERNAL_FUNCTION &&
type             2826 ext/reflection/php_reflection.c 	if (param->fptr->type != ZEND_USER_FUNCTION)
type             2985 ext/reflection/php_reflection.c 			if (param->fptr->type == ZEND_INTERNAL_FUNCTION &&
type             3908 ext/reflection/php_reflection.c 	RETURN_BOOL(ce->type == ZEND_INTERNAL_CLASS);
type             3923 ext/reflection/php_reflection.c 	RETURN_BOOL(ce->type == ZEND_USER_CLASS);
type             3953 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_CLASS) {
type             3971 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_FUNCTION) {
type             3989 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_CLASS) {
type             4007 ext/reflection/php_reflection.c 	if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
type             5033 ext/reflection/php_reflection.c 	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module) {
type             5053 ext/reflection/php_reflection.c 	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module) {
type             5638 ext/reflection/php_reflection.c 		if (fptr->common.type==ZEND_INTERNAL_FUNCTION
type             5725 ext/reflection/php_reflection.c 	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) {
type             5807 ext/reflection/php_reflection.c 		switch(dep->type) {
type             5875 ext/reflection/php_reflection.c 	RETURN_BOOL(module->type == MODULE_PERSISTENT);
type             5891 ext/reflection/php_reflection.c 	RETURN_BOOL(module->type == MODULE_TEMPORARY);
type               69 ext/simplexml/php_simplexml.h 		SXE_ITER              type;
type               29 ext/simplexml/php_simplexml_exports.h 	if ((__p)->type == XML_TEXT_NODE) { \
type               74 ext/simplexml/simplexml.c 	subnode->iter.type = itertype;
type              103 ext/simplexml/simplexml.c 	if (sxe && sxe->iter.type != SXE_ITER_NONE) {
type              134 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_NONE) {
type              146 ext/simplexml/simplexml.c 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
type              147 ext/simplexml/simplexml.c 			if (sxe->iter.type == SXE_ITER_CHILD || (
type              148 ext/simplexml/simplexml.c 				sxe->iter.type == SXE_ITER_ELEMENT && !xmlStrcmp(node->name, sxe->iter.name))) {
type              171 ext/simplexml/simplexml.c 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
type              182 ext/simplexml/simplexml.c static xmlNodePtr sxe_get_element_by_name(php_sxe_object *sxe, xmlNodePtr node, char **name, SXE_ITER *type) /* {{{ */
type              188 ext/simplexml/simplexml.c 	if (sxe->iter.type != SXE_ITER_ATTRLIST)
type              190 ext/simplexml/simplexml.c 		orgtype = sxe->iter.type;
type              191 ext/simplexml/simplexml.c 		if (sxe->iter.type == SXE_ITER_NONE) {
type              192 ext/simplexml/simplexml.c 			sxe->iter.type = SXE_ITER_CHILD;
type              195 ext/simplexml/simplexml.c 		sxe->iter.type = orgtype;
type              198 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ELEMENT) {
type              208 ext/simplexml/simplexml.c 		if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
type              212 ext/simplexml/simplexml.c 					*type = SXE_ITER_ELEMENT;
type              224 ext/simplexml/simplexml.c 		*type = SXE_ITER_NONE;
type              235 ext/simplexml/simplexml.c static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv)
type              248 ext/simplexml/simplexml.c 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
type              267 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type              273 ext/simplexml/simplexml.c 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
type              278 ext/simplexml/simplexml.c 		    node->parent->type == XML_DOCUMENT_NODE) {
type              289 ext/simplexml/simplexml.c 			if (Z_TYPE_P(member) != IS_LONG || sxe->iter.type == SXE_ITER_ATTRLIST) {
type              321 ext/simplexml/simplexml.c 				if (sxe->iter.type == SXE_ITER_CHILD) {
type              324 ext/simplexml/simplexml.c 				if (sxe->iter.type == SXE_ITER_NONE) {
type              335 ext/simplexml/simplexml.c 				} else if (type == BP_VAR_W || type == BP_VAR_RW) {
type              372 ext/simplexml/simplexml.c static zval *sxe_property_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type              374 ext/simplexml/simplexml.c 	return sxe_prop_dim_read(object, member, 1, 0, type, rv);
type              380 ext/simplexml/simplexml.c static zval *sxe_dimension_read(zval *object, zval *offset, int type, zval *rv)
type              382 ext/simplexml/simplexml.c 	return sxe_prop_dim_read(object, offset, 0, 1, type, rv);
type              454 ext/simplexml/simplexml.c 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
type              484 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type              490 ext/simplexml/simplexml.c 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
type              496 ext/simplexml/simplexml.c 		    node->parent->type == XML_DOCUMENT_NODE) {
type              504 ext/simplexml/simplexml.c 		if (attribs && !node && sxe->iter.type == SXE_ITER_ELEMENT) {
type              573 ext/simplexml/simplexml.c 				if (node->type == XML_ATTRIBUTE_NODE) {
type              578 ext/simplexml/simplexml.c 				if (sxe->iter.type == SXE_ITER_NONE) {
type              680 ext/simplexml/simplexml.c 	SXE_ITER        type;
type              687 ext/simplexml/simplexml.c 	node = sxe_get_element_by_name(sxe, node, &name, &type);
type              694 ext/simplexml/simplexml.c 	type = SXE_ITER_NONE;
type              697 ext/simplexml/simplexml.c 	_node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix);
type              731 ext/simplexml/simplexml.c 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
type              734 ext/simplexml/simplexml.c 			if (sxe->iter.type == SXE_ITER_CHILD) {
type              740 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type              746 ext/simplexml/simplexml.c 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
type              786 ext/simplexml/simplexml.c 				if (sxe->iter.type == SXE_ITER_CHILD) {
type              796 ext/simplexml/simplexml.c 					if ((node->type == XML_ELEMENT_NODE) && !xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {
type              805 ext/simplexml/simplexml.c 					(!node->children || (node->children->type == XML_TEXT_NODE && !node->children->next &&
type              859 ext/simplexml/simplexml.c 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
type              862 ext/simplexml/simplexml.c 			if (sxe->iter.type == SXE_ITER_CHILD) {
type              868 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type              874 ext/simplexml/simplexml.c 	} else if (sxe->iter.type != SXE_ITER_CHILD) {
type              911 ext/simplexml/simplexml.c 				if (sxe->iter.type == SXE_ITER_CHILD) {
type              983 ext/simplexml/simplexml.c 	if (node->children && node->children->type == XML_TEXT_NODE && !xmlIsBlankNode(node->children)) {
type             1044 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ELEMENT) {
type             1047 ext/simplexml/simplexml.c 	if (!node || node->type != XML_ENTITY_DECL) {
type             1049 ext/simplexml/simplexml.c 		test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
type             1062 ext/simplexml/simplexml.c 	if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
type             1063 ext/simplexml/simplexml.c 		if (node->type == XML_ATTRIBUTE_NODE) {
type             1065 ext/simplexml/simplexml.c 		} else if (sxe->iter.type != SXE_ITER_CHILD) {
type             1066 ext/simplexml/simplexml.c 			if (sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || node->children->next || node->children->children || node->parent->children == node->parent->last) {
type             1079 ext/simplexml/simplexml.c 				if (node->type == XML_TEXT_NODE) {
type             1089 ext/simplexml/simplexml.c 			if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
type             1153 ext/simplexml/simplexml.c 	if (is_debug || sxe->iter.type != SXE_ITER_CHILD) {
type             1154 ext/simplexml/simplexml.c 		if (sxe->iter.type == SXE_ITER_ELEMENT) {
type             1157 ext/simplexml/simplexml.c 		if (!node || node->type != XML_ENTITY_DECL) {
type             1160 ext/simplexml/simplexml.c 			test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
type             1179 ext/simplexml/simplexml.c 	if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
type             1180 ext/simplexml/simplexml.c 		if (node->type == XML_ATTRIBUTE_NODE) {
type             1184 ext/simplexml/simplexml.c 		} else if (sxe->iter.type != SXE_ITER_CHILD) {
type             1186 ext/simplexml/simplexml.c 			if ( sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || !node->next || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
type             1202 ext/simplexml/simplexml.c 				if (node->type == XML_TEXT_NODE) {
type             1213 ext/simplexml/simplexml.c 			if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
type             1316 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type             1362 ext/simplexml/simplexml.c 			if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
type             1368 ext/simplexml/simplexml.c 				if (nodeptr->type == XML_TEXT_NODE) {
type             1370 ext/simplexml/simplexml.c 				} else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
type             1436 ext/simplexml/simplexml.c 			if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
type             1465 ext/simplexml/simplexml.c 		if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
type             1527 ext/simplexml/simplexml.c 			if (node->type == XML_ELEMENT_NODE) {
type             1554 ext/simplexml/simplexml.c 		if (node->type == XML_ELEMENT_NODE) {
type             1556 ext/simplexml/simplexml.c 		} else if (node->type == XML_ATTRIBUTE_NODE && node->ns) {
type             1567 ext/simplexml/simplexml.c 	if (node->type == XML_ELEMENT_NODE) {
type             1628 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type             1678 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type             1712 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type             1780 ext/simplexml/simplexml.c 	if (node && node->type != XML_ELEMENT_NODE) {
type             1802 ext/simplexml/simplexml.c 	if (attrp != NULL && attrp->type != XML_ATTRIBUTE_DECL) {
type             1829 ext/simplexml/simplexml.c static int cast_object(zval *object, int type, char *contents)
type             1837 ext/simplexml/simplexml.c 	switch (type) {
type             1859 ext/simplexml/simplexml.c static int sxe_object_cast_ex(zval *readobj, zval *writeobj, int type)
type             1868 ext/simplexml/simplexml.c 	if (type == _IS_BOOL) {
type             1878 ext/simplexml/simplexml.c 	if (sxe->iter.type != SXE_ITER_NONE) {
type             1901 ext/simplexml/simplexml.c 	rv = cast_object(writeobj, type, (char *)contents);
type             1912 ext/simplexml/simplexml.c static int sxe_object_cast(zval *readobj, zval *writeobj, int type)
type             1914 ext/simplexml/simplexml.c 	if (type == IS_STRING
type             1920 ext/simplexml/simplexml.c 	return sxe_object_cast_ex(readobj, writeobj, type);
type             2063 ext/simplexml/simplexml.c 	clone->iter.type = sxe->iter.type;
type             2162 ext/simplexml/simplexml.c 	intern->iter.type = SXE_ITER_NONE;
type             2345 ext/simplexml/simplexml.c 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
type             2348 ext/simplexml/simplexml.c 				if (node->type == XML_ATTRIBUTE_NODE) {
type             2357 ext/simplexml/simplexml.c 				if (node->type == XML_ATTRIBUTE_NODE) {
type             2365 ext/simplexml/simplexml.c 	} else if (sxe->iter.type == SXE_ITER_ELEMENT && sxe->iter.name) {
type             2367 ext/simplexml/simplexml.c 			if (node->type == XML_ELEMENT_NODE) {
type             2376 ext/simplexml/simplexml.c 			if (node->type == XML_ELEMENT_NODE) {
type             2405 ext/simplexml/simplexml.c 		switch (sxe->iter.type) {
type             2555 ext/simplexml/simplexml.c 		if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
type             2560 ext/simplexml/simplexml.c 	if (nodep && nodep->type == XML_ELEMENT_NODE) {
type              143 ext/simplexml/sxe.c 	if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
type              152 ext/simplexml/sxe.c 	while (node && node->type != XML_ELEMENT_NODE) {
type              170 ext/simplexml/sxe.c 	if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
type              119 ext/snmp/php_snmp.h 	char type;
type              184 ext/snmp/snmp.c 	ZEND_ARG_INFO(0, type)
type              243 ext/snmp/snmp.c 	ZEND_ARG_INFO(0, type)
type              310 ext/snmp/snmp.c 	ZEND_ARG_INFO(0, type)
type              364 ext/snmp/snmp.c 	ZEND_ARG_INFO(0, type)
type              511 ext/snmp/snmp.c static void php_snmp_error(zval *object, const char *docref, int type, const char *format, ...)
type              518 ext/snmp/snmp.c 		if (type == PHP_SNMP_ERRNO_NOERROR) {
type              525 ext/snmp/snmp.c 		snmp_object->snmp_errno = type;
type              528 ext/snmp/snmp.c 	if (type == PHP_SNMP_ERRNO_NOERROR) {
type              532 ext/snmp/snmp.c 	if (object && (snmp_object->exceptions_enabled & type)) {
type              533 ext/snmp/snmp.c 		zend_throw_exception_ex(php_snmp_exception_ce, type, "%s", snmp_object->snmp_errstr);
type              603 ext/snmp/snmp.c 		switch (vars->type) {
type              671 ext/snmp/snmp.c 			php_error_docref(NULL, E_WARNING, "Unknown value type: %u", vars->type);
type              681 ext/snmp/snmp.c 		add_property_long(snmpval, "type", vars->type);
type              766 ext/snmp/snmp.c 					if ((snmp_errno = snmp_add_var(pdu, objid_query->vars[objid_query->offset].name, objid_query->vars[objid_query->offset].name_length, objid_query->vars[objid_query->offset].type, objid_query->vars[objid_query->offset].value))) {
type              768 ext/snmp/snmp.c 						php_snmp_error(getThis(), NULL, PHP_SNMP_ERRNO_OID_PARSING_ERROR, "Could not add variable: OID='%s' type='%c' value='%s': %s", buf, objid_query->vars[objid_query->offset].type, objid_query->vars[objid_query->offset].value, snmp_api_errstring(snmp_errno));
type              802 ext/snmp/snmp.c 					if ( 	vars->type == SNMP_ENDOFMIBVIEW ||
type              803 ext/snmp/snmp.c 						vars->type == SNMP_NOSUCHOBJECT ||
type              804 ext/snmp/snmp.c 						vars->type == SNMP_NOSUCHINSTANCE ) {
type              962 ext/snmp/snmp.c static int php_snmp_parse_oid(zval *object, int st, struct objid_query *objid_query, zval *oid, zval *type, zval *value)
type              973 ext/snmp/snmp.c 		if (Z_TYPE_P(type) != IS_ARRAY) {
type              974 ext/snmp/snmp.c 			convert_to_string_ex(type);
type              993 ext/snmp/snmp.c 			if (Z_TYPE_P(type) == IS_STRING && Z_TYPE_P(value) == IS_STRING) {
type              994 ext/snmp/snmp.c 				if (Z_STRLEN_P(type) != 1) {
type              995 ext/snmp/snmp.c 					php_error_docref(NULL, E_WARNING, "Bogus type '%s', should be single char, got %u", Z_STRVAL_P(type), Z_STRLEN_P(type));
type              999 ext/snmp/snmp.c 				pptr = Z_STRVAL_P(type);
type             1000 ext/snmp/snmp.c 				objid_query->vars[objid_query->count].type = *pptr;
type             1025 ext/snmp/snmp.c 				if (Z_TYPE_P(type) == IS_STRING) {
type             1026 ext/snmp/snmp.c 					pptr = Z_STRVAL_P(type);
type             1027 ext/snmp/snmp.c 					objid_query->vars[objid_query->count].type = *pptr;
type             1028 ext/snmp/snmp.c 				} else if (Z_TYPE_P(type) == IS_ARRAY) {
type             1029 ext/snmp/snmp.c 					while (idx_type < Z_ARRVAL_P(type)->nNumUsed) {
type             1030 ext/snmp/snmp.c 						tmp_type = &Z_ARRVAL_P(type)->arData[idx_type].val;
type             1036 ext/snmp/snmp.c 					if (idx_type < Z_ARRVAL_P(type)->nNumUsed) {
type             1044 ext/snmp/snmp.c 						objid_query->vars[objid_query->count].type = *pptr;
type             1416 ext/snmp/snmp.c 	zval *oid, *value, *type;
type             1438 ext/snmp/snmp.c 					&a4, &a4_len, &a5, &a5_len, &a6, &a6_len, &a7, &a7_len, &oid, &type, &value, &timeout, &retries) == FAILURE) {
type             1453 ext/snmp/snmp.c 				if (zend_parse_parameters(argc, "sszzz|ll", &a1, &a1_len, &a2, &a2_len, &oid, &type, &value, &timeout, &retries) == FAILURE) {
type             1468 ext/snmp/snmp.c 			if (zend_parse_parameters(argc, "zzz", &oid, &type, &value) == FAILURE) {
type             1494 ext/snmp/snmp.c 	if (!php_snmp_parse_oid(getThis(), st, &objid_query, oid, type, value)) {
type             1961 ext/snmp/snmp.c zval *php_snmp_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type             1988 ext/snmp/snmp.c 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
type               32 ext/soap/php_encoding.c static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               33 ext/soap/php_encoding.c static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               34 ext/soap/php_encoding.c static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               35 ext/soap/php_encoding.c static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               36 ext/soap/php_encoding.c static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               37 ext/soap/php_encoding.c static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               38 ext/soap/php_encoding.c static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               39 ext/soap/php_encoding.c static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               40 ext/soap/php_encoding.c static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               41 ext/soap/php_encoding.c static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data);
type               43 ext/soap/php_encoding.c static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               44 ext/soap/php_encoding.c static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               45 ext/soap/php_encoding.c static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               48 ext/soap/php_encoding.c static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               49 ext/soap/php_encoding.c static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               50 ext/soap/php_encoding.c static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               53 ext/soap/php_encoding.c static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               56 ext/soap/php_encoding.c static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               57 ext/soap/php_encoding.c static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               63 ext/soap/php_encoding.c static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent);
type               64 ext/soap/php_encoding.c static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               65 ext/soap/php_encoding.c static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               66 ext/soap/php_encoding.c static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               67 ext/soap/php_encoding.c static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               68 ext/soap/php_encoding.c static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               69 ext/soap/php_encoding.c static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               70 ext/soap/php_encoding.c static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               71 ext/soap/php_encoding.c static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               72 ext/soap/php_encoding.c static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               74 ext/soap/php_encoding.c static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data);
type               75 ext/soap/php_encoding.c static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data);
type               77 ext/soap/php_encoding.c static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               78 ext/soap/php_encoding.c static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               80 ext/soap/php_encoding.c static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data);
type               81 ext/soap/php_encoding.c static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               84 ext/soap/php_encoding.c static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data);
type               85 ext/soap/php_encoding.c static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type               94 ext/soap/php_encoding.c static void set_xsi_type(xmlNodePtr node, char *type);
type               96 ext/soap/php_encoding.c static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret);
type               97 ext/soap/php_encoding.c static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type);
type               99 ext/soap/php_encoding.c static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type);
type              272 ext/soap/php_encoding.c static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
type              278 ext/soap/php_encoding.c 		    if (strcmp(enc->details.type_str, type) == 0) {
type              598 ext/soap/php_encoding.c xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type              603 ext/soap/php_encoding.c 	if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) {
type              606 ext/soap/php_encoding.c 		if (call_user_function(EG(function_table), NULL, &type->map->to_xml, &return_value, 1, data) == FAILURE) {
type              624 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type              629 ext/soap/php_encoding.c zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node)
type              631 ext/soap/php_encoding.c 	if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
type              643 ext/soap/php_encoding.c 		if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data) == FAILURE) {
type              657 ext/soap/php_encoding.c static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              662 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type              678 ext/soap/php_encoding.c 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
type              689 ext/soap/php_encoding.c static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              694 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type              711 ext/soap/php_encoding.c 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
type              722 ext/soap/php_encoding.c static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              727 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type              744 ext/soap/php_encoding.c 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
type              755 ext/soap/php_encoding.c static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              762 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type              769 ext/soap/php_encoding.c 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
type              784 ext/soap/php_encoding.c static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              793 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type              795 ext/soap/php_encoding.c 		} else if (data->children->type != XML_CDATA_SECTION_NODE || data->children->next != NULL) {
type              830 ext/soap/php_encoding.c static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type              910 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type              915 ext/soap/php_encoding.c static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type              937 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type              942 ext/soap/php_encoding.c static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type              974 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type              979 ext/soap/php_encoding.c static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data)
type              985 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type             1017 ext/soap/php_encoding.c static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             1023 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type             1049 ext/soap/php_encoding.c static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             1069 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type             1074 ext/soap/php_encoding.c static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             1092 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type             1097 ext/soap/php_encoding.c static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             1103 ext/soap/php_encoding.c 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
type             1126 ext/soap/php_encoding.c static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             1141 ext/soap/php_encoding.c 		set_ns_and_type(ret, type);
type             1147 ext/soap/php_encoding.c static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             1153 ext/soap/php_encoding.c static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             1408 ext/soap/php_encoding.c static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce)
type             1412 ext/soap/php_encoding.c 	sdlTypePtr sdlType = type->sdl_type;
type             1418 ext/soap/php_encoding.c 	} else if (SOAP_GLOBAL(class_map) && type->type_str) {
type             1422 ext/soap/php_encoding.c 		if ((classname = zend_hash_str_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL &&
type             1431 ext/soap/php_encoding.c 		    sdlType->encode && type != &sdlType->encode->details) {
type             1463 ext/soap/php_encoding.c 		           type != &sdlType->encode->details) {
type             1481 ext/soap/php_encoding.c 			         (sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY &&
type             1482 ext/soap/php_encoding.c 			          sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) {
type             1573 ext/soap/php_encoding.c 			if (trav->type == XML_ELEMENT_NODE) {
type             1611 ext/soap/php_encoding.c static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             1613 ext/soap/php_encoding.c 	return to_zval_object_ex(ret, type, data, NULL);
type             1805 ext/soap/php_encoding.c static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             1809 ext/soap/php_encoding.c 	sdlTypePtr sdlType = type->sdl_type;
type             1816 ext/soap/php_encoding.c 			set_ns_and_type(xmlParam, type);
type             1829 ext/soap/php_encoding.c 		    sdlType->encode && type != &sdlType->encode->details) {
type             1855 ext/soap/php_encoding.c 		           sdlType->encode && type != &sdlType->encode->details) {
type             1951 ext/soap/php_encoding.c 			set_ns_and_type(xmlParam, type);
type             1986 ext/soap/php_encoding.c 			set_ns_and_type(xmlParam, type);
type             1993 ext/soap/php_encoding.c static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2105 ext/soap/php_encoding.c                                    sdlTypePtr type,
type             2130 ext/soap/php_encoding.c 	 			if (type) {
type             2131 ext/soap/php_encoding.c  					xmlNodeSetName(xparam, BAD_CAST(type->name));
type             2139 ext/soap/php_encoding.c  				add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style);
type             2149 ext/soap/php_encoding.c 	 			if (type) {
type             2150 ext/soap/php_encoding.c  					xmlNodeSetName(xparam, BAD_CAST(type->name));
type             2162 ext/soap/php_encoding.c 				add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
type             2173 ext/soap/php_encoding.c 	 			if (type) {
type             2174 ext/soap/php_encoding.c  					xmlNodeSetName(xparam, BAD_CAST(type->name));
type             2182 ext/soap/php_encoding.c  			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
type             2198 ext/soap/php_encoding.c static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2200 ext/soap/php_encoding.c 	sdlTypePtr sdl_type = type->sdl_type;
type             2223 ext/soap/php_encoding.c 				set_ns_and_type(xmlParam, type);
type             2456 ext/soap/php_encoding.c 			set_ns_and_type(xmlParam, type);
type             2465 ext/soap/php_encoding.c static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             2483 ext/soap/php_encoding.c 		char *type, *end, *ns;
type             2486 ext/soap/php_encoding.c 		parse_namespace(attr->children->content, &type, &ns);
type             2489 ext/soap/php_encoding.c 		end = strrchr(type,'[');
type             2496 ext/soap/php_encoding.c 			enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
type             2498 ext/soap/php_encoding.c 		efree(type);
type             2504 ext/soap/php_encoding.c 		char *type, *ns;
type             2507 ext/soap/php_encoding.c 		parse_namespace(attr->children->content, &type, &ns);
type             2510 ext/soap/php_encoding.c 			enc = get_encoder(SOAP_GLOBAL(sdl), (char*)nsptr->href, type);
type             2512 ext/soap/php_encoding.c 		efree(type);
type             2530 ext/soap/php_encoding.c 	} else if (type->sdl_type != NULL &&
type             2531 ext/soap/php_encoding.c 	           type->sdl_type->attributes != NULL &&
type             2532 ext/soap/php_encoding.c 	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
type             2536 ext/soap/php_encoding.c 		char *type, *end;
type             2538 ext/soap/php_encoding.c 		type = estrdup(ext->val);
type             2539 ext/soap/php_encoding.c 		end = strrchr(type,'[');
type             2544 ext/soap/php_encoding.c 			enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type);
type             2546 ext/soap/php_encoding.c 		efree(type);
type             2551 ext/soap/php_encoding.c 	} else if (type->sdl_type != NULL &&
type             2552 ext/soap/php_encoding.c 	           type->sdl_type->attributes != NULL &&
type             2553 ext/soap/php_encoding.c 	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
type             2562 ext/soap/php_encoding.c 		if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
type             2572 ext/soap/php_encoding.c 	} else if (type->sdl_type != NULL &&
type             2573 ext/soap/php_encoding.c 	           type->sdl_type->attributes != NULL &&
type             2574 ext/soap/php_encoding.c 	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
type             2581 ext/soap/php_encoding.c 		if (type->sdl_type && type->sdl_type->elements &&
type             2582 ext/soap/php_encoding.c 		    zend_hash_num_elements(type->sdl_type->elements) == 1 &&
type             2583 ext/soap/php_encoding.c 		    (zend_hash_internal_pointer_reset(type->sdl_type->elements),
type             2584 ext/soap/php_encoding.c 		     (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
type             2588 ext/soap/php_encoding.c 	} else if (type->sdl_type && type->sdl_type->elements &&
type             2589 ext/soap/php_encoding.c 	           zend_hash_num_elements(type->sdl_type->elements) == 1 &&
type             2590 ext/soap/php_encoding.c 	           (zend_hash_internal_pointer_reset(type->sdl_type->elements),
type             2591 ext/soap/php_encoding.c 	            (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
type             2616 ext/soap/php_encoding.c 		if (trav->type == XML_ELEMENT_NODE) {
type             2671 ext/soap/php_encoding.c static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2714 ext/soap/php_encoding.c 		set_ns_and_type(xmlParam, type);
type             2720 ext/soap/php_encoding.c static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             2766 ext/soap/php_encoding.c static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2785 ext/soap/php_encoding.c static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             2802 ext/soap/php_encoding.c 			if (enc && type == &enc->details) {
type             2833 ext/soap/php_encoding.c 					if (trav->type == XML_ELEMENT_NODE) {
type             2849 ext/soap/php_encoding.c 		add_property_long(&soapvar, "enc_type", enc->details.type);
type             2866 ext/soap/php_encoding.c static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent)
type             2925 ext/soap/php_encoding.c 		set_ns_and_type(xmlParam, type);
type             2930 ext/soap/php_encoding.c static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2933 ext/soap/php_encoding.c 	return to_xml_string(type, data, style, parent);
type             2936 ext/soap/php_encoding.c static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2938 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style, parent);
type             2941 ext/soap/php_encoding.c static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2944 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent);
type             2947 ext/soap/php_encoding.c static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2949 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent);
type             2952 ext/soap/php_encoding.c static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2954 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "%Y-%m", style, parent);
type             2957 ext/soap/php_encoding.c static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2959 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "%Y", style, parent);
type             2962 ext/soap/php_encoding.c static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2964 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "--%m-%d", style, parent);
type             2967 ext/soap/php_encoding.c static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2969 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "---%d", style, parent);
type             2972 ext/soap/php_encoding.c static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             2974 ext/soap/php_encoding.c 	return to_xml_datetime_ex(type, data, "--%m--", style, parent);
type             2987 ext/soap/php_encoding.c 		sdlTypePtr type;
type             2989 ext/soap/php_encoding.c 		ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) {
type             2990 ext/soap/php_encoding.c 			list_enc = type->encode;
type             3088 ext/soap/php_encoding.c static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data)
type             3118 ext/soap/php_encoding.c static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
type             3161 ext/soap/php_encoding.c 	sdlTypePtr type;
type             3163 ext/soap/php_encoding.c 	type = enc->sdl_type;
type             3164 ext/soap/php_encoding.c 	if (type == NULL) {
type             3196 ext/soap/php_encoding.c 	switch (type->kind) {
type             3198 ext/soap/php_encoding.c 			if (type->encode && enc != &type->encode->details) {
type             3199 ext/soap/php_encoding.c 				return master_to_zval_int(ret, type->encode, data);
type             3211 ext/soap/php_encoding.c 			if (type->encode &&
type             3212 ext/soap/php_encoding.c 			    (type->encode->details.type == IS_ARRAY ||
type             3213 ext/soap/php_encoding.c 			     type->encode->details.type == SOAP_ENC_ARRAY)) {
type             3225 ext/soap/php_encoding.c 	sdlTypePtr type;
type             3228 ext/soap/php_encoding.c 	type = enc->sdl_type;
type             3230 ext/soap/php_encoding.c 	if (type == NULL) {
type             3260 ext/soap/php_encoding.c 	switch(type->kind) {
type             3262 ext/soap/php_encoding.c 			if (type->encode && enc != &type->encode->details) {
type             3263 ext/soap/php_encoding.c 				ret = master_to_xml(type->encode, data, style, parent);
type             3277 ext/soap/php_encoding.c 			if (type->encode &&
type             3278 ext/soap/php_encoding.c 			    (type->encode->details.type == IS_ARRAY ||
type             3279 ext/soap/php_encoding.c 			     type->encode->details.type == SOAP_ENC_ARRAY)) {
type             3342 ext/soap/php_encoding.c static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type)
type             3344 ext/soap/php_encoding.c 	set_ns_and_type_ex(node, type->ns, type->type_str);
type             3347 ext/soap/php_encoding.c static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type)
type             3350 ext/soap/php_encoding.c 	get_type_str(node, ns, type, &nstype);
type             3361 ext/soap/php_encoding.c 		if (node->type == XML_ENTITY_REF_NODE ||
type             3362 ext/soap/php_encoding.c 		    node->type == XML_ENTITY_NODE ||
type             3363 ext/soap/php_encoding.c 		    node->type == XML_ENTITY_DECL) {
type             3366 ext/soap/php_encoding.c 		if (node->type == XML_ELEMENT_NODE) {
type             3442 ext/soap/php_encoding.c static void set_xsi_type(xmlNodePtr node, char *type)
type             3444 ext/soap/php_encoding.c 	set_ns_prop(node, XSI_NAMESPACE, "type", type);
type             3497 ext/soap/php_encoding.c static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type)
type             3505 ext/soap/php_encoding.c 		smart_str_appendl(type, "xsd:anyType", sizeof("xsd:anyType")-1);
type             3567 ext/soap/php_encoding.c 		smart_str_appendl(type, "xsd:anyType", sizeof("xsd:anyType")-1);
type             3578 ext/soap/php_encoding.c 				smart_str_appends(type, (char*)ns->prefix);
type             3579 ext/soap/php_encoding.c 				smart_str_appendc(type, ':');
type             3583 ext/soap/php_encoding.c 			smart_str_appends(type, cur_stype);
type             3584 ext/soap/php_encoding.c 			smart_str_0(type);
type             3593 ext/soap/php_encoding.c 			get_type_str(node, enc->details.ns, enc->details.type_str, type);
type             3600 ext/soap/php_encoding.c static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret)
type             3616 ext/soap/php_encoding.c 	smart_str_appendl(ret, type, strlen(type));
type              177 ext/soap/php_encoding.h 	int type;
type              186 ext/soap/php_encoding.h 	zval *(*to_zval)(zval *ret, encodeTypePtr type, xmlNodePtr data);
type              187 ext/soap/php_encoding.h 	xmlNodePtr (*to_xml)(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type              195 ext/soap/php_encoding.h xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
type              196 ext/soap/php_encoding.h zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node);
type               27 ext/soap/php_http.c static char *get_http_header_value(char *headers, char *type);
type             1329 ext/soap/php_http.c static char *get_http_header_value(char *headers, char *type)
type             1334 ext/soap/php_http.c 	typelen = strlen(type);
type             1342 ext/soap/php_http.c 		if (strncasecmp(pos, type, typelen) == 0) {
type               59 ext/soap/php_packet_soap.c 		if (trav->type == XML_ELEMENT_NODE) {
type              105 ext/soap/php_packet_soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type              115 ext/soap/php_packet_soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type              122 ext/soap/php_packet_soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type              254 ext/soap/php_packet_soap.c 	while (resp != NULL && resp->type != XML_ELEMENT_NODE) {
type              342 ext/soap/php_packet_soap.c 				while (val && val->type != XML_ELEMENT_NODE) {
type              396 ext/soap/php_packet_soap.c 			if (trav->type == XML_ELEMENT_NODE) {
type               47 ext/soap/php_schema.c static void schema_type_fixup(sdlCtx *ctx, sdlTypePtr type);
type               49 ext/soap/php_schema.c static encodePtr create_encoder(sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
type               60 ext/soap/php_schema.c 	smart_str_appends(&nscat, (char*)type);
type               77 ext/soap/php_schema.c 	enc->details.type_str = estrdup((char*)type);
type               89 ext/soap/php_schema.c static encodePtr get_create_encoder(sdlPtr sdl, sdlTypePtr cur_type, const xmlChar *ns, const xmlChar *type)
type               91 ext/soap/php_schema.c 	encodePtr enc = get_encoder(sdl, (char*)ns, (char*)type);
type               93 ext/soap/php_schema.c 		enc = create_encoder(sdl, cur_type, ns, type);
type              418 ext/soap/php_schema.c 		char *type, *ns;
type              421 ext/soap/php_schema.c 		parse_namespace(itemType->children->content, &type, &ns);
type              429 ext/soap/php_schema.c 			newType->name = estrdup(type);
type              432 ext/soap/php_schema.c 			newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));
type              440 ext/soap/php_schema.c 		if (type) {efree(type);}
type              502 ext/soap/php_schema.c 		char *type, *ns;
type              517 ext/soap/php_schema.c 			parse_namespace(BAD_CAST(start), &type, &ns);
type              525 ext/soap/php_schema.c 				newType->name = estrdup(type);
type              528 ext/soap/php_schema.c 				newType->encode = get_create_encoder(sdl, newType, nsptr->href, BAD_CAST(type));
type              536 ext/soap/php_schema.c 			if (type) {efree(type);}
type              645 ext/soap/php_schema.c 		char *type, *ns;
type              648 ext/soap/php_schema.c 		parse_namespace(base->children->content, &type, &ns);
type              651 ext/soap/php_schema.c 			cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
type              653 ext/soap/php_schema.c 		if (type) {efree(type);}
type              750 ext/soap/php_schema.c 		char *type, *ns;
type              753 ext/soap/php_schema.c 		parse_namespace(base->children->content, &type, &ns);
type              756 ext/soap/php_schema.c 			cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
type              758 ext/soap/php_schema.c 		if (type) {efree(type);}
type              875 ext/soap/php_schema.c 		char *type, *ns;
type              878 ext/soap/php_schema.c 		parse_namespace(base->children->content, &type, &ns);
type              881 ext/soap/php_schema.c 			cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
type              883 ext/soap/php_schema.c 		if (type) {efree(type);}
type              930 ext/soap/php_schema.c 		char *type, *ns;
type              933 ext/soap/php_schema.c 		parse_namespace(base->children->content, &type, &ns);
type              936 ext/soap/php_schema.c 			cur_type->encode = get_create_encoder(sdl, cur_type, nsptr->href, BAD_CAST(type));
type              938 ext/soap/php_schema.c 		if (type) {efree(type);}
type             1079 ext/soap/php_schema.c 			char *type, *ns;
type             1082 ext/soap/php_schema.c 			parse_namespace(ref->children->content, &type, &ns);
type             1096 ext/soap/php_schema.c 			smart_str_appends(&key, type);
type             1103 ext/soap/php_schema.c 			if (type) {efree(type);}
type             1491 ext/soap/php_schema.c 	xmlAttrPtr attrs, attr, ns, name, type, ref = NULL;
type             1514 ext/soap/php_schema.c 			char *type, *ns;
type             1517 ext/soap/php_schema.c 			parse_namespace(ref->children->content, &type, &ns);
type             1532 ext/soap/php_schema.c 			smart_str_appends(&nscat, type);
type             1533 ext/soap/php_schema.c 			newType->name = estrdup(type);
type             1535 ext/soap/php_schema.c 			if (type) {efree(type);}
type             1659 ext/soap/php_schema.c 	type = get_attribute(attrs, "type");
type             1660 ext/soap/php_schema.c 	if (type) {
type             1667 ext/soap/php_schema.c 		parse_namespace(type->children->content, &cptype, &str_ns);
type             1685 ext/soap/php_schema.c 			} else if (type != NULL) {
type             1693 ext/soap/php_schema.c 			} else if (type != NULL) {
type             1733 ext/soap/php_schema.c 	xmlAttrPtr attr, name, ref = NULL, type = NULL;
type             1806 ext/soap/php_schema.c 	type = get_attribute(attrType->properties, "type");
type             1807 ext/soap/php_schema.c 	if (type) {
type             1814 ext/soap/php_schema.c 		parse_namespace(type->children->content, &cptype, &str_ns);
type             1923 ext/soap/php_schema.c 			} else if (type != NULL) {
type             2228 ext/soap/php_schema.c static void schema_type_fixup(sdlCtx *ctx, sdlTypePtr type)
type             2233 ext/soap/php_schema.c 	if (type->ref != NULL) {
type             2235 ext/soap/php_schema.c 			tmp = (sdlTypePtr)schema_find_by_ref(ctx->sdl->elements, type->ref);
type             2237 ext/soap/php_schema.c 				type->kind = tmp->kind;
type             2238 ext/soap/php_schema.c 				type->encode = tmp->encode;
type             2240 ext/soap/php_schema.c 				  type->nillable = 1;
type             2243 ext/soap/php_schema.c 				  type->fixed = estrdup(tmp->fixed);
type             2246 ext/soap/php_schema.c 				  type->def = estrdup(tmp->def);
type             2248 ext/soap/php_schema.c 				type->form = tmp->form;
type             2249 ext/soap/php_schema.c 			} else if (strcmp(type->ref, SCHEMA_NAMESPACE ":schema") == 0) {
type             2250 ext/soap/php_schema.c 				type->encode = get_conversion(XSD_ANYXML);
type             2252 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: unresolved element 'ref' attribute '%s'", type->ref);
type             2255 ext/soap/php_schema.c 		efree(type->ref);
type             2256 ext/soap/php_schema.c 		type->ref = NULL;
type             2258 ext/soap/php_schema.c 	if (type->elements) {
type             2259 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_PTR(type->elements, tmp) {
type             2263 ext/soap/php_schema.c 	if (type->model) {
type             2264 ext/soap/php_schema.c 		schema_content_model_fixup(ctx, type->model);
type             2266 ext/soap/php_schema.c 	if (type->attributes) {
type             2270 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_KEY_PTR(type->attributes, index, str_key, attr) {
type             2274 ext/soap/php_schema.c 				schema_attributegroup_fixup(ctx, attr, type->attributes);
type             2275 ext/soap/php_schema.c 				zend_hash_index_del(type->attributes, index);
type             2285 ext/soap/php_schema.c 	sdlTypePtr type;
type             2293 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_PTR(ctx->attributeGroups, type) {
type             2294 ext/soap/php_schema.c 			schema_type_fixup(ctx, type);
type             2298 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_PTR(sdl->elements, type) {
type             2299 ext/soap/php_schema.c 			schema_type_fixup(ctx, type);
type             2303 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_PTR(sdl->groups, type) {
type             2304 ext/soap/php_schema.c 			schema_type_fixup(ctx, type);
type             2308 ext/soap/php_schema.c 		ZEND_HASH_FOREACH_PTR(sdl->types, type) {
type             2309 ext/soap/php_schema.c 			schema_type_fixup(ctx, type);
type             2372 ext/soap/php_schema.c 	sdlTypePtr type = Z_PTR_P(zv);
type             2374 ext/soap/php_schema.c 	if (type->name) {
type             2375 ext/soap/php_schema.c 		efree(type->name);
type             2377 ext/soap/php_schema.c 	if (type->namens) {
type             2378 ext/soap/php_schema.c 		efree(type->namens);
type             2380 ext/soap/php_schema.c 	if (type->def) {
type             2381 ext/soap/php_schema.c 		efree(type->def);
type             2383 ext/soap/php_schema.c 	if (type->fixed) {
type             2384 ext/soap/php_schema.c 		efree(type->fixed);
type             2386 ext/soap/php_schema.c 	if (type->elements) {
type             2387 ext/soap/php_schema.c 		zend_hash_destroy(type->elements);
type             2388 ext/soap/php_schema.c 		efree(type->elements);
type             2390 ext/soap/php_schema.c 	if (type->attributes) {
type             2391 ext/soap/php_schema.c 		zend_hash_destroy(type->attributes);
type             2392 ext/soap/php_schema.c 		efree(type->attributes);
type             2394 ext/soap/php_schema.c 	if (type->model) {
type             2396 ext/soap/php_schema.c 		ZVAL_PTR(&zv, type->model);
type             2399 ext/soap/php_schema.c 	if (type->restrictions) {
type             2400 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->minExclusive);
type             2401 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->minInclusive);
type             2402 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->maxExclusive);
type             2403 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->maxInclusive);
type             2404 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->totalDigits);
type             2405 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->fractionDigits);
type             2406 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->length);
type             2407 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->minLength);
type             2408 ext/soap/php_schema.c 		delete_restriction_var_int(type->restrictions->maxLength);
type             2409 ext/soap/php_schema.c 		delete_restriction_var_char_int(type->restrictions->whiteSpace);
type             2410 ext/soap/php_schema.c 		delete_restriction_var_char_int(type->restrictions->pattern);
type             2411 ext/soap/php_schema.c 		if (type->restrictions->enumeration) {
type             2412 ext/soap/php_schema.c 			zend_hash_destroy(type->restrictions->enumeration);
type             2413 ext/soap/php_schema.c 			efree(type->restrictions->enumeration);
type             2415 ext/soap/php_schema.c 		efree(type->restrictions);
type             2417 ext/soap/php_schema.c 	efree(type);
type             2422 ext/soap/php_schema.c 	sdlTypePtr type = Z_PTR_P(zv);
type             2423 ext/soap/php_schema.c 	if (type->name) {
type             2424 ext/soap/php_schema.c 		free(type->name);
type             2426 ext/soap/php_schema.c 	if (type->namens) {
type             2427 ext/soap/php_schema.c 		free(type->namens);
type             2429 ext/soap/php_schema.c 	if (type->def) {
type             2430 ext/soap/php_schema.c 		free(type->def);
type             2432 ext/soap/php_schema.c 	if (type->fixed) {
type             2433 ext/soap/php_schema.c 		free(type->fixed);
type             2435 ext/soap/php_schema.c 	if (type->elements) {
type             2436 ext/soap/php_schema.c 		zend_hash_destroy(type->elements);
type             2437 ext/soap/php_schema.c 		free(type->elements);
type             2439 ext/soap/php_schema.c 	if (type->attributes) {
type             2440 ext/soap/php_schema.c 		zend_hash_destroy(type->attributes);
type             2441 ext/soap/php_schema.c 		free(type->attributes);
type             2443 ext/soap/php_schema.c 	if (type->model) {
type             2444 ext/soap/php_schema.c 		delete_model_persistent_int(type->model);
type             2446 ext/soap/php_schema.c 	if (type->restrictions) {
type             2447 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->minExclusive);
type             2448 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->minInclusive);
type             2449 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->maxExclusive);
type             2450 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->maxInclusive);
type             2451 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->totalDigits);
type             2452 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->fractionDigits);
type             2453 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->length);
type             2454 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->minLength);
type             2455 ext/soap/php_schema.c 		delete_restriction_var_int_persistent(type->restrictions->maxLength);
type             2456 ext/soap/php_schema.c 		delete_restriction_var_char_persistent_int(type->restrictions->whiteSpace);
type             2457 ext/soap/php_schema.c 		delete_restriction_var_char_persistent_int(type->restrictions->pattern);
type             2458 ext/soap/php_schema.c 		if (type->restrictions->enumeration) {
type             2459 ext/soap/php_schema.c 			zend_hash_destroy(type->restrictions->enumeration);
type             2460 ext/soap/php_schema.c 			free(type->restrictions->enumeration);
type             2462 ext/soap/php_schema.c 		free(type->restrictions);
type             2464 ext/soap/php_schema.c 	free(type);
type               50 ext/soap/php_sdl.c encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
type               56 ext/soap/php_sdl.c 	parse_namespace(type, &cptype, &ns);
type               64 ext/soap/php_sdl.c 		enc = get_encoder_ex(sdl, (char*)type, xmlStrlen(type));
type               71 ext/soap/php_sdl.c static sdlTypePtr get_element(sdlPtr sdl, xmlNodePtr node, const xmlChar *type)
type               80 ext/soap/php_sdl.c 		parse_namespace(type, &cptype, &ns);
type               95 ext/soap/php_sdl.c 			} else if ((sdl_type = zend_hash_str_find_ptr(sdl->elements, (char*)type, type_len)) != NULL) {
type              100 ext/soap/php_sdl.c 			if ((sdl_type = zend_hash_str_find_ptr(sdl->elements, (char*)type, xmlStrlen(type))) != NULL) {
type              111 ext/soap/php_sdl.c encodePtr get_encoder(sdlPtr sdl, const char *ns, const char *type)
type              116 ext/soap/php_sdl.c 	int type_len = strlen(type);
type              122 ext/soap/php_sdl.c 	memcpy(nscat+ns_len+1, type, type_len);
type              141 ext/soap/php_sdl.c 		memcpy(enc_nscat+enc_ns_len+1, type, type_len);
type              180 ext/soap/php_sdl.c sdlBindingPtr get_binding_from_type(sdlPtr sdl, int type)
type              189 ext/soap/php_sdl.c 		if (binding->bindingType == type) {
type              679 ext/soap/php_sdl.c 		xmlAttrPtr element, type, name;
type              704 ext/soap/php_sdl.c 		type = get_attribute(part->properties, "type");
type              705 ext/soap/php_sdl.c 		if (type != NULL) {
type              706 ext/soap/php_sdl.c 			param->encode = get_encoder_from_prefix(ctx->sdl, part, type->children->content);
type              756 ext/soap/php_sdl.c 				xmlAttrPtr type, name, bindingAttr, location;
type              879 ext/soap/php_sdl.c 				type = get_attribute(binding->properties, "type");
type              880 ext/soap/php_sdl.c 				if (type == NULL) {
type              884 ext/soap/php_sdl.c 				ctype = strrchr((char*)type->children->content,':');
type              886 ext/soap/php_sdl.c 					ctype = (char*)type->children->content;
type             1179 ext/soap/php_sdl.c #define WSDL_CACHE_GET(ret,type,buf)   memcpy(&ret,*buf,sizeof(type)); *buf += sizeof(type);
type             1181 ext/soap/php_sdl.c #define WSDL_CACHE_GET_1(ret,type,buf) ret = (type)(**buf); (*buf)++;
type             1314 ext/soap/php_sdl.c static void sdl_deserialize_type(sdlTypePtr type, sdlTypePtr *types, encodePtr *encoders, char **in)
type             1319 ext/soap/php_sdl.c 	WSDL_CACHE_GET_1(type->kind, sdlTypeKind, in);
type             1320 ext/soap/php_sdl.c 	type->name = sdl_deserialize_string(in);
type             1321 ext/soap/php_sdl.c 	type->namens = sdl_deserialize_string(in);
type             1322 ext/soap/php_sdl.c 	type->def = sdl_deserialize_string(in);
type             1323 ext/soap/php_sdl.c 	type->fixed = sdl_deserialize_string(in);
type             1324 ext/soap/php_sdl.c 	type->ref = sdl_deserialize_string(in);
type             1325 ext/soap/php_sdl.c 	WSDL_CACHE_GET_1(type->nillable, char, in);
type             1326 ext/soap/php_sdl.c 	WSDL_CACHE_GET_1(type->form, sdlForm, in);
type             1329 ext/soap/php_sdl.c 	type->encode = encoders[i];
type             1333 ext/soap/php_sdl.c 		type->restrictions = emalloc(sizeof(sdlRestrictions));
type             1335 ext/soap/php_sdl.c 		type->restrictions->minExclusive = sdl_deserialize_resriction_int(in);
type             1336 ext/soap/php_sdl.c 		type->restrictions->minInclusive = sdl_deserialize_resriction_int(in);
type             1337 ext/soap/php_sdl.c 		type->restrictions->maxExclusive = sdl_deserialize_resriction_int(in);
type             1338 ext/soap/php_sdl.c 		type->restrictions->maxInclusive = sdl_deserialize_resriction_int(in);
type             1339 ext/soap/php_sdl.c 		type->restrictions->totalDigits = sdl_deserialize_resriction_int(in);
type             1340 ext/soap/php_sdl.c 		type->restrictions->fractionDigits = sdl_deserialize_resriction_int(in);
type             1341 ext/soap/php_sdl.c 		type->restrictions->length = sdl_deserialize_resriction_int(in);
type             1342 ext/soap/php_sdl.c 		type->restrictions->minLength = sdl_deserialize_resriction_int(in);
type             1343 ext/soap/php_sdl.c 		type->restrictions->maxLength = sdl_deserialize_resriction_int(in);
type             1344 ext/soap/php_sdl.c 		type->restrictions->whiteSpace = sdl_deserialize_resriction_char(in);
type             1345 ext/soap/php_sdl.c 		type->restrictions->pattern = sdl_deserialize_resriction_char(in);
type             1348 ext/soap/php_sdl.c 			type->restrictions->enumeration = emalloc(sizeof(HashTable));
type             1349 ext/soap/php_sdl.c 			zend_hash_init(type->restrictions->enumeration, i, NULL, delete_restriction_var_char, 0);
type             1352 ext/soap/php_sdl.c 				sdl_deserialize_key(type->restrictions->enumeration, x, in);
type             1356 ext/soap/php_sdl.c 			type->restrictions->enumeration = NULL;
type             1366 ext/soap/php_sdl.c 		type->elements = emalloc(sizeof(HashTable));
type             1367 ext/soap/php_sdl.c 		zend_hash_init(type->elements, i, NULL, delete_type, 0);
type             1371 ext/soap/php_sdl.c 			sdl_deserialize_key(type->elements, t, in);
type             1380 ext/soap/php_sdl.c 		type->attributes = emalloc(sizeof(HashTable));
type             1381 ext/soap/php_sdl.c 		zend_hash_init(type->attributes, i, NULL, delete_attribute, 0);
type             1385 ext/soap/php_sdl.c 			sdl_deserialize_key(type->attributes, attr, in);
type             1393 ext/soap/php_sdl.c 		type->model = sdl_deserialize_model(types, elements, in);
type             1406 ext/soap/php_sdl.c 	WSDL_CACHE_GET_INT(enc->details.type, in);
type             1603 ext/soap/php_sdl.c 	while (enc->details.type != END_KNOWN_TYPES) {
type             1616 ext/soap/php_sdl.c 	while (enc->details.type != END_KNOWN_TYPES) {
type             1818 ext/soap/php_sdl.c static void sdl_serialize_type_ref(sdlTypePtr type, HashTable *tmp_types, smart_str *out) {
type             1819 ext/soap/php_sdl.c 	if (type) {
type             1821 ext/soap/php_sdl.c 		if ((type_num = zend_hash_str_find(tmp_types, (char*)&type, sizeof(type))) != NULL) {
type             1915 ext/soap/php_sdl.c static void sdl_serialize_type(sdlTypePtr type, HashTable *tmp_encoders, HashTable *tmp_types, smart_str *out)
type             1920 ext/soap/php_sdl.c 	WSDL_CACHE_PUT_1(type->kind, out);
type             1921 ext/soap/php_sdl.c 	sdl_serialize_string(type->name, out);
type             1922 ext/soap/php_sdl.c 	sdl_serialize_string(type->namens, out);
type             1923 ext/soap/php_sdl.c 	sdl_serialize_string(type->def, out);
type             1924 ext/soap/php_sdl.c 	sdl_serialize_string(type->fixed, out);
type             1925 ext/soap/php_sdl.c 	sdl_serialize_string(type->ref, out);
type             1926 ext/soap/php_sdl.c 	WSDL_CACHE_PUT_1(type->nillable, out);
type             1927 ext/soap/php_sdl.c 	WSDL_CACHE_PUT_1(type->form, out);
type             1928 ext/soap/php_sdl.c 	sdl_serialize_encoder_ref(type->encode, tmp_encoders, out);
type             1930 ext/soap/php_sdl.c 	if (type->restrictions) {
type             1932 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->minExclusive,out);
type             1933 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->minInclusive,out);
type             1934 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->maxExclusive,out);
type             1935 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->maxInclusive,out);
type             1936 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->totalDigits,out);
type             1937 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->fractionDigits,out);
type             1938 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->length,out);
type             1939 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->minLength,out);
type             1940 ext/soap/php_sdl.c 		sdl_serialize_resriction_int(type->restrictions->maxLength,out);
type             1941 ext/soap/php_sdl.c 		sdl_serialize_resriction_char(type->restrictions->whiteSpace,out);
type             1942 ext/soap/php_sdl.c 		sdl_serialize_resriction_char(type->restrictions->pattern,out);
type             1943 ext/soap/php_sdl.c 		if (type->restrictions->enumeration) {
type             1944 ext/soap/php_sdl.c 			i = zend_hash_num_elements(type->restrictions->enumeration);
type             1953 ext/soap/php_sdl.c 			ZEND_HASH_FOREACH_STR_KEY_PTR(type->restrictions->enumeration, key, tmp) {
type             1961 ext/soap/php_sdl.c 	if (type->elements) {
type             1962 ext/soap/php_sdl.c 		i = zend_hash_num_elements(type->elements);
type             1975 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
type             1984 ext/soap/php_sdl.c 	if (type->attributes) {
type             1985 ext/soap/php_sdl.c 		i = zend_hash_num_elements(type->attributes);
type             1994 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
type             1999 ext/soap/php_sdl.c 	if (type->model) {
type             2001 ext/soap/php_sdl.c 		sdl_serialize_model(type->model, tmp_types, tmp_elements, out);
type             2013 ext/soap/php_sdl.c 	WSDL_CACHE_PUT_INT(enc->details.type, out);
type             2201 ext/soap/php_sdl.c 	while (enc->details.type != END_KNOWN_TYPES) {
type             2406 ext/soap/php_sdl.c static void make_persistent_sdl_type_ref(sdlTypePtr *type, HashTable *ptr_map, HashTable *bp_types)
type             2410 ext/soap/php_sdl.c 	if ((tmp = zend_hash_str_find_ptr(ptr_map, (char *)type, sizeof(sdlTypePtr))) != NULL) {
type             2411 ext/soap/php_sdl.c 		*type = tmp;
type             2413 ext/soap/php_sdl.c 		zend_hash_next_index_insert_ptr(bp_types, *type);
type             2696 ext/soap/php_sdl.c static sdlTypePtr make_persistent_sdl_type(sdlTypePtr type, HashTable *ptr_map, HashTable *bp_types, HashTable *bp_encoders)
type             2704 ext/soap/php_sdl.c 	*ptype = *type;
type             2730 ext/soap/php_sdl.c 		*ptype->restrictions = *type->restrictions;
type             2766 ext/soap/php_sdl.c 		if (type->restrictions->enumeration) {
type             2768 ext/soap/php_sdl.c 			zend_hash_init(ptype->restrictions->enumeration, zend_hash_num_elements(type->restrictions->enumeration), NULL, delete_restriction_var_char_persistent, 1);
type             2769 ext/soap/php_sdl.c 			zend_hash_copy(ptype->restrictions->enumeration, type->restrictions->enumeration, make_persistent_restriction_char);
type             2777 ext/soap/php_sdl.c 		zend_hash_init(ptype->elements, zend_hash_num_elements(type->elements), NULL, delete_type_persistent, 1);
type             2779 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->elements, key, tmp) {
type             2795 ext/soap/php_sdl.c 		zend_hash_init(ptype->attributes, zend_hash_num_elements(type->attributes), NULL, delete_attribute_persistent, 1);
type             2797 ext/soap/php_sdl.c 		ZEND_HASH_FOREACH_STR_KEY_PTR(type->attributes, key, tmp) {
type             2808 ext/soap/php_sdl.c 	if (type->model) {
type              259 ext/soap/php_sdl.h encodePtr get_encoder_from_prefix(sdlPtr sdl, xmlNodePtr data, const xmlChar *type);
type              260 ext/soap/php_sdl.h encodePtr get_encoder(sdlPtr sdl, const char *ns, const char *type);
type              263 ext/soap/php_sdl.h sdlBindingPtr get_binding_from_type(sdlPtr sdl, int type);
type              100 ext/soap/php_soap.h 	int        type;
type               54 ext/soap/php_xml.c 		if (trav->type == XML_TEXT_NODE) {
type               58 ext/soap/php_xml.c 		} else if ((trav->type != XML_ELEMENT_NODE) &&
type               59 ext/soap/php_xml.c 		           (trav->type != XML_CDATA_SECTION_NODE)) {
type               50 ext/soap/soap.c static void type_to_string(sdlTypePtr type, smart_str *buf, int level);
type              561 ext/soap/soap.c 		if (!zend_hash_index_exists(&defEncIndex, defaultEncoding[i].details.type)) {
type              562 ext/soap/soap.c 			zend_hash_index_update_ptr(&defEncIndex, defaultEncoding[i].details.type, enc);
type              565 ext/soap/soap.c 	} while (defaultEncoding[i].details.type != END_KNOWN_TYPES);
type              662 ext/soap/soap.c 		fe.type = ZEND_INTERNAL_FUNCTION;
type              989 ext/soap/soap.c 	zval *data, *type, *this_ptr;
type              993 ext/soap/soap.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "z!z|ssss", &data, &type, &stype, &stype_len, &ns, &ns_len, &name, &name_len, &namens, &namens_len) == FAILURE) {
type              998 ext/soap/soap.c 	if (Z_TYPE_P(type) == IS_NULL) {
type             1001 ext/soap/soap.c 		if (zend_hash_index_exists(&SOAP_GLOBAL(defEncIndex), Z_LVAL_P(type))) {
type             1002 ext/soap/soap.c 			add_property_long(this_ptr, "enc_type", Z_LVAL_P(type));
type             1085 ext/soap/soap.c 				new_enc->details.type = enc->details.type;
type             1091 ext/soap/soap.c 				new_enc->details.type = enc->details.type;
type             1232 ext/soap/soap.c 	service->type = SOAP_FUNCTIONS;
type             1273 ext/soap/soap.c 		if (service->type == SOAP_CLASS) {
type             1313 ext/soap/soap.c 		service->type = SOAP_CLASS;
type             1350 ext/soap/soap.c 	service->type = SOAP_OBJECT;
type             1375 ext/soap/soap.c 	if (service->type == SOAP_OBJECT) {
type             1377 ext/soap/soap.c 	} else if (service->type == SOAP_CLASS) {
type             1392 ext/soap/soap.c 			if ((service->type != SOAP_OBJECT && service->type != SOAP_CLASS) || (f->common.fn_flags & ZEND_ACC_PUBLIC)) {
type             1421 ext/soap/soap.c 		if (service->type == SOAP_FUNCTIONS) {
type             1688 ext/soap/soap.c 	if (service->type == SOAP_OBJECT) {
type             1691 ext/soap/soap.c 	} else if (service->type == SOAP_CLASS) {
type             1816 ext/soap/soap.c 			    ((service->type == SOAP_CLASS || service->type == SOAP_OBJECT) &&
type             1818 ext/soap/soap.c 				if (service->type == SOAP_CLASS || service->type == SOAP_OBJECT) {
type             1837 ext/soap/soap.c 					if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(soap_obj);}
type             1843 ext/soap/soap.c 					if (service->type == SOAP_CLASS && soap_obj) {zval_ptr_dtor(soap_obj);}
type             1855 ext/soap/soap.c 	    ((service->type == SOAP_CLASS || service->type == SOAP_OBJECT) &&
type             1857 ext/soap/soap.c 		if (service->type == SOAP_CLASS || service->type == SOAP_OBJECT) {
type             1859 ext/soap/soap.c 			if (service->type == SOAP_CLASS) {
type             1881 ext/soap/soap.c 		if (service->type == SOAP_CLASS) {
type             1920 ext/soap/soap.c 		if (service->type == SOAP_CLASS) {
type             3005 ext/soap/soap.c 		sdlTypePtr type;
type             3010 ext/soap/soap.c 			ZEND_HASH_FOREACH_PTR(sdl->types, type) {
type             3011 ext/soap/soap.c 				type_to_string(type, &buf, 0);
type             3380 ext/soap/soap.c 			if (trav->type == XML_ELEMENT_NODE) {
type             3400 ext/soap/soap.c 				if (trav->type == XML_ELEMENT_NODE) {
type             3467 ext/soap/soap.c 		if (trav->type == XML_ELEMENT_NODE) {
type             3505 ext/soap/soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type             3515 ext/soap/soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type             3522 ext/soap/soap.c 	while (trav != NULL && trav->type != XML_ELEMENT_NODE) {
type             3551 ext/soap/soap.c 		if (trav->type == XML_ELEMENT_NODE) {
type             3610 ext/soap/soap.c 			if (trav->type == XML_ELEMENT_NODE) {
type             4675 ext/soap/soap.c static void type_to_string(sdlTypePtr type, smart_str *buf, int level)
type             4686 ext/soap/soap.c 	switch (type->kind) {
type             4688 ext/soap/soap.c 			if (type->encode) {
type             4689 ext/soap/soap.c 				smart_str_appendl(buf, type->encode->details.type_str, strlen(type->encode->details.type_str));
type             4694 ext/soap/soap.c 			smart_str_appendl(buf, type->name, strlen(type->name));
type             4698 ext/soap/soap.c 			smart_str_appendl(buf, type->name, strlen(type->name));
type             4699 ext/soap/soap.c 			if (type->elements) {
type             4703 ext/soap/soap.c 				ZEND_HASH_FOREACH_PTR(type->elements, item_type) {
type             4711 ext/soap/soap.c 			smart_str_appendl(buf, type->name, strlen(type->name));
type             4712 ext/soap/soap.c 			if (type->elements) {
type             4717 ext/soap/soap.c 				ZEND_HASH_FOREACH_PTR(type->elements, item_type) {
type             4730 ext/soap/soap.c 			if (type->encode &&
type             4731 ext/soap/soap.c 			    (type->encode->details.type == IS_ARRAY ||
type             4732 ext/soap/soap.c 			     type->encode->details.type == SOAP_ENC_ARRAY)) {
type             4736 ext/soap/soap.c 				if (type->attributes &&
type             4737 ext/soap/soap.c 				    (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
type             4754 ext/soap/soap.c 					smart_str_appendl(buf, type->name, strlen(type->name));
type             4760 ext/soap/soap.c 					if (type->attributes &&
type             4761 ext/soap/soap.c 					    (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
type             4767 ext/soap/soap.c 					} else if (type->elements &&
type             4768 ext/soap/soap.c 					           zend_hash_num_elements(type->elements) == 1 &&
type             4769 ext/soap/soap.c 					           (zend_hash_internal_pointer_reset(type->elements),
type             4770 ext/soap/soap.c 					            (elementType = zend_hash_get_current_data_ptr(type->elements)) != NULL) &&
type             4777 ext/soap/soap.c 					smart_str_appendl(buf, type->name, strlen(type->name));
type             4778 ext/soap/soap.c 					if (type->attributes &&
type             4779 ext/soap/soap.c 					    (attr = zend_hash_str_find_ptr(type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
type             4792 ext/soap/soap.c 				smart_str_appendl(buf, type->name, strlen(type->name));
type             4795 ext/soap/soap.c 				if ((type->kind == XSD_TYPEKIND_RESTRICTION ||
type             4796 ext/soap/soap.c 				     type->kind == XSD_TYPEKIND_EXTENSION) && type->encode) {
type             4797 ext/soap/soap.c 					encodePtr enc = type->encode;
type             4810 ext/soap/soap.c 						smart_str_appendl(buf, type->encode->details.type_str, strlen(type->encode->details.type_str));
type             4814 ext/soap/soap.c 				if (type->model) {
type             4815 ext/soap/soap.c 					model_to_string(type->model, buf, level+1);
type             4817 ext/soap/soap.c 				if (type->attributes) {
type             4820 ext/soap/soap.c 					ZEND_HASH_FOREACH_PTR(type->attributes, attr) {
type              716 ext/sockets/conversions.c 		family = ctx->sock->type;
type              722 ext/sockets/conversions.c 		if (ctx->sock->type != AF_INET && ctx->sock->type != AF_INET6) {
type              737 ext/sockets/conversions.c 		if (ctx->sock->type != AF_INET6) {
type              752 ext/sockets/conversions.c 		if (ctx->sock->type != AF_UNIX) {
type              836 ext/sockets/conversions.c 						type;
type              859 ext/sockets/conversions.c 	from_zval_write_aggregation(arr, (char *)&type, descriptor_type, ctx);
type              864 ext/sockets/conversions.c 	entry = get_ancillary_reg_entry(level, type);
type              867 ext/sockets/conversions.c 				level, type);
type              898 ext/sockets/conversions.c 	cmsghdr->cmsg_type	= type;
type              471 ext/sockets/multicast.c 	if (sock->type == AF_INET) {
type              491 ext/sockets/multicast.c 	else if (sock->type == AF_INET6) {
type              536 ext/sockets/multicast.c 	if (sock->type == AF_INET) {
type              559 ext/sockets/multicast.c 	else if (sock->type == AF_INET6) {
type               61 ext/sockets/php_sockets.h 	int			type;
type              101 ext/sockets/sendrecvmsg.c #define PUT_ENTRY(sizev, var_size, calc, from, to, level, type) \
type              108 ext/sockets/sendrecvmsg.c 	key.cmsg_type		= type; \
type              281 ext/sockets/sendrecvmsg.c 						type,
type              286 ext/sockets/sendrecvmsg.c 			&level, &type, &n) == FAILURE) {
type              291 ext/sockets/sendrecvmsg.c 	LONG_CHECK_VALID_INT(type);
type              300 ext/sockets/sendrecvmsg.c 	entry = get_ancillary_reg_entry(level, type);
type              303 ext/sockets/sendrecvmsg.c 				"not supported by PHP", level, type);
type              117 ext/sockets/sockaddr_conv.c 	if (php_sock->type == AF_INET) {
type              127 ext/sockets/sockaddr_conv.c 	else if (php_sock->type == AF_INET6) {
type              144 ext/sockets/sockets.c 	ZEND_ARG_INFO(0, type)
type              161 ext/sockets/sockets.c 	ZEND_ARG_INFO(0, type)
type              229 ext/sockets/sockets.c 	ZEND_ARG_INFO(0, type)
type              268 ext/sockets/sockets.c 	ZEND_ARG_INFO(0, type)
type              395 ext/sockets/sockets.c 	php_sock->type		 = PF_UNSPEC;
type              449 ext/sockets/sockets.c 	sock->type = PF_INET;
type              485 ext/sockets/sockets.c 	out_sock->type = la->sa_family;
type             1141 ext/sockets/sockets.c 	zend_long		length, type = PHP_BINARY_READ;
type             1143 ext/sockets/sockets.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|l", &arg1, &length, &type) == FAILURE) {
type             1158 ext/sockets/sockets.c 	if (type == PHP_NORMAL_READ) {
type             1384 ext/sockets/sockets.c 	php_sock->type = arg1;
type             1420 ext/sockets/sockets.c 	switch(php_sock->type) {
type             1478 ext/sockets/sockets.c 			php_error_docref(NULL, E_WARNING, "Unsupported socket type %d", php_sock->type);
type             1526 ext/sockets/sockets.c 	switch(php_sock->type) {
type             1577 ext/sockets/sockets.c 			php_error_docref(NULL, E_WARNING, "unsupported socket type '%d', must be AF_UNIX, AF_INET, or AF_INET6", php_sock->type);
type             1700 ext/sockets/sockets.c 	switch (php_sock->type) {
type             1785 ext/sockets/sockets.c 			php_error_docref(NULL, E_WARNING, "Unsupported socket type %d", php_sock->type);
type             1818 ext/sockets/sockets.c 	switch (php_sock->type) {
type             1860 ext/sockets/sockets.c 			php_error_docref(NULL, E_WARNING, "Unsupported socket type %d", php_sock->type);
type             2136 ext/sockets/sockets.c 	zend_long		domain, type, protocol;
type             2138 ext/sockets/sockets.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "lllz/", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
type             2154 ext/sockets/sockets.c 	if (type > 10) {
type             2155 ext/sockets/sockets.c 		php_error_docref(NULL, E_WARNING, "invalid socket type [%pd] specified for argument 2, assuming SOCK_STREAM", type);
type             2156 ext/sockets/sockets.c 		type = SOCK_STREAM;
type             2159 ext/sockets/sockets.c 	if (socketpair(domain, type, protocol, fds_array) != 0) {
type             2172 ext/sockets/sockets.c 	php_sock[0]->type		= domain;
type             2173 ext/sockets/sockets.c 	php_sock[1]->type		= domain;
type             2266 ext/sockets/sockets.c 	int						type;
type             2267 ext/sockets/sockets.c 	socklen_t				type_len = sizeof(type);
type             2281 ext/sockets/sockets.c     if (getsockopt(socket, SOL_SOCKET, SO_DOMAIN, &type, &type_len) == 0) {
type             2282 ext/sockets/sockets.c 		retsock->type = type;
type             2286 ext/sockets/sockets.c 		retsock->type = addr.ss_family;
type              351 ext/spl/php_spl.c 		while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
type              519 ext/spl/php_spl.c 		} else if (fcc.function_handler->type == ZEND_INTERNAL_FUNCTION &&
type              278 ext/spl/spl_array.c static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval *offset, int type) /* {{{ */
type              290 ext/spl/spl_array.c 	if ((type == BP_VAR_W || type == BP_VAR_RW) && intern->nApplyCount > 0) {
type              308 ext/spl/spl_array.c 					switch (type) {
type              324 ext/spl/spl_array.c 			switch (type) {
type              358 ext/spl/spl_array.c 			switch (type) {
type              380 ext/spl/spl_array.c 		return (type == BP_VAR_W || type == BP_VAR_RW) ?
type              385 ext/spl/spl_array.c static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type, zval *rv) /* {{{ */
type              408 ext/spl/spl_array.c 	ret = spl_array_get_dimension_ptr(check_inherited, object, offset, type);
type              415 ext/spl/spl_array.c 	if ((type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) &&
type              424 ext/spl/spl_array.c static zval *spl_array_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
type              426 ext/spl/spl_array.c 	return spl_array_read_dimension_ex(1, object, offset, type, rv);
type              853 ext/spl/spl_array.c static zval *spl_array_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
type              859 ext/spl/spl_array.c 		return spl_array_read_dimension(object, member, type, rv);
type              861 ext/spl/spl_array.c 	return std_object_handlers.read_property(object, member, type, cache_slot, rv);
type              876 ext/spl/spl_array.c static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              882 ext/spl/spl_array.c 		return spl_array_get_dimension_ptr(1, object, member, type);
type              884 ext/spl/spl_array.c 	return std_object_handlers.get_property_ptr_ptr(object, member, type, cache_slot);
type               91 ext/spl/spl_directory.c 	switch(intern->type) {
type              175 ext/spl/spl_directory.c 	if (intern->type == SPL_FS_DIR) {
type              191 ext/spl/spl_directory.c 	switch (intern->type) {
type              234 ext/spl/spl_directory.c 	intern->type = SPL_FS_DIR;
type              264 ext/spl/spl_directory.c 	intern->type = SPL_FS_FILE;
type              339 ext/spl/spl_directory.c 	switch (source->type) {
type              454 ext/spl/spl_directory.c static spl_filesystem_object *spl_filesystem_object_create_type(int ht, spl_filesystem_object *source, int type, zend_class_entry *ce, zval *return_value) /* {{{ */
type              463 ext/spl/spl_directory.c 	switch (source->type) {
type              475 ext/spl/spl_directory.c 	switch (type) {
type              561 ext/spl/spl_directory.c 	switch (intern->type) {
type              614 ext/spl/spl_directory.c 	if (intern->type == SPL_FS_DIR) {
type              634 ext/spl/spl_directory.c 	if (intern->type == SPL_FS_FILE) {
type             1279 ext/spl/spl_directory.c 	if (intern->type == SPL_FS_DIR && !intern->file_name && intern->u.dir.entry.d_name[0]) {
type             1833 ext/spl/spl_directory.c static int spl_filesystem_object_cast(zval *readobj, zval *writeobj, int type)
type             1837 ext/spl/spl_directory.c 	if (type == IS_STRING) {
type             1839 ext/spl/spl_directory.c 			return std_object_handlers.cast_object(readobj, writeobj, type);
type             1842 ext/spl/spl_directory.c 		switch (intern->type) {
type             1869 ext/spl/spl_directory.c 	} else if (type == _IS_BOOL) {
type               70 ext/spl/spl_directory.h 	SPL_FS_OBJ_TYPE    type;
type              355 ext/spl/spl_fixedarray.c static zval *spl_fixedarray_object_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
type             21398 ext/sqlite3/libsqlite/sqlite3.c   etByte type;             /* Conversion paradigm */
type             21664 ext/sqlite3/libsqlite/sqlite3.c           xtype = infop->type;
type             34963 ext/sqlite3/libsqlite/sqlite3.c SQLITE_API int SQLITE_STDCALL sqlite3_win32_set_directory(DWORD type, LPCWSTR zValue){
type             34969 ext/sqlite3/libsqlite/sqlite3.c   if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){
type             34971 ext/sqlite3/libsqlite/sqlite3.c   }else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){
type             34974 ext/sqlite3/libsqlite/sqlite3.c   assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE
type             34975 ext/sqlite3/libsqlite/sqlite3.c           || type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE
type             36380 ext/sqlite3/libsqlite/sqlite3.c   int type;
type             36387 ext/sqlite3/libsqlite/sqlite3.c   type = pFile->locktype;
type             36388 ext/sqlite3/libsqlite/sqlite3.c   if( type>=EXCLUSIVE_LOCK ){
type             36397 ext/sqlite3/libsqlite/sqlite3.c   if( type>=RESERVED_LOCK ){
type             36400 ext/sqlite3/libsqlite/sqlite3.c   if( locktype==NO_LOCK && type>=SHARED_LOCK ){
type             36403 ext/sqlite3/libsqlite/sqlite3.c   if( type>=PENDING_LOCK ){
type             77490 ext/sqlite3/libsqlite/sqlite3.c     u32 type = pC->aType[p->iCol];
type             77491 ext/sqlite3/libsqlite/sqlite3.c     if( type<12 ){
type             77493 ext/sqlite3/libsqlite/sqlite3.c           type==0?"null": type==7?"real": "integer"
type             77500 ext/sqlite3/libsqlite/sqlite3.c       p->nByte = sqlite3VdbeSerialTypeLen(type);
type             82775 ext/sqlite3/libsqlite/sqlite3.c   int type,           /* NC_IsCheck or NC_PartIdx */
type             82783 ext/sqlite3/libsqlite/sqlite3.c   assert( type==NC_IsCheck || type==NC_PartIdx );
type             82792 ext/sqlite3/libsqlite/sqlite3.c   sNC.ncFlags = type;
type             90269 ext/sqlite3/libsqlite/sqlite3.c   int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
type             90301 ext/sqlite3/libsqlite/sqlite3.c     rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
type             90326 ext/sqlite3/libsqlite/sqlite3.c     sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
type             94594 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
type             94608 ext/sqlite3/libsqlite/sqlite3.c   if( type!=TK_DEFERRED ){
type             94610 ext/sqlite3/libsqlite/sqlite3.c       sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
type             97844 ext/sqlite3/libsqlite/sqlite3.c   int type;
type             97848 ext/sqlite3/libsqlite/sqlite3.c   type = sqlite3_value_numeric_type(argv[0]);
type             97849 ext/sqlite3/libsqlite/sqlite3.c   if( p && type!=SQLITE_NULL ){
type             97851 ext/sqlite3/libsqlite/sqlite3.c     if( type==SQLITE_INTEGER ){
type             123290 ext/sqlite3/libsqlite/sqlite3.c struct AttachKey { int type;  Token key; };
type               43 ext/sqlite3/php_sqlite3_structs.h 	zend_long type;
type             1420 ext/sqlite3/sqlite3.c 	param.type = SQLITE3_TEXT;
type             1422 ext/sqlite3/sqlite3.c 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "lz|l", &param.param_number, &parameter, &param.type) == FAILURE) {
type             1423 ext/sqlite3/sqlite3.c 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &param.name, &parameter, &param.type) == FAILURE) {
type             1455 ext/sqlite3/sqlite3.c 	param.type = SQLITE3_TEXT;
type             1457 ext/sqlite3/sqlite3.c 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "lz/|l", &param.param_number, &parameter, &param.type) == FAILURE) {
type             1458 ext/sqlite3/sqlite3.c 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz/|l", &param.name, &parameter, &param.type) == FAILURE) {
type             1513 ext/sqlite3/sqlite3.c 			switch (param->type) {
type             1562 ext/sqlite3/sqlite3.c 					php_sqlite3_error(stmt_obj->db_obj, "Unknown parameter type: %pd for parameter %pd", param->type, param->param_number);
type             1890 ext/sqlite3/sqlite3.c 	ZEND_ARG_INFO(0, type)
type             1896 ext/sqlite3/sqlite3.c 	ZEND_ARG_INFO(0, type)
type              967 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, type)
type              973 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, type)
type             1941 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, type)
type             2502 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, type)
type             5175 ext/standard/basic_functions.c 	file_handle.type = ZEND_HANDLE_FILENAME;
type             5916 ext/standard/basic_functions.c 	fh.type = ZEND_HANDLE_FILENAME;
type              246 ext/standard/browscap.c 	fh.type = ZEND_HANDLE_FP;
type               17 ext/standard/crypt_sha256.c #  define __alignof__(type) offsetof (struct { char c; type member;}, member)
type               16 ext/standard/crypt_sha512.c #  define __alignof__(type) offsetof (struct { char c; type member;}, member)
type               90 ext/standard/dl.c PHPAPI int php_load_extension(char *filename, int type, int start_now)
type               99 ext/standard/dl.c 	if (type == MODULE_PERSISTENT) {
type              105 ext/standard/dl.c 	if (type == MODULE_TEMPORARY) {
type              114 ext/standard/dl.c 		if (type == MODULE_TEMPORARY) {
type              192 ext/standard/dl.c 	module_entry->type = type;
type              201 ext/standard/dl.c 	if ((type == MODULE_TEMPORARY || start_now) && zend_startup_module_ex(module_entry) == FAILURE) {
type              206 ext/standard/dl.c 	if ((type == MODULE_TEMPORARY || start_now) && module_entry->request_startup_func) {
type              207 ext/standard/dl.c 		if (module_entry->request_startup_func(type, module_entry->module_number) == FAILURE) {
type              219 ext/standard/dl.c PHPAPI void php_dl(char *file, int type, zval *return_value, int start_now)
type              222 ext/standard/dl.c 	if (php_load_extension(file, type, start_now) == FAILURE) {
type              237 ext/standard/dl.c PHPAPI void php_dl(char *file, int type, zval *return_value, int start_now)
type               26 ext/standard/dl.h PHPAPI int php_load_extension(char *filename, int type, int start_now);
type               27 ext/standard/dl.h PHPAPI void php_dl(char *file, int type, zval *return_value, int start_now);
type              361 ext/standard/dns.c 	int type = T_MX, i;
type              381 ext/standard/dns.c 		if (!strcasecmp("A",     rectype)) type = T_A;
type              382 ext/standard/dns.c 		else if (!strcasecmp("NS",    rectype)) type = DNS_T_NS;
type              383 ext/standard/dns.c 		else if (!strcasecmp("MX",    rectype)) type = DNS_T_MX;
type              384 ext/standard/dns.c 		else if (!strcasecmp("PTR",   rectype)) type = DNS_T_PTR;
type              385 ext/standard/dns.c 		else if (!strcasecmp("ANY",   rectype)) type = DNS_T_ANY;
type              386 ext/standard/dns.c 		else if (!strcasecmp("SOA",   rectype)) type = DNS_T_SOA;
type              387 ext/standard/dns.c 		else if (!strcasecmp("TXT",   rectype)) type = DNS_T_TXT;
type              388 ext/standard/dns.c 		else if (!strcasecmp("CNAME", rectype)) type = DNS_T_CNAME;
type              389 ext/standard/dns.c 		else if (!strcasecmp("AAAA",  rectype)) type = DNS_T_AAAA;
type              390 ext/standard/dns.c 		else if (!strcasecmp("SRV",   rectype)) type = DNS_T_SRV;
type              391 ext/standard/dns.c 		else if (!strcasecmp("NAPTR", rectype)) type = DNS_T_NAPTR;
type              392 ext/standard/dns.c 		else if (!strcasecmp("A6",    rectype)) type = DNS_T_A6;
type              414 ext/standard/dns.c 	i = php_dns_search(handle, hostname, C_IN, type, ans, sizeof(ans));
type              435 ext/standard/dns.c 	u_short type, class, dlen;
type              452 ext/standard/dns.c 	GETSHORT(type, cp);
type              457 ext/standard/dns.c 	if (type_to_fetch != T_ANY && type != type_to_fetch) {
type              475 ext/standard/dns.c 		add_assoc_long(subarray, "type", type);
type              481 ext/standard/dns.c 	switch (type) {
type              496 ext/standard/dns.c 			if (type == DNS_T_CNAME) {
type              501 ext/standard/dns.c 			if (type == DNS_T_NS) {
type              506 ext/standard/dns.c 			if (type == DNS_T_PTR) {
type              785 ext/standard/dns.c 	int type, first_query = 1, store_results = 1;
type              828 ext/standard/dns.c 		type = -1;
type              830 ext/standard/dns.c 		type = PHP_DNS_NUM_TYPES + 1;
type              832 ext/standard/dns.c 		type = 0;
type              836 ext/standard/dns.c 		type < (addtl ? (PHP_DNS_NUM_TYPES + 2) : PHP_DNS_NUM_TYPES) || first_query;
type              837 ext/standard/dns.c 		type++
type              840 ext/standard/dns.c 		switch (type) {
type              844 ext/standard/dns.c 				type = PHP_DNS_NUM_TYPES - 1;
type             1001 ext/standard/dns.c 	u_short type, weight;
type             1065 ext/standard/dns.c 		GETSHORT(type, cp);
type             1068 ext/standard/dns.c 		if (type != DNS_T_MX) {
type               97 ext/standard/dns_win32.c 	int type = DNS_TYPE_MX;
type              112 ext/standard/dns_win32.c 		     if (!strcasecmp("A",     rectype)) type = DNS_TYPE_A;
type              113 ext/standard/dns_win32.c 		else if (!strcasecmp("NS",    rectype)) type = DNS_TYPE_NS;
type              114 ext/standard/dns_win32.c 		else if (!strcasecmp("MX",    rectype)) type = DNS_TYPE_MX;
type              115 ext/standard/dns_win32.c 		else if (!strcasecmp("PTR",   rectype)) type = DNS_TYPE_PTR;
type              116 ext/standard/dns_win32.c 		else if (!strcasecmp("ANY",   rectype)) type = DNS_TYPE_ANY;
type              117 ext/standard/dns_win32.c 		else if (!strcasecmp("SOA",   rectype)) type = DNS_TYPE_SOA;
type              118 ext/standard/dns_win32.c 		else if (!strcasecmp("TXT",   rectype)) type = DNS_TYPE_TEXT;
type              119 ext/standard/dns_win32.c 		else if (!strcasecmp("CNAME", rectype)) type = DNS_TYPE_CNAME;
type              120 ext/standard/dns_win32.c 		else if (!strcasecmp("AAAA",  rectype)) type = DNS_TYPE_AAAA;
type              121 ext/standard/dns_win32.c 		else if (!strcasecmp("SRV",   rectype)) type = DNS_TYPE_SRV;
type              122 ext/standard/dns_win32.c 		else if (!strcasecmp("NAPTR", rectype)) type = DNS_TYPE_NAPTR;
type              123 ext/standard/dns_win32.c 		else if (!strcasecmp("A6",    rectype)) type = DNS_TYPE_A6;
type              130 ext/standard/dns_win32.c 	status = DnsQuery_A(hostname, type, DNS_QUERY_STANDARD, NULL, &pResult, NULL);
type              143 ext/standard/dns_win32.c 	int type;
type              146 ext/standard/dns_win32.c 	type = pRec->wType;
type              149 ext/standard/dns_win32.c 	if (type_to_fetch != DNS_TYPE_ANY && type != type_to_fetch) {
type              164 ext/standard/dns_win32.c 		add_assoc_long(subarray, "type", type);
type              169 ext/standard/dns_win32.c 	switch (type) {
type              184 ext/standard/dns_win32.c 			if (type == DNS_TYPE_CNAME) {
type              190 ext/standard/dns_win32.c 			if (type == DNS_TYPE_NS) {
type              196 ext/standard/dns_win32.c 			if (type == DNS_TYPE_PTR) {
type              350 ext/standard/dns_win32.c 	int type, type_to_fetch, first_query = 1, store_results = 1;
type              384 ext/standard/dns_win32.c 		type = -1;
type              386 ext/standard/dns_win32.c 		type = PHP_DNS_NUM_TYPES + 1;
type              388 ext/standard/dns_win32.c 		type = 0;
type              392 ext/standard/dns_win32.c 		type < (addtl ? (PHP_DNS_NUM_TYPES + 2) : PHP_DNS_NUM_TYPES) || first_query;
type              393 ext/standard/dns_win32.c 		type++
type              399 ext/standard/dns_win32.c 		switch (type) {
type              403 ext/standard/dns_win32.c 				type = PHP_DNS_NUM_TYPES - 1;
type               93 ext/standard/exec.c PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value)
type              125 ext/standard/exec.c 	if (type != 3) {
type              144 ext/standard/exec.c 			if (type == 1) {
type              149 ext/standard/exec.c 			} else if (type == 2) {
type              163 ext/standard/exec.c 			if ((type == 2 && buf != b) || type != 2) {
type              170 ext/standard/exec.c 				if (type == 2) {
type               40 ext/standard/exec.h PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value);
type              833 ext/standard/filestat.c #define IS_ACCESS_CHECK(__t) (IS_ABLE_CHECK(type) || (__t) == FS_EXISTS)
type              837 ext/standard/filestat.c PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int type, zval *return_value)
type              859 ext/standard/filestat.c 	if (IS_ACCESS_CHECK(type)) {
type              862 ext/standard/filestat.c 			switch (type) {
type              887 ext/standard/filestat.c 	if (IS_LINK_OPERATION(type)) {
type              890 ext/standard/filestat.c 	if (IS_EXISTS_CHECK(type)) {
type              896 ext/standard/filestat.c 		if (!IS_EXISTS_CHECK(type)) {
type              897 ext/standard/filestat.c 			php_error_docref(NULL, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
type              906 ext/standard/filestat.c 	if (type >= FS_IS_W && type <= FS_IS_X) {
type              938 ext/standard/filestat.c 	if (IS_ABLE_CHECK(type) && getuid() == 0) {
type              942 ext/standard/filestat.c 			if (type == FS_IS_X) {
type              951 ext/standard/filestat.c 	switch (type) {
type               32 ext/standard/http.c 			  zval *type, char *arg_sep, int enc_type)
type               61 ext/standard/http.c 			if (ZSTR_VAL(key)[0] == '\0' && type != NULL) {
type               64 ext/standard/http.c 				zend_object *zobj = Z_OBJ_P(type);
type             1030 ext/standard/image.c     char *type;
type             1043 ext/standard/image.c 			if (!(type = strrchr(iname, '_'))) {
type             1044 ext/standard/image.c 				type = iname;
type             1046 ext/standard/image.c 				type++;
type             1049 ext/standard/image.c 			if (!strcmp("width", type)) {
type             1056 ext/standard/image.c 			if (!strcmp("height", type)) {
type               52 ext/standard/incomplete_class.c static zval *incomplete_class_get_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
type               56 ext/standard/incomplete_class.c 	if (type == BP_VAR_W || type == BP_VAR_RW) {
type               70 ext/standard/incomplete_class.c static zval *incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              569 ext/standard/pack.c 		char type = *(format++);
type              608 ext/standard/pack.c 		switch ((int) type) {
type              685 ext/standard/pack.c 				php_error_docref(NULL, E_WARNING, "Invalid format type %c", type);
type              692 ext/standard/pack.c 			php_error_docref(NULL, E_WARNING, "Type %c: integer overflow", type);
type              711 ext/standard/pack.c 				php_error_docref(NULL, E_WARNING, "Type %c: integer overflow", type);
type              717 ext/standard/pack.c 				switch ((int) type) {
type              787 ext/standard/pack.c 						int nibbleshift = (type == 'h') ? 0 : 4;
type              829 ext/standard/pack.c 						int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0;
type              843 ext/standard/pack.c 						if (type == 's') {
type              845 ext/standard/pack.c 						} else if (type == 'n') {
type              847 ext/standard/pack.c 						} else if (type == 'v') {
type              861 ext/standard/pack.c 						if (type == 'i') {
type              878 ext/standard/pack.c 						if (type == 'l' || type == 'L') {
type              880 ext/standard/pack.c 						} else if (type == 'N') {
type              883 ext/standard/pack.c 						} else if (type == 'V') {
type              894 ext/standard/pack.c  							if (type == 'l') {
type              913 ext/standard/pack.c 						if (type == 'q' || type == 'Q') {
type              915 ext/standard/pack.c 						} else if (type == 'J') {
type              918 ext/standard/pack.c 						} else if (type == 'P') {
type              925 ext/standard/pack.c 						if (type == 'q') {
type              962 ext/standard/pack.c 								php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
type              971 ext/standard/pack.c 							php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
type              981 ext/standard/pack.c 						php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
type              989 ext/standard/pack.c 				php_error_docref(NULL, E_WARNING, "Type %c: not enough input, need %d, have " ZEND_LONG_FMT, type, size, inputlen - inputpos);
type               27 ext/standard/php_dns.h #define php_dns_search(res, dname, class, type, answer, anslen) \
type               28 ext/standard/php_dns.h     	((int)dns_search(res, dname, class, type, answer, anslen, (struct sockaddr *)&from, &fromsize))
type               33 ext/standard/php_dns.h #define php_dns_search(res, dname, class, type, answer, anslen) \
type               34 ext/standard/php_dns.h 			res_nsearch(res, dname, class, type, answer, anslen);
type               40 ext/standard/php_dns.h #define php_dns_search(res, dname, class, type, answer, anslen) \
type               41 ext/standard/php_dns.h 			res_search(dname, class, type, answer, anslen)
type               88 ext/standard/php_filestat.h PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int type, zval *return_value);
type               31 ext/standard/php_http.h 				zval *type, char *arg_sep, int enc_type);
type              120 ext/standard/php_smart_string.h #define smart_string_append_generic_ex(dest, num, type, vartype, func) do {	\
type              123 ext/standard/php_smart_string.h 	smart_string_appendl_ex((dest), __t, __b + sizeof(__b) - 1 - __t, (type));	\
type              126 ext/standard/php_smart_string.h #define smart_string_append_unsigned_ex(dest, num, type) \
type              127 ext/standard/php_smart_string.h 	smart_string_append_generic_ex((dest), (num), (type), zend_ulong, _ulong)
type              129 ext/standard/php_smart_string.h #define smart_string_append_long_ex(dest, num, type) \
type              130 ext/standard/php_smart_string.h 	smart_string_append_generic_ex((dest), (num), (type), zend_ulong, _long)
type               54 ext/standard/streamsfuncs.c 	zend_long domain, type, protocol;
type               59 ext/standard/streamsfuncs.c 			&domain, &type, &protocol)) {
type               63 ext/standard/streamsfuncs.c 	if (0 != socketpair((int)domain, (int)type, (int)protocol, pair)) {
type             5516 ext/standard/string.c 	zend_long type = 0;
type             5518 ext/standard/string.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|ls", &str, &type, &char_list, &char_list_len) == FAILURE) {
type             5522 ext/standard/string.c 	switch(type) {
type             5537 ext/standard/string.c 			php_error_docref(NULL, E_WARNING, "Invalid format value " ZEND_LONG_FMT, type);
type             5563 ext/standard/string.c 			switch (type)
type             5579 ext/standard/string.c 	if (!type) {
type               96 ext/standard/type.c 	char *type;
type               99 ext/standard/type.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &var, &type, &type_len) == FAILURE) {
type              104 ext/standard/type.c 	if (!strcasecmp(type, "integer")) {
type              106 ext/standard/type.c 	} else if (!strcasecmp(type, "int")) {
type              108 ext/standard/type.c 	} else if (!strcasecmp(type, "float")) {
type              110 ext/standard/type.c 	} else if (!strcasecmp(type, "double")) { /* deprecated */
type              112 ext/standard/type.c 	} else if (!strcasecmp(type, "string")) {
type              114 ext/standard/type.c 	} else if (!strcasecmp(type, "array")) {
type              116 ext/standard/type.c 	} else if (!strcasecmp(type, "object")) {
type              118 ext/standard/type.c 	} else if (!strcasecmp(type, "bool")) {
type              120 ext/standard/type.c 	} else if (!strcasecmp(type, "boolean")) {
type              122 ext/standard/type.c 	} else if (!strcasecmp(type, "null")) {
type              124 ext/standard/type.c 	} else if (!strcasecmp(type, "resource")) {
type              213 ext/standard/type.c static inline void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
type              228 ext/standard/type.c 	if (Z_TYPE_P(arg) == type) {
type              229 ext/standard/type.c 		if (type == IS_OBJECT) {
type              235 ext/standard/type.c 		} else if (type == IS_RESOURCE) {
type              209 ext/standard/url_scanner_ex.c static inline void tag_arg(url_adapt_state_ex_t *ctx, char quotes, char type)
type              217 ext/standard/url_scanner_ex.c 		smart_str_appendc(&ctx->result, type);
type              224 ext/standard/url_scanner_ex.c 		smart_str_appendc(&ctx->result, type);
type              331 ext/standard/url_scanner_ex.c static inline void handle_val(STD_PARA, char quotes, char type)
type              334 ext/standard/url_scanner_ex.c 	tag_arg(ctx, quotes, type);
type              732 ext/standard/var.c 								ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
type              747 ext/standard/var.c 								"*", 1, ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
type              100 ext/tidy/tidy.c #define TIDY_NODE_CONST(name, type) REGISTER_LONG_CONSTANT("TIDY_NODETYPE_" #name, TidyNode_##type, CONST_CS | CONST_PERSISTENT)
type              192 ext/tidy/tidy.c 	tidy_obj_type	type;
type              738 ext/tidy/tidy.c static int tidy_doc_cast_handler(zval *in, zval *out, int type)
type              743 ext/tidy/tidy.c 	switch (type) {
type              771 ext/tidy/tidy.c static int tidy_node_cast_handler(zval *in, zval *out, int type)
type              776 ext/tidy/tidy.c 	switch(type) {
type              836 ext/tidy/tidy.c static void tidy_add_default_properties(PHPTidyObj *obj, tidy_obj_type type)
type              845 ext/tidy/tidy.c 	switch(type) {
type              857 ext/tidy/tidy.c 			ADD_PROPERTY_LONG(obj->std.properties, type, tidyNodeGetType(obj->node));
type              899 ext/tidy/tidy.c 					newobj->type = is_node;
type              926 ext/tidy/tidy.c static void *php_tidy_get_opt_val(PHPTidyDoc *ptdoc, TidyOption opt, TidyOptionType *type)
type              928 ext/tidy/tidy.c 	*type = tidyOptGetType(opt);
type              930 ext/tidy/tidy.c 	switch (*type) {
type              988 ext/tidy/tidy.c 	newobj->type  = is_node;
type             1837 ext/tidy/tidy.c 		newobj->type = is_node;
type              296 ext/tokenizer/tokenizer.c 	zend_long type;
type              298 ext/tokenizer/tokenizer.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &type) == FAILURE) {
type              302 ext/tokenizer/tokenizer.c 	RETVAL_STRING(get_token_type_name(type));
type               91 ext/wddx/wddx.c 	} type;
type              721 ext/wddx/wddx.c 		ent.type = ST_STRING;
type              727 ext/wddx/wddx.c 		ent.type = ST_BINARY;
type              745 ext/wddx/wddx.c 		ent.type = ST_NUMBER;
type              755 ext/wddx/wddx.c 				ent.type = ST_BOOLEAN;
type              765 ext/wddx/wddx.c 		ent.type = ST_NULL;
type              772 ext/wddx/wddx.c 		ent.type = ST_ARRAY;
type              778 ext/wddx/wddx.c 		ent.type = ST_STRUCT;
type              794 ext/wddx/wddx.c 		ent.type = ST_RECORDSET;
type              828 ext/wddx/wddx.c 		ent.type = ST_FIELD;
type              838 ext/wddx/wddx.c 					recordset->type == ST_RECORDSET &&
type              849 ext/wddx/wddx.c 		ent.type = ST_DATETIME;
type              914 ext/wddx/wddx.c 			if (ent2->type == ST_FIELD && Z_ISUNDEF(ent2->data)) {
type              926 ext/wddx/wddx.c 						ent2->type == ST_STRUCT && Z_TYPE(ent2->data) == IS_ARRAY) {
type              996 ext/wddx/wddx.c 		switch (ent->type) {
type              354 ext/xml/compat.c _external_entity_ref_handler(void *user, const xmlChar *names, int type, const xmlChar *sys_id, const xmlChar *pub_id, xmlChar *content)
type               54 ext/xmlreader/php_xmlreader.c 	int type;
type               67 ext/xmlreader/php_xmlreader.c 	hnd.type = rettype;
type               92 ext/xmlreader/php_xmlreader.c 	switch (hnd->type) {
type              116 ext/xmlreader/php_xmlreader.c zval *xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot)
type              139 ext/xmlreader/php_xmlreader.c 		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
type              151 ext/xmlreader/php_xmlreader.c zval *xmlreader_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
type              180 ext/xmlreader/php_xmlreader.c 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
type              274 ext/xmlreader/php_xmlreader.c static xmlRelaxNGPtr _xmlreader_get_relaxNG(char *source, size_t source_len, size_t type,
type              283 ext/xmlreader/php_xmlreader.c 	switch (type) {
type              481 ext/xmlreader/php_xmlreader.c static void php_xmlreader_set_relaxng_schema(INTERNAL_FUNCTION_PARAMETERS, int type) {
type              504 ext/xmlreader/php_xmlreader.c 			schema =  _xmlreader_get_relaxNG(source, source_len, type, NULL, NULL);
type               72 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       const char* type = NULL;
type               80 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c             type = attr_iter->val;
type               90 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          if(!type || !strcmp(type, ATTR_STRING)) {
type               93 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_INT)) {
type               96 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_BOOLEAN)) {
type               99 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_DOUBLE)) {
type              102 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_DATETIME)) {
type              105 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_BASE64)) {
type              115 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          if(!type || !strcmp(type, ATTR_MIXED)) {
type              118 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_ARRAY)) {
type              121 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          else if(!strcmp(type, ATTR_STRUCT)) {
type              177 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node);
type              179 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       int bNoAddType = (type == xmlrpc_string && request && output && output->xml_elem_opts.verbosity == xml_elem_no_white_space);
type              191 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       elem_val->name = (type == xmlrpc_vector) ? strdup(ATTR_VECTOR) : strdup(ATTR_SCALAR);
type              202 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       switch(type) {
type              108 ext/xmlrpc/libxmlrpc/xml_to_soap.c 	XMLRPC_VALUE_TYPE_EASY type = xmlrpc_type_none;
type              114 ext/xmlrpc/libxmlrpc/xml_to_soap.c 	type = XMLRPC_GetValueTypeEasy(xIter);
type              122 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		if ( (XMLRPC_GetValueTypeEasy(xIter) != type) || loopCount >= 50) {
type              123 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			type = xmlrpc_type_none;
type              130 ext/xmlrpc/libxmlrpc/xml_to_soap.c 	switch (type) {
type              252 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		const char* type = NULL, *arrayType=NULL, *actor = NULL;
type              258 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			type = el->name;
type              272 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				type = attr_iter->val;
type              342 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			if (!type && parent_array && parent_array->kids_type[0]) {
type              343 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				type = parent_array->kids_type;
type              345 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			if (!type || !strcmp(type, TOKEN_STRING)) {
type              348 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_INT)) {
type              351 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_BOOLEAN)) {
type              354 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_DOUBLE) ||
type              355 ext/xmlrpc/libxmlrpc/xml_to_soap.c 						!strcmp(type, TOKEN_FLOAT)) {
type              358 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_NULL)) {
type              361 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_DATETIME)) {
type              364 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_BASE64)) {
type              376 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			if (!type || !strcmp(type, TOKEN_STRUCT)) {
type              379 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (!strcmp(type, TOKEN_ARRAY) || arrayType != NULL) {
type              440 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		XMLRPC_VALUE_TYPE_EASY type = XMLRPC_GetValueTypeEasy(node);
type              446 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		switch (type) {
type              450 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			if (type == xmlrpc_type_array) {
type              455 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				const char* type = get_array_soap_type(node);
type              459 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				snprintf(buf, sizeof(buf), "%s[%i]", type, XMLRPC_VectorSize(node));
type              468 ext/xmlrpc/libxmlrpc/xml_to_soap.c 			else if (type == xmlrpc_type_struct) {
type              195 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c       XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(node);
type              201 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c           !(type == xmlrpc_vector &&
type              213 ext/xmlrpc/libxmlrpc/xml_to_xmlrpc.c          switch (type) {
type              420 ext/xmlrpc/libxmlrpc/xmlrpc.c 																  XMLRPC_REQUEST_TYPE type) {
type              422 ext/xmlrpc/libxmlrpc/xmlrpc.c       request->request_type = type;
type              869 ext/xmlrpc/libxmlrpc/xmlrpc.c       v->type = xmlrpc_empty;
type              959 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_string;
type              987 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_int;
type             1013 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_boolean;
type             1043 ext/xmlrpc/libxmlrpc/xmlrpc.c int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type) {
type             1048 ext/xmlrpc/libxmlrpc/xmlrpc.c 		if(value->type == xmlrpc_vector) {
type             1051 ext/xmlrpc/libxmlrpc/xmlrpc.c 					value->v->type = type;
type             1061 ext/xmlrpc/libxmlrpc/xmlrpc.c             value->v->type = type;
type             1062 ext/xmlrpc/libxmlrpc/xmlrpc.c             value->type = xmlrpc_vector;
type             1096 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type) {
type             1101 ext/xmlrpc/libxmlrpc/xmlrpc.c       if(XMLRPC_SetIsVector(val, type)) {
type             1157 ext/xmlrpc/libxmlrpc/xmlrpc.c       if(target->type == xmlrpc_vector && target->v &&
type             1158 ext/xmlrpc/libxmlrpc/xmlrpc.c          target->v->q && target->v->type != xmlrpc_vector_none) {
type             1161 ext/xmlrpc/libxmlrpc/xmlrpc.c          switch(source->type) {
type             1171 ext/xmlrpc/libxmlrpc/xmlrpc.c                if( !(source->id.len && target->v->type == xmlrpc_vector_array) ) {
type             1222 ext/xmlrpc/libxmlrpc/xmlrpc.c       if(target->type == xmlrpc_vector) {
type             1461 ext/xmlrpc/libxmlrpc/xmlrpc.c       if(value->type == xmlrpc_vector) {
type             1490 ext/xmlrpc/libxmlrpc/xmlrpc.c          switch(value->type) {
type             1547 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_datetime;
type             1633 ext/xmlrpc/libxmlrpc/xmlrpc.c 		switch (xSource->type) {
type             1651 ext/xmlrpc/libxmlrpc/xmlrpc.c 				XMLRPC_SetIsVector (xReturn, xSource->v->type);
type             1731 ext/xmlrpc/libxmlrpc/xmlrpc.c          value->type = xmlrpc_datetime;
type             1804 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_base64;
type             1865 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->type = xmlrpc_double;
type             1921 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_string) ? value->str.str : 0);
type             1968 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_int) ? value->i : 0);
type             1992 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_boolean) ? value->i : 0);
type             2016 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_double) ? value->d : 0);
type             2041 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_base64) ? value->str.str : 0);
type             2066 ext/xmlrpc/libxmlrpc/xmlrpc.c     return (time_t)((value && value->type == xmlrpc_datetime) ? value->i : 0);
type             2089 ext/xmlrpc/libxmlrpc/xmlrpc.c     return ((value && value->type == xmlrpc_datetime) ? value->str.str : 0);
type             2139 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(value && value->type == xmlrpc_vector && value->v) {
type             2167 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(value && value->type == xmlrpc_vector && value->v) {
type             2193 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(value && value->type == xmlrpc_vector && value->v) {
type             2223 ext/xmlrpc/libxmlrpc/xmlrpc.c    return value ? value->type : xmlrpc_empty;
type             2251 ext/xmlrpc/libxmlrpc/xmlrpc.c    return(value && value->v) ? value->v->type : xmlrpc_none;
type             2278 ext/xmlrpc/libxmlrpc/xmlrpc.c 		switch (value->type) {
type             2280 ext/xmlrpc/libxmlrpc/xmlrpc.c 			switch (value->v->type) {
type             2292 ext/xmlrpc/libxmlrpc/xmlrpc.c 			return(XMLRPC_VALUE_TYPE_EASY) value->type;
type             2473 ext/xmlrpc/libxmlrpc/xmlrpc.c const char* type_to_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) {
type             2474 ext/xmlrpc/libxmlrpc/xmlrpc.c     switch(type) {
type              316 ext/xmlrpc/libxmlrpc/xmlrpc.h int XMLRPC_SetIsVector(XMLRPC_VALUE value, XMLRPC_VECTOR_TYPE type);
type              332 ext/xmlrpc/libxmlrpc/xmlrpc.h XMLRPC_VALUE XMLRPC_CreateVector(const char* id, XMLRPC_VECTOR_TYPE type);
type              387 ext/xmlrpc/libxmlrpc/xmlrpc.h XMLRPC_REQUEST_TYPE XMLRPC_RequestSetRequestType(XMLRPC_REQUEST request, XMLRPC_REQUEST_TYPE type);
type              140 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c       XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(xParams);
type              141 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c       if(type == xmlrpc_string) {
type              146 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c       else if(type == xmlrpc_vector) {
type              202 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          const char* type;
type              214 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             type = XMLRPC_VectorGetStringWithID(XMLRPC_VectorRewind(
type              219 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c                                                              type ? type : type_to_str(xmlrpc_none, 0),
type              287 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c static XMLRPC_VALUE describeValue_worker(const char* type, const char* id, const char* desc, int optional, const char* default_val, XMLRPC_VALUE sub_params) {
type              292 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c       XMLRPC_VectorAppendString(xParam, xi_token_type, type, 0);
type              314 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c       const char* type = NULL;
type              327 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             type = attr_iter->val;
type              349 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c          const char* ptype = !strcmp(el->name, "value") ? type : basetype;
type               89 ext/xmlrpc/libxmlrpc/xmlrpc_private.h    XMLRPC_VALUE_TYPE type; /* data type of this value                        */
type              124 ext/xmlrpc/libxmlrpc/xmlrpc_private.h    XMLRPC_VECTOR_TYPE type;                           /* vector type                       */
type              164 ext/xmlrpc/libxmlrpc/xmlrpc_private.h const char* type_to_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype);
type              102 ext/xmlrpc/xmlrpc-epi-php.c 	ZEND_ARG_INFO(0, type)
type              254 ext/xmlrpc/xmlrpc-epi-php.c int sset_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
type              256 ext/xmlrpc/xmlrpc-epi-php.c const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype);
type              259 ext/xmlrpc/xmlrpc-epi-php.c int set_zval_xmlrpc_type(zval* value, XMLRPC_VALUE_TYPE type);
type              506 ext/xmlrpc/xmlrpc-epi-php.c 		XMLRPC_VALUE_TYPE type;
type              509 ext/xmlrpc/xmlrpc-epi-php.c 		type = get_zval_xmlrpc_type(in_val, &val);
type              512 ext/xmlrpc/xmlrpc-epi-php.c 			switch (type) {
type              615 ext/xmlrpc/xmlrpc-epi-php.c 		XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);
type              617 ext/xmlrpc/xmlrpc-epi-php.c 		switch (type) {
type              664 ext/xmlrpc/xmlrpc-epi-php.c 		set_zval_xmlrpc_type(elem, type);
type             1220 ext/xmlrpc/xmlrpc-epi-php.c const char* xmlrpc_type_as_str(XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype) /* {{{ */
type             1225 ext/xmlrpc/xmlrpc-epi-php.c 		return str_mapping[type];
type             1280 ext/xmlrpc/xmlrpc-epi-php.c 			zval type;
type             1282 ext/xmlrpc/xmlrpc-epi-php.c 			ZVAL_STRING(&type, typestr);
type             1294 ext/xmlrpc/xmlrpc-epi-php.c 						if (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type)) {
type             1298 ext/xmlrpc/xmlrpc-epi-php.c 						zval_ptr_dtor(&type);
type             1302 ext/xmlrpc/xmlrpc-epi-php.c 					zval_ptr_dtor(&type);
type             1306 ext/xmlrpc/xmlrpc-epi-php.c 				bSuccess = (zend_hash_str_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR) - 1, &type) != NULL)? SUCCESS : FAILURE;
type             1318 ext/xmlrpc/xmlrpc-epi-php.c 	XMLRPC_VALUE_TYPE type = xmlrpc_none;
type             1323 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_base64;
type             1330 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_boolean;
type             1337 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_int;
type             1340 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_double;
type             1343 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_string;
type             1346 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_string;
type             1349 ext/xmlrpc/xmlrpc-epi-php.c 				type = xmlrpc_vector;
type             1354 ext/xmlrpc/xmlrpc-epi-php.c 					type = xmlrpc_vector;
type             1358 ext/xmlrpc/xmlrpc-epi-php.c 							type = xmlrpc_str_as_type(Z_STRVAL_P(attr));
type             1369 ext/xmlrpc/xmlrpc-epi-php.c 			if ((type == xmlrpc_base64 && Z_TYPE_P(value) == IS_OBJECT) || type == xmlrpc_datetime) {
type             1379 ext/xmlrpc/xmlrpc-epi-php.c 	return type;
type             1388 ext/xmlrpc/xmlrpc-epi-php.c 	char *type;
type             1392 ext/xmlrpc/xmlrpc-epi-php.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/s", &arg, &type, &type_len) == FAILURE) {
type             1396 ext/xmlrpc/xmlrpc-epi-php.c 	vtype = xmlrpc_str_as_type(type);
type             1402 ext/xmlrpc/xmlrpc-epi-php.c 		zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
type             1413 ext/xmlrpc/xmlrpc-epi-php.c 	XMLRPC_VALUE_TYPE type;
type             1420 ext/xmlrpc/xmlrpc-epi-php.c 	type = get_zval_xmlrpc_type(arg, 0);
type             1421 ext/xmlrpc/xmlrpc-epi-php.c 	if (type == xmlrpc_vector) {
type             1425 ext/xmlrpc/xmlrpc-epi-php.c 	RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype));
type              177 ext/xsl/xsltprocessor.c static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
type              238 ext/xsl/xsltprocessor.c 		switch (obj->type) {
type              249 ext/xsl/xsltprocessor.c 				if (type == 1) {
type              253 ext/xsl/xsltprocessor.c 				} else if (type == 2) {
type              262 ext/xsl/xsltprocessor.c 							if (node->type == XML_NAMESPACE_DECL) {
type              276 ext/xsl/xsltprocessor.c 								node->type = XML_NAMESPACE_DECL;
type              453 ext/xsl/xsltprocessor.c 				if (nodep->type == XML_ELEMENT_NODE && xmlStrEqual(nodep->name, (const xmlChar *) "key") && xmlStrEqual(nodep->ns->href, XSLT_NAMESPACE)) {
type              258 ext/zip/lib/zip.h #define ZIP_SOURCE_GET_ARGS(type, data, len, error) ((len) < sizeof(type) ? zip_error_set((error), ZIP_ER_INVAL, 0), (type *)NULL : (type *)(data))
type              776 ext/zip/php_zip.c 	int type;
type              787 ext/zip/php_zip.c 	hnd.type = rettype;
type              817 ext/zip/php_zip.c 	switch (hnd->type) {
type              840 ext/zip/php_zip.c static zval *php_zip_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              863 ext/zip/php_zip.c 		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
type              874 ext/zip/php_zip.c static zval *php_zip_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
type              902 ext/zip/php_zip.c 		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
type              913 ext/zip/php_zip.c static int php_zip_has_property(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
type              937 ext/zip/php_zip.c 		if (type == 2) {
type              940 ext/zip/php_zip.c 			if (type == 1) {
type              942 ext/zip/php_zip.c 			} else if (type == 0) {
type              950 ext/zip/php_zip.c 		retval = std_hnd->has_property(object, member, type, cache_slot);
type             1610 ext/zip/php_zip.c static void php_zip_add_from_pattern(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
type             1630 ext/zip/php_zip.c 	if (type == 1) {
type             1658 ext/zip/php_zip.c 	if (type == 1) {
type             2679 ext/zip/php_zip.c static void php_zip_get_from(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
type             2702 ext/zip/php_zip.c 	if (type == 1) {
type              235 main/SAPI.h    	void (*sapi_error)(int type, const char *error_msg, ...);
type              137 main/fastcgi.c 	unsigned char type;
type              470 main/fastcgi.c void __attribute__((weak)) fcgi_log(int type, const char *format, ...) {
type              991 main/fastcgi.c static inline int fcgi_make_header(fcgi_header *hdr, fcgi_request_type type, int req_id, int len)
type             1001 main/fastcgi.c 	hdr->type = type;
type             1062 main/fastcgi.c 	while (hdr.type == FCGI_STDIN && len == 0) {
type             1078 main/fastcgi.c 	if (hdr.type == FCGI_BEGIN_REQUEST && len == sizeof(fcgi_begin_request)) {
type             1118 main/fastcgi.c 		while (hdr.type == FCGI_PARAMS && len > 0) {
type             1141 main/fastcgi.c 	} else if (hdr.type == FCGI_GET_VALUES) {
type             1215 main/fastcgi.c 			    hdr.type != FCGI_STDIN) {
type             1483 main/fastcgi.c static inline fcgi_header* open_packet(fcgi_request *req, fcgi_request_type type)
type             1486 main/fastcgi.c 	req->out_hdr->type = type;
type             1496 main/fastcgi.c 		req->out_pos += fcgi_make_header(req->out_hdr, (fcgi_request_type)req->out_hdr->type, req->id, len);
type             1531 main/fastcgi.c int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len)
type             1539 main/fastcgi.c 	if (req->out_hdr && req->out_hdr->type != type) {
type             1554 main/fastcgi.c 			open_packet(req, type);
type             1581 main/fastcgi.c 			open_packet(req, type);
type             1587 main/fastcgi.c 			open_packet(req, type);
type             1597 main/fastcgi.c 			open_packet(req, type);
type             1607 main/fastcgi.c 			open_packet(req, type);
type             1608 main/fastcgi.c 			fcgi_make_header(req->out_hdr, type, req->id, 0xfff8);
type             1623 main/fastcgi.c 		open_packet(req, type);
type             1624 main/fastcgi.c 		fcgi_make_header(req->out_hdr, type, req->id, (len - pos) - rest);
type             1634 main/fastcgi.c 			open_packet(req, type);
type              107 main/fastcgi.h typedef void (*fcgi_logger)(int type, const char *fmt, ...);
type              120 main/fastcgi.h int fcgi_write(fcgi_request *req, fcgi_request_type type, const char *str, int len);
type              347 main/main.c    	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type              706 main/main.c    PHPAPI ZEND_COLD void php_verror(const char *docref, const char *params, int type, const char *format, va_list args)
type              749 main/main.c    				ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
type              878 main/main.c    			(Z_TYPE(EG(user_error_handler)) == IS_UNDEF || !(EG(user_error_handler_error_reporting) & type))) {
type              897 main/main.c    	php_error(type, "%s", message);
type              904 main/main.c    PHPAPI ZEND_COLD void php_error_docref0(const char *docref, int type, const char *format, ...)
type              909 main/main.c    	php_verror(docref, "", type, format, args);
type              916 main/main.c    PHPAPI ZEND_COLD void php_error_docref1(const char *docref, const char *param1, int type, const char *format, ...)
type              921 main/main.c    	php_verror(docref, param1, type, format, args);
type              928 main/main.c    PHPAPI ZEND_COLD void php_error_docref2(const char *docref, const char *param1, const char *param2, int type, const char *format, ...)
type              935 main/main.c    	php_verror(docref, params ? params : "...", type, format, args);
type              973 main/main.c    static ZEND_COLD void php_error_cb(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args)
type             1011 main/main.c    		PG(last_error_type) = type;
type             1019 main/main.c    		switch (type) {
type             1041 main/main.c    					zend_throw_error_exception(EG(exception_class), buffer, 0, type);
type             1049 main/main.c    	if (display && (EG(error_reporting) & type || (type & E_CORE))
type             1053 main/main.c    		switch (type) {
type             1091 main/main.c    			if (type == E_CORE_ERROR || type == E_CORE_WARNING) {
type             1108 main/main.c    					if (type == E_ERROR || type == E_PARSE) {
type             1136 main/main.c    			switch (type) {
type             1153 main/main.c    	switch (type) {
type             1178 main/main.c    				if (type == E_PARSE) {
type             1374 main/main.c    			handle->type = ZEND_HANDLE_MAPPED;
type             1377 main/main.c    			handle->type = ZEND_HANDLE_STREAM;
type             2439 main/main.c     			primary_file->type != ZEND_HANDLE_FILENAME
type             2451 main/main.c    			prepend_file.type = ZEND_HANDLE_FILENAME;
type             2461 main/main.c    			append_file.type = ZEND_HANDLE_FILENAME;
type              670 main/output.c  PHPAPI int php_output_handler_hook(php_output_handler_hook_t type, void *arg)
type              673 main/output.c  		switch (type) {
type              298 main/php.h     PHPAPI ZEND_COLD void php_verror(const char *docref, const char *params, int type, const char *format, va_list args) PHP_ATTRIBUTE_FORMAT(printf, 4, 0);
type              301 main/php.h     PHPAPI ZEND_COLD void php_error_docref0(const char *docref, int type, const char *format, ...)
type              303 main/php.h     PHPAPI ZEND_COLD void php_error_docref1(const char *docref, const char *param1, int type, const char *format, ...)
type              305 main/php.h     PHPAPI ZEND_COLD void php_error_docref2(const char *docref, const char *param1, const char *param2, int type, const char *format, ...)
type               73 main/php_ini.c static void php_ini_displayer_cb(zend_ini_entry *ini_entry, int type)
type               76 main/php_ini.c 		ini_entry->displayer(ini_entry, type);
type               82 main/php_ini.c 		if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
type              589 main/php_ini.c 		fh.type = ZEND_HANDLE_FP;
type              667 main/php_ini.c 								fh2.type = ZEND_HANDLE_FP;
type              761 main/php_ini.c 				fh.type = ZEND_HANDLE_FP;
type              235 main/php_output.h PHPAPI int php_output_handler_hook(php_output_handler_hook_t type, void *arg);
type               73 main/streams/streams.c 	if (rsrc->type != le_pstream) {
type              113 main/streams/streams.c 		if (le->type == le_pstream) {
type              672 sapi/apache2handler/sapi_apache2.c 		zfd.type = ZEND_HANDLE_FILENAME;
type              226 sapi/cgi/cgi_main.c static void fcgi_log(int type, const char *format, ...) {
type             2304 sapi/cgi/cgi_main.c 				file_handle.type = ZEND_HANDLE_FILENAME;
type             2309 sapi/cgi/cgi_main.c 				file_handle.type = ZEND_HANDLE_FP;
type             2378 sapi/cgi/cgi_main.c 				switch (file_handle.type) {
type             2383 sapi/cgi/cgi_main.c 						file_handle.type = ZEND_HANDLE_FP;
type              618 sapi/cli/php_cli.c 	file_handle->type = ZEND_HANDLE_FP;
type              931 sapi/cli/php_cli.c 		file_handle.type = ZEND_HANDLE_FP;
type              146 sapi/cli/php_cli_server.c 	} type;
type              850 sapi/cli/php_cli_server.c 	switch (chunk->type) {
type              861 sapi/cli/php_cli_server.c 	switch (chunk->type) {
type              928 sapi/cli/php_cli_server.c 	chunk->type = PHP_CLI_SERVER_CHUNK_IMMORTAL;
type              942 sapi/cli/php_cli_server.c 	chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
type              957 sapi/cli/php_cli_server.c 	chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
type              988 sapi/cli/php_cli_server.c 		switch (chunk->type) {
type             1934 sapi/cli/php_cli_server.c 		zfd.type = ZEND_HANDLE_FILENAME;
type             2058 sapi/cli/php_cli_server.c 	zfd.type = ZEND_HANDLE_FILENAME;
type              313 sapi/cli/php_http_parser.c #define start_state (parser->type == PHP_HTTP_REQUEST ? s_start_req : s_start_res)
type              403 sapi/cli/php_http_parser.c           parser->type = PHP_HTTP_REQUEST;
type              411 sapi/cli/php_http_parser.c           parser->type = PHP_HTTP_RESPONSE;
type              415 sapi/cli/php_http_parser.c           parser->type = PHP_HTTP_REQUEST;
type             1432 sapi/cli/php_http_parser.c             if (parser->type == PHP_HTTP_REQUEST || php_http_should_keep_alive(parser)) {
type             1618 sapi/cli/php_http_parser.c   parser->type = t;
type              116 sapi/cli/php_http_parser.h   unsigned char type : 2;
type              157 sapi/cli/php_http_parser.h void php_http_parser_init(php_http_parser *parser, enum php_http_parser_type type);
type               13 sapi/fpm/fpm/fpm_cleanup.c 	int type;
type               20 sapi/fpm/fpm/fpm_cleanup.c int fpm_cleanup_add(int type, void (*cleanup)(int, void *), void *arg) /* {{{ */
type               30 sapi/fpm/fpm/fpm_cleanup.c 	c->type = type;
type               38 sapi/fpm/fpm/fpm_cleanup.c void fpm_cleanups_run(int type) /* {{{ */
type               44 sapi/fpm/fpm/fpm_cleanup.c 		if (c->type & type) {
type               45 sapi/fpm/fpm/fpm_cleanup.c 			c->cleanup(type, c->arg);
type                8 sapi/fpm/fpm/fpm_cleanup.h int fpm_cleanup_add(int type, void (*cleanup)(int, void *), void *);
type                9 sapi/fpm/fpm/fpm_cleanup.h void fpm_cleanups_run(int type);
type              461 sapi/fpm/fpm/fpm_main.c static void fpm_fcgi_log(int type, const char *fmt, ...) /* {{{ */
type              463 sapi/fpm/fpm/fpm_main.c void fcgi_log(int type, const char *fmt, ...)
type              468 sapi/fpm/fpm/fpm_main.c 	vzlog("", 0, type, fmt, args);
type              134 sapi/fpm/fpm/fpm_php_trace.c 			zend_uchar *type;
type              146 sapi/fpm/fpm/fpm_php_trace.c 			type = (zend_uchar *)&l;
type              147 sapi/fpm/fpm/fpm_php_trace.c 			if (0 > fpm_trace_get_long(function + offsetof(zend_function, type), &l)) { 
type              151 sapi/fpm/fpm/fpm_php_trace.c 			if (ZEND_USER_CODE(*type)) {
type               36 sapi/fpm/fpm/fpm_sockets.c 	int type;
type               62 sapi/fpm/fpm/fpm_sockets.c 			if (ls->type == FPM_AF_UNIX) {
type               98 sapi/fpm/fpm/fpm_sockets.c static int fpm_sockets_hash_op(int sock, struct sockaddr *sa, char *key, int type, int op) /* {{{ */
type              101 sapi/fpm/fpm/fpm_sockets.c 		switch (type) {
type              152 sapi/fpm/fpm/fpm_sockets.c 			ls->type = type;
type              337 sapi/fpm/fpm/fpm_sockets.c 		int type, fd_no;
type              348 sapi/fpm/fpm/fpm_sockets.c 			type = fpm_sockets_domain_from_address(inherited);
type              350 sapi/fpm/fpm/fpm_sockets.c 			fpm_sockets_hash_op(fd_no, 0, inherited, type, FPM_STORE_SOCKET);
type              390 sapi/fpm/fpm/fpm_sockets.c 			if (ls->type == FPM_AF_UNIX) {
type              524 sapi/litespeed/lsapi_main.c     file_handle->type = ZEND_HANDLE_FP;
type              539 sapi/litespeed/lsapi_main.c     file_handle->type = ZEND_HANDLE_FILENAME;
type              589 sapi/litespeed/lsapi_main.c     int type = ZEND_INI_PERDIR;
type              593 sapi/litespeed/lsapi_main.c             type = ZEND_INI_SYSTEM;
type              609 sapi/litespeed/lsapi_main.c                              type, PHP_INI_STAGE_ACTIVATE);
type              614 sapi/litespeed/lsapi_main.c                              type, PHP_INI_STAGE_ACTIVATE);
type              848 sapi/litespeed/lsapi_main.c                 file_handle.type = ZEND_HANDLE_FP;
type              245 sapi/litespeed/lsapilib.c                                 char type, int len )
type              249 sapi/litespeed/lsapilib.c     pHeader->m_type      = type;
type              108 sapi/phpdbg/phpdbg.c 	pg->err_buf.type = 0;
type              317 sapi/phpdbg/phpdbg.c 	while (ex && ex->func && !ZEND_USER_CODE(ex->func->type)) {
type              540 sapi/phpdbg/phpdbg.c 		if (func->type == ZEND_USER_FUNCTION) {
type              554 sapi/phpdbg/phpdbg.c 		if (ce->type == ZEND_USER_CLASS) {
type              557 sapi/phpdbg/phpdbg.c 					if (func->type == ZEND_USER_FUNCTION && zend_hash_exists(files, func->op_array.filename)) {
type              269 sapi/phpdbg/phpdbg.h 	zend_op_array *(*compile_file)(zend_file_handle *file_handle, int type);
type              270 sapi/phpdbg/phpdbg.h 	zend_op_array *(*init_compile_file)(zend_file_handle *file_handle, int type);
type              288 sapi/phpdbg/phpdbg.h 		int type;
type               56 sapi/phpdbg/phpdbg_bp.c 	b.type = t; \
type              136 sapi/phpdbg/phpdbg_bp.c 					switch (brake->type) {
type              189 sapi/phpdbg/phpdbg_bp.c 								switch (conditional->param.type) {
type              498 sapi/phpdbg/phpdbg_bp.c 		opline_break.type = PHPDBG_BREAK_METHOD_OPLINE;
type              500 sapi/phpdbg/phpdbg_bp.c 		opline_break.type = PHPDBG_BREAK_FUNCTION_OPLINE;
type              502 sapi/phpdbg/phpdbg_bp.c 		opline_break.type = PHPDBG_BREAK_FILE_OPLINE;
type              566 sapi/phpdbg/phpdbg_bp.c 				if (ZEND_USER_CODE(execute_data->func->common.type)) {
type              597 sapi/phpdbg/phpdbg_bp.c 	if (func->type != ZEND_USER_FUNCTION) {
type              918 sapi/phpdbg/phpdbg_bp.c 	if (fbc->type != ZEND_USER_FUNCTION) {
type              986 sapi/phpdbg/phpdbg_bp.c 	switch (param->type) {
type              991 sapi/phpdbg/phpdbg_bp.c 			if (function->type != ZEND_USER_FUNCTION) {
type             1003 sapi/phpdbg/phpdbg_bp.c 					return param->type == STR_PARAM || execute_data->opline - ops->opcodes == param->num;
type             1022 sapi/phpdbg/phpdbg_bp.c 			if (function->type != ZEND_USER_FUNCTION) {
type             1036 sapi/phpdbg/phpdbg_bp.c 							return param->type == METHOD_PARAM || (execute_data->opline - ops->opcodes) == param->num;
type             1157 sapi/phpdbg/phpdbg_bp.c 		int type = brake->type;
type             1161 sapi/phpdbg/phpdbg_bp.c 		switch (type) {
type             1167 sapi/phpdbg/phpdbg_bp.c 					if (zend_hash_num_elements(&PHPDBG_G(bp)[type]) == 1) {
type             1168 sapi/phpdbg/phpdbg_bp.c 						PHPDBG_G(flags) &= ~(1<<(brake->type+1));
type             1175 sapi/phpdbg/phpdbg_bp.c 					PHPDBG_G(flags) &= ~(1<<(brake->type+1));
type             1180 sapi/phpdbg/phpdbg_bp.c 		switch (type) {
type             1196 sapi/phpdbg/phpdbg_bp.c 		switch (type) {
type             1200 sapi/phpdbg/phpdbg_bp.c 					zend_hash_str_del(&PHPDBG_G(bp)[type], name, name_len);
type             1246 sapi/phpdbg/phpdbg_bp.c 	switch (brake->type) {
type             1405 sapi/phpdbg/phpdbg_bp.c PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type) /* {{{ */
type             1409 sapi/phpdbg/phpdbg_bp.c 	switch (type) {
type             1474 sapi/phpdbg/phpdbg_bp.c 				const char *type;
type             1475 sapi/phpdbg/phpdbg_bp.c 				switch (brake->type) {
type             1477 sapi/phpdbg/phpdbg_bp.c 						type = "method";
type             1480 sapi/phpdbg/phpdbg_bp.c 						type = "function";
type             1483 sapi/phpdbg/phpdbg_bp.c 						type = "method";
type             1486 sapi/phpdbg/phpdbg_bp.c 						if (brake->type == PHPDBG_BREAK_METHOD_OPLINE) {
type             1487 sapi/phpdbg/phpdbg_bp.c 							type = "method";
type             1488 sapi/phpdbg/phpdbg_bp.c 						} else if (brake->type == PHPDBG_BREAK_FUNCTION_OPLINE) {
type             1489 sapi/phpdbg/phpdbg_bp.c 							type = "function";
type             1490 sapi/phpdbg/phpdbg_bp.c 						} else if (brake->type == PHPDBG_BREAK_FILE_OPLINE) {
type             1491 sapi/phpdbg/phpdbg_bp.c 							type = "file";
type             1495 sapi/phpdbg/phpdbg_bp.c 							brake->id, brake->opline, type,
type             1565 sapi/phpdbg/phpdbg_bp.c 					switch (brake->param.type) {
type               44 sapi/phpdbg/phpdbg_bp.h 	zend_uchar  type; \
type              145 sapi/phpdbg/phpdbg_bp.h PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type);
type               49 sapi/phpdbg/phpdbg_cmd.c 	switch (param->type) {
type               76 sapi/phpdbg/phpdbg_cmd.c 		switch (param->type) {
type               96 sapi/phpdbg/phpdbg_cmd.c 	switch (param->type) {
type              138 sapi/phpdbg/phpdbg_cmd.c 	switch ((dest->type = src->type)) {
type              196 sapi/phpdbg/phpdbg_cmd.c 	zend_ulong hash = param->type;
type              198 sapi/phpdbg/phpdbg_cmd.c 	switch (param->type) {
type              252 sapi/phpdbg/phpdbg_cmd.c 		if (l->type == r->type) {
type              253 sapi/phpdbg/phpdbg_cmd.c 			switch (l->type) {
type              325 sapi/phpdbg/phpdbg_cmd.c 	if (param && param->type) {
type              326 sapi/phpdbg/phpdbg_cmd.c 		switch (param->type) {
type              385 sapi/phpdbg/phpdbg_cmd.c 			switch (remove->type) {
type              462 sapi/phpdbg/phpdbg_cmd.c 	stack->type = STACK_PARAM;
type              480 sapi/phpdbg/phpdbg_cmd.c 			if (!top || top->type == STACK_PARAM) {
type              510 sapi/phpdbg/phpdbg_cmd.c } else if ((a)->type != (t)) { \
type              520 sapi/phpdbg/phpdbg_cmd.c 			if (top && top->type == STACK_PARAM) {
type              655 sapi/phpdbg/phpdbg_cmd.c 	if (command->subs && (*top) && ((*top)->type == STR_PARAM)) {
type              668 sapi/phpdbg/phpdbg_cmd.c 	switch (top->type) {
type              720 sapi/phpdbg/phpdbg_cmd.c 	if (stack->type != STACK_PARAM) {
type              731 sapi/phpdbg/phpdbg_cmd.c 		if (top->type == STACK_PARAM) {
type               54 sapi/phpdbg/phpdbg_cmd.h 	phpdbg_param_type type;
type               72 sapi/phpdbg/phpdbg_cmd.h 	(v)->type = (t); \
type               97 sapi/phpdbg/phpdbg_frame.c 	zval *funcname, *class, class_zv, *type, *args, *argstmp;
type              109 sapi/phpdbg/phpdbg_frame.c 		type = zend_hash_str_find(Z_ARRVAL_P(tmp), ZEND_STRL("type"));
type              114 sapi/phpdbg/phpdbg_frame.c 	phpdbg_xml(" symbol=\"%s%s%s\"", class ? Z_STRVAL_P(class) : "", class ? Z_STRVAL_P(type) : "", Z_STRVAL_P(funcname));
type              122 sapi/phpdbg/phpdbg_frame.c 	phpdbg_out("%s%s%s(", class ? Z_STRVAL_P(class) : "", class ? Z_STRVAL_P(type) : "", Z_STRVAL_P(funcname));
type              148 sapi/phpdbg/phpdbg_frame.c 					if (func->type == ZEND_INTERNAL_FUNCTION) {
type              217 sapi/phpdbg/phpdbg_help.c 	if (!param || param->type == EMPTY_PARAM) {
type              222 sapi/phpdbg/phpdbg_help.c 	if (param && param->type == STR_PARAM) {
type              241 sapi/phpdbg/phpdbg_info.c 							const char *type = zend_rsrc_list_get_rsrc_type(Z_RES_P(data));
type              242 sapi/phpdbg/phpdbg_info.c 							VARIABLEINFO("type=\"%s\"", "\n|-------(typeof)------> (%s)\n", type ? type : "unknown");
type              378 sapi/phpdbg/phpdbg_info.c 	const char *visibility = ce->type == ZEND_USER_CLASS ? "User" : "Internal";
type              379 sapi/phpdbg/phpdbg_info.c 	const char *type = (ce->ce_flags & ZEND_ACC_INTERFACE) ? "Interface" : (ce->ce_flags & ZEND_ACC_ABSTRACT) ? "Abstract Class" : "Class";
type              381 sapi/phpdbg/phpdbg_info.c 	phpdbg_writeln("class", "type=\"%s\" flags=\"%s\" name=\"%.*s\" methodcount=\"%d\"", "%s %s %.*s (%d)", visibility, type, (int) ZSTR_LEN(ce->name), ZSTR_VAL(ce->name), zend_hash_num_elements(&ce->function_table));
type              393 sapi/phpdbg/phpdbg_info.c 			if (ce->type == ZEND_USER_CLASS) {
type              439 sapi/phpdbg/phpdbg_info.c 			if (zf->type == ZEND_USER_FUNCTION) {
type               56 sapi/phpdbg/phpdbg_list.c 	switch (param->type) {
type              110 sapi/phpdbg/phpdbg_list.c 		if (ce->type == ZEND_USER_CLASS) {
type              184 sapi/phpdbg/phpdbg_list.c 	if (fbc->type != ZEND_USER_FUNCTION) {
type              235 sapi/phpdbg/phpdbg_list.c zend_op_array *phpdbg_compile_file(zend_file_handle *file, int type) {
type              257 sapi/phpdbg/phpdbg_list.c 	fake.type = ZEND_HANDLE_MAPPED;
type              277 sapi/phpdbg/phpdbg_list.c 	ret = PHPDBG_G(compile_file)(&fake, type);
type              295 sapi/phpdbg/phpdbg_list.c zend_op_array *phpdbg_init_compile_file(zend_file_handle *file, int type) {
type              305 sapi/phpdbg/phpdbg_list.c 	op_array = PHPDBG_G(init_compile_file)(file, type);
type               39 sapi/phpdbg/phpdbg_opcode.c static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, uint32_t type) /* {{{ */
type               43 sapi/phpdbg/phpdbg_opcode.c 	switch (type) {
type              952 sapi/phpdbg/phpdbg_out.c static int phpdbg_process_print(int fd, int type, const char *tag, const char *msg, int msglen, const char *xml, int xmllen) {
type              957 sapi/phpdbg/phpdbg_out.c 	if ((PHPDBG_G(flags) & PHPDBG_WRITE_XML) && PHPDBG_G(in_script_xml) && PHPDBG_G(in_script_xml) != type) {
type              962 sapi/phpdbg/phpdbg_out.c 	switch (type) {
type             1027 sapi/phpdbg/phpdbg_out.c 					if (PHPDBG_G(in_script_xml) != type) {
type             1029 sapi/phpdbg/phpdbg_out.c 						int stream_buflen = phpdbg_asprintf(&stream_buf, "<stream type=\"%s\">", type == P_STDERR ? "stderr" : "stdout");
type             1032 sapi/phpdbg/phpdbg_out.c 						PHPDBG_G(in_script_xml) = type;
type             1098 sapi/phpdbg/phpdbg_out.c PHPDBG_API int phpdbg_vprint(int type, int fd, const char *tag, const char *xmlfmt, const char *strfmt, va_list args) {
type             1120 sapi/phpdbg/phpdbg_out.c 	if (PHPDBG_G(err_buf).active && type != P_STDOUT && type != P_STDERR) {
type             1123 sapi/phpdbg/phpdbg_out.c 		PHPDBG_G(err_buf).type = type;
type             1136 sapi/phpdbg/phpdbg_out.c 	len = phpdbg_process_print(fd, type, tag, msg, msglen, xml, xmllen);
type             1150 sapi/phpdbg/phpdbg_out.c 	if (PHPDBG_G(err_buf).type == 0) {
type             1154 sapi/phpdbg/phpdbg_out.c 	PHPDBG_G(err_buf).type = 0;
type             1179 sapi/phpdbg/phpdbg_out.c 	len = phpdbg_vprint(PHPDBG_G(err_buf).type, PHPDBG_G(err_buf).fd, tag ? tag : PHPDBG_G(err_buf).tag, xmlfmt, strfmt, args);
type             1188 sapi/phpdbg/phpdbg_out.c PHPDBG_API int phpdbg_print(int type, int fd, const char *tag, const char *xmlfmt, const char *strfmt, ...) {
type             1197 sapi/phpdbg/phpdbg_out.c 	len = phpdbg_vprint(type, fd, tag, xmlfmt, strfmt, args);
type               47 sapi/phpdbg/phpdbg_out.h #define phpdbg_script(type, fmt, ...)                       phpdbg_print(type     , PHPDBG_G(io)[PHPDBG_STDOUT].fd, NULL, NULL,   fmt,    ##__VA_ARGS__)
type               56 sapi/phpdbg/phpdbg_out.h #define phpdbg_script_ex(out, type, fmt, ...)               phpdbg_print(type     , out, NULL, NULL,   fmt,    ##__VA_ARGS__)
type               89 sapi/phpdbg/phpdbg_parser.y 		$$.type = FILE_PARAM;
type               94 sapi/phpdbg/phpdbg_parser.y 		$$.type = NUMERIC_FILE_PARAM;
type               99 sapi/phpdbg/phpdbg_parser.y 		$$.type = FILE_PARAM;
type              109 sapi/phpdbg/phpdbg_parser.y 		$$.type = NUMERIC_FILE_PARAM;
type              119 sapi/phpdbg/phpdbg_parser.y 		$$.type = METHOD_PARAM;
type              124 sapi/phpdbg/phpdbg_parser.y 		$$.type = NUMERIC_METHOD_PARAM;
type              130 sapi/phpdbg/phpdbg_parser.y 		$$.type = NUMERIC_FUNCTION_PARAM;
type              136 sapi/phpdbg/phpdbg_parser.y 		$$.type = COND_PARAM;
type              156 sapi/phpdbg/phpdbg_parser.y 		$$.type = EVAL_PARAM;
type              161 sapi/phpdbg/phpdbg_parser.y 		$$.type = SHELL_PARAM;
type              166 sapi/phpdbg/phpdbg_parser.y 		$$.type = RUN_PARAM;
type              170 sapi/phpdbg/phpdbg_parser.y 		$$.type = RUN_PARAM;
type               55 sapi/phpdbg/phpdbg_print.c 	switch (method->type) {
type              155 sapi/phpdbg/phpdbg_print.c 			(ce->type == ZEND_USER_CLASS) ?
type              194 sapi/phpdbg/phpdbg_print.c 				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
type              196 sapi/phpdbg/phpdbg_print.c 				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
type              242 sapi/phpdbg/phpdbg_print.c 				(fbc->type == ZEND_USER_FUNCTION) ? "User" : "Internal",
type              245 sapi/phpdbg/phpdbg_print.c 				(fbc->type == ZEND_USER_FUNCTION) ? fbc->op_array.last : 0);
type              271 sapi/phpdbg/phpdbg_print.c 			if (func->type == ZEND_USER_FUNCTION && *rt_name->val == '\0') {
type              288 sapi/phpdbg/phpdbg_print.c 	if (ce->type != ZEND_USER_CLASS) {
type              307 sapi/phpdbg/phpdbg_print.c 			if (ce->type == ZEND_USER_CLASS && *rt_name->val == '\0') {
type              326 sapi/phpdbg/phpdbg_print.c 		(ce->type == ZEND_USER_CLASS) ?
type              335 sapi/phpdbg/phpdbg_print.c 	if (ce->type != ZEND_USER_CLASS) {
type              365 sapi/phpdbg/phpdbg_print.c 			if (ce->type == ZEND_USER_CLASS && *rt_name->val == '\0') {
type              391 sapi/phpdbg/phpdbg_print.c 			if (func->type == ZEND_USER_FUNCTION) {
type              398 sapi/phpdbg/phpdbg_print.c 			if (ce->type == ZEND_USER_CLASS) {
type              104 sapi/phpdbg/phpdbg_prompt.c 	if (stack->type == STACK_PARAM) {
type              109 sapi/phpdbg/phpdbg_prompt.c 		if (!name || name->type != STR_PARAM) {
type              139 sapi/phpdbg/phpdbg_prompt.c 					switch (next->type) {
type              706 sapi/phpdbg/phpdbg_prompt.c 		if (param && param->type != EMPTY_PARAM && param->len != 0) {
type              889 sapi/phpdbg/phpdbg_prompt.c 	if (!param || param->type == EMPTY_PARAM) {
type              891 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type              955 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type             1128 sapi/phpdbg/phpdbg_prompt.c 		module_entry->type = MODULE_PERSISTENT;
type             1165 sapi/phpdbg/phpdbg_prompt.c 	const char *type;
type             1168 sapi/phpdbg/phpdbg_prompt.c 	if (!param || param->type == EMPTY_PARAM) {
type             1174 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type             1180 sapi/phpdbg/phpdbg_prompt.c 			if ((type = phpdbg_load_module_or_extension(&path, &name)) == NULL) {
type             1184 sapi/phpdbg/phpdbg_prompt.c 				phpdbg_notice("dl", "extensiontype=\"%s\" name=\"%s\" path=\"%s\"", "Successfully loaded the %s %s at path %s", type, name, path);
type             1306 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type             1328 sapi/phpdbg/phpdbg_prompt.c 	if (!param || param->type == EMPTY_PARAM) {
type             1330 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type             1367 sapi/phpdbg/phpdbg_prompt.c #define PARA ((phpdbg_param_t *)stack.next)->type
type             1432 sapi/phpdbg/phpdbg_prompt.c 		if (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type)) { \
type             1453 sapi/phpdbg/phpdbg_prompt.c 				if (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) \
type             1508 sapi/phpdbg/phpdbg_prompt.c 				if (!prev_ex->func || !ZEND_USER_CODE(prev_ex->func->common.type)) {
type             1612 sapi/phpdbg/phpdbg_prompt.c 			    && (brake->type != PHPDBG_BREAK_FILE || execute_data->opline->lineno != PHPDBG_G(last_line))) {
type             1634 sapi/phpdbg/phpdbg_prompt.c 		     execute_data->call->func->type == ZEND_USER_FUNCTION) {
type             1661 sapi/phpdbg/phpdbg_prompt.c 			if (ZEND_USER_CODE(data->func->type)) {
type             1688 sapi/phpdbg/phpdbg_prompt.c 	if (!param || param->type == EMPTY_PARAM) {
type             1690 sapi/phpdbg/phpdbg_prompt.c 	} else switch (param->type) {
type               52 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type               63 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type               65 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type               83 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type               85 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type               99 sapi/phpdbg/phpdbg_set.c 	switch (param->type) {
type              126 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              128 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              183 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              185 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              204 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              206 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              233 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              235 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              252 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              254 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              273 sapi/phpdbg/phpdbg_set.c 	if (!param || param->type == EMPTY_PARAM) {
type              275 sapi/phpdbg/phpdbg_set.c 	} else switch (param->type) {
type              103 sapi/phpdbg/phpdbg_utils.h 	while (!ex->func || !ZEND_USER_CODE(ex->func->common.type)) {
type               26 sapi/phpdbg/phpdbg_wait.c static void phpdbg_rebuild_http_globals_array(int type, const char *name) {
type               28 sapi/phpdbg/phpdbg_wait.c 	if (Z_TYPE(PG(http_globals)[type]) != IS_UNDEF) {
type               29 sapi/phpdbg/phpdbg_wait.c 		zval_dtor(&PG(http_globals)[type]);
type               33 sapi/phpdbg/phpdbg_wait.c 		PG(http_globals)[type] = *zvp;
type              157 sapi/phpdbg/phpdbg_watch.c 	watch->type = WATCH_ON_ZVAL;
type              162 sapi/phpdbg/phpdbg_watch.c 	watch->type = WATCH_ON_HASHTABLE;
type              189 sapi/phpdbg/phpdbg_watch.c 	watch->type = WATCH_ON_REFCOUNTED;
type              305 sapi/phpdbg/phpdbg_watch.c 	if (parent->type == WATCH_ON_HASHTABLE) {
type              312 sapi/phpdbg/phpdbg_watch.c 	ZEND_ASSERT(parent->type == WATCH_ON_ZVAL);
type              325 sapi/phpdbg/phpdbg_watch.c 	if (watch->type == WATCH_ON_ZVAL) {
type              336 sapi/phpdbg/phpdbg_watch.c 	if (!watch->parent || watch->parent->type != WATCH_ON_ZVAL || watch->type == WATCH_ON_HASHTABLE) {
type              366 sapi/phpdbg/phpdbg_watch.c 			if (watch->parent && watch->parent->type == WATCH_ON_HASHTABLE) {
type              375 sapi/phpdbg/phpdbg_watch.c 	if (watch->parent && watch->parent->type == WATCH_ON_ZVAL && Z_REFCOUNTED_P(watch->parent->addr.zv)) {
type              379 sapi/phpdbg/phpdbg_watch.c 	if (watch->type == WATCH_ON_ZVAL) {
type              443 sapi/phpdbg/phpdbg_watch.c 	if (watch->type != WATCH_ON_ZVAL) {
type              458 sapi/phpdbg/phpdbg_watch.c 	ZEND_ASSERT(watch->type == WATCH_ON_HASHTABLE);
type              492 sapi/phpdbg/phpdbg_watch.c 	ZEND_ASSERT(watch->type == WATCH_ON_ZVAL);
type              532 sapi/phpdbg/phpdbg_watch.c 	if (parent->type == WATCH_ON_HASHTABLE && --parent->implicit_ht_count) {
type              538 sapi/phpdbg/phpdbg_watch.c 		if (parent->type == WATCH_ON_ZVAL && Z_REFCOUNTED_P(watch->addr.zv)) {
type              547 sapi/phpdbg/phpdbg_watch.c 	if (watch->type == WATCH_ON_HASHTABLE) {
type              560 sapi/phpdbg/phpdbg_watch.c 	} else if (watch->type == WATCH_ON_ZVAL) {
type              595 sapi/phpdbg/phpdbg_watch.c 	if (watch->type == WATCH_ON_ZVAL) {
type              597 sapi/phpdbg/phpdbg_watch.c 	} else if (watch->type == WATCH_ON_HASHTABLE) {
type              696 sapi/phpdbg/phpdbg_watch.c 	switch (param->type) {
type              717 sapi/phpdbg/phpdbg_watch.c 	switch (param->type) {
type              736 sapi/phpdbg/phpdbg_watch.c 	switch (param->type) {
type              855 sapi/phpdbg/phpdbg_watch.c 		if (watch->type == WATCH_ON_ZVAL) {
type              857 sapi/phpdbg/phpdbg_watch.c 		} else if (watch->type == WATCH_ON_HASHTABLE) {
type              930 sapi/phpdbg/phpdbg_watch.c 		if ((watch->type == WATCH_ON_HASHTABLE || watch->type == WATCH_ON_ZVAL) && watch->parent_container) {
type              936 sapi/phpdbg/phpdbg_watch.c 				if (watch->type == WATCH_ON_HASHTABLE) {
type              965 sapi/phpdbg/phpdbg_watch.c 			switch (watch->type) {
type             1000 sapi/phpdbg/phpdbg_watch.c 			switch (watch->type) {
type             1128 sapi/phpdbg/phpdbg_watch.c 			phpdbg_writeln("watchvariable", "variable=\"%.*s\" on=\"%s\" type=\"%s\"", "%.*s (%s, %s)", (int) ZSTR_LEN(watch->str), ZSTR_VAL(watch->str), watch->type == WATCH_ON_HASHTABLE ? "array" : watch->type == WATCH_ON_REFCOUNTED ? "refcount" : "variable", watch->flags == PHPDBG_WATCH_RECURSIVE ? "recursive" : "simple");
type             1144 sapi/phpdbg/phpdbg_watch.c 			if (watch->type == WATCH_ON_REFCOUNTED) {
type             1149 sapi/phpdbg/phpdbg_watch.c 				if (watch->type == WATCH_ON_ZVAL) {
type             1152 sapi/phpdbg/phpdbg_watch.c 				if (watch->type == WATCH_ON_HASHTABLE && (watch->flags & PHPDBG_WATCH_SIMPLE)) {
type             1156 sapi/phpdbg/phpdbg_watch.c 				if (watch->type == WATCH_ON_HASHTABLE || watch->parent == NULL || watch->parent->type != WATCH_ON_ZVAL) { /* no references */
type               69 sapi/phpdbg/phpdbg_watch.h 	phpdbg_watchtype type;
type               90 win32/registry.c 			DWORD name_len, type, value_len;
type               99 win32/registry.c 				if (RegEnumValue(key, i, name, &name_len, NULL, &type, value, &value_len) == ERROR_SUCCESS) {
type              100 win32/registry.c 					if ((type == REG_SZ) || (type == REG_EXPAND_SZ)) {
type               31 win32/sockets.c PHPAPI int socketpair(int domain, int type, int protocol, SOCKET sock[2])
type               45 win32/sockets.c 	sock[0]	= socket(domain, type, protocol);
type               66 win32/sockets.c 	sock[1] = socket(domain, type, protocol);
type               26 win32/sockets.h PHPAPI int socketpair(int domain, int type, int protocol, SOCKET sock[2]);