val               104 Zend/zend.c    	zend_long *p, val;
val               115 Zend/zend.c    	val = zend_atol(ZSTR_VAL(new_value), (int)ZSTR_LEN(new_value));
val               119 Zend/zend.c    	    *p != val &&
val               120 Zend/zend.c    	    (*p < 0 || val < 0)) {
val               125 Zend/zend.c    	*p = val;
val              1131 Zend/zend_API.c 			zval *val;
val              1135 Zend/zend_API.c 			ZEND_HASH_FOREACH_VAL(&class_type->constants_table, val) {
val              1136 Zend/zend_API.c 				ZVAL_DEREF(val);
val              1137 Zend/zend_API.c 				if (Z_CONSTANT_P(val)) {
val              1138 Zend/zend_API.c 					if (UNEXPECTED(zval_update_constant_ex(val, 1, class_type) != SUCCESS)) {
val              1149 Zend/zend_API.c 							val = CE_STATIC_MEMBERS(class_type) + prop_info->offset;
val              1151 Zend/zend_API.c 							val = (zval*)((char*)class_type->default_properties_table + prop_info->offset - OBJ_PROP_TO_OFFSET(0));
val              1153 Zend/zend_API.c 						ZVAL_DEREF(val);
val              1154 Zend/zend_API.c 						if (Z_CONSTANT_P(val)) {
val              1156 Zend/zend_API.c 							if (UNEXPECTED(zval_update_constant_ex(val, 1, NULL) != SUCCESS)) {
val              1878 Zend/zend_API.c 		m = (zend_module_entry*)Z_PTR(b1->val);
val              1885 Zend/zend_API.c 						r = (zend_module_entry*)Z_PTR(b2->val);
val                66 Zend/zend_ast.c 	ZVAL_COPY_VALUE(&ast->val, zv);
val                67 Zend/zend_ast.c 	ast->val.u2.lineno = CG(zend_lineno);
val               422 Zend/zend_ast.c 		ZVAL_COPY(&new->val, zend_ast_get_zval(ast));
val               867 Zend/zend_ast.c 	zval *val;
val               897 Zend/zend_ast.c 			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(zv), idx, key, val) {
val               911 Zend/zend_ast.c 				zend_ast_export_zval(str, val, 0, indent);
val               174 Zend/zend_ast.h 	zval val;
val               226 Zend/zend_ast.h 	return &((zend_ast_zval *) ast)->val;
val               749 Zend/zend_builtin_functions.c 	zval *val;
val               752 Zend/zend_builtin_functions.c 	ZEND_HASH_FOREACH_VAL_IND(ht, val) {
val               753 Zend/zend_builtin_functions.c 		ZVAL_DEREF(val);
val               754 Zend/zend_builtin_functions.c 		if (Z_REFCOUNTED_P(val)) {
val               755 Zend/zend_builtin_functions.c 			if (Z_TYPE_P(val) == IS_ARRAY) {
val               756 Zend/zend_builtin_functions.c 				if (!Z_IMMUTABLE_P(val)) {
val               757 Zend/zend_builtin_functions.c 					if (Z_ARRVAL_P(val)->u.v.nApplyCount > 0) {
val               761 Zend/zend_builtin_functions.c 					} else if (!validate_constant_array(Z_ARRVAL_P(val))) {
val               766 Zend/zend_builtin_functions.c 			} else if (Z_TYPE_P(val) != IS_STRING && Z_TYPE_P(val) != IS_RESOURCE) {
val               782 Zend/zend_builtin_functions.c 	zval *new_val, *val;
val               785 Zend/zend_builtin_functions.c 	ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(src), idx, key, val) {
val               787 Zend/zend_builtin_functions.c 		ZVAL_DEREF(val);
val               789 Zend/zend_builtin_functions.c 			new_val = zend_hash_add_new(Z_ARRVAL_P(dst), key, val);
val               791 Zend/zend_builtin_functions.c 			new_val = zend_hash_index_add_new(Z_ARRVAL_P(dst), idx, val);
val               793 Zend/zend_builtin_functions.c 		if (Z_TYPE_P(val) == IS_ARRAY) {
val               794 Zend/zend_builtin_functions.c 			if (!Z_IMMUTABLE_P(val)) {
val               795 Zend/zend_builtin_functions.c 				copy_constant_array(new_val, val);
val               797 Zend/zend_builtin_functions.c 		} else if (Z_REFCOUNTED_P(val)) {
val               798 Zend/zend_builtin_functions.c 			Z_ADDREF_P(val);
val               799 Zend/zend_builtin_functions.c 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_RESOURCE_EX)) {
val               812 Zend/zend_builtin_functions.c 	zval *val, val_free;
val               818 Zend/zend_builtin_functions.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|b", &name, &val, &non_cs) == FAILURE) {
val               824 Zend/zend_builtin_functions.c 		Z_PARAM_ZVAL(val)
val               843 Zend/zend_builtin_functions.c 	switch (Z_TYPE_P(val)) {
val               852 Zend/zend_builtin_functions.c 			ZVAL_COPY(&val_free, val);
val               855 Zend/zend_builtin_functions.c 			val = &val_free;
val               858 Zend/zend_builtin_functions.c 			if (!Z_IMMUTABLE_P(val)) {
val               859 Zend/zend_builtin_functions.c 				if (!validate_constant_array(Z_ARRVAL_P(val))) {
val               862 Zend/zend_builtin_functions.c 					copy_constant_array(&c.value, val);
val               869 Zend/zend_builtin_functions.c 				if (Z_OBJ_HT_P(val)->get) {
val               871 Zend/zend_builtin_functions.c 					val = Z_OBJ_HT_P(val)->get(val, &rv);
val               872 Zend/zend_builtin_functions.c 					ZVAL_COPY_VALUE(&val_free, val);
val               874 Zend/zend_builtin_functions.c 				} else if (Z_OBJ_HT_P(val)->cast_object) {
val               875 Zend/zend_builtin_functions.c 					if (Z_OBJ_HT_P(val)->cast_object(val, &val_free, IS_STRING) == SUCCESS) {
val               876 Zend/zend_builtin_functions.c 						val = &val_free;
val               888 Zend/zend_builtin_functions.c 	ZVAL_DUP(&c.value, val);
val              2085 Zend/zend_builtin_functions.c 	zval *val;
val              2093 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
val              2095 Zend/zend_builtin_functions.c 				Z_ADDREF_P(val);
val              2096 Zend/zend_builtin_functions.c 				zend_hash_index_add_new(Z_ARRVAL_P(return_value), index, val);
val              2101 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
val              2102 Zend/zend_builtin_functions.c 			if (!key && Z_RES_TYPE_P(val) <= 0) {
val              2103 Zend/zend_builtin_functions.c 				Z_ADDREF_P(val);
val              2104 Zend/zend_builtin_functions.c 				zend_hash_index_add_new(Z_ARRVAL_P(return_value), index, val);
val              2116 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) {
val              2117 Zend/zend_builtin_functions.c 			if (!key && Z_RES_TYPE_P(val) == id) {
val              2118 Zend/zend_builtin_functions.c 				Z_ADDREF_P(val);
val              2119 Zend/zend_builtin_functions.c 				zend_hash_index_add_new(Z_ARRVAL_P(return_value), index, val);
val              2193 Zend/zend_builtin_functions.c 		zend_constant *val;
val              2210 Zend/zend_builtin_functions.c 		ZEND_HASH_FOREACH_PTR(EG(zend_constants), val) {
val              2211 Zend/zend_builtin_functions.c 			if (!val->name) {
val              2216 Zend/zend_builtin_functions.c 			if (val->module_number == PHP_USER_CONSTANT) {
val              2218 Zend/zend_builtin_functions.c 			} else if (val->module_number > i || val->module_number < 0) {
val              2222 Zend/zend_builtin_functions.c 				module_number = val->module_number;
val              2230 Zend/zend_builtin_functions.c 			ZVAL_DUP(&const_val, &val->value);
val              2231 Zend/zend_builtin_functions.c 			zend_hash_add_new(Z_ARRVAL(modules[module_number]), val->name, &const_val);
val               418 Zend/zend_closures.c 	zval val;
val               429 Zend/zend_closures.c 		ZVAL_ARR(&val, zend_array_dup(static_variables));
val               430 Zend/zend_closures.c 		zend_hash_str_update(debug_info, "static", sizeof("static")-1, &val);
val               443 Zend/zend_closures.c 		array_init(&val);
val               462 Zend/zend_closures.c 			zend_hash_update(Z_ARRVAL(val), name, &info);
val               466 Zend/zend_closures.c 		zend_hash_str_update(debug_info, "parameter", sizeof("parameter")-1, &val);
val              1536 Zend/zend_execute_API.c 					zval *val = Z_INDIRECT_P(zv);
val              1538 Zend/zend_execute_API.c 					ZVAL_COPY_VALUE(var, val);
val               126 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val) \
val               128 Zend/zend_float.h                 double _xpfpa_result = (val); \
val               132 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val) \
val               134 Zend/zend_float.h                 float _xpfpa_result = (val); \
val               139 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
val               141 Zend/zend_float.h                 long double _xpfpa_result = (val); \
val               185 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val) \
val               187 Zend/zend_float.h                 double _xpfpa_result = (val); \
val               191 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val) \
val               193 Zend/zend_float.h                 float _xpfpa_result = (val); \
val               198 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
val               200 Zend/zend_float.h                 long double _xpfpa_result = (val); \
val               245 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val) \
val               247 Zend/zend_float.h                 volatile double _xpfpa_result = (val); \
val               251 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val) \
val               253 Zend/zend_float.h                 volatile float _xpfpa_result = (val); \
val               257 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
val               259 Zend/zend_float.h                 volatile long double _xpfpa_result = (val); \
val               301 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val) \
val               303 Zend/zend_float.h                 volatile double _xpfpa_result = (val); \
val               307 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val) \
val               309 Zend/zend_float.h                 volatile float _xpfpa_result = (val); \
val               313 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
val               315 Zend/zend_float.h                 volatile long double _xpfpa_result = (val); \
val               379 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val) \
val               381 Zend/zend_float.h                 volatile double _xpfpa_result = (val); \
val               385 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val) \
val               387 Zend/zend_float.h                 volatile float _xpfpa_result = (val); \
val               391 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
val               393 Zend/zend_float.h                 volatile long double _xpfpa_result = (val); \
val               414 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE(val)           return (val)
val               415 Zend/zend_float.h # define XPFPA_RETURN_SINGLE(val)           return (val)
val               416 Zend/zend_float.h # define XPFPA_RETURN_DOUBLE_EXTENDED(val)  return (val)
val               101 Zend/zend_gc.c 			obj->ce->name->val, obj->handle);
val               358 Zend/zend_gc.c 		if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
val               359 Zend/zend_gc.c 			ref = Z_COUNTED(((zend_reference*)ref)->val);
val               375 Zend/zend_gc.c 		zv = &end->val;
val               385 Zend/zend_gc.c 		zv = &p->val;
val               398 Zend/zend_gc.c 	zv = &p->val;
val               464 Zend/zend_gc.c 			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
val               466 Zend/zend_gc.c 					Z_TYPE(((zend_reference*)ref)->val) == IS_OBJECT) {
val               467 Zend/zend_gc.c 					Z_TYPE_INFO(((zend_reference*)ref)->val) = IS_NULL;
val               470 Zend/zend_gc.c 				ref = Z_COUNTED(((zend_reference*)ref)->val);
val               484 Zend/zend_gc.c 			zv = &end->val;
val               494 Zend/zend_gc.c 			zv = &p->val;
val               510 Zend/zend_gc.c 		zv = &p->val;
val               590 Zend/zend_gc.c 				if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
val               591 Zend/zend_gc.c 					ref = Z_COUNTED(((zend_reference*)ref)->val);
val               604 Zend/zend_gc.c 				zv = &end->val;
val               614 Zend/zend_gc.c 				zv = &p->val;
val               624 Zend/zend_gc.c 			zv = &p->val;
val               780 Zend/zend_gc.c 			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
val               781 Zend/zend_gc.c 				ref = Z_COUNTED(((zend_reference*)ref)->val);
val               795 Zend/zend_gc.c 			zv = &end->val;
val               809 Zend/zend_gc.c 			zv = &p->val;
val               823 Zend/zend_gc.c 		zv = &p->val;
val               937 Zend/zend_gc.c 			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
val               938 Zend/zend_gc.c 				ref = Z_COUNTED(((zend_reference*)ref)->val);
val               951 Zend/zend_gc.c 			zv = &end->val;
val               961 Zend/zend_gc.c 			zv = &p->val;
val               971 Zend/zend_gc.c 		zv = &p->val;
val               559 Zend/zend_generators.c 			value = &p->val;
val               290 Zend/zend_hash.c        zval *val;
val               293 Zend/zend_hash.c 	   ZEND_HASH_FOREACH_VAL(ht, val) {
val               294 Zend/zend_hash.c 		   if (Z_TYPE_P(val) == IS_UNDEF) continue;
val               295 Zend/zend_hash.c 		   if (Z_TYPE_P(val) == IS_INDIRECT) {
val               296 Zend/zend_hash.c 			   if (UNEXPECTED(Z_TYPE_P(Z_INDIRECT_P(val)) == IS_UNDEF)) {
val               504 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val               527 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val               547 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val               577 Zend/zend_hash.c 				ZEND_ASSERT(&p->val != pData);
val               578 Zend/zend_hash.c 				data = &p->val;
val               588 Zend/zend_hash.c 				ZEND_ASSERT(&p->val != pData);
val               589 Zend/zend_hash.c 				data = &p->val;
val               622 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&p->val, pData);
val               624 Zend/zend_hash.c 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               628 Zend/zend_hash.c 	return &p->val;
val               739 Zend/zend_hash.c 			if (Z_TYPE(p->val) != IS_UNDEF) {
val               744 Zend/zend_hash.c 					ht->pDestructor(&p->val);
val               746 Zend/zend_hash.c 				ZVAL_COPY_VALUE(&p->val, pData);
val               750 Zend/zend_hash.c 				return &p->val;
val               773 Zend/zend_hash.c 					ZVAL_UNDEF(&q->val);
val               789 Zend/zend_hash.c 		ZVAL_COPY_VALUE(&p->val, pData);
val               793 Zend/zend_hash.c 		return &p->val;
val               803 Zend/zend_hash.c 			ZEND_ASSERT(&p->val != pData);
val               806 Zend/zend_hash.c 				ht->pDestructor(&p->val);
val               808 Zend/zend_hash.c 			ZVAL_COPY_VALUE(&p->val, pData);
val               813 Zend/zend_hash.c 			return &p->val;
val               834 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&p->val, pData);
val               835 Zend/zend_hash.c 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               839 Zend/zend_hash.c 	return &p->val;
val               922 Zend/zend_hash.c 			Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               928 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) {
val               935 Zend/zend_hash.c 						if (EXPECTED(Z_TYPE_INFO(p->val) != IS_UNDEF)) {
val               936 Zend/zend_hash.c 							ZVAL_COPY_VALUE(&q->val, &p->val);
val               940 Zend/zend_hash.c 							Z_NEXT(q->val) = HT_HASH(ht, nIndex);
val               954 Zend/zend_hash.c 						if (EXPECTED(Z_TYPE_INFO(p->val) != IS_UNDEF)) {
val               955 Zend/zend_hash.c 							ZVAL_COPY_VALUE(&q->val, &p->val);
val               959 Zend/zend_hash.c 							Z_NEXT(q->val) = HT_HASH(ht, nIndex);
val               977 Zend/zend_hash.c 			Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               990 Zend/zend_hash.c 			Z_NEXT(prev->val) = Z_NEXT(p->val);
val               992 Zend/zend_hash.c 			HT_HASH(ht, p->h | ht->nTableMask) = Z_NEXT(p->val);
val               998 Zend/zend_hash.c 		} while (ht->nNumUsed > 0 && (UNEXPECTED(Z_TYPE(ht->arData[ht->nNumUsed-1].val) == IS_UNDEF)));
val              1010 Zend/zend_hash.c 			} else if (Z_TYPE(ht->arData[new_idx].val) != IS_UNDEF) {
val              1024 Zend/zend_hash.c 		ZVAL_COPY_VALUE(&tmp, &p->val);
val              1025 Zend/zend_hash.c 		ZVAL_UNDEF(&p->val);
val              1028 Zend/zend_hash.c 		ZVAL_UNDEF(&p->val);
val              1043 Zend/zend_hash.c 			while (Z_NEXT(prev->val) != idx) {
val              1044 Zend/zend_hash.c 				i = Z_NEXT(prev->val);
val              1086 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val              1113 Zend/zend_hash.c 			if (Z_TYPE(p->val) == IS_INDIRECT) {
val              1114 Zend/zend_hash.c 				zval *data = Z_INDIRECT(p->val);
val              1135 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val              1161 Zend/zend_hash.c 			if (Z_TYPE(p->val) == IS_INDIRECT) {
val              1162 Zend/zend_hash.c 				zval *data = Z_INDIRECT(p->val);
val              1179 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val              1209 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val              1227 Zend/zend_hash.c 			if (Z_TYPE(p->val) != IS_UNDEF) {
val              1244 Zend/zend_hash.c 		idx = Z_NEXT(p->val);
val              1265 Zend/zend_hash.c 						ht->pDestructor(&p->val);
val              1269 Zend/zend_hash.c 						if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1270 Zend/zend_hash.c 							ht->pDestructor(&p->val);
val              1276 Zend/zend_hash.c 					ht->pDestructor(&p->val);
val              1283 Zend/zend_hash.c 					if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1284 Zend/zend_hash.c 						ht->pDestructor(&p->val);
val              1296 Zend/zend_hash.c 					if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1335 Zend/zend_hash.c 				i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1339 Zend/zend_hash.c 				i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1346 Zend/zend_hash.c 				if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1347 Zend/zend_hash.c 					i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1378 Zend/zend_hash.c 						ht->pDestructor(&p->val);
val              1382 Zend/zend_hash.c 						if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1383 Zend/zend_hash.c 							ht->pDestructor(&p->val);
val              1389 Zend/zend_hash.c 					ht->pDestructor(&p->val);
val              1396 Zend/zend_hash.c 					if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1397 Zend/zend_hash.c 						ht->pDestructor(&p->val);
val              1414 Zend/zend_hash.c 						if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1445 Zend/zend_hash.c 				i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1449 Zend/zend_hash.c 				i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1454 Zend/zend_hash.c 				if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
val              1455 Zend/zend_hash.c 					i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
val              1478 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1501 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1533 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1534 Zend/zend_hash.c 		result = apply_func(&p->val);
val              1559 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1560 Zend/zend_hash.c 		result = apply_func(&p->val, argument);
val              1588 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1593 Zend/zend_hash.c 		result = apply_func(&p->val, num_args, args, &hash_key);
val              1623 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1625 Zend/zend_hash.c 		result = apply_func(&p->val);
val              1652 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1658 Zend/zend_hash.c 		data = &p->val;
val              1676 Zend/zend_hash.c 		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
val              1686 Zend/zend_hash.c 	zval *data = &p->val;
val              1718 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&q->val, data);
val              1732 Zend/zend_hash.c 		Z_NEXT(q->val) = HT_HASH(target, nIndex);
val              1747 Zend/zend_hash.c 				ZVAL_UNDEF(&q->val);
val              1816 Zend/zend_hash.c 			while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
val              1839 Zend/zend_hash.c 			while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
val              1888 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1889 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_INDIRECT) &&
val              1890 Zend/zend_hash.c 			    UNEXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF)) {
val              1894 Zend/zend_hash.c 				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
val              1899 Zend/zend_hash.c 				t = zend_hash_index_update(target, p->h, &p->val);
val              1908 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1909 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_INDIRECT) &&
val              1910 Zend/zend_hash.c 			    UNEXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF)) {
val              1914 Zend/zend_hash.c 				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
val              1919 Zend/zend_hash.c 				t = zend_hash_index_add(target, p->h, &p->val);
val              1928 Zend/zend_hash.c 		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
val              1958 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              1959 Zend/zend_hash.c 		if (zend_hash_replace_checker_wrapper(target, &p->val, p, pParam, pMergeSource)) {
val              1960 Zend/zend_hash.c 			t = zend_hash_update(target, p->key, &p->val);
val              1968 Zend/zend_hash.c 		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
val              1984 Zend/zend_hash.c 	return p ? &p->val : NULL;
val              1996 Zend/zend_hash.c 	return p ? &p->val : NULL;
val              2030 Zend/zend_hash.c 			if (Z_TYPE(p->val) != IS_UNDEF) {
val              2031 Zend/zend_hash.c 				return &p->val;
val              2038 Zend/zend_hash.c 	return p ? &p->val : NULL;
val              2050 Zend/zend_hash.c 			if (Z_TYPE(ht->arData[h].val) != IS_UNDEF) {
val              2070 Zend/zend_hash.c 		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
val              2092 Zend/zend_hash.c 		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
val              2115 Zend/zend_hash.c 			if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
val              2135 Zend/zend_hash.c 			if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
val              2212 Zend/zend_hash.c 		return &p->val;
val              2220 Zend/zend_hash.c 	zval val;
val              2224 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&val, &p->val);
val              2228 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&p->val, &q->val);
val              2232 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&q->val, &val);
val              2239 Zend/zend_hash.c 	zval val;
val              2241 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&val, &p->val);
val              2242 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&p->val, &q->val);
val              2243 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&q->val, &val);
val              2248 Zend/zend_hash.c 	zval val;
val              2251 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&val, &p->val);
val              2254 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&p->val, &q->val);
val              2257 Zend/zend_hash.c 	ZVAL_COPY_VALUE(&q->val, &val);
val              2278 Zend/zend_hash.c 			if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              2344 Zend/zend_hash.c 		if (Z_TYPE(p1->val) == IS_UNDEF) continue;
val              2349 Zend/zend_hash.c 				if (Z_TYPE(p2->val) != IS_UNDEF) break;
val              2369 Zend/zend_hash.c 			pData2 = &p2->val;
val              2385 Zend/zend_hash.c 		pData1 = &p1->val;
val              2442 Zend/zend_hash.c 		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) break;
val              2448 Zend/zend_hash.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val              2460 Zend/zend_hash.c 	return &res->val;
val               750 Zend/zend_hash.h 			zval *_z = &_p->val; \
val               760 Zend/zend_hash.h 			zval *_z = &_p->val; \
val               892 Zend/zend_hash.h 		ZVAL_COPY_VALUE(&__fill_bkt->val, _val); \
val               912 Zend/zend_hash.h 	ZVAL_COPY_VALUE(&p->val, zv);
val               921 Zend/zend_hash.h 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               925 Zend/zend_hash.h 	return &p->val;
val               934 Zend/zend_hash.h 	ZVAL_PTR(&p->val, ptr);
val               943 Zend/zend_hash.h 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               947 Zend/zend_hash.h 	return &p->val;
val               956 Zend/zend_hash.h 	ZVAL_INDIRECT(&p->val, ptr);
val               965 Zend/zend_hash.h 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val              2277 Zend/zend_operators.c 				zval *val;
val              2279 Zend/zend_operators.c 				val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv);
val              2280 Zend/zend_operators.c 				Z_TRY_ADDREF_P(val);
val              2281 Zend/zend_operators.c 				increment_function(val);
val              2282 Zend/zend_operators.c 				Z_OBJ_HANDLER_P(op1, set)(op1, val);
val              2283 Zend/zend_operators.c 				zval_ptr_dtor(val);
val              2345 Zend/zend_operators.c 				zval *val;
val              2347 Zend/zend_operators.c 				val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv);
val              2348 Zend/zend_operators.c 				Z_TRY_ADDREF_P(val);
val              2349 Zend/zend_operators.c 				decrement_function(val);
val              2350 Zend/zend_operators.c 				Z_OBJ_HANDLER_P(op1, set)(op1, val);
val              2351 Zend/zend_operators.c 				zval_ptr_dtor(val);
val              2650 Zend/zend_operators.c 	if ((ret1 = is_numeric_string_ex(s1->val, s1->len, &lval1, &dval1, 0, &oflow1)) &&
val              2651 Zend/zend_operators.c 		(ret2 = is_numeric_string_ex(s2->val, s2->len, &lval2, &dval2, 0, &oflow2))) {
val              2688 Zend/zend_operators.c 		strcmp_ret = zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len);
val                39 Zend/zend_smart_str.h #define smart_str_append_long(dest, val) \
val                40 Zend/zend_smart_str.h 	smart_str_append_long_ex((dest), (val), 0)
val                41 Zend/zend_smart_str.h #define smart_str_append_unsigned(dest, val) \
val                42 Zend/zend_smart_str.h 	smart_str_append_unsigned_ex((dest), (val), 0)
val               101 Zend/zend_string.c 		idx = Z_NEXT(p->val);
val               138 Zend/zend_string.c 	Z_STR(p->val) = str;
val               139 Zend/zend_string.c 	Z_TYPE_INFO(p->val) = IS_INTERNED_STRING_EX;
val               141 Zend/zend_string.c 	Z_NEXT(p->val) = HT_HASH(&CG(interned_strings), nIndex);
val               189 Zend/zend_string.c 			HT_HASH(&CG(interned_strings), nIndex) = Z_NEXT(p->val);
val               192 Zend/zend_string.c 			while (Z_NEXT(HT_HASH_TO_BUCKET(&CG(interned_strings), prev)->val) != idx) {
val               193 Zend/zend_string.c 				prev = Z_NEXT(HT_HASH_TO_BUCKET(&CG(interned_strings), prev)->val);
val               195 Zend/zend_string.c 			Z_NEXT(HT_HASH_TO_BUCKET(&CG(interned_strings), prev)->val) = Z_NEXT(p->val);
val                40 Zend/zend_string.h #define ZSTR_VAL(zstr)  (zstr)->val
val                60 Zend/zend_string.h #define _ZSTR_HEADER_SIZE XtOffsetOf(zend_string, val)
val               165 Zend/zend_types.h 	char              val[1];
val               169 Zend/zend_types.h 	zval              val;
val               293 Zend/zend_types.h 	zval              val;
val               566 Zend/zend_types.h #define Z_REFVAL(zval)				&Z_REF(zval)->val
val               739 Zend/zend_types.h 		ZVAL_COPY_VALUE(&_ref->val, r);							\
val               749 Zend/zend_types.h 		ZVAL_COPY_VALUE(&_ref->val, r);							\
val               909 Zend/zend_types.h 		ZVAL_COPY_VALUE(_z, &ref->val);					\
val                73 Zend/zend_variables.c 					i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC);
val               122 Zend/zend_variables.c 				i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC);
val               148 Zend/zend_variables.c 				zval_internal_ptr_dtor(&ref->val);
val               179 Zend/zend_variables.c 				zval_internal_ptr_dtor(&ref->val);
val               680 Zend/zend_vm_def.h 	zval *val;
val               683 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val               684 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val               686 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val               688 Zend/zend_vm_def.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val               690 Zend/zend_vm_def.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val               695 Zend/zend_vm_def.h 		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
val              2455 Zend/zend_vm_def.h 	zval *val;
val              2457 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              2459 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2462 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2463 Zend/zend_vm_def.h 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2465 Zend/zend_vm_def.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2474 Zend/zend_vm_def.h 	if (i_zend_is_true(val)) {
val              2490 Zend/zend_vm_def.h 	zval *val;
val              2492 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              2494 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2497 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2498 Zend/zend_vm_def.h 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2500 Zend/zend_vm_def.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2508 Zend/zend_vm_def.h 	if (i_zend_is_true(val)) {
val              2524 Zend/zend_vm_def.h 	zval *val;
val              2526 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              2528 Zend/zend_vm_def.h 	if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
val              2531 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2533 Zend/zend_vm_def.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2535 Zend/zend_vm_def.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2545 Zend/zend_vm_def.h 	if (i_zend_is_true(val)) {
val              2561 Zend/zend_vm_def.h 	zval *val;
val              2564 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              2566 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2570 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2573 Zend/zend_vm_def.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2575 Zend/zend_vm_def.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2585 Zend/zend_vm_def.h 	ret = i_zend_is_true(val);
val              2604 Zend/zend_vm_def.h 	zval *val;
val              2607 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              2609 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2613 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2615 Zend/zend_vm_def.h 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2617 Zend/zend_vm_def.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2625 Zend/zend_vm_def.h 	ret = i_zend_is_true(val);
val              4817 Zend/zend_vm_def.h 	zval *val;
val              4820 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
val              4821 Zend/zend_vm_def.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              4823 Zend/zend_vm_def.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              4825 Zend/zend_vm_def.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              4827 Zend/zend_vm_def.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              4832 Zend/zend_vm_def.h 		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
val              5777 Zend/zend_vm_def.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              5778 Zend/zend_vm_def.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              5779 Zend/zend_vm_def.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              5889 Zend/zend_vm_def.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              5890 Zend/zend_vm_def.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              5891 Zend/zend_vm_def.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              5922 Zend/zend_vm_def.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              5923 Zend/zend_vm_def.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              5924 Zend/zend_vm_def.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              6029 Zend/zend_vm_def.h 			value = &p->val;
val              6069 Zend/zend_vm_def.h 				value = &p->val;
val              6111 Zend/zend_vm_def.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              6112 Zend/zend_vm_def.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              6113 Zend/zend_vm_def.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              6208 Zend/zend_vm_def.h 			value = &p->val;
val              6239 Zend/zend_vm_def.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              6240 Zend/zend_vm_def.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              6241 Zend/zend_vm_def.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              6261 Zend/zend_vm_def.h 				value = &p->val;
val              6303 Zend/zend_vm_def.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              6304 Zend/zend_vm_def.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              6305 Zend/zend_vm_def.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              7229 Zend/zend_vm_def.h 	zval *val;
val              7234 Zend/zend_vm_def.h 	val   = GET_OP2_ZVAL_PTR(BP_VAR_R);
val              7236 Zend/zend_vm_def.h 	ZVAL_COPY_VALUE(&c.value, val);
val              7448 Zend/zend_vm_def.h 	zval *val;
val              7452 Zend/zend_vm_def.h 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
val              7454 Zend/zend_vm_def.h 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              7455 Zend/zend_vm_def.h 		ZVAL_COPY_VALUE(&generator->values, val);
val              7456 Zend/zend_vm_def.h 		if (OP1_TYPE != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
val              7457 Zend/zend_vm_def.h 			Z_ADDREF_P(val);
val              7462 Zend/zend_vm_def.h 	} else if (OP1_TYPE != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
val              7463 Zend/zend_vm_def.h 		zend_class_entry *ce = Z_OBJCE_P(val);
val              7465 Zend/zend_vm_def.h 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
val              7468 Zend/zend_vm_def.h 				Z_ADDREF_P(val);
val              7489 Zend/zend_vm_def.h 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
val              7626 Zend/zend_vm_def.h 		if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              7633 Zend/zend_vm_def.h 			value = &EG(symbol_table).arData[idx].val;
val              7665 Zend/zend_vm_def.h 			ZVAL_COPY_VALUE(&ref->val, value);
val              2834 Zend/zend_vm_execute.h 	zval *val;
val              2837 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              2838 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2840 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2842 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2844 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2849 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
val              2889 Zend/zend_vm_execute.h 	zval *val;
val              2891 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              2893 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2896 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2897 Zend/zend_vm_execute.h 		if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2899 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2908 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              2924 Zend/zend_vm_execute.h 	zval *val;
val              2926 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              2928 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              2931 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2932 Zend/zend_vm_execute.h 		if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2934 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2942 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              2958 Zend/zend_vm_execute.h 	zval *val;
val              2960 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              2962 Zend/zend_vm_execute.h 	if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
val              2965 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              2967 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              2969 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              2979 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              2995 Zend/zend_vm_execute.h 	zval *val;
val              2998 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              3000 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              3004 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              3007 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              3009 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              3019 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              3038 Zend/zend_vm_execute.h 	zval *val;
val              3041 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              3043 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              3047 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              3049 Zend/zend_vm_execute.h 		if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              3051 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              3059 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              3321 Zend/zend_vm_execute.h 	zval *val;
val              3324 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              3325 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              3327 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              3329 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              3331 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              3336 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
val              3743 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              3744 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              3745 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              3853 Zend/zend_vm_execute.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              3854 Zend/zend_vm_execute.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              3855 Zend/zend_vm_execute.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              3885 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              3886 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              3887 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              4116 Zend/zend_vm_execute.h 	zval *val;
val              4120 Zend/zend_vm_execute.h 	val = EX_CONSTANT(opline->op1);
val              4122 Zend/zend_vm_execute.h 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              4123 Zend/zend_vm_execute.h 		ZVAL_COPY_VALUE(&generator->values, val);
val              4124 Zend/zend_vm_execute.h 		if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
val              4125 Zend/zend_vm_execute.h 			Z_ADDREF_P(val);
val              4129 Zend/zend_vm_execute.h 	} else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
val              4130 Zend/zend_vm_execute.h 		zend_class_entry *ce = Z_OBJCE_P(val);
val              4132 Zend/zend_vm_execute.h 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
val              4135 Zend/zend_vm_execute.h 				Z_ADDREF_P(val);
val              4155 Zend/zend_vm_execute.h 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
val              6485 Zend/zend_vm_execute.h 	zval *val;
val              6490 Zend/zend_vm_execute.h 	val   = EX_CONSTANT(opline->op2);
val              6492 Zend/zend_vm_execute.h 	ZVAL_COPY_VALUE(&c.value, val);
val              12147 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              12148 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              12149 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              12258 Zend/zend_vm_execute.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              12259 Zend/zend_vm_execute.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              12260 Zend/zend_vm_execute.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              12290 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              12291 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              12292 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              12504 Zend/zend_vm_execute.h 	zval *val;
val              12508 Zend/zend_vm_execute.h 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
val              12510 Zend/zend_vm_execute.h 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              12511 Zend/zend_vm_execute.h 		ZVAL_COPY_VALUE(&generator->values, val);
val              12512 Zend/zend_vm_execute.h 		if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
val              12513 Zend/zend_vm_execute.h 			Z_ADDREF_P(val);
val              12517 Zend/zend_vm_execute.h 	} else if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
val              12518 Zend/zend_vm_execute.h 		zend_class_entry *ce = Z_OBJCE_P(val);
val              12520 Zend/zend_vm_execute.h 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
val              12523 Zend/zend_vm_execute.h 				Z_ADDREF_P(val);
val              12543 Zend/zend_vm_execute.h 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
val              15595 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              15596 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              15597 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              15707 Zend/zend_vm_execute.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              15708 Zend/zend_vm_execute.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              15709 Zend/zend_vm_execute.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              15740 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              15741 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              15742 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              15847 Zend/zend_vm_execute.h 			value = &p->val;
val              15887 Zend/zend_vm_execute.h 				value = &p->val;
val              15929 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              15930 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              15931 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              16026 Zend/zend_vm_execute.h 			value = &p->val;
val              16057 Zend/zend_vm_execute.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              16058 Zend/zend_vm_execute.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              16059 Zend/zend_vm_execute.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              16079 Zend/zend_vm_execute.h 				value = &p->val;
val              16121 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              16122 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              16123 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              16323 Zend/zend_vm_execute.h 	zval *val;
val              16327 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
val              16329 Zend/zend_vm_execute.h 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              16330 Zend/zend_vm_execute.h 		ZVAL_COPY_VALUE(&generator->values, val);
val              16331 Zend/zend_vm_execute.h 		if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
val              16332 Zend/zend_vm_execute.h 			Z_ADDREF_P(val);
val              16337 Zend/zend_vm_execute.h 	} else if (IS_VAR != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
val              16338 Zend/zend_vm_execute.h 		zend_class_entry *ce = Z_OBJCE_P(val);
val              16340 Zend/zend_vm_execute.h 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
val              16343 Zend/zend_vm_execute.h 				Z_ADDREF_P(val);
val              16364 Zend/zend_vm_execute.h 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
val              28164 Zend/zend_vm_execute.h 	zval *val;
val              28167 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28168 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28170 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28172 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28174 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28179 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
val              28385 Zend/zend_vm_execute.h 	zval *val;
val              28387 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28389 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28392 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28393 Zend/zend_vm_execute.h 		if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28395 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28404 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              28420 Zend/zend_vm_execute.h 	zval *val;
val              28422 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28424 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28427 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28428 Zend/zend_vm_execute.h 		if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28430 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28438 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              28454 Zend/zend_vm_execute.h 	zval *val;
val              28456 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28458 Zend/zend_vm_execute.h 	if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
val              28461 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28463 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28465 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28475 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              28491 Zend/zend_vm_execute.h 	zval *val;
val              28494 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28496 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28500 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28503 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28505 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28515 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              28534 Zend/zend_vm_execute.h 	zval *val;
val              28537 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28539 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28543 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28545 Zend/zend_vm_execute.h 		if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28547 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28555 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              28944 Zend/zend_vm_execute.h 	zval *val;
val              28947 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
val              28948 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              28950 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              28952 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              28954 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              28959 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
val              29314 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              29315 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              29316 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              29424 Zend/zend_vm_execute.h 			if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              29425 Zend/zend_vm_execute.h 			    (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              29426 Zend/zend_vm_execute.h 			     EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
val              29456 Zend/zend_vm_execute.h 				if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              29457 Zend/zend_vm_execute.h 				     (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
val              29458 Zend/zend_vm_execute.h 				      EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
val              29687 Zend/zend_vm_execute.h 	zval *val;
val              29691 Zend/zend_vm_execute.h 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
val              29693 Zend/zend_vm_execute.h 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              29694 Zend/zend_vm_execute.h 		ZVAL_COPY_VALUE(&generator->values, val);
val              29695 Zend/zend_vm_execute.h 		if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
val              29696 Zend/zend_vm_execute.h 			Z_ADDREF_P(val);
val              29700 Zend/zend_vm_execute.h 	} else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
val              29701 Zend/zend_vm_execute.h 		zend_class_entry *ce = Z_OBJCE_P(val);
val              29703 Zend/zend_vm_execute.h 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
val              29706 Zend/zend_vm_execute.h 				Z_ADDREF_P(val);
val              29726 Zend/zend_vm_execute.h 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
val              32959 Zend/zend_vm_execute.h 		if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
val              32966 Zend/zend_vm_execute.h 			value = &EG(symbol_table).arData[idx].val;
val              32998 Zend/zend_vm_execute.h 			ZVAL_COPY_VALUE(&ref->val, value);
val              40259 Zend/zend_vm_execute.h 	zval *val;
val              40262 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40263 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40265 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40267 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40269 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40274 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
val              40315 Zend/zend_vm_execute.h 	zval *val;
val              40317 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40319 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40322 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40323 Zend/zend_vm_execute.h 		if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40325 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40334 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              40350 Zend/zend_vm_execute.h 	zval *val;
val              40352 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40354 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40357 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40358 Zend/zend_vm_execute.h 		if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40360 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40368 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              40384 Zend/zend_vm_execute.h 	zval *val;
val              40386 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40388 Zend/zend_vm_execute.h 	if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
val              40391 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40393 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40395 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40405 Zend/zend_vm_execute.h 	if (i_zend_is_true(val)) {
val              40421 Zend/zend_vm_execute.h 	zval *val;
val              40424 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40426 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40430 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40433 Zend/zend_vm_execute.h 			if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40435 Zend/zend_vm_execute.h 				GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40445 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              40464 Zend/zend_vm_execute.h 	zval *val;
val              40467 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40469 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40473 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40475 Zend/zend_vm_execute.h 		if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40477 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40485 Zend/zend_vm_execute.h 	ret = i_zend_is_true(val);
val              40526 Zend/zend_vm_execute.h 	zval *val;
val              40529 Zend/zend_vm_execute.h 	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
val              40530 Zend/zend_vm_execute.h 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
val              40532 Zend/zend_vm_execute.h 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
val              40534 Zend/zend_vm_execute.h 		if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
val              40536 Zend/zend_vm_execute.h 			GET_OP1_UNDEF_CV(val, BP_VAR_R);
val              40541 Zend/zend_vm_execute.h 		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
val               116 ext/bcmath/libbcmath/src/bcmath.h _PROTOTYPE(void bc_int2num, (bc_num *num, int val));
val                93 ext/bcmath/libbcmath/src/div.c   int  scale1, val;
val               220 ext/bcmath/libbcmath/src/div.c 		  val = (int) *ptr1 - (int) *ptr2-- - borrow;
val               221 ext/bcmath/libbcmath/src/div.c 		  if (val < 0)
val               223 ext/bcmath/libbcmath/src/div.c 		      val += 10;
val               228 ext/bcmath/libbcmath/src/div.c 		  *ptr1-- = val;
val               241 ext/bcmath/libbcmath/src/div.c 		  val = (int) *ptr1 + (int) *ptr2-- + carry;
val               242 ext/bcmath/libbcmath/src/div.c 		  if (val > 9)
val               244 ext/bcmath/libbcmath/src/div.c 		      val -= 10;
val               249 ext/bcmath/libbcmath/src/div.c 		  *ptr1-- = val;
val               147 ext/bcmath/libbcmath/src/doaddsub.c   int borrow, count, val;
val               184 ext/bcmath/libbcmath/src/doaddsub.c 	  val = - *n2ptr-- - borrow;
val               185 ext/bcmath/libbcmath/src/doaddsub.c 	  if (val < 0)
val               187 ext/bcmath/libbcmath/src/doaddsub.c 	      val += BASE;
val               192 ext/bcmath/libbcmath/src/doaddsub.c 	  *diffptr-- = val;
val               200 ext/bcmath/libbcmath/src/doaddsub.c       val = *n1ptr-- - *n2ptr-- - borrow;
val               201 ext/bcmath/libbcmath/src/doaddsub.c       if (val < 0)
val               203 ext/bcmath/libbcmath/src/doaddsub.c 	  val += BASE;
val               208 ext/bcmath/libbcmath/src/doaddsub.c       *diffptr-- = val;
val               216 ext/bcmath/libbcmath/src/doaddsub.c 	  val = *n1ptr-- - borrow;
val               217 ext/bcmath/libbcmath/src/doaddsub.c 	  if (val < 0)
val               219 ext/bcmath/libbcmath/src/doaddsub.c 	      val += BASE;
val               224 ext/bcmath/libbcmath/src/doaddsub.c 	  *diffptr-- = val;
val                45 ext/bcmath/libbcmath/src/int2num.c bc_int2num (num, val)
val                47 ext/bcmath/libbcmath/src/int2num.c      int val;
val                55 ext/bcmath/libbcmath/src/int2num.c   if (val < 0)
val                58 ext/bcmath/libbcmath/src/int2num.c       val = -val;
val                63 ext/bcmath/libbcmath/src/int2num.c   *bptr++ = val % BASE;
val                64 ext/bcmath/libbcmath/src/int2num.c   val = val / BASE;
val                67 ext/bcmath/libbcmath/src/int2num.c   while (val != 0)
val                69 ext/bcmath/libbcmath/src/int2num.c       *bptr++ = val % BASE;
val                70 ext/bcmath/libbcmath/src/int2num.c       val = val / BASE;
val                50 ext/bcmath/libbcmath/src/num2long.c   long val;
val                55 ext/bcmath/libbcmath/src/num2long.c   val = 0;
val                57 ext/bcmath/libbcmath/src/num2long.c   for (index=num->n_len; (index>0) && (val<=(LONG_MAX/BASE)); index--)
val                58 ext/bcmath/libbcmath/src/num2long.c     val = val*BASE + *nptr++;
val                61 ext/bcmath/libbcmath/src/num2long.c   if (index>0) val = 0;
val                62 ext/bcmath/libbcmath/src/num2long.c   if (val < 0) val = 0;
val                66 ext/bcmath/libbcmath/src/num2long.c     return (val);
val                68 ext/bcmath/libbcmath/src/num2long.c     return (-val);
val                61 ext/bcmath/libbcmath/src/output.c bc_out_long (val, size, space, out_char)
val                62 ext/bcmath/libbcmath/src/output.c      long val;
val                74 ext/bcmath/libbcmath/src/output.c   snprintf(digits, sizeof(digits), "%ld", val);
val               116 ext/bcmath/libbcmath/src/recmul.c _bc_shift_addsub (bc_num accum, bc_num val, int shift, int sub)
val               121 ext/bcmath/libbcmath/src/recmul.c   count = val->n_len;
val               122 ext/bcmath/libbcmath/src/recmul.c   if (val->n_value[0] == 0)
val               129 ext/bcmath/libbcmath/src/recmul.c   valp = (signed char *)(val->n_value + val->n_len - 1);
val               301 ext/calendar/calendar.c 		zval val;
val               306 ext/calendar/calendar.c 			_php_cal_info(i, &val);
val               307 ext/calendar/calendar.c 			add_index_zval(return_value, i, &val);
val               479 ext/com_dotnet/com_com.c 	hr = php_com_get_id_of_name(obj, f->function_name->val, f->function_name->len, &dispid);
val               485 ext/com_dotnet/com_com.c 		spprintf(&msg, 0, "Unable to lookup `%s': %s", f->function_name->val, winerr);
val               278 ext/com_dotnet/com_extension.c 	if (NULL == new_value || !new_value->val[0] || (typelib_file = VCWD_FOPEN(new_value->val, "r"))==NULL) {
val               269 ext/com_dotnet/com_handlers.c 	if (FAILED(php_com_get_id_of_name(obj, name->val, name->len, &dummy))) {
val               297 ext/com_dotnet/com_handlers.c 				olename = php_com_string_to_olestring(name->val, name->len, obj->code_page);
val               410 ext/com_dotnet/com_handlers.c 	switch (obj->ce->name->val[0]) {
val                94 ext/com_dotnet/com_wrapper.c 		trace(" PHP Object:%p (name:%s) %s\n", Z_OBJ(disp->object), Z_OBJCE(disp->object)->name->val, methname); 	\
val               566 ext/com_dotnet/com_wrapper.c 		trace("destroying COM wrapper for PHP object %p (name:%s)\n", Z_OBJ(disp->object), Z_OBJCE(disp->object)->name->val);
val               584 ext/com_dotnet/com_wrapper.c PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid,
val               587 ext/com_dotnet/com_wrapper.c 	php_dispatchex *disp = disp_constructor(val);
val               620 ext/com_dotnet/com_wrapper.c PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val)
val               624 ext/com_dotnet/com_wrapper.c 	if (Z_TYPE_P(val) != IS_OBJECT) {
val               628 ext/com_dotnet/com_wrapper.c 	if (php_com_is_valid_object(val)) {
val               630 ext/com_dotnet/com_wrapper.c 		php_com_dotnet_object *obj = CDNO_FETCH(val);
val               643 ext/com_dotnet/com_wrapper.c 	disp = disp_constructor(val);
val                60 ext/com_dotnet/php_com_dotnet_internal.h 	return strcmp("com", ce->name->val) == 0 ||
val                61 ext/com_dotnet/php_com_dotnet_internal.h 		strcmp("dotnet", ce->name->val) == 0 ||
val                62 ext/com_dotnet/php_com_dotnet_internal.h 		strcmp("variant", ce->name->val) == 0;
val               118 ext/com_dotnet/php_com_dotnet_internal.h PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid, HashTable *id_to_name);
val               119 ext/com_dotnet/php_com_dotnet_internal.h PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val);
val              1779 ext/curl/interface.c 			char *val;
val              1790 ext/curl/interface.c 				val = tmp+1;
val              1791 ext/curl/interface.c 				add_assoc_string(hash, key, val);
val              2431 ext/curl/interface.c 			zend_string *val;
val              2473 ext/curl/interface.c 				val = zval_get_string(current);
val              2474 ext/curl/interface.c 				slist = curl_slist_append(slist, ZSTR_VAL(val));
val              2475 ext/curl/interface.c 				zend_string_release(val);
val              1677 ext/date/php_date.c 		real_len = strlen(buf->val);
val               576 ext/dba/dba.c  	char *val;
val               580 ext/dba/dba.c  	if (zend_parse_parameters(ac, "zsr", &key, &val, &val_len, &id) == FAILURE) {
val               592 ext/dba/dba.c  	if (info->hnd->update(info, key_str, key_len, val, val_len, mode) == SUCCESS) {
val              1020 ext/dba/dba.c  	char *val;
val              1048 ext/dba/dba.c  	if((val = info->hnd->fetch(info, key_str, key_len, skip, &len)) != NULL) {
val              1050 ext/dba/dba.c  		RETVAL_STRINGL(val, len);
val              1051 ext/dba/dba.c  		efree(val);
val               189 ext/dba/dba_cdb.c 	if (cdb_make_add(&cdb->m, key, keylen, val, vallen) != -1)
val               117 ext/dba/dba_db1.c 	gval.data = (char *) val;
val               119 ext/dba/dba_db2.c 	gval.data = (char *) val;
val               153 ext/dba/dba_db3.c 	gval.data = (char *) val;
val               188 ext/dba/dba_db4.c 	gval.data = (char *) val;
val               124 ext/dba/dba_dbm.c 	gval.dptr = (char *) val;
val                87 ext/dba/dba_flatfile.c 	gval.dptr = (char *) val;
val                99 ext/dba/dba_flatfile.c 			php_error_docref2(NULL, key, val, E_WARNING, "Unknown return value");
val               104 ext/dba/dba_gdbm.c 	gval.dptr = (char *) val;
val               113 ext/dba/dba_gdbm.c 			php_error_docref2(NULL, key, val, E_WARNING, "%s", gdbm_strerror(gdbm_errno));
val               116 ext/dba/dba_gdbm.c 			php_error_docref2(NULL, key, val, E_WARNING, "Unknown return value");
val                88 ext/dba/dba_inifile.c 	ini_val.value = val;
val                96 ext/dba/dba_ndbm.c 	gval.dptr = (char *) val;
val               100 ext/dba/dba_qdbm.c 	if (dpput(dba->dbf, key, keylen, val, vallen, mode == 1 ? DP_DKEEP : DP_DOVER)) {
val               105 ext/dba/dba_qdbm.c 		php_error_docref2(NULL, key, val, E_WARNING, "%s", dperrmsg(dpecode));
val               119 ext/dba/dba_tcadb.c 	result = tcadbput(dba->tcadb, key, keylen, val, vallen);
val               125 ext/dba/dba_tcadb.c 	php_error_docref2(NULL, key, val, E_WARNING, "Error updating data");
val                63 ext/dba/libinifile/inifile.c void inifile_val_free(val_type *val)
val                65 ext/dba/libinifile/inifile.c 	if (val->value) {
val                66 ext/dba/libinifile/inifile.c 		efree(val->value);
val                68 ext/dba/libinifile/inifile.c 	memset(val, 0, sizeof(val_type));
val                76 ext/dba/libinifile/inifile.c 	inifile_val_free(&ln->val);
val               147 ext/dba/libinifile/inifile.c 	char *val;
val               153 ext/dba/libinifile/inifile.c 	val = (char*)str;
val               154 ext/dba/libinifile/inifile.c 	while (*val && strchr(" \t\r\n", *val)) {
val               155 ext/dba/libinifile/inifile.c 		val++;
val               157 ext/dba/libinifile/inifile.c 	l = strlen(val);
val               158 ext/dba/libinifile/inifile.c 	while (l && (strchr(" \t\r\n", val[l-1]))) {
val               161 ext/dba/libinifile/inifile.c 	return estrndup(val, l);
val               171 ext/dba/libinifile/inifile.c 	inifile_val_free(&ln->val);
val               203 ext/dba/libinifile/inifile.c 					ln->val.value = etrim(pos+1);
val               247 ext/dba/libinifile/inifile.c 	val_type val;
val               265 ext/dba/libinifile/inifile.c 				val.value = estrdup(ln.val.value ? ln.val.value : "");
val               270 ext/dba/libinifile/inifile.c 				return val;
val               282 ext/dba/libinifile/inifile.c 	return ln.val;
val                35 ext/dba/libinifile/inifile.h 	val_type val;
val                53 ext/dba/libinifile/inifile.h int inifile_replace(inifile *dba, const key_type *key, const val_type *val);
val                54 ext/dba/libinifile/inifile.h int inifile_replace_ex(inifile *dba, const key_type *key, const val_type *val, zend_bool *found);
val                55 ext/dba/libinifile/inifile.h int inifile_append(inifile *dba, const key_type *key, const val_type *val);
val                62 ext/dba/libinifile/inifile.h void inifile_val_free(val_type *val);
val               103 ext/dba/php_dba.h 	int dba_update_##x(dba_info *info, char *key, int keylen, char *val, int vallen, int mode)
val              1931 ext/exif/exif.c 	char    buffer[64], *val, *name, uname[64];
val              1984 ext/exif/exif.c 						if (!(val = info_value->s)) {
val              1985 ext/exif/exif.c 							val = "";
val              1988 ext/exif/exif.c 							add_index_string(&tmpi, idx++, val);
val              1990 ext/exif/exif.c 							add_assoc_string(&tmpi, name, val);
val               716 ext/fileinfo/libmagic/apprentice.c 	size_t v, val = 2 * MULT;	/* baseline strength */
val               725 ext/fileinfo/libmagic/apprentice.c 		val += 1 * MULT;
val               731 ext/fileinfo/libmagic/apprentice.c 		val += 2 * MULT;
val               738 ext/fileinfo/libmagic/apprentice.c 		val += 4 * MULT;
val               743 ext/fileinfo/libmagic/apprentice.c 		val += m->vallen * MULT;
val               748 ext/fileinfo/libmagic/apprentice.c 		val += m->vallen * MULT / 2;
val               752 ext/fileinfo/libmagic/apprentice.c 		val += m->vallen * MAX(MULT / m->vallen, 1);
val               757 ext/fileinfo/libmagic/apprentice.c 		val += v * MAX(MULT / v, 1);
val               771 ext/fileinfo/libmagic/apprentice.c 		val += 4 * MULT;
val               789 ext/fileinfo/libmagic/apprentice.c 		val += 8 * MULT;
val               805 ext/fileinfo/libmagic/apprentice.c 		val = 0;
val               809 ext/fileinfo/libmagic/apprentice.c 		val += MULT;
val               814 ext/fileinfo/libmagic/apprentice.c 		val -= 2 * MULT;
val               819 ext/fileinfo/libmagic/apprentice.c 		val -= MULT;
val               827 ext/fileinfo/libmagic/apprentice.c 	if (val == 0)	/* ensure we only return 0 for FILE_DEFAULT */
val               828 ext/fileinfo/libmagic/apprentice.c 		val = 1;
val               834 ext/fileinfo/libmagic/apprentice.c 		val += m->factor;
val               837 ext/fileinfo/libmagic/apprentice.c 		val -= m->factor;
val               840 ext/fileinfo/libmagic/apprentice.c 		val *= m->factor;
val               843 ext/fileinfo/libmagic/apprentice.c 		val /= m->factor;
val               854 ext/fileinfo/libmagic/apprentice.c 		val++;
val               855 ext/fileinfo/libmagic/apprentice.c 	return val;
val              1583 ext/fileinfo/libmagic/apprentice.c 	uint64_t val;
val              1587 ext/fileinfo/libmagic/apprentice.c 	val = (uint64_t)strtoull(l, &t, 0);
val              1589 ext/fileinfo/libmagic/apprentice.c 	m->num_mask = file_signextend(ms, m, val);
val              2525 ext/fileinfo/libmagic/apprentice.c 	int	val;
val              2629 ext/fileinfo/libmagic/apprentice.c 				val = c - '0';
val              2632 ext/fileinfo/libmagic/apprentice.c 					val = (val << 3) | (c - '0');
val              2635 ext/fileinfo/libmagic/apprentice.c 						val = (val << 3) | (c-'0');
val              2641 ext/fileinfo/libmagic/apprentice.c 				*p++ = (char)val;
val              2646 ext/fileinfo/libmagic/apprentice.c 				val = 'x';	/* Default if no digits */
val              2649 ext/fileinfo/libmagic/apprentice.c 					val = c;
val              2652 ext/fileinfo/libmagic/apprentice.c 						val = (val << 4) + c;
val              2657 ext/fileinfo/libmagic/apprentice.c 				*p++ = (char)val;
val               194 ext/fileinfo/libmagic/cdf.h #define CDF_ROUND(val, by)     (((val) + (by) - 1) & ~((by) - 1))
val                59 ext/fileinfo/libmagic/funcs.c extern public void convert_libmagic_pattern(zval *pattern, char *val, int len, int options);
val               478 ext/fileinfo/libmagic/magic.c magic_setparam(struct magic_set *ms, int param, const void *val)
val               482 ext/fileinfo/libmagic/magic.c 		ms->indir_max = (uint16_t)*(const size_t *)val;
val               485 ext/fileinfo/libmagic/magic.c 		ms->name_max = (uint16_t)*(const size_t *)val;
val               488 ext/fileinfo/libmagic/magic.c 		ms->elf_phnum_max = (uint16_t)*(const size_t *)val;
val               491 ext/fileinfo/libmagic/magic.c 		ms->elf_shnum_max = (uint16_t)*(const size_t *)val;
val               494 ext/fileinfo/libmagic/magic.c 		ms->elf_notes_max = (uint16_t)*(const size_t *)val;
val               503 ext/fileinfo/libmagic/magic.c magic_getparam(struct magic_set *ms, int param, void *val)
val               507 ext/fileinfo/libmagic/magic.c 		*(size_t *)val = ms->indir_max;
val               510 ext/fileinfo/libmagic/magic.c 		*(size_t *)val = ms->name_max;
val               513 ext/fileinfo/libmagic/magic.c 		*(size_t *)val = ms->elf_phnum_max;
val               516 ext/fileinfo/libmagic/magic.c 		*(size_t *)val = ms->elf_shnum_max;
val               519 ext/fileinfo/libmagic/magic.c 		*(size_t *)val = ms->elf_notes_max;
val              1808 ext/fileinfo/libmagic/softmagic.c convert_libmagic_pattern(zval *pattern, char *val, int len, int options)
val              1818 ext/fileinfo/libmagic/softmagic.c 		switch (val[i]) {
val              1824 ext/fileinfo/libmagic/softmagic.c 				ZSTR_VAL(t)[j] = val[i];
val                81 ext/filter/filter.c static unsigned int php_sapi_filter(int arg, char *var, char **val, size_t val_len, size_t *new_val_len);
val               419 ext/filter/filter.c static unsigned int php_sapi_filter(int arg, char *var, char **val, size_t val_len, size_t *new_val_len) /* {{{ */
val               425 ext/filter/filter.c 	assert(*val != NULL);
val               461 ext/filter/filter.c 		ZVAL_STRINGL(&raw_var, *val, val_len);
val               468 ext/filter/filter.c 			ZVAL_STRINGL(&new_var, *val, val_len);
val               471 ext/filter/filter.c 			ZVAL_STRINGL(&new_var, *val, val_len);
val               485 ext/filter/filter.c 		efree(*val);
val               487 ext/filter/filter.c 			*val = estrndup(Z_STRVAL(new_var), Z_STRLEN(new_var));
val               489 ext/filter/filter.c 			*val = estrdup("");
val               230 ext/gd/libgd/gd_jpeg.c 				int val = im->tpixels[i][j];
val               232 ext/gd/libgd/gd_jpeg.c 				row[jidx++] = gdTrueColorGetRed (val);
val               233 ext/gd/libgd/gd_jpeg.c 				row[jidx++] = gdTrueColorGetGreen (val);
val               234 ext/gd/libgd/gd_jpeg.c 				row[jidx++] = gdTrueColorGetBlue (val);
val                40 ext/gd/libgd/mathmake.c       int val;
val                41 ext/gd/libgd/mathmake.c       val = cost[(i + 270) % 360];
val                44 ext/gd/libgd/mathmake.c 	  printf ("%d,\n  ", val);
val                48 ext/gd/libgd/mathmake.c 	  printf ("%d\n", val);
val               335 ext/gmp/gmp.c  static int convert_to_gmp(mpz_t gmpnumber, zval *val, zend_long base);
val               709 ext/gmp/gmp.c  static int convert_to_gmp(mpz_t gmpnumber, zval *val, zend_long base)
val               711 ext/gmp/gmp.c  	switch (Z_TYPE_P(val)) {
val               715 ext/gmp/gmp.c  		mpz_set_si(gmpnumber, zval_get_long(val));
val               719 ext/gmp/gmp.c  		char *numstr = Z_STRVAL_P(val);
val               723 ext/gmp/gmp.c  		if (Z_STRLEN_P(val) > 2 && numstr[0] == '0') {
val                90 ext/interbase/ibase_query.c 	} val;
val               433 ext/interbase/ibase_query.c static int _php_ibase_bind_array(zval *val, char *buf, zend_ulong buf_size, /* {{{ */
val               446 ext/interbase/ibase_query.c 		zval *subval = val;
val               448 ext/interbase/ibase_query.c 		if (Z_TYPE_P(val) == IS_ARRAY) {
val               449 ext/interbase/ibase_query.c 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(val));
val               454 ext/interbase/ibase_query.c 			if (Z_TYPE_P(val) == IS_ARRAY &&
val               455 ext/interbase/ibase_query.c 				(subval = zend_hash_get_current_data(Z_ARRVAL_P(val))) == NULL)
val               466 ext/interbase/ibase_query.c 			if (Z_TYPE_P(val) == IS_ARRAY) {
val               467 ext/interbase/ibase_query.c 				zend_hash_move_forward(Z_ARRVAL_P(val));
val               471 ext/interbase/ibase_query.c 		if (Z_TYPE_P(val) == IS_ARRAY) {
val               472 ext/interbase/ibase_query.c 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(val));
val               477 ext/interbase/ibase_query.c 		if (Z_TYPE_P(val) == IS_NULL) {
val               484 ext/interbase/ibase_query.c 			convert_to_double(val);
val               486 ext/interbase/ibase_query.c 			if (Z_DVAL_P(val) > 0) {
val               487 ext/interbase/ibase_query.c 				l = Z_DVAL_P(val) * pow(10, -array->ar_desc.array_desc_scale) + .5;
val               489 ext/interbase/ibase_query.c 				l = Z_DVAL_P(val) * pow(10, -array->ar_desc.array_desc_scale) - .5;
val               511 ext/interbase/ibase_query.c 						convert_to_string(val);
val               513 ext/interbase/ibase_query.c 						if (!sscanf(Z_STRVAL_P(val), "%Lf", &l)) {
val               515 ext/interbase/ibase_query.c 								 Z_STRVAL_P(val));
val               541 ext/interbase/ibase_query.c 					convert_to_long(val);
val               542 ext/interbase/ibase_query.c 					if (Z_LVAL_P(val) > SHRT_MAX || Z_LVAL_P(val) < SHRT_MIN) {
val               546 ext/interbase/ibase_query.c 					*(short *) buf = (short) Z_LVAL_P(val);
val               549 ext/interbase/ibase_query.c 					convert_to_long(val);
val               551 ext/interbase/ibase_query.c 					if (Z_LVAL_P(val) > ISC_LONG_MAX || Z_LVAL_P(val) < ISC_LONG_MIN) {
val               556 ext/interbase/ibase_query.c 					*(ISC_LONG *) buf = (ISC_LONG) Z_LVAL_P(val);
val               560 ext/interbase/ibase_query.c 					convert_to_long(val);
val               561 ext/interbase/ibase_query.c 					*(zend_long *) buf = Z_LVAL_P(val);
val               563 ext/interbase/ibase_query.c 					convert_to_string(val);
val               564 ext/interbase/ibase_query.c 					if (!sscanf(Z_STRVAL_P(val), "%" LL_MASK "d", &l)) {
val               566 ext/interbase/ibase_query.c 							 Z_STRVAL_P(val));
val               574 ext/interbase/ibase_query.c 					convert_to_double(val);
val               575 ext/interbase/ibase_query.c 					*(float*) buf = (float) Z_DVAL_P(val);
val               578 ext/interbase/ibase_query.c 					convert_to_double(val);
val               579 ext/interbase/ibase_query.c 					*(double*) buf = Z_DVAL_P(val);
val               582 ext/interbase/ibase_query.c 					convert_to_string(val);
val               584 ext/interbase/ibase_query.c 					strptime(Z_STRVAL_P(val), INI_STR("ibase.timestampformat"), &t);
val               586 ext/interbase/ibase_query.c 					n = sscanf(Z_STRVAL_P(val), "%d%*[/]%d%*[/]%d %d%*[:]%d%*[:]%d",
val               591 ext/interbase/ibase_query.c 							" Use format 'm/d/Y H:i:s'. You gave '%s')", n, Z_STRVAL_P(val));
val               600 ext/interbase/ibase_query.c 					convert_to_string(val);
val               602 ext/interbase/ibase_query.c 					strptime(Z_STRVAL_P(val), INI_STR("ibase.dateformat"), &t);
val               604 ext/interbase/ibase_query.c 					n = sscanf(Z_STRVAL_P(val), "%d%*[/]%d%*[/]%d", &t.tm_mon, &t.tm_mday, &t.tm_year);
val               608 ext/interbase/ibase_query.c 							"Use format 'm/d/Y' You gave '%s')", n, Z_STRVAL_P(val));
val               617 ext/interbase/ibase_query.c 					convert_to_string(val);
val               619 ext/interbase/ibase_query.c 					strptime(Z_STRVAL_P(val), INI_STR("ibase.timeformat"), &t);
val               621 ext/interbase/ibase_query.c 					n = sscanf(Z_STRVAL_P(val), "%d%*[:]%d%*[:]%d", &t.tm_hour, &t.tm_min, &t.tm_sec);
val               625 ext/interbase/ibase_query.c 							"Use format 'H:i:s'. You gave '%s')", n, Z_STRVAL_P(val));
val               632 ext/interbase/ibase_query.c 					convert_to_string(val);
val               633 ext/interbase/ibase_query.c 					strlcpy(buf, Z_STRVAL_P(val), buf_size);
val               688 ext/interbase/ibase_query.c 		var->sqldata = (void*)&buf[i].val;
val               726 ext/interbase/ibase_query.c 						isc_encode_timestamp(&t, &buf[i].val.tsval);
val               729 ext/interbase/ibase_query.c 						isc_encode_sql_date(&t, &buf[i].val.dtval);
val               732 ext/interbase/ibase_query.c 						isc_encode_sql_time(&t, &buf[i].val.tmval);
val               742 ext/interbase/ibase_query.c 					!_php_ibase_string_to_quad(Z_STRVAL_P(b_var), &buf[i].val.qval)) {
val               760 ext/interbase/ibase_query.c 					buf[i].val.qval = ib_blob.bl_qd;
val               770 ext/interbase/ibase_query.c 						!_php_ibase_string_to_quad(Z_STRVAL_P(b_var), &buf[i].val.qval)) {
val               795 ext/interbase/ibase_query.c 					buf[i].val.qval = array_id;
val              1295 ext/interbase/ibase_query.c static int _php_ibase_var_zval(zval *val, void *data, int type, int len, /* {{{ */
val              1328 ext/interbase/ibase_query.c 			ZVAL_STRINGL(val, (char*)data, len);
val              1340 ext/interbase/ibase_query.c 				ZVAL_STRINGL(val,string_data,l);
val              1351 ext/interbase/ibase_query.c 				ZVAL_STRINGL(val,string_data,l);
val              1359 ext/interbase/ibase_query.c 				ZVAL_LONG(val,n);
val              1370 ext/interbase/ibase_query.c 				ZVAL_STRINGL(val, string_data, l);
val              1374 ext/interbase/ibase_query.c 			ZVAL_DOUBLE(val, *(float *) data);
val              1377 ext/interbase/ibase_query.c 			ZVAL_DOUBLE(val, *(double *) data);
val              1401 ext/interbase/ibase_query.c 				ZVAL_LONG(val, mktime(&t));
val              1419 ext/interbase/ibase_query.c 				ZVAL_STRINGL(val, string_data, l);
val               218 ext/intl/collator/collator_sort.c 	first = &f->val;
val               219 ext/intl/collator/collator_sort.c 	second = &s->val;
val               165 ext/intl/converter/converter.c static void php_converter_append_toUnicode_target(zval *val, UConverterToUnicodeArgs *args, php_converter_object *objval) {
val               166 ext/intl/converter/converter.c 	switch (Z_TYPE_P(val)) {
val               172 ext/intl/converter/converter.c 			zend_long lval = Z_LVAL_P(val);
val               194 ext/intl/converter/converter.c 			const char *strval = Z_STRVAL_P(val);
val               195 ext/intl/converter/converter.c 			int i = 0, strlen = Z_STRLEN_P(val);
val               206 ext/intl/converter/converter.c 			HashTable *ht = Z_ARRVAL_P(val);
val               262 ext/intl/converter/converter.c static void php_converter_append_fromUnicode_target(zval *val, UConverterFromUnicodeArgs *args, php_converter_object *objval) {
val               263 ext/intl/converter/converter.c 	switch (Z_TYPE_P(val)) {
val               269 ext/intl/converter/converter.c 				*(args->target++) = Z_LVAL_P(val);
val               274 ext/intl/converter/converter.c 			size_t vallen = Z_STRLEN_P(val);
val               276 ext/intl/converter/converter.c 				memcpy(args->target, Z_STRVAL_P(val), vallen);
val               283 ext/intl/converter/converter.c 			HashTable *ht = Z_ARRVAL_P(val);
val               320 ext/intl/locale/locale_methods.c 			buflen = uloc_getScript ( mod_loc_name , tag_value->val , tag_value_len , &status);
val               323 ext/intl/locale/locale_methods.c 			buflen = uloc_getLanguage ( mod_loc_name , tag_value->val , tag_value_len , &status);
val               326 ext/intl/locale/locale_methods.c 			buflen = uloc_getCountry ( mod_loc_name , tag_value->val , tag_value_len , &status);
val               329 ext/intl/locale/locale_methods.c 			buflen = uloc_getVariant ( mod_loc_name , tag_value->val , tag_value_len , &status);
val               332 ext/intl/locale/locale_methods.c 			buflen = uloc_canonicalize ( mod_loc_name , tag_value->val , tag_value_len , &status);
val               371 ext/intl/locale/locale_methods.c 	tag_value->len = strlen(tag_value->val);
val              1059 ext/intl/locale/locale_methods.c 			token = php_strtok_r( key_value->val , DELIMITER ,&last_ptr);
val              1183 ext/intl/locale/locale_methods.c 			token = php_strtok_r( variant->val , DELIMITER , &saved_ptr);
val              1300 ext/intl/locale/locale_methods.c 		result = strToMatch( can_lang_tag->val , cur_lang_tag);
val              1308 ext/intl/locale/locale_methods.c 		result = strToMatch( can_loc_range->val , cur_loc_range );
val              1457 ext/intl/locale/locale_methods.c 			if(result != 1 || lang_tag == NULL || !lang_tag->val[0]) {
val              1465 ext/intl/locale/locale_methods.c 			result = strToMatch(lang_tag->val, cur_arr[i*2]);
val              1478 ext/intl/locale/locale_methods.c 		if( result != 1 || can_loc_range == NULL || !can_loc_range->val[0]) {
val              1486 ext/intl/locale/locale_methods.c 			loc_range = can_loc_range->val;
val               732 ext/intl/uchar/uchar.c #define IC_CONSTL(name, val) \
val               733 ext/intl/uchar/uchar.c 	zend_declare_class_constant_long(ce, name, strlen(name), val);
val               194 ext/json/json.c PHP_JSON_API void php_json_encode(smart_str *buf, zval *val, int options) /* {{{ */
val               196 ext/json/json.c 	php_json_encode_zval(buf, val, options);
val                46 ext/json/json_encoder.c static int php_json_determine_array_type(zval *val) /* {{{ */
val                49 ext/json/json_encoder.c 	HashTable *myht = Z_ARRVAL_P(val);
val               118 ext/json/json_encoder.c static void php_json_encode_array(smart_str *buf, zval *val, int options) /* {{{ */
val               123 ext/json/json_encoder.c 	if (Z_TYPE_P(val) == IS_ARRAY) {
val               124 ext/json/json_encoder.c 		myht = Z_ARRVAL_P(val);
val               125 ext/json/json_encoder.c 		r = (options & PHP_JSON_FORCE_OBJECT) ? PHP_JSON_OUTPUT_OBJECT : php_json_determine_array_type(val);
val               127 ext/json/json_encoder.c 		myht = Z_OBJPROP_P(val);
val               172 ext/json/json_encoder.c 					if (ZSTR_VAL(key)[0] == '\0' && Z_TYPE_P(val) == IS_OBJECT) {
val               446 ext/json/json_encoder.c static void php_json_encode_serializable_object(smart_str *buf, zval *val, int options) /* {{{ */
val               448 ext/json/json_encoder.c 	zend_class_entry *ce = Z_OBJCE_P(val);
val               452 ext/json/json_encoder.c 	if (Z_TYPE_P(val) == IS_ARRAY) {
val               453 ext/json/json_encoder.c 		myht = Z_ARRVAL_P(val);
val               455 ext/json/json_encoder.c 		myht = Z_OBJPROP_P(val);
val               466 ext/json/json_encoder.c 	if (FAILURE == call_user_function_ex(EG(function_table), val, &fname, &retval, 0, NULL, 1, NULL) || Z_TYPE(retval) == IS_UNDEF) {
val               482 ext/json/json_encoder.c 		(Z_OBJ(retval) == Z_OBJ_P(val))) {
val               495 ext/json/json_encoder.c void php_json_encode_zval(smart_str *buf, zval *val, int options) /* {{{ */
val               498 ext/json/json_encoder.c 	switch (Z_TYPE_P(val))
val               512 ext/json/json_encoder.c 			smart_str_append_long(buf, Z_LVAL_P(val));
val               516 ext/json/json_encoder.c 			if (php_json_is_valid_double(Z_DVAL_P(val))) {
val               517 ext/json/json_encoder.c 				php_json_encode_double(buf, Z_DVAL_P(val), options);
val               525 ext/json/json_encoder.c 			php_json_escape_string(buf, Z_STRVAL_P(val), Z_STRLEN_P(val), options);
val               529 ext/json/json_encoder.c 			if (instanceof_function(Z_OBJCE_P(val), php_json_serializable_ce)) {
val               530 ext/json/json_encoder.c 				php_json_encode_serializable_object(buf, val, options);
val               535 ext/json/json_encoder.c 			php_json_encode_array(buf, val, options);
val               539 ext/json/json_encoder.c 			val = Z_REFVAL_P(val);
val                80 ext/json/json_parser.tab.h 		zval val;
val                50 ext/json/json_parser.y 		zval val;
val                70 ext/json/json_parser.y %destructor { zend_string_release($$.key); zval_dtor(&$$.val); } <pair>
val               152 ext/json/json_parser.y 				ZVAL_COPY_VALUE(&$$.val, &$3);
val                95 ext/json/php_json.h PHP_JSON_API void php_json_encode(smart_str *buf, zval *val, int options);
val                25 ext/json/php_json_encoder.h void php_json_encode_zval(smart_str *buf, zval *val, int options);
val              2100 ext/ldap/ldap.c 			int val;
val              2102 ext/ldap/ldap.c 			if (ldap_get_option(ld->link, option, &val)) {
val              2106 ext/ldap/ldap.c 			ZVAL_LONG(retval, val);
val              2172 ext/ldap/ldap.c 			char *val = NULL;
val              2174 ext/ldap/ldap.c 			if (ldap_get_option(ld->link, option, &val) || val == NULL || *val == '\0') {
val              2175 ext/ldap/ldap.c 				if (val) {
val              2176 ext/ldap/ldap.c 					ldap_memfree(val);
val              2181 ext/ldap/ldap.c 			ZVAL_STRING(retval, val);
val              2182 ext/ldap/ldap.c 			ldap_memfree(val);
val              2233 ext/ldap/ldap.c 			int val;
val              2236 ext/ldap/ldap.c 			val = Z_LVAL_P(newval);
val              2237 ext/ldap/ldap.c 			if (ldap_set_option(ldap, option, &val)) {
val              2293 ext/ldap/ldap.c 			char *val;
val              2295 ext/ldap/ldap.c 			val = Z_STRVAL_P(newval);
val              2296 ext/ldap/ldap.c 			if (ldap_set_option(ldap, option, val)) {
val              2306 ext/ldap/ldap.c 			void *val;
val              2308 ext/ldap/ldap.c 			val = Z_TYPE_P(newval) == IS_TRUE
val              2310 ext/ldap/ldap.c 			if (ldap_set_option(ldap, option, val)) {
val              2319 ext/ldap/ldap.c 			zval *ctrlval, *val;
val              2336 ext/ldap/ldap.c 				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "oid", sizeof("oid") - 1)) == NULL) {
val              2342 ext/ldap/ldap.c 				convert_to_string_ex(val);
val              2343 ext/ldap/ldap.c 				ctrl->ldctl_oid = Z_STRVAL_P(val);
val              2344 ext/ldap/ldap.c 				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "value", sizeof("value") - 1)) != NULL) {
val              2345 ext/ldap/ldap.c 					convert_to_string_ex(val);
val              2346 ext/ldap/ldap.c 					ctrl->ldctl_value.bv_val = Z_STRVAL_P(val);
val              2347 ext/ldap/ldap.c 					ctrl->ldctl_value.bv_len = Z_STRLEN_P(val);
val              2352 ext/ldap/ldap.c 				if ((val = zend_hash_str_find(Z_ARRVAL_P(ctrlval), "iscritical", sizeof("iscritical") - 1)) != NULL) {
val              2353 ext/ldap/ldap.c 					convert_to_boolean_ex(val);
val              2354 ext/ldap/ldap.c 					ctrl->ldctl_iscritical = Z_TYPE_P(val) == IS_TRUE;
val               278 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val               286 ext/mbstring/libmbfl/mbfl/mbfilter.c 					*loc = p - string->val;
val               294 ext/mbstring/libmbfl/mbfl/mbfilter.c 		*loc = p - string->val;
val               322 ext/mbstring/libmbfl/mbfl/mbfilter.c 		result->val = convd->device.buffer;
val               493 ext/mbstring/libmbfl/mbfl/mbfilter.c 	if (identd != NULL && string != NULL && string->val != NULL) {
val               496 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val               610 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val               659 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val               742 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val               833 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val               855 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val               961 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val               991 ext/mbstring/libmbfl/mbfl/mbfilter.c 	if (haystack == NULL || haystack->val == NULL || needle == NULL || needle->val == NULL) {
val              1041 ext/mbstring/libmbfl/mbfl/mbfilter.c 		const unsigned char *haystack_u8_val = haystack_u8->val,
val              1042 ext/mbstring/libmbfl/mbfl/mbfilter.c 		                    *needle_u8_val = needle_u8->val;
val              1092 ext/mbstring/libmbfl/mbfl/mbfilter.c 		const unsigned char *haystack_u8_val = haystack_u8->val,
val              1093 ext/mbstring/libmbfl/mbfl/mbfilter.c 		                    *needle_u8_val = needle_u8->val;
val              1213 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = needle->val;
val              1249 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = haystack->val;
val              1337 ext/mbstring/libmbfl/mbfl/mbfilter.c 			p = string->val;
val              1385 ext/mbstring/libmbfl/mbfl/mbfilter.c 		result->val = w = (unsigned char*)mbfl_malloc((n + 8)*sizeof(unsigned char));
val              1387 ext/mbstring/libmbfl/mbfl/mbfilter.c 			p = string->val;
val              1434 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val              1469 ext/mbstring/libmbfl/mbfl/mbfilter.c 	if (string == NULL || string->val == NULL || result == NULL) {
val              1508 ext/mbstring/libmbfl/mbfl/mbfilter.c 			start = string->val + from;
val              1517 ext/mbstring/libmbfl/mbfl/mbfilter.c 			start = string->val + from;
val              1524 ext/mbstring/libmbfl/mbfl/mbfilter.c 			start = string->val + from;
val              1532 ext/mbstring/libmbfl/mbfl/mbfilter.c 			for (m = 0, p = string->val, q = p + from;
val              1542 ext/mbstring/libmbfl/mbfl/mbfilter.c 			if (length >= (int)string->len - (start - string->val)) {
val              1543 ext/mbstring/libmbfl/mbfl/mbfilter.c 				end = string->val + string->len;
val              1570 ext/mbstring/libmbfl/mbfl/mbfilter.c 		result->val = w;
val              1603 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val              1606 ext/mbstring/libmbfl/mbfl/mbfilter.c 		for (q = string->val + from; p < q; p++) {
val              1615 ext/mbstring/libmbfl/mbfl/mbfilter.c 		q = string->val + string->len;
val              1785 ext/mbstring/libmbfl/mbfl/mbfilter.c 	if (string->len > 0 && string->val != NULL) {
val              1797 ext/mbstring/libmbfl/mbfl/mbfilter.c 		p = string->val;
val              1912 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val              1936 ext/mbstring/libmbfl/mbfl/mbfilter.c 				p = marker->val;
val              2033 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val              2375 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val              2660 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val              3088 ext/mbstring/libmbfl/mbfl/mbfilter.c 	p = string->val;
val               123 ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c 		result->val = device->buffer;
val               127 ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c 		if (result->val == NULL) {
val                51 ext/mbstring/libmbfl/mbfl/mbfl_string.c 		string->val = (unsigned char*)NULL;
val                62 ext/mbstring/libmbfl/mbfl/mbfl_string.c 		string->val = (unsigned char*)NULL;
val                71 ext/mbstring/libmbfl/mbfl/mbfl_string.c 		if (string->val != (unsigned char*)NULL) {
val                72 ext/mbstring/libmbfl/mbfl/mbfl_string.c 			mbfl_free(string->val);
val                74 ext/mbstring/libmbfl/mbfl/mbfl_string.c 		string->val = (unsigned char*)NULL;
val                44 ext/mbstring/libmbfl/mbfl/mbfl_string.h 	unsigned char *val;
val                18 ext/mbstring/libmbfl/tests/conv_encoding.c 		printf("%%%02x", ptr->val[i]);
val                18 ext/mbstring/libmbfl/tests/conv_kana.c 		printf("%%%02x", ptr->val[i]);
val                18 ext/mbstring/libmbfl/tests/emoji.c 		printf("%%%02x", ptr->val[i]);
val                83 ext/mbstring/libmbfl/tests/emoji.c 		if (result.val[i] >= 0xD8 && result.val[i] < 0xE0) { // Surrogate pair
val                84 ext/mbstring/libmbfl/tests/emoji.c 			int h = (result.val[i] & 0x07)<<8 | result.val[i+1];
val                85 ext/mbstring/libmbfl/tests/emoji.c 			int l = (result.val[i+2] & 0x03)<<8 | result.val[i+3];
val                90 ext/mbstring/libmbfl/tests/emoji.c 			printf("U+%x\n",(result.val[i] << 8) | result.val[i+1]);
val               103 ext/mbstring/libmbfl/tests/emoji.c 	memcpy(dev2.buffer, result.val, result.len+1);
val                29 ext/mbstring/libmbfl/tests/sample.c 	string.val = (unsigned char *)input;
val                36 ext/mbstring/libmbfl/tests/sample.c 	puts(ret->val);
val                19 ext/mbstring/libmbfl/tests/strcut.c 		printf("%%%02x", ptr->val[i]);
val               195 ext/mbstring/mb_gpc.c 	char *var, *val;
val               235 ext/mbstring/mb_gpc.c 		val = strchr(var, '=');
val               236 ext/mbstring/mb_gpc.c 		if (val) { /* have a value */
val               237 ext/mbstring/mb_gpc.c 			len_list[n] = php_url_decode(var, val-var);
val               241 ext/mbstring/mb_gpc.c 			*val++ = '\0';
val               242 ext/mbstring/mb_gpc.c 			val_list[n] = val;
val               243 ext/mbstring/mb_gpc.c 			len_list[n] = php_url_decode(val, strlen(val));
val               275 ext/mbstring/mb_gpc.c 				string.val = (unsigned char *)val_list[n];
val               312 ext/mbstring/mb_gpc.c 		string.val = (unsigned char *)val_list[n];
val               315 ext/mbstring/mb_gpc.c 			var = (char *)resvar.val;
val               320 ext/mbstring/mb_gpc.c 		string.val = (unsigned char *)val_list[n];
val               323 ext/mbstring/mb_gpc.c 			val = (char *)resval.val;
val               326 ext/mbstring/mb_gpc.c 			val = val_list[n];
val               331 ext/mbstring/mb_gpc.c 		val = estrndup(val, val_len);
val               332 ext/mbstring/mb_gpc.c 		if (sapi_module.input_filter(info->data_type, var, &val, val_len, &new_val_len)) {
val               334 ext/mbstring/mb_gpc.c 			php_register_variable_safe(var, val, new_val_len, array_ptr);
val               336 ext/mbstring/mb_gpc.c 		efree(val);
val               914 ext/mbstring/mbstring.c 	string.val = (unsigned char *)arg_string;
val               931 ext/mbstring/mbstring.c 	string.val = (unsigned char*)from;
val               955 ext/mbstring/mbstring.c 	*to = result.val;
val              2197 ext/mbstring/mbstring.c  	string.val = (unsigned char *)arg_string;
val              2206 ext/mbstring/mbstring.c  	RETVAL_STRINGL((char *)result.val, result.len);		/* the string is already strdup()'ed */
val              2207 ext/mbstring/mbstring.c 	efree(result.val);
val              2229 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string_len, &enc_name, &enc_name_len) == FAILURE) {
val              2277 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &enc_name, &enc_name_len) == FAILURE) {
val              2354 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|zs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &zoffset, &enc_name, &enc_name_len) == FAILURE) {
val              2453 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
val              2472 ext/mbstring/mbstring.c 	n = php_mb_stripos(0, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, offset, from_encoding);
val              2492 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|ls", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
val              2507 ext/mbstring/mbstring.c 	n = php_mb_stripos(1, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, offset, from_encoding);
val              2534 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &enc_name, &enc_name_len) == FAILURE) {
val              2568 ext/mbstring/mbstring.c 				RETVAL_STRINGL((char *)ret->val, ret->len);
val              2569 ext/mbstring/mbstring.c 				efree(ret->val);
val              2578 ext/mbstring/mbstring.c 				RETVAL_STRINGL((char *)ret->val, ret->len);
val              2579 ext/mbstring/mbstring.c 				efree(ret->val);
val              2607 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &enc_name, &enc_name_len) == FAILURE) {
val              2643 ext/mbstring/mbstring.c 				RETVAL_STRINGL((char *)ret->val, ret->len);
val              2644 ext/mbstring/mbstring.c 				efree(ret->val);
val              2653 ext/mbstring/mbstring.c 				RETVAL_STRINGL((char *)ret->val, ret->len);
val              2654 ext/mbstring/mbstring.c 				efree(ret->val);
val              2682 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
val              2708 ext/mbstring/mbstring.c 	n = php_mb_stripos(0, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, 0, from_encoding);
val              2720 ext/mbstring/mbstring.c 			RETVAL_STRINGL((char *)ret->val, ret->len);
val              2721 ext/mbstring/mbstring.c 			efree(ret->val);
val              2730 ext/mbstring/mbstring.c 			RETVAL_STRINGL((char *)ret->val, ret->len);
val              2731 ext/mbstring/mbstring.c 			efree(ret->val);
val              2756 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bs", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
val              2777 ext/mbstring/mbstring.c 	n = php_mb_stripos(1, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, 0, from_encoding);
val              2789 ext/mbstring/mbstring.c 			RETVAL_STRINGL((char *)ret->val, ret->len);
val              2790 ext/mbstring/mbstring.c 			efree(ret->val);
val              2799 ext/mbstring/mbstring.c 			RETVAL_STRINGL((char *)ret->val, ret->len);
val              2800 ext/mbstring/mbstring.c 			efree(ret->val);
val              2824 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|s", (char **)&haystack.val, &haystack_len, (char **)&needle.val, &needle_len, &enc_name, &enc_name_len) == FAILURE) {
val              2888 ext/mbstring/mbstring.c 	string.val = (unsigned char *)str;
val              2932 ext/mbstring/mbstring.c 	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
val              2933 ext/mbstring/mbstring.c 	efree(ret->val);
val              2951 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!s", (char **)&string.val, &string_len, &from, &len, &len_is_null, &encoding, &encoding_len) == FAILURE) {
val              3004 ext/mbstring/mbstring.c 	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
val              3005 ext/mbstring/mbstring.c 	efree(ret->val);
val              3023 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", (char **)&string.val, &string_len, &enc_name, &enc_name_len) == FAILURE) {
val              3070 ext/mbstring/mbstring.c 	marker.val = NULL;
val              3081 ext/mbstring/mbstring.c 	string.val = (unsigned char *)str;
val              3095 ext/mbstring/mbstring.c 		marker.val = (unsigned char *)trimmarker;
val              3105 ext/mbstring/mbstring.c 	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
val              3106 ext/mbstring/mbstring.c 	efree(ret->val);
val              3143 ext/mbstring/mbstring.c 	string.val = (unsigned char *)input;
val              3188 ext/mbstring/mbstring.c 		output = (char *)ret->val;
val              3406 ext/mbstring/mbstring.c 	string.val = (unsigned char *)str;
val              3485 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|sssl", (char **)&string.val, &string_len, &charset_name, &charset_name_len, &trans_enc_name, &trans_enc_name_len, &linefeed, &linefeed_len, &indent) == FAILURE) {
val              3525 ext/mbstring/mbstring.c 		RETVAL_STRINGL((char *)ret->val, ret->len);	/* the string is already strdup()'ed */
val              3526 ext/mbstring/mbstring.c 		efree(ret->val);
val              3544 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", (char **)&string.val, &string_len) == FAILURE) {
val              3559 ext/mbstring/mbstring.c 		RETVAL_STRINGL((char *)ret->val, ret->len);	/* the string is already strdup()'ed */
val              3560 ext/mbstring/mbstring.c 		efree(ret->val);
val              3582 ext/mbstring/mbstring.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ss", (char **)&string.val, &string_len, &optstr, &optstr_len, &encname, &encname_len) == FAILURE) {
val              3671 ext/mbstring/mbstring.c 		RETVAL_STRINGL((char *)ret->val, ret->len);		/* the string is already strdup()'ed */
val              3672 ext/mbstring/mbstring.c 		efree(ret->val);
val              3781 ext/mbstring/mbstring.c 								string.val = (unsigned char *)Z_STRVAL_P(hash_entry);
val              3790 ext/mbstring/mbstring.c 					string.val = (unsigned char *)Z_STRVAL_P(var);
val              3870 ext/mbstring/mbstring.c 							string.val = (unsigned char *)Z_STRVAL_P(hash_entry);
val              3876 ext/mbstring/mbstring.c 								ZVAL_STRINGL(hash_entry_ptr, (char *)ret->val, ret->len);
val              3877 ext/mbstring/mbstring.c 								efree(ret->val);
val              3883 ext/mbstring/mbstring.c 				string.val = (unsigned char *)Z_STRVAL_P(var);
val              3889 ext/mbstring/mbstring.c 					ZVAL_STRINGL(var, (char *)ret->val, ret->len);
val              3890 ext/mbstring/mbstring.c 					efree(ret->val);
val              3929 ext/mbstring/mbstring.c 	string.val = (unsigned char *)str;
val              3971 ext/mbstring/mbstring.c 		RETVAL_STRINGL((char *)ret->val, ret->len);
val              3972 ext/mbstring/mbstring.c 		efree(ret->val);
val              4121 ext/mbstring/mbstring.c 								zval val;
val              4125 ext/mbstring/mbstring.c 								ZVAL_STR(&val, fld_val);
val              4127 ext/mbstring/mbstring.c 								zend_hash_update(ht, fld_name, &val);
val              4169 ext/mbstring/mbstring.c 			zval val;
val              4173 ext/mbstring/mbstring.c 			ZVAL_STR(&val, fld_val);
val              4175 ext/mbstring/mbstring.c 			zend_hash_update(ht, fld_name, &val);
val              4343 ext/mbstring/mbstring.c 		orig_str.val = (unsigned char *)subject;
val              4352 ext/mbstring/mbstring.c 			subject_buf = subject = (char *)pstr->val;
val              4362 ext/mbstring/mbstring.c 		orig_str.val = (unsigned char *)message;
val              4378 ext/mbstring/mbstring.c 				efree(tmpstr.val);
val              4382 ext/mbstring/mbstring.c 			message_buf = message = (char *)pstr->val;
val              4689 ext/mbstring/mbstring.c 	string.val = (unsigned char *)var;
val              4697 ext/mbstring/mbstring.c 		if (illegalchars == 0 && string.len == result.len && memcmp(string.val, result.val, string.len) == 0) {
val              4830 ext/mbstring/mbstring.c 		haystack.val = (unsigned char *)php_unicode_convert_case(PHP_UNICODE_CASE_UPPER, (char *)old_haystack, old_haystack_len, &len, from_encoding);
val              4833 ext/mbstring/mbstring.c 		if (!haystack.val) {
val              4841 ext/mbstring/mbstring.c 		needle.val = (unsigned char *)php_unicode_convert_case(PHP_UNICODE_CASE_UPPER, (char *)old_needle, old_needle_len, &len, from_encoding);
val              4844 ext/mbstring/mbstring.c 		if (!needle.val) {
val              4878 ext/mbstring/mbstring.c 	if (haystack.val) {
val              4879 ext/mbstring/mbstring.c 		efree(haystack.val);
val              4882 ext/mbstring/mbstring.c 	if (needle.val) {
val              4883 ext/mbstring/mbstring.c 		efree(needle.val);
val              1110 ext/mbstring/oniguruma/enc/mktable.c   int c, val, enc;
val              1118 ext/mbstring/oniguruma/enc/mktable.c     val = 0;
val              1119 ext/mbstring/oniguruma/enc/mktable.c     if (IsNewline(enc, c))  val |= BIT_CTYPE_NEWLINE;
val              1120 ext/mbstring/oniguruma/enc/mktable.c     if (IsAlpha (enc, c))   val |= (BIT_CTYPE_ALPHA | BIT_CTYPE_ALNUM);
val              1121 ext/mbstring/oniguruma/enc/mktable.c     if (IsBlank (enc, c))   val |= BIT_CTYPE_BLANK;
val              1122 ext/mbstring/oniguruma/enc/mktable.c     if (IsCntrl (enc, c))   val |= BIT_CTYPE_CNTRL;
val              1123 ext/mbstring/oniguruma/enc/mktable.c     if (IsDigit (enc, c))   val |= (BIT_CTYPE_DIGIT | BIT_CTYPE_ALNUM);
val              1124 ext/mbstring/oniguruma/enc/mktable.c     if (IsGraph (enc, c))   val |= BIT_CTYPE_GRAPH;
val              1125 ext/mbstring/oniguruma/enc/mktable.c     if (IsLower (enc, c))   val |= BIT_CTYPE_LOWER;
val              1126 ext/mbstring/oniguruma/enc/mktable.c     if (IsPrint (enc, c))   val |= BIT_CTYPE_PRINT;
val              1127 ext/mbstring/oniguruma/enc/mktable.c     if (IsPunct (enc, c))   val |= BIT_CTYPE_PUNCT;
val              1128 ext/mbstring/oniguruma/enc/mktable.c     if (IsSpace (enc, c))   val |= BIT_CTYPE_SPACE;
val              1129 ext/mbstring/oniguruma/enc/mktable.c     if (IsUpper (enc, c))   val |= BIT_CTYPE_UPPER;
val              1130 ext/mbstring/oniguruma/enc/mktable.c     if (IsXDigit(enc, c))   val |= BIT_CTYPE_XDIGIT;
val              1131 ext/mbstring/oniguruma/enc/mktable.c     if (IsWord  (enc, c))   val |= BIT_CTYPE_WORD;
val              1132 ext/mbstring/oniguruma/enc/mktable.c     if (IsAscii (enc, c))   val |= BIT_CTYPE_ASCII;
val              1135 ext/mbstring/oniguruma/enc/mktable.c     fprintf(fp, "0x%04x", val);
val              4414 ext/mbstring/oniguruma/regcomp.c   int i, val;
val              4425 ext/mbstring/oniguruma/regcomp.c   val = 0;
val              4431 ext/mbstring/oniguruma/regcomp.c       val += map_position_value(enc, i);
val              4433 ext/mbstring/oniguruma/regcomp.c   to->value = val;
val                72 ext/mbstring/oniguruma/regenc.h #define ONIG_CHECK_NULL_RETURN_VAL(p,val)  if (ONIG_IS_NULL(p)) return (val)
val               217 ext/mbstring/oniguruma/regint.h #define PLATFORM_GET_INC(val,p,type) do{\
val               218 ext/mbstring/oniguruma/regint.h   val  = *(type* )p;\
val               224 ext/mbstring/oniguruma/regint.h #define PLATFORM_GET_INC(val,p,type) do{\
val               225 ext/mbstring/oniguruma/regint.h   xmemcpy(&val, (p), sizeof(type));\
val               339 ext/mbstring/oniguruma/regparse.c   int val = 0;
val               343 ext/mbstring/oniguruma/regparse.c     val = val * 997 + (int )*p++;
val               346 ext/mbstring/oniguruma/regparse.c   return val + (val >> 5);
val              1571 ext/mbstring/oniguruma/regparse.c node_str_head_pad(StrNode* sn, int num, UChar val)
val              1582 ext/mbstring/oniguruma/regparse.c     sn->s[i] = val;
val              1590 ext/mbstring/oniguruma/regparse.c   unsigned int num, val;
val              1599 ext/mbstring/oniguruma/regparse.c       val = (unsigned int )DIGITVAL(c);
val              1600 ext/mbstring/oniguruma/regparse.c       if ((INT_MAX_LIMIT - val) / 10UL < num)
val              1603 ext/mbstring/oniguruma/regparse.c       num = num * 10 + val;
val              1619 ext/mbstring/oniguruma/regparse.c   unsigned int num, val;
val              1627 ext/mbstring/oniguruma/regparse.c       val = (unsigned int )XDIGITVAL(enc,c);
val              1628 ext/mbstring/oniguruma/regparse.c       if ((INT_MAX_LIMIT - val) / 16UL < num)
val              1647 ext/mbstring/oniguruma/regparse.c   unsigned int num, val;
val              1655 ext/mbstring/oniguruma/regparse.c       val = ODIGITVAL(c);
val              1656 ext/mbstring/oniguruma/regparse.c       if ((INT_MAX_LIMIT - val) / 8UL < num)
val              1659 ext/mbstring/oniguruma/regparse.c       num = (num << 3) + val;
val              4869 ext/mbstring/oniguruma/regparse.c   int i, val;
val              4872 ext/mbstring/oniguruma/regparse.c   val = 0;
val              4876 ext/mbstring/oniguruma/regparse.c     val = val * 997 + (int )*p++;
val              4881 ext/mbstring/oniguruma/regparse.c     val = val * 997 + (int )*p++;
val              4884 ext/mbstring/oniguruma/regparse.c   val += key->not;
val              4885 ext/mbstring/oniguruma/regparse.c   return val + (val >> 5);
val               544 ext/mbstring/oniguruma/st.c     register int val = 0;
val               547 ext/mbstring/oniguruma/st.c 	val += c;
val               548 ext/mbstring/oniguruma/st.c 	val += (val << 10);
val               549 ext/mbstring/oniguruma/st.c 	val ^= (val >> 6);
val               551 ext/mbstring/oniguruma/st.c     val += (val << 3);
val               552 ext/mbstring/oniguruma/st.c     val ^= (val >> 11);
val               554 ext/mbstring/oniguruma/st.c     return val + (val << 15);
val               556 ext/mbstring/oniguruma/st.c     register int val = 0;
val               559 ext/mbstring/oniguruma/st.c 	val = val*997 + c;
val               562 ext/mbstring/oniguruma/st.c     return val + (val>>5);
val               262 ext/mbstring/php_unicode.c #define UINT32_TO_BE_ARY(ptr,val) { \
val               263 ext/mbstring/php_unicode.c 	unsigned int v = val; \
val               125 ext/mysqli/mysqli.c 		if (type == FETCH_RESULT && bbuf.buf[i].val) {
val               126 ext/mysqli/mysqli.c 			efree(bbuf.buf[i].val);
val               421 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].val = (char *)emalloc(sizeof(float));
val               423 ext/mysqli/mysqli_api.c 				bind[ofs].buffer = stmt->result.buf[ofs].val;
val               432 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].val = (char *)emalloc(sizeof(double));
val               434 ext/mysqli/mysqli_api.c 				bind[ofs].buffer = stmt->result.buf[ofs].val;
val               458 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].val = (char *)emalloc(sizeof(int));
val               460 ext/mysqli/mysqli_api.c 				bind[ofs].buffer = stmt->result.buf[ofs].val;
val               471 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].val = (char *)emalloc(stmt->result.buf[ofs].buflen);
val               473 ext/mysqli/mysqli_api.c 				bind[ofs].buffer = stmt->result.buf[ofs].val;
val               529 ext/mysqli/mysqli_api.c 				stmt->result.buf[ofs].val = (char *)emalloc(stmt->result.buf[ofs].buflen);
val               531 ext/mysqli/mysqli_api.c 				bind[ofs].buffer = stmt->result.buf[ofs].val;
val               549 ext/mysqli/mysqli_api.c 			if (stmt->result.buf[i].val) {
val               550 ext/mysqli/mysqli_api.c 				efree(stmt->result.buf[i].val);
val               957 ext/mysqli/mysqli_api.c 			memset(stmt->result.buf[i].val, 0, stmt->result.buf[i].buflen);
val               988 ext/mysqli/mysqli_api.c 							uval= *(unsigned int *) stmt->result.buf[i].val;
val              1008 ext/mysqli/mysqli_api.c 							ZVAL_LONG(result, *(unsigned int *)stmt->result.buf[i].val);
val              1010 ext/mysqli/mysqli_api.c 							ZVAL_LONG(result, *(int *)stmt->result.buf[i].val);
val              1020 ext/mysqli/mysqli_api.c 							dval = mysql_float_to_double(*(float *)stmt->result.buf[i].val,
val              1024 ext/mysqli/mysqli_api.c 							dval = *((double *)stmt->result.buf[i].val);
val              1040 ext/mysqli/mysqli_api.c 									case 8:llval = (my_ulonglong)  bit_uint8korr(stmt->result.buf[i].val);break;
val              1041 ext/mysqli/mysqli_api.c 									case 7:llval = (my_ulonglong)  bit_uint7korr(stmt->result.buf[i].val);break;
val              1042 ext/mysqli/mysqli_api.c 									case 6:llval = (my_ulonglong)  bit_uint6korr(stmt->result.buf[i].val);break;
val              1043 ext/mysqli/mysqli_api.c 									case 5:llval = (my_ulonglong)  bit_uint5korr(stmt->result.buf[i].val);break;
val              1044 ext/mysqli/mysqli_api.c 									case 4:llval = (my_ulonglong)  bit_uint4korr(stmt->result.buf[i].val);break;
val              1045 ext/mysqli/mysqli_api.c 									case 3:llval = (my_ulonglong)  bit_uint3korr(stmt->result.buf[i].val);break;
val              1046 ext/mysqli/mysqli_api.c 									case 2:llval = (my_ulonglong)  bit_uint2korr(stmt->result.buf[i].val);break;
val              1047 ext/mysqli/mysqli_api.c 									case 1:llval = (my_ulonglong)  uint1korr(stmt->result.buf[i].val);break;
val              1052 ext/mysqli/mysqli_api.c 								llval= *(my_ulonglong *) stmt->result.buf[i].val;
val              1076 ext/mysqli/mysqli_api.c 								ZVAL_STRINGL(result, stmt->result.buf[i].val, stmt->stmt->bind[i].buffer_length);
val              1081 ext/mysqli/mysqli_api.c 								ZVAL_STRINGL(result, stmt->result.buf[i].val, stmt->result.buf[i].output_len);
val               101 ext/mysqli/php_mysqli_structs.h 	char		*val;
val               810 ext/mysqlnd/mysqlnd_net.c 			enum mysqlnd_ssl_peer val = *((enum mysqlnd_ssl_peer *)value);
val               811 ext/mysqlnd/mysqlnd_net.c 			switch (val) {
val               820 ext/mysqlnd/mysqlnd_net.c 					val = MYSQLND_SSL_PEER_DEFAULT;
val               824 ext/mysqlnd/mysqlnd_net.c 					val = MYSQLND_SSL_PEER_DEFAULT;
val               827 ext/mysqlnd/mysqlnd_net.c 			net->data->options.ssl_verify_peer = val;
val               170 ext/mysqlnd/mysqlnd_plugin.c 	zval *val;
val               173 ext/mysqlnd/mysqlnd_plugin.c 	ZEND_HASH_FOREACH_VAL(&mysqlnd_registered_plugins, val) {
val               174 ext/mysqlnd/mysqlnd_plugin.c 		result = apply_func(val, argument);
val                40 ext/mysqlnd/mysqlnd_statistics.h #define MYSQLND_STAT_CALL_TRIGGER(s_array, statistic, val) \
val                45 ext/mysqlnd/mysqlnd_statistics.h 				(s_array)->triggers[(statistic)]((s_array), (statistic), (val)); \
val                51 ext/mysqlnd/mysqlnd_statistics.h #define MYSQLND_STAT_CALL_TRIGGER(s_array, statistic, val)
val               972 ext/oci8/oci8_statement.c 		zval *val = bind->zval;
val               973 ext/oci8/oci8_statement.c 		if (Z_TYPE_P(val) == IS_STRING) {
val               974 ext/oci8/oci8_statement.c 			*Z_STRVAL_P(val) = '\0'; /* XXX avoid warning in debug mode */
val               976 ext/oci8/oci8_statement.c 		zval_dtor(val);
val               977 ext/oci8/oci8_statement.c 		ZVAL_NULL(val);
val              1341 ext/oci8/oci8_statement.c 	zval *val;
val              1343 ext/oci8/oci8_statement.c 	if (!(phpbind=(php_oci_bind *)ictxp) || !(val = phpbind->zval)) {
val              1348 ext/oci8/oci8_statement.c 	if (Z_ISNULL_P(val)) {
val              1356 ext/oci8/oci8_statement.c 		convert_to_string(val);
val              1358 ext/oci8/oci8_statement.c 		*bufpp = Z_STRVAL_P(val);
val              1359 ext/oci8/oci8_statement.c 		*alenp = (ub4) Z_STRLEN_P(val);
val              1401 ext/oci8/oci8_statement.c 	zval *val;
val              1404 ext/oci8/oci8_statement.c 	if (!(phpbind=(php_oci_bind *)octxp) || !(val = phpbind->zval)) {
val              1409 ext/oci8/oci8_statement.c 	if (Z_TYPE_P(val) == IS_RESOURCE) {
val              1419 ext/oci8/oci8_statement.c 	} else if (Z_TYPE_P(val) == IS_OBJECT) {
val              1431 ext/oci8/oci8_statement.c 		if ((tmp = zend_hash_str_find(Z_OBJPROP_P(val), "descriptor", sizeof("descriptor")-1)) == NULL) {
val              1445 ext/oci8/oci8_statement.c 		convert_to_string(val);
val              1446 ext/oci8/oci8_statement.c 		zval_dtor(val);
val              1450 ext/oci8/oci8_statement.c 			ZVAL_STRINGL(val, p, PHP_OCI_PIECE_SIZE);
val              1454 ext/oci8/oci8_statement.c 		Z_STRLEN_P(val) = PHP_OCI_PIECE_SIZE; /* 64K-1 is max XXX */
val              1455 ext/oci8/oci8_statement.c 		Z_STRVAL_P(val) = ecalloc(1, Z_STRLEN_P(val) + 1);
val              1457 ext/oci8/oci8_statement.c 		ZVAL_STRINGL(val, NULL, Z_STRLEN(phpbind->zval) + 1);
val               320 ext/opcache/Optimizer/compact_literals.c 			fprintf(stderr, "File %s func %s\n", op_array->filename->val,
val               321 ext/opcache/Optimizer/compact_literals.c 					op_array->function_name ? op_array->function_name->val : "main");
val               203 ext/opcache/Optimizer/pass1_5.c 				ptr = str->val;
val                37 ext/opcache/Optimizer/zend_optimizer.c 	zval val;
val                43 ext/opcache/Optimizer/zend_optimizer.c 	ZVAL_DUP(&val, value);
val                44 ext/opcache/Optimizer/zend_optimizer.c 	zend_hash_add(ctx->constants, Z_STR_P(name), &val);
val                49 ext/opcache/Optimizer/zend_optimizer.c 	zval *val;
val                51 ext/opcache/Optimizer/zend_optimizer.c 	if ((val = zend_hash_find(constants, Z_STR_P(name))) != NULL) {
val                52 ext/opcache/Optimizer/zend_optimizer.c 		ZVAL_DUP(value, val);
val               127 ext/opcache/Optimizer/zend_optimizer.c static inline void drop_leading_backslash(zval *val) {
val               128 ext/opcache/Optimizer/zend_optimizer.c 	if (Z_STRVAL_P(val)[0] == '\\') {
val               129 ext/opcache/Optimizer/zend_optimizer.c 		zend_string *str = zend_string_init(Z_STRVAL_P(val) + 1, Z_STRLEN_P(val) - 1, 0);
val               130 ext/opcache/Optimizer/zend_optimizer.c 		zval_dtor(val);
val               131 ext/opcache/Optimizer/zend_optimizer.c 		ZVAL_STR(val, str);
val               144 ext/opcache/Optimizer/zend_optimizer.c #define REQUIRES_STRING(val) do { \
val               145 ext/opcache/Optimizer/zend_optimizer.c 	if (Z_TYPE_P(val) != IS_STRING) { \
val               146 ext/opcache/Optimizer/zend_optimizer.c 		zval_dtor(val); \
val               151 ext/opcache/Optimizer/zend_optimizer.c #define TO_STRING_NOWARN(val) do { \
val               152 ext/opcache/Optimizer/zend_optimizer.c 	if (Z_TYPE_P(val) >= IS_ARRAY) { \
val               153 ext/opcache/Optimizer/zend_optimizer.c 		zval_dtor(val); \
val               156 ext/opcache/Optimizer/zend_optimizer.c 	convert_to_string(val); \
val               161 ext/opcache/Optimizer/zend_optimizer.c                                     zval          *val)
val               166 ext/opcache/Optimizer/zend_optimizer.c 			zval_dtor(val);
val               173 ext/opcache/Optimizer/zend_optimizer.c 			REQUIRES_STRING(val);
val               174 ext/opcache/Optimizer/zend_optimizer.c 			drop_leading_backslash(val);
val               175 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.constant = zend_optimizer_add_literal(op_array, val);
val               177 ext/opcache/Optimizer/zend_optimizer.c 			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
val               185 ext/opcache/Optimizer/zend_optimizer.c 			TO_STRING_NOWARN(val);
val               186 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.constant = zend_optimizer_add_literal(op_array, val);
val               193 ext/opcache/Optimizer/zend_optimizer.c 			TO_STRING_NOWARN(val);
val               196 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.constant = zend_optimizer_add_literal(op_array, val);
val               209 ext/opcache/Optimizer/zend_optimizer.c                                     zval          *val)
val               213 ext/opcache/Optimizer/zend_optimizer.c 			zval_dtor(val);
val               229 ext/opcache/Optimizer/zend_optimizer.c 			REQUIRES_STRING(val);
val               230 ext/opcache/Optimizer/zend_optimizer.c 			drop_leading_backslash(val);
val               231 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               232 ext/opcache/Optimizer/zend_optimizer.c 			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
val               236 ext/opcache/Optimizer/zend_optimizer.c 			REQUIRES_STRING(val);
val               237 ext/opcache/Optimizer/zend_optimizer.c 			zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
val               238 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               242 ext/opcache/Optimizer/zend_optimizer.c 			if (Z_TYPE_P(val) == IS_STRING) {
val               243 ext/opcache/Optimizer/zend_optimizer.c 				if (zend_memrchr(Z_STRVAL_P(val), ':', Z_STRLEN_P(val))) {
val               244 ext/opcache/Optimizer/zend_optimizer.c 					zval_dtor(val);
val               249 ext/opcache/Optimizer/zend_optimizer.c 				drop_leading_backslash(val);
val               250 ext/opcache/Optimizer/zend_optimizer.c 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               251 ext/opcache/Optimizer/zend_optimizer.c 				zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
val               254 ext/opcache/Optimizer/zend_optimizer.c 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               259 ext/opcache/Optimizer/zend_optimizer.c 			REQUIRES_STRING(val);
val               260 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               261 ext/opcache/Optimizer/zend_optimizer.c 			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
val               278 ext/opcache/Optimizer/zend_optimizer.c 			TO_STRING_NOWARN(val);
val               279 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               295 ext/opcache/Optimizer/zend_optimizer.c 				TO_STRING_NOWARN(val);
val               296 ext/opcache/Optimizer/zend_optimizer.c 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               299 ext/opcache/Optimizer/zend_optimizer.c 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               318 ext/opcache/Optimizer/zend_optimizer.c 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               334 ext/opcache/Optimizer/zend_optimizer.c 			if (Z_TYPE_P(val) == IS_STRING) {
val               336 ext/opcache/Optimizer/zend_optimizer.c 				if (ZEND_HANDLE_NUMERIC(Z_STR_P(val), index)) {
val               337 ext/opcache/Optimizer/zend_optimizer.c 					zval_dtor(val);
val               338 ext/opcache/Optimizer/zend_optimizer.c 					ZVAL_LONG(val, index);
val               341 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               348 ext/opcache/Optimizer/zend_optimizer.c 			TO_STRING_NOWARN(val);
val               351 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
val               366 ext/opcache/Optimizer/zend_optimizer.c                                     zval          *val)
val               381 ext/opcache/Optimizer/zend_optimizer.c 					zval_dtor(val);
val               394 ext/opcache/Optimizer/zend_optimizer.c 							zval_dtor(val);
val               429 ext/opcache/Optimizer/zend_optimizer.c 						zval_dtor(val);
val               440 ext/opcache/Optimizer/zend_optimizer.c 								ZVAL_COPY_VALUE(&old_val, val);
val               441 ext/opcache/Optimizer/zend_optimizer.c 								zval_copy_ctor(val);
val               442 ext/opcache/Optimizer/zend_optimizer.c 								zend_optimizer_update_op1_const(op_array, m, val);
val               443 ext/opcache/Optimizer/zend_optimizer.c 								ZVAL_COPY_VALUE(val, &old_val);
val               452 ext/opcache/Optimizer/zend_optimizer.c 					zval_dtor(val);
val               460 ext/opcache/Optimizer/zend_optimizer.c 						|| !ZEND_SAME_FAKE_TYPE(ret_info->type_hint, Z_TYPE_P(val))
val               462 ext/opcache/Optimizer/zend_optimizer.c 						zval_dtor(val);
val               466 ext/opcache/Optimizer/zend_optimizer.c 					zend_optimizer_update_op1_const(op_array, opline + 1, val);
val               472 ext/opcache/Optimizer/zend_optimizer.c 			return zend_optimizer_update_op1_const(op_array, opline, val);
val               477 ext/opcache/Optimizer/zend_optimizer.c 			return zend_optimizer_update_op2_const(op_array, opline, val);
val               685 ext/opcache/Optimizer/zend_optimizer.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               686 ext/opcache/Optimizer/zend_optimizer.c 		op_array = (zend_op_array*)Z_PTR(p->val);
val               692 ext/opcache/Optimizer/zend_optimizer.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               693 ext/opcache/Optimizer/zend_optimizer.c 		ce = (zend_class_entry*)Z_PTR(p->val);
val               696 ext/opcache/Optimizer/zend_optimizer.c 			if (Z_TYPE(q->val) == IS_UNDEF) continue;
val               697 ext/opcache/Optimizer/zend_optimizer.c 			op_array = (zend_op_array*)Z_PTR(q->val);
val               716 ext/opcache/Optimizer/zend_optimizer.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               717 ext/opcache/Optimizer/zend_optimizer.c 			op_array = (zend_op_array*)Z_PTR(p->val);
val               723 ext/opcache/Optimizer/zend_optimizer.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               724 ext/opcache/Optimizer/zend_optimizer.c 			ce = (zend_class_entry*)Z_PTR(p->val);
val               727 ext/opcache/Optimizer/zend_optimizer.c 				if (Z_TYPE(q->val) == IS_UNDEF) continue;
val               728 ext/opcache/Optimizer/zend_optimizer.c 				op_array = (zend_op_array*)Z_PTR(q->val);
val                94 ext/opcache/Optimizer/zend_optimizer_internal.h #define LITERAL_LONG(op, val) do { \
val                96 ext/opcache/Optimizer/zend_optimizer_internal.h 		ZVAL_LONG(&_c, val); \
val               100 ext/opcache/Optimizer/zend_optimizer_internal.h #define LITERAL_BOOL(op, val) do { \
val               102 ext/opcache/Optimizer/zend_optimizer_internal.h 		ZVAL_BOOL(&_c, val); \
val               123 ext/opcache/Optimizer/zend_optimizer_internal.h                                     zval          *val);
val               126 ext/opcache/Optimizer/zend_optimizer_internal.h                                     zval          *val);
val               131 ext/opcache/Optimizer/zend_optimizer_internal.h                                      zval          *val);
val               362 ext/opcache/ZendAccelerator.c 			HT_HASH(&ZCSG(interned_strings), nIndex) = Z_NEXT(p->val);
val               365 ext/opcache/ZendAccelerator.c 			while (Z_NEXT(HT_HASH_TO_BUCKET(&ZCSG(interned_strings), prev)->val) != idx) {
val               366 ext/opcache/ZendAccelerator.c 				prev = Z_NEXT(HT_HASH_TO_BUCKET(&ZCSG(interned_strings), prev)->val);
val               368 ext/opcache/ZendAccelerator.c 			Z_NEXT(HT_HASH_TO_BUCKET(&ZCSG(interned_strings), prev)->val) = Z_NEXT(p->val);
val               412 ext/opcache/ZendAccelerator.c 		idx = Z_NEXT(p->val);
val               452 ext/opcache/ZendAccelerator.c 		idx = Z_NEXT(p->val);
val               481 ext/opcache/ZendAccelerator.c 	ZVAL_INTERNED_STR(&p->val, p->key);
val               482 ext/opcache/ZendAccelerator.c 	Z_NEXT(p->val) = HT_HASH(&ZCSG(interned_strings), nIndex);
val               510 ext/opcache/ZendAccelerator.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               514 ext/opcache/ZendAccelerator.c 		if (Z_FUNC(p->val)->common.function_name) {
val               515 ext/opcache/ZendAccelerator.c 			Z_FUNC(p->val)->common.function_name = accel_new_interned_string(Z_FUNC(p->val)->common.function_name);
val               524 ext/opcache/ZendAccelerator.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               525 ext/opcache/ZendAccelerator.c 		ce = (zend_class_entry*)Z_PTR(p->val);
val               539 ext/opcache/ZendAccelerator.c 			if (Z_TYPE(q->val) == IS_UNDEF) continue;
val               541 ext/opcache/ZendAccelerator.c 			info = (zend_property_info*)Z_PTR(q->val);
val               554 ext/opcache/ZendAccelerator.c 			if (Z_TYPE(q->val) == IS_UNDEF) continue;
val               558 ext/opcache/ZendAccelerator.c 			if (Z_FUNC(q->val)->common.function_name) {
val               559 ext/opcache/ZendAccelerator.c 				Z_FUNC(q->val)->common.function_name = accel_new_interned_string(Z_FUNC(q->val)->common.function_name);
val               565 ext/opcache/ZendAccelerator.c 			if (!Z_TYPE(q->val) == IS_UNDEF) continue;
val               575 ext/opcache/ZendAccelerator.c 		if (!Z_TYPE(p->val) == IS_UNDEF) continue;
val               586 ext/opcache/ZendAccelerator.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               588 ext/opcache/ZendAccelerator.c 		auto_global = (zend_auto_global*)Z_PTR(p->val);;
val               735 ext/opcache/ZendAccelerator.c 	if (file_handle->opened_path && GetFileAttributesEx(file_handle->opened_path->val, GetFileExInfoStandard, &fdata) != 0) {
val              2140 ext/opcache/ZendAccelerator.c 					if (Z_REFCOUNTED(ref->val) && Z_DELREF(ref->val) == 0) {
val              2141 ext/opcache/ZendAccelerator.c 						zvalue = &ref->val;
val              2156 ext/opcache/ZendAccelerator.c 		if (Z_REFCOUNTED(p->val) && Z_DELREF(p->val) == 0) {
val              2157 ext/opcache/ZendAccelerator.c 			accel_fast_zval_dtor(&p->val);
val              2171 ext/opcache/ZendAccelerator.c 		while (Z_NEXT(prev->val) != idx) {
val              2172 ext/opcache/ZendAccelerator.c 			i = Z_NEXT(prev->val);
val              2175 ext/opcache/ZendAccelerator.c 		Z_NEXT(prev->val) = Z_NEXT(p->val);
val              2177 ext/opcache/ZendAccelerator.c 		HT_HASH(ht, p->h | ht->nTableMask) = Z_NEXT(p->val);
val              2191 ext/opcache/ZendAccelerator.c 				if (Z_REFCOUNTED(_p->val) && Z_DELREF(_p->val) == 0) {
val              2192 ext/opcache/ZendAccelerator.c 					accel_fast_zval_dtor(&_p->val);
val              2200 ext/opcache/ZendAccelerator.c 			zend_function *func = Z_PTR(_p->val);
val              2217 ext/opcache/ZendAccelerator.c 			zend_class_entry *ce = Z_PTR(_p->val);
val              2259 ext/opcache/ZendAccelerator.c 			zend_function *func = Z_PTR(_p->val);
val              2269 ext/opcache/ZendAccelerator.c 			zend_class_entry *ce = Z_PTR(_p->val);
val              2280 ext/opcache/ZendAccelerator.c 		zend_constant *c = Z_PTR(_p->val);
val               128 ext/opcache/zend_accelerator_util_funcs.c 		zend_function *function = Z_PTR(p->val);
val               166 ext/opcache/zend_accelerator_util_funcs.c 			ZVAL_NEW_REF(src, &old->val);
val               196 ext/opcache/zend_accelerator_util_funcs.c 		ZVAL_COPY_VALUE(&copy->val, zend_ast_get_zval(ast));
val               255 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               260 ext/opcache/zend_accelerator_util_funcs.c 		Z_NEXT(q->val) = HT_HASH(ht, nIndex);
val               268 ext/opcache/zend_accelerator_util_funcs.c 		ZVAL_COPY_VALUE(&q->val, &p->val);
val               269 ext/opcache/zend_accelerator_util_funcs.c 		zend_clone_zval(&q->val);
val               300 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               306 ext/opcache/zend_accelerator_util_funcs.c 		Z_NEXT(q->val) = HT_HASH(ht, nIndex);
val               315 ext/opcache/zend_accelerator_util_funcs.c 		ZVAL_PTR(&q->val, ARENA_REALLOC(Z_PTR(p->val)));
val               316 ext/opcache/zend_accelerator_util_funcs.c 		new_entry = (zend_op_array*)Z_PTR(q->val);
val               358 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               364 ext/opcache/zend_accelerator_util_funcs.c 		Z_NEXT(q->val) = HT_HASH(ht, nIndex);
val               373 ext/opcache/zend_accelerator_util_funcs.c 		prop_info = ARENA_REALLOC(Z_PTR(p->val));
val               374 ext/opcache/zend_accelerator_util_funcs.c 		ZVAL_PTR(&q->val, prop_info);
val               533 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               539 ext/opcache/zend_accelerator_util_funcs.c 				t = zend_hash_update(target, p->key, &p->val);
val               544 ext/opcache/zend_accelerator_util_funcs.c 			_zend_hash_append_ptr(target, p->key, Z_PTR(p->val));
val               551 ext/opcache/zend_accelerator_util_funcs.c 	function1 = Z_PTR(p->val);
val               577 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               583 ext/opcache/zend_accelerator_util_funcs.c 				zend_hash_update_ptr(target, p->key, ARENA_REALLOC(Z_PTR(p->val)));
val               588 ext/opcache/zend_accelerator_util_funcs.c 			_zend_hash_append_ptr(target, p->key, ARENA_REALLOC(Z_PTR(p->val)));
val               595 ext/opcache/zend_accelerator_util_funcs.c 	function1 = Z_PTR(p->val);
val               621 ext/opcache/zend_accelerator_util_funcs.c 		if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
val               632 ext/opcache/zend_accelerator_util_funcs.c 			t = _zend_hash_append_ptr(target, p->key, Z_PTR(p->val));
val               642 ext/opcache/zend_accelerator_util_funcs.c 	ce1 = Z_PTR(p->val);
val               261 ext/opcache/zend_file_cache.c 		if (Z_TYPE(p->val) != IS_UNDEF) {
val               263 ext/opcache/zend_file_cache.c 			func(&p->val, script, info, buf);
val               282 ext/opcache/zend_file_cache.c 		zend_file_cache_serialize_zval(&((zend_ast_zval*)ast)->val, script, info, buf);
val               330 ext/opcache/zend_file_cache.c 				zend_file_cache_serialize_zval(&ref->val, script, info, buf);
val               785 ext/opcache/zend_file_cache.c 		write(fd, ((zend_string*)ZCG(mem))->val, info.str_size) != info.str_size
val               827 ext/opcache/zend_file_cache.c 		if (Z_TYPE(p->val) != IS_UNDEF) {
val               829 ext/opcache/zend_file_cache.c 			func(&p->val, script, buf);
val               844 ext/opcache/zend_file_cache.c 		zend_file_cache_unserialize_zval(&((zend_ast_zval*)ast)->val, script, buf);
val               890 ext/opcache/zend_file_cache.c 				zend_file_cache_unserialize_zval(&ref->val, script, buf);
val               117 ext/opcache/zend_persist.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               125 ext/opcache/zend_persist.c 			pPersistElement(&p->val);
val               128 ext/opcache/zend_persist.c 			Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               145 ext/opcache/zend_persist.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               153 ext/opcache/zend_persist.c 		pPersistElement(&p->val);
val               199 ext/opcache/zend_persist.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               207 ext/opcache/zend_persist.c 			zend_persist_zval_const(&p->val);
val               210 ext/opcache/zend_persist.c 			Z_NEXT(p->val) = HT_HASH(ht, nIndex);
val               224 ext/opcache/zend_persist.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val               232 ext/opcache/zend_persist.c 		zend_persist_zval_const(&p->val);
val               243 ext/opcache/zend_persist.c 		zend_persist_zval(&copy->val);
val                82 ext/opcache/zend_persist_calc.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val                91 ext/opcache/zend_persist_calc.c 		pPersistElement(&p->val);
val                80 ext/opcache/zend_shared_alloc.c 	int val;
val                93 ext/opcache/zend_shared_alloc.c 	val = fcntl(lock_file, F_GETFD, 0);
val                94 ext/opcache/zend_shared_alloc.c 	val |= FD_CLOEXEC;
val                95 ext/opcache/zend_shared_alloc.c 	fcntl(lock_file, F_SETFD, val);
val               644 ext/openssl/openssl.c static X509 * php_openssl_x509_from_zval(zval * val, int makeresource, zend_resource **resourceval);
val               645 ext/openssl/openssl.c static EVP_PKEY * php_openssl_evp_from_zval(zval * val, int public_key, char * passphrase, int makeresource, zend_resource **resourceval);
val               649 ext/openssl/openssl.c static X509_REQ * php_openssl_csr_from_zval(zval * val, int makeresource, zend_resource ** resourceval);
val               652 ext/openssl/openssl.c static void add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int shortname) /* {{{ */
val               666 ext/openssl/openssl.c 		ZVAL_COPY_VALUE(&subitem, val);
val               708 ext/openssl/openssl.c 		zend_hash_str_update(Z_ARRVAL_P(val), key, strlen(key), &subitem);
val               713 ext/openssl/openssl.c static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */
val               715 ext/openssl/openssl.c 	add_assoc_stringl(val, key, (char *)str->data, str->length);
val              1381 ext/openssl/openssl.c static X509 * php_openssl_x509_from_zval(zval * val, int makeresource, zend_resource **resourceval)
val              1388 ext/openssl/openssl.c 	if (Z_TYPE_P(val) == IS_RESOURCE) {
val              1391 ext/openssl/openssl.c 		zend_resource *res = Z_RES_P(val);
val              1400 ext/openssl/openssl.c 			Z_ADDREF_P(val);
val              1405 ext/openssl/openssl.c 	if (!(Z_TYPE_P(val) == IS_STRING || Z_TYPE_P(val) == IS_OBJECT)) {
val              1410 ext/openssl/openssl.c 	convert_to_string_ex(val);
val              1412 ext/openssl/openssl.c 	if (Z_STRLEN_P(val) > 7 && memcmp(Z_STRVAL_P(val), "file://", sizeof("file://") - 1) == 0) {
val              1416 ext/openssl/openssl.c 		if (php_openssl_open_base_dir_chk(Z_STRVAL_P(val) + (sizeof("file://") - 1))) {
val              1420 ext/openssl/openssl.c 		in = BIO_new_file(Z_STRVAL_P(val) + (sizeof("file://") - 1), "r");
val              1429 ext/openssl/openssl.c 		in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
val              2807 ext/openssl/openssl.c static X509_REQ * php_openssl_csr_from_zval(zval * val, int makeresource, zend_resource **resourceval)
val              2816 ext/openssl/openssl.c 	if (Z_TYPE_P(val) == IS_RESOURCE) {
val              2818 ext/openssl/openssl.c 		zend_resource *res = Z_RES_P(val);
val              2824 ext/openssl/openssl.c 				Z_ADDREF_P(val);
val              2829 ext/openssl/openssl.c 	} else if (Z_TYPE_P(val) != IS_STRING) {
val              2833 ext/openssl/openssl.c 	if (Z_STRLEN_P(val) > 7 && memcmp(Z_STRVAL_P(val), "file://", sizeof("file://") - 1) == 0) {
val              2834 ext/openssl/openssl.c 		filename = Z_STRVAL_P(val) + (sizeof("file://") - 1);
val              2842 ext/openssl/openssl.c 		in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
val              3229 ext/openssl/openssl.c static EVP_PKEY * php_openssl_evp_from_zval(zval * val, int public_key, char * passphrase, int makeresource, zend_resource **resourceval)
val              3249 ext/openssl/openssl.c 	if (Z_TYPE_P(val) == IS_ARRAY) {
val              3254 ext/openssl/openssl.c 		if ((zphrase = zend_hash_index_find(Z_ARRVAL_P(val), 1)) == NULL) {
val              3268 ext/openssl/openssl.c 		if ((val = zend_hash_index_find(Z_ARRVAL_P(val), 0)) == NULL) {
val              3274 ext/openssl/openssl.c 	if (Z_TYPE_P(val) == IS_RESOURCE) {
val              3276 ext/openssl/openssl.c 		zend_resource * res = Z_RES_P(val);
val              3284 ext/openssl/openssl.c 			Z_ADDREF_P(val);
val              3320 ext/openssl/openssl.c 		if (!(Z_TYPE_P(val) == IS_STRING || Z_TYPE_P(val) == IS_OBJECT)) {
val              3323 ext/openssl/openssl.c 		convert_to_string_ex(val);
val              3325 ext/openssl/openssl.c 		if (Z_STRLEN_P(val) > 7 && memcmp(Z_STRVAL_P(val), "file://", sizeof("file://") - 1) == 0) {
val              3326 ext/openssl/openssl.c 			filename = Z_STRVAL_P(val) + (sizeof("file://") - 1);
val              3330 ext/openssl/openssl.c 			cert = php_openssl_x509_from_zval(val, 0, &cert_res);
val              3339 ext/openssl/openssl.c 					in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
val              3357 ext/openssl/openssl.c 				in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
val              4757 ext/openssl/openssl.c 	unsigned long val;
val              4763 ext/openssl/openssl.c 	val = ERR_get_error();
val              4764 ext/openssl/openssl.c 	if (val) {
val              4765 ext/openssl/openssl.c 		RETURN_STRING(ERR_error_string(val, buf));
val              5496 ext/openssl/openssl.c 	if (php_win32_get_random_bytes((unsigned char*)buffer->val, (size_t) buffer_length) == FAILURE){
val                96 ext/openssl/xp_ssl.c #define GET_VER_OPT(name)               (PHP_STREAM_CONTEXT(stream) && (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "ssl", name)) != NULL)
val                97 ext/openssl/xp_ssl.c #define GET_VER_OPT_STRING(name, str)   if (GET_VER_OPT(name)) { convert_to_string_ex(val); str = Z_STRVAL_P(val); }
val                98 ext/openssl/xp_ssl.c #define GET_VER_OPT_LONG(name, num)     if (GET_VER_OPT(name)) { convert_to_long_ex(val); num = Z_LVAL_P(val); }
val               276 ext/openssl/xp_ssl.c 	zval *val;
val               293 ext/openssl/xp_ssl.c 		zend_is_true(val)
val               323 ext/openssl/xp_ssl.c static zend_bool php_x509_fingerprint_match(X509 *peer, zval *val)
val               325 ext/openssl/xp_ssl.c 	if (Z_TYPE_P(val) == IS_STRING) {
val               328 ext/openssl/xp_ssl.c 		switch (Z_STRLEN_P(val)) {
val               338 ext/openssl/xp_ssl.c 		return method && php_x509_fingerprint_cmp(peer, method, Z_STRVAL_P(val)) == 0;
val               339 ext/openssl/xp_ssl.c 	} else if (Z_TYPE_P(val) == IS_ARRAY) {
val               343 ext/openssl/xp_ssl.c 		if (!zend_hash_num_elements(Z_ARRVAL_P(val))) {
val               348 ext/openssl/xp_ssl.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(val), key, current) {
val               482 ext/openssl/xp_ssl.c 	zval *val = NULL;
val               492 ext/openssl/xp_ssl.c 		? zend_is_true(val)
val               496 ext/openssl/xp_ssl.c 		? zend_is_true(val)
val               514 ext/openssl/xp_ssl.c 				if (GET_VER_OPT("allow_self_signed") && zend_is_true(val)) {
val               531 ext/openssl/xp_ssl.c 		if (Z_TYPE_P(val) == IS_STRING || Z_TYPE_P(val) == IS_ARRAY) {
val               532 ext/openssl/xp_ssl.c 			if (!php_x509_fingerprint_match(peer, val)) {
val               575 ext/openssl/xp_ssl.c 	zval *val = NULL;
val               582 ext/openssl/xp_ssl.c 		if (Z_STRLEN_P(val) < num - 1) {
val               583 ext/openssl/xp_ssl.c 			memcpy(buf, Z_STRVAL_P(val), Z_STRLEN_P(val)+1);
val               584 ext/openssl/xp_ssl.c 			return (int)Z_STRLEN_P(val);
val               600 ext/openssl/xp_ssl.c 	zval *val;
val               741 ext/openssl/xp_ssl.c 				&& GET_VER_OPT("allow_self_signed") && zend_is_true(val)) {
val               837 ext/openssl/xp_ssl.c 	zval *val = NULL;
val               897 ext/openssl/xp_ssl.c 	zval *val = NULL;
val              1059 ext/openssl/xp_ssl.c 		zval *val;
val              1064 ext/openssl/xp_ssl.c 		if (PHP_STREAM_CONTEXT(stream) && (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1073 ext/openssl/xp_ssl.c 			if (FAILURE == call_user_function_ex(EG(function_table), NULL, val, &retval, 1, &param, 0, NULL)) {
val              1103 ext/openssl/xp_ssl.c 	zval *val;
val              1108 ext/openssl/xp_ssl.c 		NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1111 ext/openssl/xp_ssl.c 		convert_to_long(val);
val              1112 ext/openssl/xp_ssl.c 		limit = Z_LVAL_P(val);
val              1121 ext/openssl/xp_ssl.c 		NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1124 ext/openssl/xp_ssl.c 		convert_to_long(val);
val              1125 ext/openssl/xp_ssl.c 		window = Z_LVAL_P(val);
val              1323 ext/openssl/xp_ssl.c 	zval *val;
val              1332 ext/openssl/xp_ssl.c 	if (GET_VER_OPT("SNI_enabled") && !zend_is_true(val)) {
val              1341 ext/openssl/xp_ssl.c 	if (Z_TYPE_P(val) != IS_ARRAY) {
val              1348 ext/openssl/xp_ssl.c 	sslsock->sni_cert_count = zend_hash_num_elements(Z_ARRVAL_P(val));
val              1360 ext/openssl/xp_ssl.c 	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(val), key_index, key, current) {
val              1412 ext/openssl/xp_ssl.c 	zval *val;
val              1416 ext/openssl/xp_ssl.c 	if (GET_VER_OPT("SNI_enabled") && !zend_is_true(val)) {
val              1500 ext/openssl/xp_ssl.c 	zval *val;
val              1546 ext/openssl/xp_ssl.c 	if (GET_VER_OPT("no_ticket") && zend_is_true(val)) {
val              1556 ext/openssl/xp_ssl.c 	if (!GET_VER_OPT("disable_compression") || zend_is_true(val)) {
val              1561 ext/openssl/xp_ssl.c 	if (GET_VER_OPT("verify_peer") && !zend_is_true(val)) {
val              1722 ext/openssl/xp_ssl.c 	zval *val, zcert;
val              1725 ext/openssl/xp_ssl.c 	if (NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1727 ext/openssl/xp_ssl.c 		zend_is_true(val)
val              1735 ext/openssl/xp_ssl.c 	if (NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1737 ext/openssl/xp_ssl.c 		zend_is_true(val)
val              1865 ext/openssl/xp_ssl.c 					zval *val;
val              1866 ext/openssl/xp_ssl.c 					if (NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream),
val              1874 ext/openssl/xp_ssl.c 					if (val && zend_is_true(val)) {
val              2494 ext/openssl/xp_ssl.c 	zval *val;
val              2496 ext/openssl/xp_ssl.c 	if (ctx && (val = php_stream_context_get_option(ctx, "ssl", "crypto_method")) != NULL) {
val              2497 ext/openssl/xp_ssl.c 		convert_to_long_ex(val);
val              2498 ext/openssl/xp_ssl.c 		crypto_method = (zend_long)Z_LVAL_P(val);
val              6208 ext/pcre/pcrelib/pcre_exec.c #define LBL(val) case val: goto L_RM##val;
val               609 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 	int i, val;
val               616 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		val = inst->operand_value[i];
val               618 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		bits |= operand->insert(val);
val              1383 ext/pcre/php_pcre.c 					if (Z_TYPE(Z_ARRVAL_P(replace)->arData[replace_idx].val) != IS_UNDEF) {
val              1384 ext/pcre/php_pcre.c 						ZVAL_COPY(&replace_str, &Z_ARRVAL_P(replace)->arData[replace_idx].val);
val               921 ext/pdo/pdo_stmt.c 					zval val;
val               929 ext/pdo/pdo_stmt.c 					fetch_value(stmt, &val, i++, NULL);
val               930 ext/pdo/pdo_stmt.c 					if (Z_TYPE(val) != IS_NULL) {
val               931 ext/pdo/pdo_stmt.c 						convert_to_string(&val);
val               932 ext/pdo/pdo_stmt.c 						if ((cep = zend_lookup_class(Z_STR(val))) == NULL) {
val               940 ext/pdo/pdo_stmt.c 					zval_dtor(&val);
val              1021 ext/pdo/pdo_stmt.c 			zval val;
val              1022 ext/pdo/pdo_stmt.c 			fetch_value(stmt, &val, i, NULL);
val              1026 ext/pdo/pdo_stmt.c 					zend_symtable_update(Z_ARRVAL_P(return_value), stmt->columns[i].name, &val);
val              1034 ext/pdo/pdo_stmt.c 						if (Z_TYPE(val) == IS_LONG) {
val              1035 ext/pdo/pdo_stmt.c 							zend_hash_index_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_LVAL(val), &tmp);
val              1037 ext/pdo/pdo_stmt.c 							convert_to_string(&val);
val              1038 ext/pdo/pdo_stmt.c 							zend_symtable_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_STR(val), &tmp);
val              1040 ext/pdo/pdo_stmt.c 						zval_ptr_dtor(&val);
val              1047 ext/pdo/pdo_stmt.c 					zend_symtable_update(Z_ARRVAL_P(return_value), stmt->columns[i].name, &val);
val              1048 ext/pdo/pdo_stmt.c 					if (Z_REFCOUNTED(val)) {
val              1049 ext/pdo/pdo_stmt.c 						Z_ADDREF(val);
val              1051 ext/pdo/pdo_stmt.c 					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &val);
val              1081 ext/pdo/pdo_stmt.c 							zend_hash_next_index_insert_new(Z_ARRVAL(arr), &val);
val              1083 ext/pdo/pdo_stmt.c 							zend_hash_update(Z_ARRVAL_P(return_value), stmt->columns[i].name, &val);
val              1089 ext/pdo/pdo_stmt.c 					zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &val);
val              1096 ext/pdo/pdo_stmt.c 						&val);
val              1097 ext/pdo/pdo_stmt.c 					zval_ptr_dtor(&val);
val              1104 ext/pdo/pdo_stmt.c 							&val);
val              1105 ext/pdo/pdo_stmt.c 						zval_ptr_dtor(&val);
val              1111 ext/pdo/pdo_stmt.c 						if (php_var_unserialize(return_value, (const unsigned char**)&Z_STRVAL(val), Z_STRVAL(val)+Z_STRLEN(val), NULL) == FAILURE) {
val              1119 ext/pdo/pdo_stmt.c 							zval_ptr_dtor(&val);
val              1122 ext/pdo/pdo_stmt.c 						} else if (ce->unserialize(return_value, ce, (unsigned char *)(Z_TYPE(val) == IS_STRING ? Z_STRVAL(val) : ""), Z_TYPE(val) == IS_STRING ? Z_STRLEN(val) : 0, NULL) == FAILURE) {
val              1123 ext/pdo/pdo_stmt.c 							zval_ptr_dtor(&val);
val              1129 ext/pdo/pdo_stmt.c 							zval_ptr_dtor(&val);
val              1135 ext/pdo/pdo_stmt.c 					ZVAL_COPY_VALUE(&stmt->fetch.func.values[idx], &val);
val              1140 ext/pdo/pdo_stmt.c 					zval_ptr_dtor(&val);
val              2597 ext/pdo/pdo_stmt.c 		zval val;
val              2598 ext/pdo/pdo_stmt.c 		fetch_value(stmt, &val, i, NULL);
val              2600 ext/pdo/pdo_stmt.c 		zend_hash_update(stmt->std.properties, stmt->columns[i].name, &val);
val               257 ext/pdo/php_pdo_driver.h typedef int (*pdo_dbh_set_attr_func)(pdo_dbh_t *dbh, zend_long attr, zval *val);
val               272 ext/pdo/php_pdo_driver.h typedef int (*pdo_dbh_get_attr_func)(pdo_dbh_t *dbh, zend_long attr, zval *val);
val               358 ext/pdo/php_pdo_driver.h typedef int (*pdo_stmt_set_attr_func)(pdo_stmt_t *stmt, zend_long attr, zval *val);
val               361 ext/pdo/php_pdo_driver.h typedef int (*pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, zend_long attr, zval *val);
val               277 ext/pdo_dblib/dblib_driver.c static int dblib_set_attr(pdo_dbh_t *dbh, zend_long attr, zval *val)
val               471 ext/pdo_firebird/firebird_driver.c static int firebird_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
val               478 ext/pdo_firebird/firebird_driver.c 				zend_bool bval = zval_get_long(val)? 1 : 0;
val               502 ext/pdo_firebird/firebird_driver.c 			H->fetch_table_names = zval_get_long(val)? 1 : 0;
val               507 ext/pdo_firebird/firebird_driver.c 				zend_string *str = zval_get_string(val);
val               518 ext/pdo_firebird/firebird_driver.c 				zend_string *str = zval_get_string(val);
val               529 ext/pdo_firebird/firebird_driver.c 				zend_string *str = zval_get_string(val);
val               555 ext/pdo_firebird/firebird_driver.c static int firebird_handle_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
val               563 ext/pdo_firebird/firebird_driver.c 			ZVAL_LONG(val,dbh->auto_commit);
val               567 ext/pdo_firebird/firebird_driver.c 			ZVAL_BOOL(val, !isc_version(&H->db, firebird_info_cb, NULL));
val               585 ext/pdo_firebird/firebird_driver.c 				ZVAL_STRING(val, tmp);
val               588 ext/pdo_firebird/firebird_driver.c 			ZVAL_NULL(val);
val               598 ext/pdo_firebird/firebird_driver.c 				ZVAL_STRING(val, tmp);
val               603 ext/pdo_firebird/firebird_driver.c 			ZVAL_BOOL(val, H->fetch_table_names);
val               658 ext/pdo_firebird/firebird_statement.c static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, zend_long attr, zval *val) /* {{{ */
val               666 ext/pdo_firebird/firebird_statement.c 			convert_to_string(val);
val               668 ext/pdo_firebird/firebird_statement.c 			if (isc_dsql_set_cursor_name(S->H->isc_status, &S->stmt, Z_STRVAL_P(val),0)) {
val               672 ext/pdo_firebird/firebird_statement.c 			strlcpy(S->name, Z_STRVAL_P(val), sizeof(S->name));
val               679 ext/pdo_firebird/firebird_statement.c static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, zend_long attr, zval *val) /* {{{ */
val               688 ext/pdo_firebird/firebird_statement.c 				ZVAL_STRING(val, S->name);
val               690 ext/pdo_firebird/firebird_statement.c 				ZVAL_NULL(val);
val               369 ext/pdo_mysql/mysql_driver.c static int pdo_mysql_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val)
val               371 ext/pdo_mysql/mysql_driver.c 	zend_long lval = zval_get_long(val);
val               441 ext/pdo_oci/oci_driver.c static int oci_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
val               443 ext/pdo_oci/oci_driver.c 	zend_long lval = zval_get_long(val);
val               273 ext/pdo_oci/oci_statement.c 	*bufpp = (Z_STR_P(parameter))->val;
val               345 ext/pdo_oci/oci_statement.c 							&P->bind, S->err, (text*)param->name->val,
val               339 ext/pdo_odbc/odbc_driver.c static int odbc_handle_set_attr(pdo_dbh_t *dbh, zend_long attr, zval *val)
val               344 ext/pdo_odbc/odbc_driver.c 			H->assume_utf8 = zval_is_true(val);
val               354 ext/pdo_odbc/odbc_driver.c static int odbc_handle_get_attr(pdo_dbh_t *dbh, zend_long attr, zval *val)
val               359 ext/pdo_odbc/odbc_driver.c 			ZVAL_STRING(val, "ODBC-" PDO_ODBC_TYPE);
val               369 ext/pdo_odbc/odbc_driver.c 			ZVAL_BOOL(val, H->assume_utf8 ? 1 : 0);
val               757 ext/pdo_odbc/odbc_stmt.c static int odbc_stmt_set_param(pdo_stmt_t *stmt, zend_long attr, zval *val)
val               764 ext/pdo_odbc/odbc_stmt.c 			convert_to_string(val);
val               765 ext/pdo_odbc/odbc_stmt.c 			rc = SQLSetCursorName(S->stmt, Z_STRVAL_P(val), Z_STRLEN_P(val));
val               774 ext/pdo_odbc/odbc_stmt.c 			S->assume_utf8 = zval_is_true(val);
val               784 ext/pdo_odbc/odbc_stmt.c static int odbc_stmt_get_attr(pdo_stmt_t *stmt, zend_long attr, zval *val)
val               797 ext/pdo_odbc/odbc_stmt.c 				ZVAL_STRINGL(val, buf, len);
val               805 ext/pdo_odbc/odbc_stmt.c 			ZVAL_BOOL(val, S->assume_utf8 ? 1 : 0);
val              1153 ext/pdo_pgsql/pgsql_driver.c static int pdo_pgsql_set_attr(pdo_dbh_t *dbh, zend_long attr, zval *val)
val              1155 ext/pdo_pgsql/pgsql_driver.c 	zend_bool bval = zval_get_long(val)? 1 : 0;
val               298 ext/pdo_sqlite/sqlite_driver.c static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, zend_long attr, zval *val)
val               304 ext/pdo_sqlite/sqlite_driver.c 			sqlite3_busy_timeout(H->db, zval_get_long(val) * 1000);
val               346 ext/pdo_sqlite/sqlite_driver.c 			if (Z_ISUNDEF(agg_context->val)) {
val               349 ext/pdo_sqlite/sqlite_driver.c 				ZVAL_NULL(&agg_context->val);
val               423 ext/pdo_sqlite/sqlite_driver.c 			zval_ptr_dtor(&agg_context->val);
val               429 ext/pdo_sqlite/sqlite_driver.c 			zval_ptr_dtor(&agg_context->val);
val               432 ext/pdo_sqlite/sqlite_driver.c 			ZVAL_COPY_VALUE(&agg_context->val, &retval);
val               435 ext/pdo_sqlite/sqlite_driver.c 			ZVAL_UNDEF(&agg_context->val);
val              5804 ext/pgsql/pgsql.c 	zval meta, *def, *type, *not_null, *has_default, *is_enum, *val, new_val;
val              5824 ext/pgsql/pgsql.c 	ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(values), field, val) {
val              5853 ext/pgsql/pgsql.c 		if (!err && (Z_TYPE_P(val) == IS_ARRAY || Z_TYPE_P(val) == IS_OBJECT)) {
val              5872 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              5874 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              5878 ext/pgsql/pgsql.c 							if (!strcmp(Z_STRVAL_P(val), "t") || !strcmp(Z_STRVAL_P(val), "T") ||
val              5879 ext/pgsql/pgsql.c 								!strcmp(Z_STRVAL_P(val), "y") || !strcmp(Z_STRVAL_P(val), "Y") ||
val              5880 ext/pgsql/pgsql.c 								!strcmp(Z_STRVAL_P(val), "true") || !strcmp(Z_STRVAL_P(val), "True") ||
val              5881 ext/pgsql/pgsql.c 								!strcmp(Z_STRVAL_P(val), "yes") || !strcmp(Z_STRVAL_P(val), "Yes") ||
val              5882 ext/pgsql/pgsql.c 								!strcmp(Z_STRVAL_P(val), "1")) {
val              5885 ext/pgsql/pgsql.c 							else if (!strcmp(Z_STRVAL_P(val), "f") || !strcmp(Z_STRVAL_P(val), "F") ||
val              5886 ext/pgsql/pgsql.c 									 !strcmp(Z_STRVAL_P(val), "n") || !strcmp(Z_STRVAL_P(val), "N") ||
val              5887 ext/pgsql/pgsql.c 									 !strcmp(Z_STRVAL_P(val), "false") ||  !strcmp(Z_STRVAL_P(val), "False") ||
val              5888 ext/pgsql/pgsql.c 									 !strcmp(Z_STRVAL_P(val), "no") ||  !strcmp(Z_STRVAL_P(val), "No") ||
val              5889 ext/pgsql/pgsql.c 									 !strcmp(Z_STRVAL_P(val), "0")) {
val              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));
val              5900 ext/pgsql/pgsql.c 						if (Z_LVAL_P(val)) {
val              5933 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              5935 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              5940 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([+-]{0,1}[0-9]+)$", 0) == FAILURE) {
val              5944 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              5950 ext/pgsql/pgsql.c 						ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
val              5955 ext/pgsql/pgsql.c 						ZVAL_LONG(&new_val, Z_LVAL_P(val));
val              5975 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              5977 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              5982 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$", 0) == FAILURE) {
val              5983 ext/pgsql/pgsql.c 								if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^[+-]{0,1}(inf)(inity){0,1}$", 1) == FAILURE) {
val              5986 ext/pgsql/pgsql.c 									ZVAL_STRING(&new_val, Z_STRVAL_P(val));
val              5991 ext/pgsql/pgsql.c 								ZVAL_STRING(&new_val, Z_STRVAL_P(val));
val              5997 ext/pgsql/pgsql.c 						ZVAL_LONG(&new_val, Z_LVAL_P(val));
val              6001 ext/pgsql/pgsql.c 						ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
val              6036 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              6038 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6048 ext/pgsql/pgsql.c 							str = zend_string_alloc(Z_STRLEN_P(val) * 2, 0);
val              6050 ext/pgsql/pgsql.c 							ZSTR_LEN(str) = PQescapeStringConn(pg_link, ZSTR_VAL(str), Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
val              6058 ext/pgsql/pgsql.c 						ZVAL_LONG(&new_val, Z_LVAL_P(val));
val              6063 ext/pgsql/pgsql.c 						ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
val              6083 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              6085 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6090 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^[0-9]+$", 0) == FAILURE) {
val              6094 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6101 ext/pgsql/pgsql.c 						ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
val              6106 ext/pgsql/pgsql.c 						ZVAL_LONG(&new_val, Z_LVAL_P(val));
val              6124 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              6126 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6131 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$", 0) == FAILURE) {
val              6135 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6157 ext/pgsql/pgsql.c 				switch(Z_TYPE_P(val)) {
val              6159 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6161 ext/pgsql/pgsql.c 						} else if (!strcasecmp(Z_STRVAL_P(val), "now()")) {
val              6165 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})([ \\t]+(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}(\\.[0-9]+){0,1}([ \\t]*([+-][0-9]{1,4}(:[0-9]{1,2}){0,1}|[-a-zA-Z_/+]{1,50})){0,1})){0,1}$", 1) == FAILURE) {
val              6168 ext/pgsql/pgsql.c 								ZVAL_STRING(&new_val, Z_STRVAL_P(val));
val              6188 ext/pgsql/pgsql.c 				switch(Z_TYPE_P(val)) {
val              6190 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6195 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})$", 1) == FAILURE) {
val              6199 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6219 ext/pgsql/pgsql.c 				switch(Z_TYPE_P(val)) {
val              6221 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6226 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1})){0,1}$", 1) == FAILURE) {
val              6230 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6250 ext/pgsql/pgsql.c 				switch(Z_TYPE_P(val)) {
val              6252 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6273 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val),
val              6309 ext/pgsql/pgsql.c 								ZVAL_STRING(&new_val, Z_STRVAL_P(val));
val              6329 ext/pgsql/pgsql.c 				switch (Z_TYPE_P(val)) {
val              6331 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6339 ext/pgsql/pgsql.c 							tmp = PQescapeByteaConn(pg_link, (unsigned char *)Z_STRVAL_P(val), Z_STRLEN_P(val), &to_len);
val              6341 ext/pgsql/pgsql.c 							tmp = PQescapeBytea(Z_STRVAL_P(val), (unsigned char *)Z_STRLEN_P(val), &to_len);
val              6354 ext/pgsql/pgsql.c 						ZVAL_LONG(&new_val, Z_LVAL_P(val));
val              6359 ext/pgsql/pgsql.c 						ZVAL_DOUBLE(&new_val, Z_DVAL_P(val));
val              6378 ext/pgsql/pgsql.c 				switch(Z_TYPE_P(val)) {
val              6380 ext/pgsql/pgsql.c 						if (Z_STRLEN_P(val) == 0) {
val              6384 ext/pgsql/pgsql.c 							if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([0-9a-f]{2,2}:){5,5}[0-9a-f]{2,2}$", 1) == FAILURE) {
val              6388 ext/pgsql/pgsql.c 								ZVAL_STRINGL(&new_val, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6545 ext/pgsql/pgsql.c 	zval *val, converted;
val              6596 ext/pgsql/pgsql.c 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(var_array), val) {
val              6598 ext/pgsql/pgsql.c 		switch (Z_TYPE_P(val)) {
val              6603 ext/pgsql/pgsql.c 					tmp = (char *)safe_emalloc(Z_STRLEN_P(val), 2, 1);
val              6604 ext/pgsql/pgsql.c 					new_len = PQescapeStringConn(pg_link, tmp, Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
val              6610 ext/pgsql/pgsql.c 					smart_str_appendl(&querystr, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6614 ext/pgsql/pgsql.c 				smart_str_append_long(&querystr, Z_LVAL_P(val));
val              6617 ext/pgsql/pgsql.c 				smart_str_appendl(&querystr, buf, snprintf(buf, sizeof(buf), "%F", Z_DVAL_P(val)));
val              6623 ext/pgsql/pgsql.c 				php_error_docref(NULL, E_WARNING, "Expects scaler values. type = %d", Z_TYPE_P(val));
val              6748 ext/pgsql/pgsql.c 	zval *val;
val              6750 ext/pgsql/pgsql.c 	ZEND_HASH_FOREACH_STR_KEY_VAL(ht, fld, val) {
val              6762 ext/pgsql/pgsql.c 		if (where_cond && (Z_TYPE_P(val) == IS_TRUE || Z_TYPE_P(val) == IS_FALSE || (Z_TYPE_P(val) == IS_STRING && !strcmp(Z_STRVAL_P(val), "NULL")))) {
val              6768 ext/pgsql/pgsql.c 		switch (Z_TYPE_P(val)) {
val              6772 ext/pgsql/pgsql.c 					tmp = (char *)safe_emalloc(Z_STRLEN_P(val), 2, 1);
val              6773 ext/pgsql/pgsql.c 					new_len = PQescapeStringConn(pg_link, tmp, Z_STRVAL_P(val), Z_STRLEN_P(val), NULL);
val              6779 ext/pgsql/pgsql.c 					smart_str_appendl(querystr, Z_STRVAL_P(val), Z_STRLEN_P(val));
val              6783 ext/pgsql/pgsql.c 				smart_str_append_long(querystr, Z_LVAL_P(val));
val              6786 ext/pgsql/pgsql.c 				smart_str_appendl(querystr, buf, MIN(snprintf(buf, sizeof(buf), "%F", Z_DVAL_P(val)), sizeof(buf)-1));
val              6792 ext/pgsql/pgsql.c 				php_error_docref(NULL, E_WARNING, "Expects scaler values. type=%d", Z_TYPE_P(val));
val               809 ext/phar/phar_object.c 		zval *val;
val               814 ext/phar/phar_object.c 			if (NULL != (val = zend_hash_str_find(Z_ARRVAL_P(mimeoverride), ext, strlen(ext)))) {
val               815 ext/phar/phar_object.c 				switch (Z_TYPE_P(val)) {
val               817 ext/phar/phar_object.c 						if (Z_LVAL_P(val) == PHAR_MIME_PHP || Z_LVAL_P(val) == PHAR_MIME_PHPS) {
val               819 ext/phar/phar_object.c 							code = Z_LVAL_P(val);
val               834 ext/phar/phar_object.c 						mime_type = Z_STRVAL_P(val);
val               907 ext/phar/stream.c 			entry = Z_PTR(b->val);
val                65 ext/phar/tar.c static int phar_tar_octal(char *buf, php_uint32 val, int len) /* {{{ */
val                72 ext/phar/tar.c 		*--p = (char)('0' + (val & 7));
val                73 ext/phar/tar.c 		val >>= 3;
val                76 ext/phar/tar.c 	if (val == 0)
val               444 ext/posix/posix.c 	zend_long val;	\
val               445 ext/posix/posix.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &val) == FAILURE) RETURN_FALSE;	\
val               446 ext/posix/posix.c 	if (func_name(val) < 0) {	\
val               642 ext/posix/posix.c 	zend_long val;
val               643 ext/posix/posix.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &val) == FAILURE) {
val               647 ext/posix/posix.c 	if ((val = getpgid(val)) < 0) {
val               651 ext/posix/posix.c 	RETURN_LONG(val);
val               661 ext/posix/posix.c 	zend_long val;
val               662 ext/posix/posix.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &val) == FAILURE) {
val               666 ext/posix/posix.c 	if ((val = getsid(val)) < 0) {
val               670 ext/posix/posix.c 	RETURN_LONG(val);
val              1882 ext/reflection/php_reflection.c 	zval *val;
val              1898 ext/reflection/php_reflection.c 		ZEND_HASH_FOREACH_VAL(fptr->op_array.static_variables, val) {
val              1899 ext/reflection/php_reflection.c 			if (UNEXPECTED(zval_update_constant_ex(val, 1, fptr->common.scope) != SUCCESS)) {
val              1962 ext/reflection/php_reflection.c 	zval *params, *val;
val              1982 ext/reflection/php_reflection.c 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(param_array), val) {
val              1983 ext/reflection/php_reflection.c 		ZVAL_COPY(&params[argc], val);
val              3253 ext/reflection/php_reflection.c 	zval *params, *val, *object;
val              3293 ext/reflection/php_reflection.c 	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(param_array), val) {
val              3294 ext/reflection/php_reflection.c 		ZVAL_COPY(&params[argc], val);
val              4398 ext/reflection/php_reflection.c 	zval *val;
val              4405 ext/reflection/php_reflection.c 	ZEND_HASH_FOREACH_VAL(&ce->constants_table, val) {
val              4406 ext/reflection/php_reflection.c 		if (UNEXPECTED(zval_update_constant_ex(val, 1, ce) != SUCCESS)) {
val              4678 ext/reflection/php_reflection.c 	zval retval, *val;
val              4721 ext/reflection/php_reflection.c 			ZEND_HASH_FOREACH_VAL(args, val) {
val              4722 ext/reflection/php_reflection.c 				ZVAL_COPY(&params[argc], val);
val               223 ext/session/mod_files.c static int ps_files_write(ps_files *data, zend_string *key, zend_string *val)
val               236 ext/session/mod_files.c 	if (ZSTR_LEN(val) < data->st_size) {
val               241 ext/session/mod_files.c 	n = pwrite(data->fd, ZSTR_VAL(val), ZSTR_LEN(val), 0);
val               246 ext/session/mod_files.c 		unsigned int to_write = ZSTR_LEN(val) > UINT_MAX ? UINT_MAX : (unsigned int)ZSTR_LEN(val);
val               247 ext/session/mod_files.c 		char *buf = ZSTR_VAL(val);
val               255 ext/session/mod_files.c 			to_write = wrote > -1 ? (ZSTR_LEN(val) - n > UINT_MAX ? UINT_MAX : (unsigned int)(ZSTR_LEN(val) - n)): 0;
val               260 ext/session/mod_files.c 	n = write(data->fd, ZSTR_VAL(val), ZSTR_LEN(val));
val               264 ext/session/mod_files.c 	if (n != ZSTR_LEN(val)) {
val               480 ext/session/mod_files.c 		*val = ZSTR_EMPTY_ALLOC();
val               484 ext/session/mod_files.c 	*val = zend_string_alloc(sbuf.st_size, 0);
val               487 ext/session/mod_files.c 	n = pread(data->fd, ZSTR_VAL(*val), ZSTR_LEN(*val), 0);
val               492 ext/session/mod_files.c 		unsigned int to_read = ZSTR_LEN(*val) > UINT_MAX ? UINT_MAX : (unsigned int)ZSTR_LEN(*val);
val               493 ext/session/mod_files.c 		char *buf = ZSTR_VAL(*val);
val               501 ext/session/mod_files.c 			to_read = read_in > -1 ? (ZSTR_LEN(*val) - n > UINT_MAX ? UINT_MAX : (unsigned int)(ZSTR_LEN(*val) - n)): 0;
val               507 ext/session/mod_files.c 	n = read(data->fd, ZSTR_VAL(*val), ZSTR_LEN(*val));
val               517 ext/session/mod_files.c 		zend_string_release(*val);
val               518 ext/session/mod_files.c 		*val =  ZSTR_EMPTY_ALLOC();
val               522 ext/session/mod_files.c 	ZSTR_VAL(*val)[ZSTR_LEN(*val)] = '\0';
val               539 ext/session/mod_files.c 	return ps_files_write(data, key, val);
val               578 ext/session/mod_files.c 		return ps_files_write(data, key, val);
val               359 ext/session/mod_mm.c 		&& ps_mm_key_exists(data, key->val) == FAILURE) {
val               376 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, PS(id)->val, 0);
val               378 ext/session/mod_mm.c 		*val = zend_string_init(sd->data, sd->datalen, 0);
val               394 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key->val, 1);
val               396 ext/session/mod_mm.c 		sd = ps_sd_new(data, key->val);
val               397 ext/session/mod_mm.c 		ps_mm_debug(("new entry for %s\n", key->val));
val               401 ext/session/mod_mm.c 		if (val->len >= sd->alloclen) {
val               405 ext/session/mod_mm.c 			sd->alloclen = val->len + 1;
val               415 ext/session/mod_mm.c 			sd->datalen = val->len;
val               416 ext/session/mod_mm.c 			memcpy(sd->data, val->val, val->len);
val               433 ext/session/mod_mm.c 	sd = ps_sd_lookup(data, key->val, 0);
val               485 ext/session/mod_mm.c 		if (ps_mm_key_exists(data, sid->val) == SUCCESS) {
val               133 ext/session/mod_user.c 			*val = zend_string_copy(Z_STR(retval));
val               148 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[1], val);
val               234 ext/session/mod_user.c 	ZVAL_STR_COPY(&args[1], val);
val                74 ext/session/mod_user_class.c 	zend_string *val;
val                83 ext/session/mod_user_class.c 	if (PS(default_mod)->s_read(&PS(mod_data), key, &val, PS(gc_maxlifetime)) == FAILURE) {
val                87 ext/session/mod_user_class.c 	RETURN_STR(val);
val                95 ext/session/mod_user_class.c 	zend_string *key, *val;
val                99 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &key, &val) == FAILURE) {
val               103 ext/session/mod_user_class.c 	RETURN_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, PS(gc_maxlifetime)));
val               179 ext/session/mod_user_class.c 	zend_string *key, *val;
val               183 ext/session/mod_user_class.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &key, &val) == FAILURE) {
val               188 ext/session/mod_user_class.c 	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, PS(gc_maxlifetime)));
val                39 ext/session/php_session.h #define PS_READ_ARGS     void **mod_data, zend_string *key, zend_string **val, zend_long maxlifetime
val                40 ext/session/php_session.h #define PS_WRITE_ARGS    void **mod_data, zend_string *key, zend_string *val, zend_long maxlifetime
val                45 ext/session/php_session.h #define PS_UPDATE_TIMESTAMP_ARGS void **mod_data, zend_string *key, zend_string *val, zend_long maxlifetime
val               230 ext/session/php_session.h #define PS_SERIALIZER_DECODE_ARGS const char *val, size_t vallen
val               504 ext/session/session.c 	zend_string *val = NULL;
val               548 ext/session/session.c 	if (PS(mod)->s_read(&PS(mod_data), PS(id), &val, PS(gc_maxlifetime)) == FAILURE) {
val               563 ext/session/session.c 	if (val) {
val               565 ext/session/session.c 			PS(session_vars) = zend_string_copy(val);
val               567 ext/session/session.c 		php_session_decode(val);
val               568 ext/session/session.c 		zend_string_release(val);
val               580 ext/session/session.c 				zend_string *val;
val               582 ext/session/session.c 				val = php_session_encode();
val               583 ext/session/session.c 				if (val) {
val               587 ext/session/session.c 						&& ZSTR_LEN(val) == ZSTR_LEN(PS(session_vars))
val               588 ext/session/session.c 						&& !memcmp(ZSTR_VAL(val), ZSTR_VAL(PS(session_vars)), ZSTR_LEN(val))
val               590 ext/session/session.c 						ret = PS(mod)->s_update_timestamp(&PS(mod_data), PS(id), val, PS(gc_maxlifetime));
val               592 ext/session/session.c 						ret = PS(mod)->s_write(&PS(mod_data), PS(id), val, PS(gc_maxlifetime));
val               594 ext/session/session.c 					zend_string_release(val);
val               749 ext/session/session.c 	zend_long val;
val               756 ext/session/session.c 	val = ZEND_STRTOL(ZSTR_VAL(new_value), &endptr, 10);
val               759 ext/session/session.c 		PS(hash_func) = val ? 1 : 0;
val               890 ext/session/session.c 	const char *endptr = val + vallen;
val               897 ext/session/session.c 	php_var_unserialize(&session_vars, (const unsigned char **)&val, (const unsigned char *)endptr, &var_hash);
val               946 ext/session/session.c 	const char *endptr = val + vallen;
val               955 ext/session/session.c 	for (p = val; p < endptr; ) {
val              1035 ext/session/session.c 	const char *endptr = val + vallen;
val              1044 ext/session/session.c 	p = val;
val              2297 ext/session/session.c 							zend_string *val = zval_get_string(value);
val              2298 ext/session/session.c 							if (php_session_start_set_ini(str_idx, val) == FAILURE) {
val              2301 ext/session/session.c 							zend_string_release(val);
val              2496 ext/session/session.c 	ZEND_ARG_INFO(0, val)
val              2516 ext/session/session.c 	ZEND_ARG_INFO(0, val)
val               550 ext/snmp/snmp.c 	zval val;
val               605 ext/snmp/snmp.c 			ZVAL_STRINGL(&val, (char *)vars->val.bitstring, vars->val_len);
val               610 ext/snmp/snmp.c 			ZVAL_STRINGL(&val, (char *)vars->val.string, vars->val_len);
val               614 ext/snmp/snmp.c 			ZVAL_NULL(&val);
val               618 ext/snmp/snmp.c 			snprint_objid(buf, buflen, vars->val.objid, vars->val_len / sizeof(oid));
val               619 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               624 ext/snmp/snmp.c 				 (vars->val.string)[0], (vars->val.string)[1],
val               625 ext/snmp/snmp.c 				 (vars->val.string)[2], (vars->val.string)[3]);
val               627 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               635 ext/snmp/snmp.c 			snprintf(buf, buflen, "%lu", *vars->val.integer);
val               637 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               641 ext/snmp/snmp.c 			snprintf(buf, buflen, "%ld", *vars->val.integer);
val               643 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               648 ext/snmp/snmp.c 			snprintf(buf, buflen, "%f", *vars->val.floatVal);
val               649 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               653 ext/snmp/snmp.c 			snprintf(buf, buflen, "%Lf", *vars->val.doubleVal);
val               654 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               658 ext/snmp/snmp.c 			printI64(buf, vars->val.counter64);
val               659 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               665 ext/snmp/snmp.c 			printU64(buf, vars->val.counter64);
val               666 ext/snmp/snmp.c 			ZVAL_STRING(&val, buf);
val               670 ext/snmp/snmp.c 			ZVAL_STRING(&val, "Unknown value type");
val               676 ext/snmp/snmp.c 		ZVAL_STRING(&val, buf);
val               682 ext/snmp/snmp.c 		add_property_zval(snmpval, "value", &val);
val               684 ext/snmp/snmp.c 		ZVAL_COPY(snmpval, &val);
val               686 ext/snmp/snmp.c 	zval_ptr_dtor(&val);
val              1030 ext/snmp/snmp.c 						tmp_type = &Z_ARRVAL_P(type)->arData[idx_type].val;
val              1057 ext/snmp/snmp.c 						tmp_value = &Z_ARRVAL_P(value)->arData[idx_value].val;
val              2102 ext/snmp/snmp.c 	zval val;
val              2110 ext/snmp/snmp.c 	ZVAL_STRINGL(&val, snmp_object->session->peername, strlen(snmp_object->session->peername));
val              2111 ext/snmp/snmp.c 	add_assoc_zval(retval, "hostname", &val);
val              2113 ext/snmp/snmp.c 	ZVAL_LONG(&val, snmp_object->session->remote_port);
val              2114 ext/snmp/snmp.c 	add_assoc_zval(retval, "port", &val);
val              2116 ext/snmp/snmp.c 	ZVAL_LONG(&val, snmp_object->session->timeout);
val              2117 ext/snmp/snmp.c 	add_assoc_zval(retval, "timeout", &val);
val              2119 ext/snmp/snmp.c 	ZVAL_LONG(&val, snmp_object->session->retries);
val              2120 ext/snmp/snmp.c 	add_assoc_zval(retval, "retries", &val);
val                92 ext/soap/php_encoding.c static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val);
val              1165 ext/soap/php_encoding.c static void set_zval_property(zval* object, char* name, zval* val)
val              1171 ext/soap/php_encoding.c 	add_property_zval(object, name, val);
val              1172 ext/soap/php_encoding.c 	if (Z_REFCOUNTED_P(val)) Z_DELREF_P(val);
val              1233 ext/soap/php_encoding.c 	zval rv, arr, val;
val              1240 ext/soap/php_encoding.c 			ZVAL_NULL(&val);
val              1241 ext/soap/php_encoding.c 			master_to_zval(&val, get_conversion(XSD_ANYXML), node);
val              1254 ext/soap/php_encoding.c 			if (Z_TYPE(val) == IS_STRING && *Z_STRVAL(val) == '<') {
val              1261 ext/soap/php_encoding.c 					if (Z_TYPE(val2) != IS_STRING ||  *Z_STRVAL(val) != '<') {
val              1264 ext/soap/php_encoding.c 					concat_function(&val, &val, &val2);
val              1276 ext/soap/php_encoding.c 					add_assoc_zval(&arr, name, &val);
val              1280 ext/soap/php_encoding.c 					any = &val;
val              1293 ext/soap/php_encoding.c 						add_next_index_zval(el, &val);
val              1295 ext/soap/php_encoding.c 						add_assoc_zval(any, name, &val);
val              1298 ext/soap/php_encoding.c 					add_next_index_zval(any, &val);
val              1318 ext/soap/php_encoding.c 					zval val;
val              1321 ext/soap/php_encoding.c 					ZVAL_NULL(&val);
val              1327 ext/soap/php_encoding.c 						master_to_zval(&val, model->u.element->encode, r_node);
val              1331 ext/soap/php_encoding.c 						master_to_zval(&val, model->u.element->encode, dummy);
val              1336 ext/soap/php_encoding.c 						master_to_zval(&val, model->u.element->encode, dummy);
val              1339 ext/soap/php_encoding.c 						master_to_zval(&val, model->u.element->encode, r_node);
val              1345 ext/soap/php_encoding.c 						add_next_index_zval(&array, &val);
val              1351 ext/soap/php_encoding.c 								master_to_zval(&val, model->u.element->encode, node);
val              1355 ext/soap/php_encoding.c 								master_to_zval(&val, model->u.element->encode, dummy);
val              1360 ext/soap/php_encoding.c 								master_to_zval(&val, model->u.element->encode, dummy);
val              1363 ext/soap/php_encoding.c 								master_to_zval(&val, model->u.element->encode, node);
val              1365 ext/soap/php_encoding.c 							add_next_index_zval(&array, &val);
val              1367 ext/soap/php_encoding.c 						ZVAL_COPY_VALUE(&val, &array);
val              1368 ext/soap/php_encoding.c 					} else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) &&
val              1374 ext/soap/php_encoding.c 						add_next_index_zval(&array, &val);
val              1375 ext/soap/php_encoding.c 						ZVAL_COPY_VALUE(&val, &array);
val              1377 ext/soap/php_encoding.c 					set_zval_property(ret, model->u.element->name, &val);
val              1533 ext/soap/php_encoding.c 					xmlAttrPtr val = get_attribute(data->properties, attr->name);
val              1536 ext/soap/php_encoding.c 					if (val && val->children && val->children->content) {
val              1537 ext/soap/php_encoding.c 						str_val = (char*)val->children->content;
val              1640 ext/soap/php_encoding.c 					zval *val;
val              1642 ext/soap/php_encoding.c 					ZEND_HASH_FOREACH_VAL(ht, val) {
val              1643 ext/soap/php_encoding.c 						if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) {
val              1648 ext/soap/php_encoding.c 							property = master_to_xml(enc, val, style, node);
val              1718 ext/soap/php_encoding.c 					zval *val;
val              1720 ext/soap/php_encoding.c 					ZEND_HASH_FOREACH_VAL(ht, val) {
val              1721 ext/soap/php_encoding.c 						master_to_xml(enc, val, style, node);
val              1893 ext/soap/php_encoding.c 				zval *val;
val              1895 ext/soap/php_encoding.c 				ZEND_HASH_FOREACH_VAL(prop, val) {
val              1897 ext/soap/php_encoding.c 					if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) {
val              1902 ext/soap/php_encoding.c 						property = master_to_xml(array_el->encode, val, style, xmlParam);
val              2191 ext/soap/php_encoding.c 	    Z_TYPE(ht->arData[ht->nNumUsed-1].val) != IS_UNDEF &&
val              2232 ext/soap/php_encoding.c 		zval                   *val;
val              2254 ext/soap/php_encoding.c 			val = iter->funcs->get_current_data(iter);
val              2264 ext/soap/php_encoding.c 				array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
val              2265 ext/soap/php_encoding.c 				zval_ptr_dtor(val);
val              2268 ext/soap/php_encoding.c 				add_next_index_zval(&array_copy, val);
val              2270 ext/soap/php_encoding.c 			Z_ADDREF_P(val);
val              2304 ext/soap/php_encoding.c 			value = estrdup(ext->val);
val              2350 ext/soap/php_encoding.c 				enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
val              2351 ext/soap/php_encoding.c 				get_type_str(xmlParam, ext->ns, ext->val, &array_type);
val              2353 ext/soap/php_encoding.c 				smart_str_appends(&array_type, ext->val);
val              2359 ext/soap/php_encoding.c 				dimension = calc_dimension_12(ext->val);
val              2360 ext/soap/php_encoding.c 				dims = get_position_12(dimension, ext->val);
val              2379 ext/soap/php_encoding.c 			dimension = calc_dimension_12(ext->val);
val              2380 ext/soap/php_encoding.c 			dims = get_position_12(dimension, ext->val);
val              2538 ext/soap/php_encoding.c 		type = estrdup(ext->val);
val              2559 ext/soap/php_encoding.c 			enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
val              2566 ext/soap/php_encoding.c 			dimension = calc_dimension_12(ext->val);
val              2567 ext/soap/php_encoding.c 			dims = get_position_12(dimension, ext->val);
val              2579 ext/soap/php_encoding.c 		dimension = calc_dimension_12(ext->val);
val              2580 ext/soap/php_encoding.c 		dims = get_position_12(dimension, ext->val);
val              3432 ext/soap/php_encoding.c static void set_ns_prop(xmlNodePtr node, char *ns, char *name, char *val)
val              3434 ext/soap/php_encoding.c 	xmlSetNsProp(node, encode_add_ns(node, ns), BAD_CAST(name), BAD_CAST(val));
val               853 ext/soap/php_http.c 		smart_str_appendl(&soap_headers, request->val, request->len);
val              1154 ext/soap/php_http.c 				char *name, *val;
val              1163 ext/soap/php_http.c 						val = s;
val              1166 ext/soap/php_http.c 						val = s;
val              1183 ext/soap/php_http.c 					add_assoc_string(&digest, name, val);
val              1255 ext/soap/php_http.c 			ZVAL_STRINGL(&params[0], http_body->val+10, http_body->len-10);
val              1422 ext/soap/php_http.c 						int len_read = php_stream_read(stream, http_buf->val + http_buf_size, buf_size - len_size);
val              1480 ext/soap/php_http.c 			int len_read = php_stream_read(stream, http_buf->val + http_buf_size, header_length - http_buf_size);
val              1494 ext/soap/php_http.c 			len_read = php_stream_read(stream, http_buf->val + http_buf_size, 4096);
val              1503 ext/soap/php_http.c 	http_buf->val[http_buf_size] = '\0';
val               261 ext/soap/php_packet_soap.c 			xmlNodePtr val = NULL;
val               299 ext/soap/php_packet_soap.c 							val = cur;
val               301 ext/soap/php_packet_soap.c 							val = get_node(cur->children, param->paramName);
val               303 ext/soap/php_packet_soap.c 								if (val == NULL) {
val               304 ext/soap/php_packet_soap.c 									val = get_node(cur->children, "return");
val               306 ext/soap/php_packet_soap.c 								if (val == NULL) {
val               307 ext/soap/php_packet_soap.c 									val = get_node(cur->children, "result");
val               309 ext/soap/php_packet_soap.c 								if (val == NULL && cur->children && cur->children->next == NULL) {
val               310 ext/soap/php_packet_soap.c 									val = cur->children;
val               316 ext/soap/php_packet_soap.c 					if (!val) {
val               327 ext/soap/php_packet_soap.c 							master_to_zval(&tmp, param->encode, val);
val               329 ext/soap/php_packet_soap.c 							master_to_zval(&tmp, NULL, val);
val               339 ext/soap/php_packet_soap.c 			xmlNodePtr val;
val               340 ext/soap/php_packet_soap.c 			val = resp->children;
val               341 ext/soap/php_packet_soap.c 			while (val != NULL) {
val               342 ext/soap/php_packet_soap.c 				while (val && val->type != XML_ELEMENT_NODE) {
val               343 ext/soap/php_packet_soap.c 					val = val->next;
val               345 ext/soap/php_packet_soap.c 				if (val != NULL) {
val               346 ext/soap/php_packet_soap.c 					if (!node_is_equal_ex(val,"result",RPC_SOAP12_NAMESPACE)) {
val               350 ext/soap/php_packet_soap.c 						master_to_zval(&tmp, NULL, val);
val               351 ext/soap/php_packet_soap.c 						if (val->name) {
val               352 ext/soap/php_packet_soap.c 							if ((arr = zend_hash_str_find(Z_ARRVAL_P(return_value), (char*)val->name, strlen((char*)val->name))) != NULL) {
val               354 ext/soap/php_packet_soap.c 							} else if (val->next && get_node(val->next, (char*)val->name)) {
val               359 ext/soap/php_packet_soap.c 								add_assoc_zval(return_value, (char*)val->name, &arr);
val               361 ext/soap/php_packet_soap.c 								add_assoc_zval(return_value, (char*)val->name, &tmp);
val               368 ext/soap/php_packet_soap.c 					val = val->next;
val               398 ext/soap/php_packet_soap.c 				zval val;
val               415 ext/soap/php_packet_soap.c 				master_to_zval(&val, enc, trav);
val               416 ext/soap/php_packet_soap.c 				add_assoc_zval(soap_headers, (char*)trav->name, &val);
val                43 ext/soap/php_schema.c static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr);
val                45 ext/soap/php_schema.c static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr);
val               805 ext/soap/php_schema.c static int schema_restriction_var_int(xmlNodePtr val, sdlRestrictionIntPtr *valptr)
val               814 ext/soap/php_schema.c 	fixed = get_attribute(val->properties, "fixed");
val               822 ext/soap/php_schema.c 	value = get_attribute(val->properties, "value");
val               832 ext/soap/php_schema.c static int schema_restriction_var_char(xmlNodePtr val, sdlRestrictionCharPtr *valptr)
val               841 ext/soap/php_schema.c 	fixed = get_attribute(val->properties, "fixed");
val               850 ext/soap/php_schema.c 	value = get_attribute(val->properties, "value");
val              1870 ext/soap/php_schema.c 					ext->val = estrdup(value);
val              1872 ext/soap/php_schema.c 					ext->val = estrdup((char*)attr->children->content);
val              2063 ext/soap/php_schema.c 	if (new_attr->val) {
val              2064 ext/soap/php_schema.c 		new_attr->val = estrdup(new_attr->val);
val              2474 ext/soap/php_schema.c 	if (attr->val) {
val              2475 ext/soap/php_schema.c 		efree(attr->val);
val              2487 ext/soap/php_schema.c 	if (attr->val) {
val              2488 ext/soap/php_schema.c 		free(attr->val);
val              1185 ext/soap/php_sdl.c #define WSDL_CACHE_PUT_INT(val,buf)    smart_str_appendc(buf,val & 0xff); \
val              1186 ext/soap/php_sdl.c                                        smart_str_appendc(buf,(val >> 8) & 0xff); \
val              1187 ext/soap/php_sdl.c                                        smart_str_appendc(buf,(val >> 16) & 0xff); \
val              1188 ext/soap/php_sdl.c                                        smart_str_appendc(buf,(val >> 24) & 0xff);
val              1189 ext/soap/php_sdl.c #define WSDL_CACHE_PUT_1(val,buf)      smart_str_appendc(buf,val);
val              1190 ext/soap/php_sdl.c #define WSDL_CACHE_PUT_N(val,n,buf)    smart_str_appendl(buf,(char*)val,n);
val              1242 ext/soap/php_sdl.c 			x->val = sdl_deserialize_string(in);
val              1856 ext/soap/php_sdl.c 			sdl_serialize_string(tmp->val, out);
val              2634 ext/soap/php_sdl.c 				if (tmp->val) {
val              2635 ext/soap/php_sdl.c 					pextra->val = strdup(tmp->val);
val               241 ext/soap/php_sdl.h 	char *val;
val                28 ext/soap/php_xml.h #define get_node_with_attribute(node, name, attr, val) get_node_with_attribute_ex(node, name, NULL, attr, val, NULL)
val                29 ext/soap/php_xml.h #define get_node_with_attribute_recursive(node, name, attr, val) get_node_with_attribute_recursive_ex(node, name, NULL, attr, val, NULL)
val                66 ext/soap/soap.c static xmlNodePtr serialize_zval(zval *val, sdlParamPtr param, char *paramName, int style, xmlNodePtr parent);
val              3137 ext/soap/soap.c 	char *val = NULL;
val              3142 ext/soap/soap.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", &name, &name_len, &val, &val_len) == FAILURE) {
val              3146 ext/soap/soap.c 	if (val == NULL) {
val              3163 ext/soap/soap.c 		add_index_stringl(&zcookie, 0, val, val_len);
val              3345 ext/soap/soap.c 		xmlNodePtr val;
val              3360 ext/soap/soap.c 				val = get_node(params, param->paramName);
val              3361 ext/soap/soap.c 				if (!val) {
val              3365 ext/soap/soap.c 					master_to_zval(&tmp_parameters[cur_param], param->encode, val);
val              4442 ext/soap/soap.c static xmlNodePtr serialize_zval(zval *val, sdlParamPtr param, char *paramName, int style, xmlNodePtr parent)
val              4451 ext/soap/soap.c 		if (val == NULL) {
val              4455 ext/soap/soap.c 					val = &defval;
val              4458 ext/soap/soap.c 					val = &defval;
val              4465 ext/soap/soap.c 	xmlParam = master_to_xml(enc, val, style, parent);
val              4741 ext/soap/soap.c 					char *end = strchr(ext->val, '[');
val              4744 ext/soap/soap.c 						len = strlen(ext->val);
val              4746 ext/soap/soap.c 						len = end - ext->val;
val              4751 ext/soap/soap.c 						smart_str_appendl(buf, ext->val, len);
val              4765 ext/soap/soap.c 						smart_str_appends(buf, ext->val);
val              4784 ext/soap/soap.c 						smart_str_appends(buf, ext->val);
val                66 ext/sockets/multicast.c int php_string_to_if_index(const char *val, unsigned *out)
val                71 ext/sockets/multicast.c 	ind = if_nametoindex(val);
val                74 ext/sockets/multicast.c 			"no interface with name \"%s\" could be found", val);
val                88 ext/sockets/multicast.c static int php_get_if_index_from_zval(zval *val, unsigned *out)
val                92 ext/sockets/multicast.c 	if (Z_TYPE_P(val) == IS_LONG) {
val                93 ext/sockets/multicast.c 		if (Z_LVAL_P(val) < 0 || Z_LVAL_P(val) > UINT_MAX) {
val                96 ext/sockets/multicast.c 				" given %pd", UINT_MAX, Z_LVAL_P(val));
val                99 ext/sockets/multicast.c 			*out = Z_LVAL_P(val);
val               103 ext/sockets/multicast.c 		if (Z_REFCOUNTED_P(val)) {
val               104 ext/sockets/multicast.c 			Z_ADDREF_P(val);
val               106 ext/sockets/multicast.c 		convert_to_string_ex(val);
val               107 ext/sockets/multicast.c 		ret = php_string_to_if_index(Z_STRVAL_P(val), out);
val               108 ext/sockets/multicast.c 		zval_ptr_dtor(val);
val               119 ext/sockets/multicast.c 	zval *val;
val               121 ext/sockets/multicast.c 	if ((val = zend_hash_str_find(ht, key, strlen(key))) == NULL) {
val               126 ext/sockets/multicast.c 	return php_get_if_index_from_zval(val, if_index);
val               132 ext/sockets/multicast.c 	zval *val;
val               134 ext/sockets/multicast.c 	if ((val = zend_hash_str_find(ht, key, strlen(key))) == NULL) {
val               138 ext/sockets/multicast.c 	if (Z_REFCOUNTED_P(val)) {
val               139 ext/sockets/multicast.c 		Z_ADDREF_P(val);
val               141 ext/sockets/multicast.c 	convert_to_string_ex(val);
val               142 ext/sockets/multicast.c 	if (!php_set_inet46_addr(ss, ss_len, Z_STRVAL_P(val), sock)) {
val               143 ext/sockets/multicast.c 		zval_ptr_dtor(val);
val               146 ext/sockets/multicast.c 	zval_ptr_dtor(val);
val                68 ext/sockets/multicast.h int php_string_to_if_index(const char *val, unsigned *out);
val                12 ext/sockets/sockaddr_conv.c extern int php_string_to_if_index(const char *val, unsigned *out);
val              2202 ext/spl/spl_directory.c 					while (Z_ISUNDEF(Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val)) {
val              2205 ext/spl/spl_directory.c 					first = &Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val;
val              15410 ext/sqlite3/libsqlite/sqlite3.c   int val;
val              15424 ext/sqlite3/libsqlite/sqlite3.c     val = 0;
val              15429 ext/sqlite3/libsqlite/sqlite3.c       val = val*10 + *zDate - '0';
val              15432 ext/sqlite3/libsqlite/sqlite3.c     if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
val              15435 ext/sqlite3/libsqlite/sqlite3.c     *pVal = val;
val              19960 ext/sqlite3/libsqlite/sqlite3.c       unsigned long val;
val              19961 ext/sqlite3/libsqlite/sqlite3.c       __asm__ __volatile__ ("rdtsc" : "=A" (val));
val              19962 ext/sqlite3/libsqlite/sqlite3.c       return val;
val              21466 ext/sqlite3/libsqlite/sqlite3.c static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
val              21471 ext/sqlite3/libsqlite/sqlite3.c   digit = (int)*val;
val              21474 ext/sqlite3/libsqlite/sqlite3.c   *val = (*val - d)*10.0;
val              25607 ext/sqlite3/libsqlite/sqlite3.c       unsigned long val;
val              25608 ext/sqlite3/libsqlite/sqlite3.c       __asm__ __volatile__ ("rdtsc" : "=A" (val));
val              25609 ext/sqlite3/libsqlite/sqlite3.c       return val;
val              33126 ext/sqlite3/libsqlite/sqlite3.c       unsigned long val;
val              33127 ext/sqlite3/libsqlite/sqlite3.c       __asm__ __volatile__ ("rdtsc" : "=A" (val));
val              33128 ext/sqlite3/libsqlite/sqlite3.c       return val;
val              42704 ext/sqlite3/libsqlite/sqlite3.c static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
val              42706 ext/sqlite3/libsqlite/sqlite3.c   put32bits(ac, val);
val              63578 ext/sqlite3/libsqlite/sqlite3.c     double val = (double)0;
val              63579 ext/sqlite3/libsqlite/sqlite3.c     sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
val              63580 ext/sqlite3/libsqlite/sqlite3.c     return val;
val              63766 ext/sqlite3/libsqlite/sqlite3.c static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
val              63768 ext/sqlite3/libsqlite/sqlite3.c   pMem->u.i = val;
val              63776 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
val              63778 ext/sqlite3/libsqlite/sqlite3.c     vdbeReleaseAndSetInt64(pMem, val);
val              63780 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = val;
val              63790 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
val              63792 ext/sqlite3/libsqlite/sqlite3.c   if( !sqlite3IsNaN(val) ){
val              63793 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.r = val;
val              65419 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
val              65422 ext/sqlite3/libsqlite/sqlite3.c     p->aOp[addr].p1 = val;
val              65430 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
val              65433 ext/sqlite3/libsqlite/sqlite3.c     p->aOp[addr].p2 = val;
val              65440 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
val              65443 ext/sqlite3/libsqlite/sqlite3.c     p->aOp[addr].p3 = val;
val              65451 ext/sqlite3/libsqlite/sqlite3.c SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
val              65455 ext/sqlite3/libsqlite/sqlite3.c     p->aOp[p->nOp-1].p5 = val;
val              69893 ext/sqlite3/libsqlite/sqlite3.c   const void *val;
val              69894 ext/sqlite3/libsqlite/sqlite3.c   val = sqlite3_value_blob( columnMem(pStmt,i) );
val              69900 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69903 ext/sqlite3/libsqlite/sqlite3.c   int val = sqlite3_value_bytes( columnMem(pStmt,i) );
val              69905 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69908 ext/sqlite3/libsqlite/sqlite3.c   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
val              69910 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69913 ext/sqlite3/libsqlite/sqlite3.c   double val = sqlite3_value_double( columnMem(pStmt,i) );
val              69915 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69918 ext/sqlite3/libsqlite/sqlite3.c   int val = sqlite3_value_int( columnMem(pStmt,i) );
val              69920 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69923 ext/sqlite3/libsqlite/sqlite3.c   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
val              69925 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69928 ext/sqlite3/libsqlite/sqlite3.c   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
val              69930 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              69943 ext/sqlite3/libsqlite/sqlite3.c   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
val              69945 ext/sqlite3/libsqlite/sqlite3.c   return val;
val              71288 ext/sqlite3/libsqlite/sqlite3.c       unsigned long val;
val              71289 ext/sqlite3/libsqlite/sqlite3.c       __asm__ __volatile__ ("rdtsc" : "=A" (val));
val              71290 ext/sqlite3/libsqlite/sqlite3.c       return val;
val              76146 ext/sqlite3/libsqlite/sqlite3.c   i64 val;
val              76150 ext/sqlite3/libsqlite/sqlite3.c    || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0
val              76159 ext/sqlite3/libsqlite/sqlite3.c     sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
val              151972 ext/sqlite3/libsqlite/sqlite3.c   sqlite3_rtree_dbl val;     /* Coordinate value convert to a double */
val              151985 ext/sqlite3/libsqlite/sqlite3.c       RTREE_DECODE_COORD(eInt, pCellData, val);
val              151987 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.rValue>=val ) return;
val              151993 ext/sqlite3/libsqlite/sqlite3.c       RTREE_DECODE_COORD(eInt, pCellData, val);
val              151995 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.rValue<=val ) return;
val               155 ext/standard/array.c 			t = is_numeric_string(s->key->val, s->key->len, &l2, &d, 1);
val               169 ext/standard/array.c 			t = is_numeric_string(f->key->val, f->key->len, &l1, &d, 1);
val               199 ext/standard/array.c 			d1 = zend_strtod(f->key->val, NULL);
val               204 ext/standard/array.c 			d2 = zend_strtod(s->key->val, NULL);
val               229 ext/standard/array.c 		s1 = f->key->val;
val               236 ext/standard/array.c 		s2 = s->key->val;
val               262 ext/standard/array.c 		s1 = f->key->val;
val               269 ext/standard/array.c 		s2 = s->key->val;
val               295 ext/standard/array.c 		s1 = f->key->val;
val               302 ext/standard/array.c 		s2 = s->key->val;
val               346 ext/standard/array.c 		s1 = f->key->val;
val               351 ext/standard/array.c 		s2 = s->key->val;
val               383 ext/standard/array.c 	first = &f->val;
val               384 ext/standard/array.c 	second = &s->val;
val               417 ext/standard/array.c 	first = &f->val;
val               418 ext/standard/array.c 	second = &s->val;
val               447 ext/standard/array.c 	first = &f->val;
val               448 ext/standard/array.c 	second = &s->val;
val               477 ext/standard/array.c 	first = &f->val;
val               478 ext/standard/array.c 	second = &s->val;
val               501 ext/standard/array.c 	zend_string *str1 = zval_get_string(&f->val);
val               502 ext/standard/array.c 	zend_string *str2 = zval_get_string(&s->val);
val               547 ext/standard/array.c 	first = &f->val;
val               548 ext/standard/array.c 	second = &s->val;
val               985 ext/standard/array.c 	ZVAL_COPY(&args[0], &f->val);
val               986 ext/standard/array.c 	ZVAL_COPY(&args[1], &s->val);
val              2007 ext/standard/array.c 	zval *val;
val              2010 ext/standard/array.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "llz", &start_key, &num, &val) == FAILURE) {
val              2027 ext/standard/array.c 	zend_hash_index_update(Z_ARRVAL_P(return_value), start_key, val);
val              2028 ext/standard/array.c 	Z_TRY_ADDREF_P(val);
val              2031 ext/standard/array.c 		if (zend_hash_next_index_insert(Z_ARRVAL_P(return_value), val) != NULL) {
val              2032 ext/standard/array.c 			Z_TRY_ADDREF_P(val);
val              2046 ext/standard/array.c 	zval *keys, *val, *entry;
val              2048 ext/standard/array.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "az", &keys, &val) == FAILURE) {
val              2057 ext/standard/array.c 		Z_TRY_ADDREF_P(val);
val              2059 ext/standard/array.c 			zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val);
val              2062 ext/standard/array.c 			zend_symtable_update(Z_ARRVAL_P(return_value), key, val);
val              2315 ext/standard/array.c 				if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2337 ext/standard/array.c 				if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2428 ext/standard/array.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2430 ext/standard/array.c 		entry = &p->val;
val              2451 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2453 ext/standard/array.c 			entry = &p->val;
val              2474 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2501 ext/standard/array.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2502 ext/standard/array.c 		entry = &p->val;
val              2571 ext/standard/array.c 		 *val;		/* Value to be popped */
val              2597 ext/standard/array.c 		val = &p->val;
val              2598 ext/standard/array.c 		if (Z_TYPE_P(val) == IS_INDIRECT) {
val              2599 ext/standard/array.c 			val = Z_INDIRECT_P(val);
val              2601 ext/standard/array.c 		if (Z_TYPE_P(val) != IS_UNDEF) {
val              2605 ext/standard/array.c 	ZVAL_DEREF(val);
val              2606 ext/standard/array.c 	ZVAL_COPY(return_value, val);
val              2632 ext/standard/array.c 		 *val;		/* Value to be popped */
val              2657 ext/standard/array.c 		val = &p->val;
val              2658 ext/standard/array.c 		if (Z_TYPE_P(val) == IS_INDIRECT) {
val              2659 ext/standard/array.c 			val = Z_INDIRECT_P(val);
val              2661 ext/standard/array.c 		if (Z_TYPE_P(val) != IS_UNDEF) {
val              2666 ext/standard/array.c 	ZVAL_DEREF(val);
val              2667 ext/standard/array.c 	ZVAL_COPY(return_value, val);
val              2687 ext/standard/array.c 				if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2692 ext/standard/array.c 					ZVAL_COPY_VALUE(&q->val, &p->val);
val              2693 ext/standard/array.c 					ZVAL_UNDEF(&p->val);
val              2702 ext/standard/array.c 				if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              2707 ext/standard/array.c 					ZVAL_COPY_VALUE(&q->val, &p->val);
val              2708 ext/standard/array.c 					ZVAL_UNDEF(&p->val);
val              2725 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              3782 ext/standard/array.c 		if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              3783 ext/standard/array.c 		if (Z_TYPE(p->val) == IS_INDIRECT && Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF) continue;
val              3788 ext/standard/array.c 	ZVAL_UNDEF(&arTmp[i].b.val);
val              3793 ext/standard/array.c 	for (cmpdata = arTmp + 1; Z_TYPE(cmpdata->b.val) != IS_UNDEF; cmpdata++) {
val              3855 ext/standard/array.c 	zval *val, *data;
val              3897 ext/standard/array.c 		val = &p->val;
val              3898 ext/standard/array.c 		if (Z_TYPE_P(val) == IS_UNDEF) continue;
val              3899 ext/standard/array.c 		if (UNEXPECTED(Z_TYPE_P(val) == IS_INDIRECT)) {
val              3900 ext/standard/array.c 			val = Z_INDIRECT_P(val);
val              3901 ext/standard/array.c 			if (Z_TYPE_P(val) == IS_UNDEF) continue;
val              3903 ext/standard/array.c 		if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
val              3904 ext/standard/array.c 			ZVAL_UNREF(val);
val              3911 ext/standard/array.c 					intersect_data_compare_func(val, data) != 0)
val              3918 ext/standard/array.c 				if (Z_REFCOUNTED_P(val)) {
val              3919 ext/standard/array.c 					Z_ADDREF_P(val);
val              3921 ext/standard/array.c 				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, val);
val              3928 ext/standard/array.c 					intersect_data_compare_func(val, data) != 0)
val              3935 ext/standard/array.c 				if (Z_REFCOUNTED_P(val)) {
val              3936 ext/standard/array.c 					Z_ADDREF_P(val);
val              3938 ext/standard/array.c 				zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
val              4081 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              4084 ext/standard/array.c 		ZVAL_UNDEF(&list->val);
val              4100 ext/standard/array.c 	while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
val              4109 ext/standard/array.c 				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_data_compare_func(ptrs[0], ptrs[i])))) {
val              4113 ext/standard/array.c 				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_key_compare_func(ptrs[0], ptrs[i])))) {
val              4116 ext/standard/array.c 				if ((!c && Z_TYPE(ptrs[i]->val) != IS_UNDEF) && (behavior == INTERSECT_ASSOC)) { /* only when INTERSECT_ASSOC */
val              4138 ext/standard/array.c 			if (Z_TYPE(ptrs[i]->val) == IS_UNDEF) {
val              4144 ext/standard/array.c 					if (Z_TYPE(p->val) == IS_UNDEF) {
val              4168 ext/standard/array.c 				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
val              4184 ext/standard/array.c 				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
val              4283 ext/standard/array.c 	zval *val, *data;
val              4320 ext/standard/array.c 		val = &p->val;
val              4321 ext/standard/array.c 		if (Z_TYPE_P(val) == IS_UNDEF) continue;
val              4322 ext/standard/array.c 		if (UNEXPECTED(Z_TYPE_P(val) == IS_INDIRECT)) {
val              4323 ext/standard/array.c 			val = Z_INDIRECT_P(val);
val              4324 ext/standard/array.c 			if (Z_TYPE_P(val) == IS_UNDEF) continue;
val              4326 ext/standard/array.c 		if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
val              4327 ext/standard/array.c 			ZVAL_UNREF(val);
val              4334 ext/standard/array.c 					diff_data_compare_func(val, data) == 0)
val              4341 ext/standard/array.c 				if (Z_REFCOUNTED_P(val)) {
val              4342 ext/standard/array.c 					Z_ADDREF_P(val);
val              4344 ext/standard/array.c 				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, val);
val              4351 ext/standard/array.c 					diff_data_compare_func(val, data) == 0)
val              4358 ext/standard/array.c 				if (Z_REFCOUNTED_P(val)) {
val              4359 ext/standard/array.c 					Z_ADDREF_P(val);
val              4361 ext/standard/array.c 				zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
val              4503 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              4506 ext/standard/array.c 		ZVAL_UNDEF(&list->val);
val              4522 ext/standard/array.c 	while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
val              4534 ext/standard/array.c 				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = diff_data_compare_func(ptrs[0], ptrs[i])))) {
val              4538 ext/standard/array.c 				while (Z_TYPE(ptr->val) != IS_UNDEF && (0 != (c = diff_key_compare_func(ptrs[0], ptr)))) {
val              4544 ext/standard/array.c 					if (Z_TYPE(ptrs[i]->val) != IS_UNDEF) {
val              4551 ext/standard/array.c 					if (Z_TYPE(ptr->val) != IS_UNDEF) {
val              4588 ext/standard/array.c 				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
val              4604 ext/standard/array.c 				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
val              4777 ext/standard/array.c 	} while (Z_TYPE(ab[r].val) != IS_UNDEF);
val              4927 ext/standard/array.c 			if (Z_TYPE(p->val) == IS_UNDEF) continue;
val              4933 ext/standard/array.c 		ZVAL_UNDEF(&indirect[k][num_arrays].val);
val              5348 ext/standard/array.c 						} else if (Z_TYPE(Z_ARRVAL(arrays[i])->arData[pos].val) != IS_UNDEF) {
val              5349 ext/standard/array.c 							ZVAL_COPY(&zv, &Z_ARRVAL(arrays[i])->arData[pos].val);
val              5374 ext/standard/array.c 						} else if (Z_TYPE(Z_ARRVAL(arrays[i])->arData[pos].val) != IS_UNDEF) {
val              5375 ext/standard/array.c 							ZVAL_COPY(&params[i], &Z_ARRVAL(arrays[i])->arData[pos].val);
val              5550 ext/standard/array.c 			} else if (Z_TYPE(values->arData[pos_values].val) != IS_UNDEF) {
val              5551 ext/standard/array.c 				entry_values = &values->arData[pos_values].val;
val               152 ext/standard/assert.c 	int val;
val               200 ext/standard/assert.c 		val = Z_TYPE(retval) == IS_TRUE;
val               202 ext/standard/assert.c 		val = zend_is_true(assertion);
val               205 ext/standard/assert.c 	if (val) {
val               363 ext/standard/assert.c 			zend_string *val = zval_get_string(value);
val               364 ext/standard/assert.c 			zend_alter_ini_entry_ex(key, val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
val               365 ext/standard/assert.c 			zend_string_release(val);
val               344 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, val)
val               349 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, val)
val              1670 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, val)
val              1674 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, val)
val              1678 ext/standard/basic_functions.c 	ZEND_ARG_INFO(0, val)
val              3493 ext/standard/basic_functions.c 	double val = 0.0;
val              3494 ext/standard/basic_functions.c 	((php_uint32*)&val)[1] = PHP_DOUBLE_QUIET_NAN_HIGH;
val              3495 ext/standard/basic_functions.c 	((php_uint32*)&val)[0] = 0;
val              3496 ext/standard/basic_functions.c 	return val;
val              3510 ext/standard/basic_functions.c 	double val = 0.0;
val              3511 ext/standard/basic_functions.c 	((php_uint32*)&val)[1] = PHP_DOUBLE_INFINITY_HIGH;
val              3512 ext/standard/basic_functions.c 	((php_uint32*)&val)[0] = 0;
val              3513 ext/standard/basic_functions.c 	return val;
val              4258 ext/standard/basic_functions.c 	zval val, *args = NULL, *p_longopts = NULL;
val              4374 ext/standard/basic_functions.c 			ZVAL_STRING(&val, php_optarg);
val              4376 ext/standard/basic_functions.c 			ZVAL_FALSE(&val);
val              4388 ext/standard/basic_functions.c 				zend_hash_next_index_insert(Z_ARRVAL_P(args), &val);
val              4390 ext/standard/basic_functions.c 				zend_hash_index_update(Z_ARRVAL_P(return_value), optname_int, &val);
val              4398 ext/standard/basic_functions.c 				zend_hash_next_index_insert(Z_ARRVAL_P(args), &val);
val              4400 ext/standard/basic_functions.c 				zend_hash_str_add(Z_ARRVAL_P(return_value), optname, strlen(optname), &val);
val                51 ext/standard/crypt_blowfish.c #define __set_errno(val) errno = (val)
val               223 ext/standard/dns_win32.c 				txt_dst = txt->val;
val               230 ext/standard/dns_win32.c 				txt->len = txt_dst - txt->val;
val               235 ext/standard/ftp_fopen_wrapper.c #define PHP_FTP_CNTRL_CHK(val, val_len, err_msg) {	\
val               236 ext/standard/ftp_fopen_wrapper.c 	unsigned char *s = (unsigned char *) val, *e = (unsigned char *) s + val_len;	\
val               239 ext/standard/ftp_fopen_wrapper.c 			php_stream_wrapper_log_error(wrapper, options, err_msg, val);	\
val               869 ext/standard/http_fopen_wrapper.c #define CHECK_FOR_CNTRL_CHARS(val) { \
val               870 ext/standard/http_fopen_wrapper.c 	if (val) { \
val               873 ext/standard/http_fopen_wrapper.c 		l = php_url_decode(val, strlen(val)); \
val               874 ext/standard/http_fopen_wrapper.c 		s = (unsigned char*)val; e = s + l; \
val               137 ext/standard/incomplete_class.c 	zval *val;
val               142 ext/standard/incomplete_class.c 	if ((val = zend_hash_str_find(object_properties, MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1)) != NULL && Z_TYPE_P(val) == IS_STRING) {
val               143 ext/standard/incomplete_class.c 		return zend_string_copy(Z_STR_P(val));
val               154 ext/standard/incomplete_class.c 	zval val;
val               157 ext/standard/incomplete_class.c 	ZVAL_STRINGL(&val, name, len);
val               158 ext/standard/incomplete_class.c 	zend_hash_str_update(Z_OBJPROP_P(object), MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1, &val);
val               815 ext/standard/info.c 	return strcasecmp(((zend_module_entry *)Z_PTR(f->val))->name,
val               816 ext/standard/info.c 				  ((zend_module_entry *)Z_PTR(s->val))->name);
val               282 ext/standard/mail.c #define MAIL_RET(val) \
val               286 ext/standard/mail.c 	return val;	\
val                93 ext/standard/pack.c static void php_pack(zval *val, size_t size, int *map, char *output)
val                98 ext/standard/pack.c 	convert_to_long_ex(val);
val                99 ext/standard/pack.c 	v = (char *) &Z_LVAL_P(val);
val              1068 ext/standard/pack.c 		zval val;
val              1069 ext/standard/pack.c 		int size = sizeof(Z_LVAL(val));
val              1070 ext/standard/pack.c 		Z_LVAL(val)=0; /*silence a warning*/
val                90 ext/standard/php_smart_string.h #define smart_string_append_long(dest, val) \
val                91 ext/standard/php_smart_string.h 	smart_string_append_long_ex((dest), (val), 0)
val                92 ext/standard/php_smart_string.h #define smart_string_append_unsigned(dest, val) \
val                93 ext/standard/php_smart_string.h 	smart_string_append_unsigned_ex((dest), (val), 0)
val               119 ext/standard/php_var.h PHPAPI void var_push_dtor(php_unserialize_data_t *var_hash, zval *val);
val                43 ext/standard/streamsfuncs.c #define GET_CTX_OPT(stream, wrapper, name, val) (PHP_STREAM_CONTEXT(stream) && NULL != (val = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), wrapper, name)))
val              1530 ext/standard/streamsfuncs.c 			zval *val;
val              1532 ext/standard/streamsfuncs.c 			if (!GET_CTX_OPT(stream, "ssl", "crypto_method", val)) {
val              1537 ext/standard/streamsfuncs.c 			cryptokind = Z_LVAL_P(val);
val              1232 ext/standard/string.c 			double val = Z_LVAL_P(tmp);
val              1235 ext/standard/string.c 			if (val < 0) {
val              1236 ext/standard/string.c 				val = -10 * val;
val              1238 ext/standard/string.c 			if (val < 10) {
val              1241 ext/standard/string.c 				len += (int) log10(10 * (double) val);
val              1261 ext/standard/string.c 			zend_long val = ((zend_long *) (strings + numelems))[strptr - strings];
val              1262 ext/standard/string.c 			cptr = zend_print_long_to_buf(cptr, val);
val              2533 ext/standard/string.c 					tmp_repl = &Z_ARRVAL_P(repl)->arData[repl_idx].val;
val              2579 ext/standard/string.c 					tmp_from = &Z_ARRVAL_P(from)->arData[from_idx].val;
val              2614 ext/standard/string.c 					tmp_len = &Z_ARRVAL_P(len)->arData[len_idx].val;
val              2647 ext/standard/string.c 					tmp_repl = &Z_ARRVAL_P(repl)->arData[repl_idx].val;
val              4005 ext/standard/string.c 					replace_entry = &Z_ARRVAL_P(replace)->arData[replace_idx].val;
val              4516 ext/standard/string.c 				plocale = &Z_ARRVAL(args[0])->arData[idx].val;
val               183 ext/standard/type.c 	zval *val;
val               185 ext/standard/type.c 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &val) == FAILURE) {
val               189 ext/standard/type.c 	RETURN_BOOL(zend_is_true(val));
val                76 ext/standard/url_scanner_ex.c 		char *val;
val                78 ext/standard/url_scanner_ex.c 		val = strchr(key, '=');
val                79 ext/standard/url_scanner_ex.c 		if (val) {
val                83 ext/standard/url_scanner_ex.c 			*val++ = '\0';
val                89 ext/standard/url_scanner_ex.c 			zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
val               219 ext/standard/url_scanner_ex.c 		append_modified_url(&ctx->val, &ctx->result, &ctx->url_app, PG(arg_separator).output);
val               221 ext/standard/url_scanner_ex.c 		smart_str_append_smart_str(&ctx->result, &ctx->val);
val               273 ext/standard/url_scanner_ex.c 				if (doit && ctx->val.s && ctx->lookup_data && *ctx->lookup_data) {
val               274 ext/standard/url_scanner_ex.c 					char *e, *p = (char *)zend_memnstr(ZSTR_VAL(ctx->val.s), "://", sizeof("://") - 1, ZSTR_VAL(ctx->val.s) + ZSTR_LEN(ctx->val.s));
val               276 ext/standard/url_scanner_ex.c 						e = memchr(p, '/', (ZSTR_VAL(ctx->val.s) + ZSTR_LEN(ctx->val.s)) - p);
val               278 ext/standard/url_scanner_ex.c 							e = ZSTR_VAL(ctx->val.s) + ZSTR_LEN(ctx->val.s);
val               333 ext/standard/url_scanner_ex.c 	smart_str_setl(&ctx->val, start + quotes, YYCURSOR - start - quotes * 2);
val               925 ext/standard/url_scanner_ex.c 		smart_str_free(&ctx->val);
val                40 ext/standard/url_scanner_ex.h 	smart_str val; /* read only */
val                86 ext/standard/var.c 	zval *val;
val               126 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
val               127 ext/standard/var.c 				php_array_element_dump(val, num, key, level);
val               156 ext/standard/var.c 				zval *val;
val               158 ext/standard/var.c 				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
val               159 ext/standard/var.c 					php_object_property_dump(val, num, key, level);
val               256 ext/standard/var.c 	zval *val;
val               294 ext/standard/var.c 		ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
val               295 ext/standard/var.c 			zval_array_element_dump(val, index, key, level);
val               323 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
val               324 ext/standard/var.c 				zval_object_property_dump(val, index, key, level);
val               444 ext/standard/var.c 	zval *val;
val               498 ext/standard/var.c 			ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
val               499 ext/standard/var.c 				php_array_element_export(val, index, key, level, buf);
val               531 ext/standard/var.c 				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
val               532 ext/standard/var.c 					php_object_element_export(val, index, key, level, buf);
val               636 ext/standard/var.c static inline void php_var_serialize_long(smart_str *buf, zend_long val) /* {{{ */
val               639 ext/standard/var.c 	smart_str_append_long(buf, val);
val               696 ext/standard/var.c 		zval *d, *val;
val               704 ext/standard/var.c 		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
val               709 ext/standard/var.c 			if (Z_TYPE_P(val) != IS_STRING) {
val               713 ext/standard/var.c 			name = zval_get_string(val);
val                48 ext/sysvsem/sysvsem.c 	int val;                    /* value for SETVAL */
val               258 ext/sysvsem/sysvsem.c 		semarg.val = max_acquire;
val               876 ext/tidy/tidy.c 				char *name, *val;
val               881 ext/tidy/tidy.c 					val = (char *)tidyAttrValue(tempattr);
val               882 ext/tidy/tidy.c 					if (name && val) {
val               883 ext/tidy/tidy.c 						add_assoc_string(&attribute, name, val);
val               932 ext/tidy/tidy.c 			char *val = (char *) tidyOptGetValue(ptdoc->doc, tidyOptGetId(opt));
val               933 ext/tidy/tidy.c 			if (val) {
val               934 ext/tidy/tidy.c 				return (void *) zend_string_init(val, strlen(val), 0);
val               300 ext/wddx/wddx.c 	if ((ret = php_wddx_deserialize_ex(val, vallen, &retval)) == SUCCESS) {
val               663 ext/wddx/wddx.c 	zval *val;
val               668 ext/wddx/wddx.c 		if ((val = zend_hash_find(symbol_table, Z_STR_P(name_var))) != NULL) {
val               669 ext/wddx/wddx.c 			if (Z_TYPE_P(val) == IS_INDIRECT) {
val               670 ext/wddx/wddx.c 				val = Z_INDIRECT_P(val);
val               672 ext/wddx/wddx.c 			php_wddx_serialize_var(packet, val, Z_STR_P(name_var));
val               685 ext/wddx/wddx.c 			ZEND_HASH_FOREACH_VAL(target_hash, val) {
val               686 ext/wddx/wddx.c 				php_wddx_add_var(packet, val);
val               689 ext/wddx/wddx.c 			ZEND_HASH_FOREACH_VAL(target_hash, val) {
val               694 ext/wddx/wddx.c 				ZVAL_DEREF(val);
val               695 ext/wddx/wddx.c 				php_wddx_add_var(packet, val);
val               668 ext/xml/xml.c  PHP_XML_API char *_xml_zval_strdup(zval *val)
val               670 ext/xml/xml.c  	if (Z_TYPE_P(val) == IS_STRING) {
val               671 ext/xml/xml.c  		char *buf = emalloc(Z_STRLEN_P(val) + 1);
val               672 ext/xml/xml.c  		memcpy(buf, Z_STRVAL_P(val), Z_STRLEN_P(val));
val               673 ext/xml/xml.c  		buf[Z_STRLEN_P(val)] = '\0';
val               721 ext/xml/xml.c  	zend_string *att, *tag_name, *val;
val               738 ext/xml/xml.c  				val = xml_utf8_decode(attributes[1], strlen((char *)attributes[1]), parser->target_encoding);
val               740 ext/xml/xml.c  				ZVAL_STR(&tmp, val);
val               775 ext/xml/xml.c  					val = xml_utf8_decode(attributes[1], strlen((char *)attributes[1]), parser->target_encoding);
val               777 ext/xml/xml.c  					ZVAL_STR(&tmp, val);
val              1588 ext/xml/xml.c  	zval *pind, *val;
val              1591 ext/xml/xml.c  	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz", &pind, &opt, &val) == FAILURE) {
val              1601 ext/xml/xml.c  			convert_to_long_ex(val);
val              1602 ext/xml/xml.c  			parser->case_folding = Z_LVAL_P(val);
val              1605 ext/xml/xml.c  			convert_to_long_ex(val);
val              1606 ext/xml/xml.c  			parser->toffset = Z_LVAL_P(val);
val              1609 ext/xml/xml.c  			convert_to_long_ex(val);
val              1610 ext/xml/xml.c  			parser->skipwhite = Z_LVAL_P(val);
val              1614 ext/xml/xml.c  			convert_to_string_ex(val);
val              1615 ext/xml/xml.c  			enc = xml_get_encoding((XML_Char*)Z_STRVAL_P(val));
val              1617 ext/xml/xml.c  				php_error_docref(NULL, E_WARNING, "Unsupported target encoding \"%s\"", Z_STRVAL_P(val));
val               856 ext/xmlrpc/libxmlrpc/queue.c    int low, mid, hi, val;
val               863 ext/xmlrpc/libxmlrpc/queue.c       val = Comp(key, index[ mid ]);
val               865 ext/xmlrpc/libxmlrpc/queue.c       if(val < 0)
val               868 ext/xmlrpc/libxmlrpc/queue.c       else if(val > 0)
val               202 ext/xmlrpc/libxmlrpc/xml_element.c          my_free(attrs->val);
val               428 ext/xmlrpc/libxmlrpc/xml_element.c             xml_elem_writefunc(fptr, iter->val, data, 0);
val               613 ext/xmlrpc/libxmlrpc/xml_element.c             attr->val = strdup(*(p+1));
val               138 ext/xmlrpc/libxmlrpc/xml_element.h    char* val;        /* attribute value */
val                77 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c             id = attr_iter->val;
val                80 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c             type = attr_iter->val;
val               187 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          attr_type->val = 0;
val               197 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c             attr_id->val = strdup(id);
val               268 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c          attr_type->val = strdup(pAttrType);
val               287 ext/xmlrpc/libxmlrpc/xml_to_dandarpc.c       version->val = strdup(VAL_VERSION_0_9);
val                68 ext/xmlrpc/libxmlrpc/xml_to_soap.c static xml_element_attr* new_attr(const char* key, const char* val) {
val                72 ext/xmlrpc/libxmlrpc/xml_to_soap.c 		attr->val = val ? strdup(val) : NULL;
val               272 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				type = attr_iter->val;
val               276 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				arrayType = attr_iter->val;
val               280 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				b_must_understand = strchr(attr_iter->val, '1') ? 1 : 0;
val               284 ext/xmlrpc/libxmlrpc/xml_to_soap.c 				actor = attr_iter->val;
val               663 ext/xmlrpc/libxmlrpc/xmlrpc.c char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val, int* buf_len) {
val               664 ext/xmlrpc/libxmlrpc/xmlrpc.c    xml_element *root_elem = XMLRPC_VALUE_to_xml_element(val);
val               953 ext/xmlrpc/libxmlrpc/xmlrpc.c const char *XMLRPC_SetValueString(XMLRPC_VALUE value, const char* val, int len) {
val               955 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(value && val) {
val               957 ext/xmlrpc/libxmlrpc/xmlrpc.c       (len > 0) ? simplestring_addn(&value->str, val, len) :
val               958 ext/xmlrpc/libxmlrpc/xmlrpc.c                   simplestring_add(&value->str, val);
val               985 ext/xmlrpc/libxmlrpc/xmlrpc.c void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val) {
val               988 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->i = val;
val              1011 ext/xmlrpc/libxmlrpc/xmlrpc.c void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val) {
val              1014 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->i = val ? 1 : 0;
val              1097 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = NULL;
val              1099 ext/xmlrpc/libxmlrpc/xmlrpc.c    val = XMLRPC_CreateValueEmpty();
val              1100 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1101 ext/xmlrpc/libxmlrpc/xmlrpc.c       if(XMLRPC_SetIsVector(val, type)) {
val              1105 ext/xmlrpc/libxmlrpc/xmlrpc.c             pSVI = XMLRPC_SetValueID(val, id, 0);
val              1107 ext/xmlrpc/libxmlrpc/xmlrpc.c                val = NULL;
val              1112 ext/xmlrpc/libxmlrpc/xmlrpc.c          val = NULL;
val              1115 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1337 ext/xmlrpc/libxmlrpc/xmlrpc.c XMLRPC_VALUE XMLRPC_CreateValueString(const char* id, const char* val, int len) {
val              1339 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1342 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueString(value, val, len);
val              1373 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1374 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1375 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueInt(val, i);
val              1377 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1380 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1405 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1406 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1407 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueBoolean(val, i);
val              1409 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1412 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1691 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1692 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1693 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueDateTime(val, time);
val              1695 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1698 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1764 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1765 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1766 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueDateTime_ISO8601(val, s);
val              1768 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1771 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1833 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1834 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1835 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueBase64(val, s, len);
val              1837 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1840 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val              1863 ext/xmlrpc/libxmlrpc/xmlrpc.c void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val) {
val              1866 ext/xmlrpc/libxmlrpc/xmlrpc.c       value->d = val;
val              1891 ext/xmlrpc/libxmlrpc/xmlrpc.c    XMLRPC_VALUE val = XMLRPC_CreateValueEmpty();
val              1892 ext/xmlrpc/libxmlrpc/xmlrpc.c    if(val) {
val              1893 ext/xmlrpc/libxmlrpc/xmlrpc.c       XMLRPC_SetValueDouble(val, d);
val              1895 ext/xmlrpc/libxmlrpc/xmlrpc.c          XMLRPC_SetValueID(val, id, 0);
val              1898 ext/xmlrpc/libxmlrpc/xmlrpc.c    return val;
val               348 ext/xmlrpc/libxmlrpc/xmlrpc.h void XMLRPC_SetValueDouble(XMLRPC_VALUE value, double val);
val               349 ext/xmlrpc/libxmlrpc/xmlrpc.h void XMLRPC_SetValueInt(XMLRPC_VALUE value, int val);
val               350 ext/xmlrpc/libxmlrpc/xmlrpc.h void XMLRPC_SetValueBoolean(XMLRPC_VALUE value, int val);
val               376 ext/xmlrpc/libxmlrpc/xmlrpc.h char* XMLRPC_VALUE_ToXML(XMLRPC_VALUE val, int* buf_len);
val               324 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             name = attr_iter->val;
val               327 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             type = attr_iter->val;
val               330 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             basetype = attr_iter->val;
val               333 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             desc = attr_iter->val;
val               336 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             if(attr_iter->val && !strcmp(attr_iter->val, "yes")) {
val               341 ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c             def = attr_iter->val;
val               338 ext/xmlrpc/xmlrpc-epi-php.c static void add_zval(zval* list, const char* id, zval* val)
val               340 ext/xmlrpc/xmlrpc-epi-php.c 	if (list && val) {
val               345 ext/xmlrpc/xmlrpc-epi-php.c 				zend_hash_index_update(Z_ARRVAL_P(list), index, val);
val               347 ext/xmlrpc/xmlrpc-epi-php.c 				zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val);
val               350 ext/xmlrpc/xmlrpc-epi-php.c 			zend_hash_next_index_insert(Z_ARRVAL_P(list), val);
val               373 ext/xmlrpc/xmlrpc-epi-php.c 			zval* val;
val               376 ext/xmlrpc/xmlrpc-epi-php.c 			if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN)) != NULL) {
val               377 ext/xmlrpc/xmlrpc-epi-php.c 				if (Z_TYPE_P(val) == IS_STRING) {
val               378 ext/xmlrpc/xmlrpc-epi-php.c 					if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_PHP)) {
val               380 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), OUTPUT_TYPE_VALUE_XML)) {
val               387 ext/xmlrpc/xmlrpc-epi-php.c 			if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERBOSITY_KEY, VERBOSITY_KEY_LEN)) != NULL) {
val               388 ext/xmlrpc/xmlrpc-epi-php.c 				if (Z_TYPE_P(val) == IS_STRING) {
val               389 ext/xmlrpc/xmlrpc-epi-php.c 					if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NO_WHITE_SPACE)) {
val               391 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_NEWLINES_ONLY)) {
val               393 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), VERBOSITY_VALUE_PRETTY)) {
val               400 ext/xmlrpc/xmlrpc-epi-php.c 			if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), VERSION_KEY, VERSION_KEY_LEN)) != NULL) {
val               401 ext/xmlrpc/xmlrpc-epi-php.c 				if (Z_TYPE_P(val) == IS_STRING) {
val               403 ext/xmlrpc/xmlrpc-epi-php.c 					if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_XMLRPC)) {
val               405 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SIMPLE)) {
val               407 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), VERSION_VALUE_SOAP11)) {
val               417 ext/xmlrpc/xmlrpc-epi-php.c 			if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ENCODING_KEY, ENCODING_KEY_LEN)) != NULL) {
val               418 ext/xmlrpc/xmlrpc-epi-php.c 				if (Z_TYPE_P(val) == IS_STRING) {
val               419 ext/xmlrpc/xmlrpc-epi-php.c 					options->xmlrpc_out.xml_elem_opts.encoding = estrdup(Z_STRVAL_P(val));
val               424 ext/xmlrpc/xmlrpc-epi-php.c 			if ((val = zend_hash_str_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN)) != NULL) {
val               426 ext/xmlrpc/xmlrpc-epi-php.c 				if (Z_TYPE_P(val) == IS_ARRAY) {
val               431 ext/xmlrpc/xmlrpc-epi-php.c 					ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(val), iter_val) {
val               445 ext/xmlrpc/xmlrpc-epi-php.c 				} else if (Z_TYPE_P(val) == IS_STRING) {
val               446 ext/xmlrpc/xmlrpc-epi-php.c 					if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_CDATA)) {
val               448 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_ASCII)) {
val               450 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_NON_PRINT)) {
val               452 ext/xmlrpc/xmlrpc-epi-php.c 					} else if (!strcmp(Z_STRVAL_P(val), ESCAPING_VALUE_MARKUP)) {
val               505 ext/xmlrpc/xmlrpc-epi-php.c 		zval val;
val               508 ext/xmlrpc/xmlrpc-epi-php.c 		ZVAL_UNDEF(&val);
val               509 ext/xmlrpc/xmlrpc-epi-php.c 		type = get_zval_xmlrpc_type(in_val, &val);
val               511 ext/xmlrpc/xmlrpc-epi-php.c 		if (!Z_ISUNDEF(val)) {
val               514 ext/xmlrpc/xmlrpc-epi-php.c 					if (Z_TYPE(val) == IS_NULL) {
val               518 ext/xmlrpc/xmlrpc-epi-php.c 						if (Z_TYPE(val) != IS_STRING) {
val               520 ext/xmlrpc/xmlrpc-epi-php.c 							ZVAL_DUP(&newvalue, &val);
val               525 ext/xmlrpc/xmlrpc-epi-php.c 							xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(val), Z_STRLEN(val));
val               530 ext/xmlrpc/xmlrpc-epi-php.c 					convert_to_string(&val);
val               531 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL(val));
val               534 ext/xmlrpc/xmlrpc-epi-php.c 					convert_to_boolean(&val);
val               535 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE(val) == IS_TRUE);
val               538 ext/xmlrpc/xmlrpc-epi-php.c 					convert_to_long(&val);
val               539 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueInt(key, Z_LVAL(val));
val               542 ext/xmlrpc/xmlrpc-epi-php.c 					convert_to_double(&val);
val               543 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL(val));
val               546 ext/xmlrpc/xmlrpc-epi-php.c 					convert_to_string(&val);
val               547 ext/xmlrpc/xmlrpc-epi-php.c 					xReturn = XMLRPC_CreateValueString(key, Z_STRVAL(val), Z_STRLEN(val));
val               558 ext/xmlrpc/xmlrpc-epi-php.c 						ht = HASH_OF(&val);
val               564 ext/xmlrpc/xmlrpc-epi-php.c 						ZVAL_COPY(&val_arr, &val);
val               651 ext/xmlrpc/xmlrpc-epi-php.c 						zval val;
val               652 ext/xmlrpc/xmlrpc-epi-php.c 						ZVAL_UNDEF(&val);
val               653 ext/xmlrpc/xmlrpc-epi-php.c 						XMLRPC_to_PHP(xIter, &val);
val               654 ext/xmlrpc/xmlrpc-epi-php.c 						if (!Z_ISUNDEF(val)) {
val               655 ext/xmlrpc/xmlrpc-epi-php.c 							add_zval(elem, XMLRPC_GetValueID(xIter), &val);
val              1367 ext/xmlrpc/xmlrpc-epi-php.c 			zval* val;
val              1370 ext/xmlrpc/xmlrpc-epi-php.c 				if ((val = zend_hash_str_find(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR) - 1)) != NULL) {
val              1371 ext/xmlrpc/xmlrpc-epi-php.c 					ZVAL_COPY_VALUE(newvalue, val);
val               976 ext/zip/php_zip.c 		zval *ret, val;
val               977 ext/zip/php_zip.c 		ret = php_zip_property_reader(obj, hnd, &val);
val               980 main/SAPI.c    SAPI_API int sapi_register_input_filter(unsigned int (*input_filter)(int arg, char *var, char **val, size_t val_len, size_t *new_val_len), unsigned int (*input_filter_init)(void))
val               200 main/SAPI.h    SAPI_API int sapi_register_input_filter(unsigned int (*input_filter)(int arg, char *var, char **val, size_t val_len, size_t *new_val_len), unsigned int (*input_filter_init)(void));
val               268 main/SAPI.h    	unsigned int (*input_filter)(int arg, char *var, char **val, size_t val_len, size_t *new_val_len);
val               302 main/SAPI.h    #define SAPI_INPUT_FILTER_FUNC(input_filter) unsigned int input_filter(int arg, char *var, char **val, size_t val_len, size_t *new_val_len)
val               177 main/fastcgi.c 	char                     *val;
val               330 main/fastcgi.c static char* fcgi_hash_set(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, char *val, unsigned int val_len)
val               341 main/fastcgi.c 			p->val = fcgi_hash_strndup(h, val, val_len);
val               342 main/fastcgi.c 			return p->val;
val               363 main/fastcgi.c 	p->val = fcgi_hash_strndup(h, val, val_len);
val               364 main/fastcgi.c 	return p->val;
val               377 main/fastcgi.c 		    (*p)->val = NULL; /* NULL value means deleted */
val               396 main/fastcgi.c 		    return p->val;
val               408 main/fastcgi.c 		if (EXPECTED(p->val != NULL)) {
val               409 main/fastcgi.c 			func(p->var, p->var_len, p->val, p->val_len, arg);
val              1678 main/fastcgi.c char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val)
val              1681 main/fastcgi.c 	if (val == NULL) {
val              1685 main/fastcgi.c 		return fcgi_hash_set(&req->env, FCGI_HASH_FUNC(var, var_len), var, var_len, val, (unsigned int)strlen(val));
val              1689 main/fastcgi.c char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val)
val              1691 main/fastcgi.c 	if (val == NULL) {
val              1695 main/fastcgi.c 		return fcgi_hash_set(&req->env, hash_value, var, var_len, val, (unsigned int)strlen(val));
val                82 main/fastcgi.h typedef void (*fcgi_apply_func)(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg);
val               113 main/fastcgi.h char* fcgi_putenv(fcgi_request *req, char* var, int var_len, char* val);
val               115 main/fastcgi.h char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val);
val               900 main/network.c 				int val = 1;
val               902 main/network.c 					setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char*)&val, sizeof(val));
val                56 main/php_variables.c PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars_array)
val                76 main/php_variables.c 		zval_dtor(val);
val               107 main/php_variables.c 		zval_dtor(val);
val               116 main/php_variables.c 		zval_dtor(val);
val               139 main/php_variables.c 				zval_dtor(val);
val               178 main/php_variables.c 					zval_dtor(val);
val               213 main/php_variables.c 		ZVAL_COPY_VALUE(&gpc_element, val);
val               246 main/php_variables.c 	char *ksep, *vsep, *val;
val               278 main/php_variables.c 	val = estrndup(ksep, vlen);
val               280 main/php_variables.c 		vlen = php_url_decode(val, vlen);
val               283 main/php_variables.c 	if (sapi_module.input_filter(PARSE_POST, var->ptr, &val, vlen, &new_vlen)) {
val               284 main/php_variables.c 		php_register_variable_safe(var->ptr, val, new_vlen, arr);
val               286 main/php_variables.c 	efree(val);
val               363 main/php_variables.c 	char *res = NULL, *var, *val, *separator = NULL;
val               439 main/php_variables.c 		val = strchr(var, '=');
val               446 main/php_variables.c 			if (var == val || *var == '\0') {
val               456 main/php_variables.c 		if (val) { /* have a value */
val               460 main/php_variables.c 			*val++ = '\0';
val               462 main/php_variables.c 			val_len = php_url_decode(val, strlen(val));
val               463 main/php_variables.c 			val = estrndup(val, val_len);
val               464 main/php_variables.c 			if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len)) {
val               465 main/php_variables.c 				php_register_variable_safe(var, val, new_val_len, &array);
val               467 main/php_variables.c 			efree(val);
val               474 main/php_variables.c 			val = estrndup("", val_len);
val               475 main/php_variables.c 			if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len)) {
val               476 main/php_variables.c 				php_register_variable_safe(var, val, new_val_len, &array);
val               478 main/php_variables.c 			efree(val);
val                39 main/php_variables.h PHPAPI void php_register_variable(char *var, char *val, zval *track_vars_array);
val                41 main/php_variables.h PHPAPI void php_register_variable_safe(char *var, char *val, size_t val_len, zval *track_vars_array);
val                42 main/php_variables.h PHPAPI void php_register_variable_ex(char *var, zval *val, zval *track_vars_array);
val               324 main/reentrancy.c 	u_long val = (u_long) *ctx;
val               325 main/reentrancy.c 	*ctx = do_rand(&val);
val               173 main/rfc1867.c static void safe_php_register_variable_ex(char *var, zval *val, zval *track_vars_array, zend_bool override_protection) /* {{{ */
val               176 main/rfc1867.c 		php_register_variable_ex(var, val, track_vars_array);
val               181 main/rfc1867.c static void register_http_post_files_variable(char *strvar, char *val, zval *http_post_files, zend_bool override_protection) /* {{{ */
val               183 main/rfc1867.c 	safe_php_register_variable(strvar, val, strlen(val), http_post_files, override_protection);
val               187 main/rfc1867.c static void register_http_post_files_variable_ex(char *var, zval *val, zval *http_post_files, zend_bool override_protection) /* {{{ */
val               189 main/rfc1867.c 	safe_php_register_variable_ex(var, val, http_post_files, override_protection);
val                61 sapi/apache2handler/php_apache.h #define APR_ARRAY_FOREACH_OPEN(arr, key, val) 		\
val                68 sapi/apache2handler/php_apache.h 		val = elts[i].val;
val               177 sapi/apache2handler/php_functions.c 	char *key, *val;
val               188 sapi/apache2handler/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               189 sapi/apache2handler/php_functions.c 		if (!val) val = "";
val               190 sapi/apache2handler/php_functions.c 		add_assoc_string(return_value, key, val);
val               201 sapi/apache2handler/php_functions.c 	char *key, *val;
val               212 sapi/apache2handler/php_functions.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               213 sapi/apache2handler/php_functions.c 		if (!val) val = "";
val               214 sapi/apache2handler/php_functions.c 		add_assoc_string(return_value, key, val);
val               393 sapi/apache2handler/php_functions.c 			tmp1.s->val[tmp1.s->len - 1] = '\0';
val               395 sapi/apache2handler/php_functions.c 			tmp1.s->val[0] = '\0';
val               433 sapi/apache2handler/php_functions.c 	php_info_print_table_row(2, "Loaded Modules", tmp1.s->val);
val               442 sapi/apache2handler/php_functions.c 		char *key, *val;
val               447 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               448 sapi/apache2handler/php_functions.c 			if (!val) {
val               449 sapi/apache2handler/php_functions.c 				val = "";
val               451 sapi/apache2handler/php_functions.c 			php_info_print_table_row(2, key, val);
val               462 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               463 sapi/apache2handler/php_functions.c 			if (!val) {
val               464 sapi/apache2handler/php_functions.c 				val = "";
val               466 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
val               471 sapi/apache2handler/php_functions.c 		APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               472 sapi/apache2handler/php_functions.c 			if (!val) {
val               473 sapi/apache2handler/php_functions.c 				val = "";
val               475 sapi/apache2handler/php_functions.c 		        php_info_print_table_row(2, key, val);
val                92 sapi/apache2handler/sapi_apache2.c 	char *val, *ptr;
val               107 sapi/apache2handler/sapi_apache2.c 			val = strchr(sapi_header->header, ':');
val               109 sapi/apache2handler/sapi_apache2.c 			if (!val) {
val               112 sapi/apache2handler/sapi_apache2.c 			ptr = val;
val               114 sapi/apache2handler/sapi_apache2.c 			*val = '\0';
val               117 sapi/apache2handler/sapi_apache2.c 				val++;
val               118 sapi/apache2handler/sapi_apache2.c 			} while (*val == ' ');
val               124 sapi/apache2handler/sapi_apache2.c 				ctx->content_type = estrdup(val);
val               128 sapi/apache2handler/sapi_apache2.c 				if (APR_SUCCESS != apr_strtoff(&clen, val, (char **) NULL, 10)) {
val               131 sapi/apache2handler/sapi_apache2.c 					clen = (apr_off_t) strtol(val, (char **) NULL, 10);
val               136 sapi/apache2handler/sapi_apache2.c 				apr_table_set(ctx->r->headers_out, sapi_header->header, val);
val               138 sapi/apache2handler/sapi_apache2.c 				apr_table_add(ctx->r->headers_out, sapi_header->header, val);
val               274 sapi/apache2handler/sapi_apache2.c 	char *key, *val;
val               277 sapi/apache2handler/sapi_apache2.c 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
val               278 sapi/apache2handler/sapi_apache2.c 		if (!val) {
val               279 sapi/apache2handler/sapi_apache2.c 			val = "";
val               281 sapi/apache2handler/sapi_apache2.c 		if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len)) {
val               282 sapi/apache2handler/sapi_apache2.c 			php_register_variable_safe(key, val, new_val_len, track_vars_array);
val               247 sapi/cgi/cgi_main.c 	return strcasecmp(	((zend_module_entry *)Z_PTR(f->val))->name,
val               248 sapi/cgi/cgi_main.c 						((zend_module_entry *)Z_PTR(s->val))->name);
val               602 sapi/cgi/cgi_main.c static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg)
val               608 sapi/cgi/cgi_main.c 	if (sapi_module.input_filter(filter_arg, var, &val, strlen(val), &new_val_len)) {
val               609 sapi/cgi/cgi_main.c 		php_register_variable_safe(var, val, new_val_len, array_ptr);
val              1511 sapi/cgi/cgi_main.c static void add_request_header(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg) /* {{{ */
val              1552 sapi/cgi/cgi_main.c 	add_assoc_stringl_ex(return_value, var, var_len, val, val_len);
val              1571 sapi/cgi/cgi_main.c 		char **env, *p, *q, *var, *val, *t = buf;
val              1576 sapi/cgi/cgi_main.c 			val = strchr(*env, '=');
val              1577 sapi/cgi/cgi_main.c 			if (!val) {				/* malformed entry? */
val              1580 sapi/cgi/cgi_main.c 			var_len = val - *env;
val              1632 sapi/cgi/cgi_main.c 			val++;
val              1633 sapi/cgi/cgi_main.c 			add_assoc_string_ex(return_value, var, var_len, val);
val              1836 sapi/cgi/cgi_main.c 				char *val;
val              1838 sapi/cgi/cgi_main.c 				if ((val = strchr(php_optarg, '='))) {
val              1839 sapi/cgi/cgi_main.c 					val++;
val              1840 sapi/cgi/cgi_main.c 					if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
val              1842 sapi/cgi/cgi_main.c 						memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
val              1843 sapi/cgi/cgi_main.c 						ini_entries_len += (val - php_optarg);
val              1846 sapi/cgi/cgi_main.c 						memcpy(cgi_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
val              1847 sapi/cgi/cgi_main.c 						ini_entries_len += len - (val - php_optarg);
val               195 sapi/cli/php_cli.c 	return strcasecmp(((zend_module_entry *)Z_PTR(f->val))->name,
val               196 sapi/cli/php_cli.c 				  ((zend_module_entry *)Z_PTR(s->val))->name);
val              1250 sapi/cli/php_cli.c 				char *val;
val              1252 sapi/cli/php_cli.c 				if ((val = strchr(php_optarg, '='))) {
val              1253 sapi/cli/php_cli.c 					val++;
val              1254 sapi/cli/php_cli.c 					if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
val              1256 sapi/cli/php_cli.c 						memcpy(ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
val              1257 sapi/cli/php_cli.c 						ini_entries_len += (int)(val - php_optarg);
val              1260 sapi/cli/php_cli.c 						memcpy(ini_entries + ini_entries_len, val, len - (val - php_optarg));
val              1261 sapi/cli/php_cli.c 						ini_entries_len += len - (int)(val - php_optarg);
val               343 sapi/cli/php_cli_server.c 		char *val;
val               344 sapi/cli/php_cli_server.c 		if (NULL != (val = zend_hash_str_find_ptr(&client->request.headers, "host", sizeof("host")-1))) {
val               347 sapi/cli/php_cli_server.c 			smart_str_appends_ex(buffer, val, persistent);
val               559 sapi/cli/php_cli_server.c 	char *val;
val               560 sapi/cli/php_cli_server.c 	if (NULL == (val = zend_hash_str_find_ptr(&client->request.headers, "cookie", sizeof("cookie")-1))) {
val               563 sapi/cli/php_cli_server.c 	return val;
val               579 sapi/cli/php_cli_server.c static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val) /* {{{ */
val               581 sapi/cli/php_cli_server.c 	char *new_val = (char *)val;
val               584 sapi/cli/php_cli_server.c 	if (NULL == val) {
val               588 sapi/cli/php_cli_server.c 	if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len)) {
val              1235 sapi/cli/php_cli_server.c 			int val = 1;
val              1236 sapi/cli/php_cli_server.c 			setsockopt(retval, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
val              1763 sapi/cli/php_cli_server.c 	char *val;
val              1772 sapi/cli/php_cli_server.c 	if (NULL != (val = zend_hash_str_find_ptr(&client->request.headers, "content-type", sizeof("content-type")-1))) {
val              1773 sapi/cli/php_cli_server.c 		request_info->content_type = val;
val               211 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               212 sapi/fpm/fpm/fpm_conf.c 	long value_y = !strcasecmp(val, "1");
val               213 sapi/fpm/fpm/fpm_conf.c 	long value_n = !strcasecmp(val, "");
val               251 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               255 sapi/fpm/fpm/fpm_conf.c 	for (p = val; *p; p++) {
val               256 sapi/fpm/fpm/fpm_conf.c 		if (p == val && *p == '-') continue;
val               261 sapi/fpm/fpm/fpm_conf.c 	* (int *) ((char *) *config + offset) = atoi(val);
val               269 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               272 sapi/fpm/fpm/fpm_conf.c 	for (p = val; *p; p++) {
val               273 sapi/fpm/fpm/fpm_conf.c 		if ( p == val && *p == '-' ) continue;
val               278 sapi/fpm/fpm/fpm_conf.c 	* (long int *) ((char *) *config + offset) = atol(val);
val               286 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               287 sapi/fpm/fpm/fpm_conf.c 	int len = strlen(val);
val               294 sapi/fpm/fpm/fpm_conf.c 	suffix = val[len-1];
val               297 sapi/fpm/fpm/fpm_conf.c 			val[len-1] = '\0';
val               298 sapi/fpm/fpm/fpm_conf.c 			seconds = 60 * atoi(val);
val               301 sapi/fpm/fpm/fpm_conf.c 			val[len-1] = '\0';
val               302 sapi/fpm/fpm/fpm_conf.c 			seconds = 60 * 60 * atoi(val);
val               305 sapi/fpm/fpm/fpm_conf.c 			val[len-1] = '\0';
val               306 sapi/fpm/fpm/fpm_conf.c 			seconds = 24 * 60 * 60 * atoi(val);
val               309 sapi/fpm/fpm/fpm_conf.c 			val[len-1] = '\0';
val               315 sapi/fpm/fpm/fpm_conf.c 			seconds = atoi(val);
val               326 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               329 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "debug")) {
val               331 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "notice")) {
val               333 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "warning") || !strcasecmp(val, "warn")) {
val               335 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "error")) {
val               337 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "alert")) {
val               351 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               355 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "AUTH")) {
val               362 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "AUTHPRIV")) {
val               369 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "CRON")) {
val               376 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "DAEMON")) {
val               383 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "FTP")) {
val               390 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "KERN")) {
val               397 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LPR")) {
val               404 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "MAIL")) {
val               411 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "NEWS")) {
val               418 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "SYSLOG")) {
val               425 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "USER")) {
val               432 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "UUCP")) {
val               439 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL0")) {
val               446 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL1")) {
val               453 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL2")) {
val               460 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL3")) {
val               467 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL4")) {
val               474 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL5")) {
val               481 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL6")) {
val               488 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "LOCAL7")) {
val               501 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               504 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "unlimited")) {
val               530 sapi/fpm/fpm/fpm_conf.c 	char *val = Z_STRVAL_P(value);
val               532 sapi/fpm/fpm/fpm_conf.c 	if (!strcasecmp(val, "static")) {
val               534 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "dynamic")) {
val               536 sapi/fpm/fpm/fpm_conf.c 	} else if (!strcasecmp(val, "ondemand")) {
val               235 sapi/fpm/fpm/fpm_main.c 	return strcasecmp(	((zend_module_entry *) Z_PTR(f->val))->name,
val               236 sapi/fpm/fpm/fpm_main.c 						((zend_module_entry *) Z_PTR(s->val))->name);
val               550 sapi/fpm/fpm/fpm_main.c static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg) /* {{{ */
val               556 sapi/fpm/fpm/fpm_main.c 	if (sapi_module.input_filter(filter_arg, var, &val, strlen(val), &new_val_len)) {
val               557 sapi/fpm/fpm/fpm_main.c 		php_register_variable_safe(var, val, new_val_len, array_ptr);
val              1652 sapi/fpm/fpm/fpm_main.c 				char *val;
val              1654 sapi/fpm/fpm/fpm_main.c 				if ((val = strchr(php_optarg, '='))) {
val              1655 sapi/fpm/fpm/fpm_main.c 					val++;
val              1656 sapi/fpm/fpm/fpm_main.c 					if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
val              1658 sapi/fpm/fpm/fpm_main.c 						memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
val              1659 sapi/fpm/fpm/fpm_main.c 						ini_entries_len += (val - php_optarg);
val              1662 sapi/fpm/fpm/fpm_main.c 						memcpy(cgi_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
val              1663 sapi/fpm/fpm/fpm_main.c 						ini_entries_len += len - (val - php_optarg);
val               112 sapi/fpm/fpm/fpm_php_trace.c 				if (0 > fpm_trace_get_strz(buf, buf_size, function_name + offsetof(zend_string, val))) {
val               158 sapi/fpm/fpm/fpm_php_trace.c 				if (0 > fpm_trace_get_strz(buf, buf_size, file_name + offsetof(zend_string, val))) {
val               459 sapi/fpm/fpm/fpm_sockets.c 	int val;
val               460 sapi/fpm/fpm/fpm_sockets.c 	socklen_t len = sizeof(val);
val               463 sapi/fpm/fpm/fpm_sockets.c 		if (0 > getsockopt(sock, SOL_SOCKET, SO_LISTENQLEN, &val, &len)) {
val               467 sapi/fpm/fpm/fpm_sockets.c 		*cur_lq = val;
val               471 sapi/fpm/fpm/fpm_sockets.c 		if (0 > getsockopt(sock, SOL_SOCKET, SO_LISTENQLIMIT, &val, &len)) {
val               475 sapi/fpm/fpm/fpm_sockets.c 		*max_lq = val;
val               256 sapi/litespeed/lsapilib.c     int val = fcntl( fd, F_GETFL, 0 );
val               259 sapi/litespeed/lsapilib.c         if (!( val & O_NONBLOCK ))
val               261 sapi/litespeed/lsapilib.c             return fcntl( fd, F_SETFL, val | O_NONBLOCK );
val               266 sapi/litespeed/lsapilib.c         if ( val & O_NONBLOCK )
val               268 sapi/litespeed/lsapilib.c             return fcntl( fd, F_SETFL, val &(~O_NONBLOCK) );
val              1390 sapi/phpdbg/phpdbg.c 				char *val;
val              1392 sapi/phpdbg/phpdbg.c 				if ((val = strchr(php_optarg, '='))) {
val              1393 sapi/phpdbg/phpdbg.c 				  val++;
val              1394 sapi/phpdbg/phpdbg.c 				  if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
val              1396 sapi/phpdbg/phpdbg.c 					  memcpy(ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
val              1397 sapi/phpdbg/phpdbg.c 					  ini_entries_len += (val - php_optarg);
val              1400 sapi/phpdbg/phpdbg.c 					  memcpy(ini_entries + ini_entries_len, val, len - (val - php_optarg));
val              1401 sapi/phpdbg/phpdbg.c 					  ini_entries_len += len - (val - php_optarg);
val               215 sapi/phpdbg/phpdbg_info.c 				phpdbg_notice("variableinfo", "method=\"%s::%s\" num=\"%d\"", "Variables in %s::%s() (%d)", ops->scope->name->val, ops->function_name->val, zend_hash_num_elements(&vars));
val               316 sapi/phpdbg/phpdbg_info.c 				phpdbg_notice("literalinfo", "method=\"%s::%s\" num=\"%d\"", "Literal Constants in %s::%s() (%d)", ops->scope->name->val, ops->function_name->val, count);
val               318 sapi/phpdbg/phpdbg_info.c 				phpdbg_notice("literalinfo", "function=\"%s\" num=\"%d\"", "Literal Constants in %s() (%d)", ops->function_name->val, count);
val               271 sapi/phpdbg/phpdbg_print.c 			if (func->type == ZEND_USER_FUNCTION && *rt_name->val == '\0') {
val               272 sapi/phpdbg/phpdbg_print.c 				if (func->op_array.function_name->len == len && !zend_binary_strcasecmp(function, len, func->op_array.function_name->val, func->op_array.function_name->len)) {
val               273 sapi/phpdbg/phpdbg_print.c 					phpdbg_print_opcodes_function(rt_name->val, rt_name->len);
val               289 sapi/phpdbg/phpdbg_print.c 		phpdbg_out("function name: %s::%s (internal)\n", ce->name->val, function);
val               297 sapi/phpdbg/phpdbg_print.c 	phpdbg_out("function name: %s::%s\n", ce->name->val, function);
val               307 sapi/phpdbg/phpdbg_print.c 			if (ce->type == ZEND_USER_CLASS && *rt_name->val == '\0') {
val               308 sapi/phpdbg/phpdbg_print.c 				if (ce->name->len == strlen(class) && !zend_binary_strcasecmp(class, strlen(class), ce->name->val, ce->name->len)) {
val               365 sapi/phpdbg/phpdbg_print.c 			if (ce->type == ZEND_USER_CLASS && *rt_name->val == '\0') {
val               366 sapi/phpdbg/phpdbg_print.c 				if (ce->name->len == strlen(class) && !zend_binary_strcasecmp(class, strlen(class), ce->name->val, ce->name->len)) {
val              1662 sapi/phpdbg/phpdbg_prompt.c 				phpdbg_notice("hardinterrupt", "opline=\"%p\" num=\"%lu\" file=\"%s\" line=\"%u\"", "Current opline: %p (op #%lu) in %s:%u", data->opline, (data->opline - data->func->op_array.opcodes) / sizeof(data->opline), data->func->op_array.filename->val, data->opline->lineno);
val              1664 sapi/phpdbg/phpdbg_prompt.c 				phpdbg_notice("hardinterrupt", "func=\"%s\"", "Current opline: in internal function %s", data->func->internal_function.function_name->val);
val               659 sapi/phpdbg/phpdbg_utils.c 	zval *val;
val               714 sapi/phpdbg/phpdbg_utils.c 					ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
val               715 sapi/phpdbg/phpdbg_utils.c 						element_dump_func(val, key, num);
val                59 sapi/phpdbg/phpdbg_wait.c 	first = &f->val;
val                60 sapi/phpdbg/phpdbg_wait.c 	second = &s->val;
val               233 win32/php_stdint.h #define INT8_C(val)  val##i8
val               234 win32/php_stdint.h #define INT16_C(val) val##i16
val               235 win32/php_stdint.h #define INT32_C(val) val##i32
val               236 win32/php_stdint.h #define INT64_C(val) val##i64
val               238 win32/php_stdint.h #define UINT8_C(val)  val##ui8
val               239 win32/php_stdint.h #define UINT16_C(val) val##ui16
val               240 win32/php_stdint.h #define UINT32_C(val) val##ui32
val               241 win32/php_stdint.h #define UINT64_C(val) val##ui64
val               174 win32/sendmail.c 				   result, result->val, (int)result->len,
val               235 win32/sendmail.c 			headers_lc->val[i] = tolower(headers_lc->val[i]);
val               246 win32/sendmail.c 		char *lookup = headers_lc->val;
val               253 win32/sendmail.c 			} else if (pos1 != headers_lc->val && *(pos1-1) != '\n') {
val               305 win32/sendmail.c 		ret = SendText(RPath, Subject, mailTo, mailCc, mailBcc, data, headers, headers_lc->val, error_message);
val               636 win32/sendmail.c 		char c, *e2, *e = data_cln->val + data_cln->len;
val               637 win32/sendmail.c 		p = data_cln->val;
val               714 win32/sendmail.c 		snprintf(header_buffer, MAIL_BUFFER_SIZE, "Date: %s\r\n", dt->val);