constant         3630 Zend/zend_API.c 	zval *constant;
constant         3633 Zend/zend_API.c 		ALLOC_PERMANENT_ZVAL(constant);
constant         3635 Zend/zend_API.c 		ALLOC_ZVAL(constant);
constant         3637 Zend/zend_API.c 	ZVAL_NULL(constant);
constant         3638 Zend/zend_API.c 	INIT_PZVAL(constant);
constant         3639 Zend/zend_API.c 	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
constant         3645 Zend/zend_API.c 	zval *constant;
constant         3648 Zend/zend_API.c 		ALLOC_PERMANENT_ZVAL(constant);
constant         3650 Zend/zend_API.c 		ALLOC_ZVAL(constant);
constant         3652 Zend/zend_API.c 	ZVAL_LONG(constant, value);
constant         3653 Zend/zend_API.c 	INIT_PZVAL(constant);
constant         3654 Zend/zend_API.c 	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
constant         3660 Zend/zend_API.c 	zval *constant;
constant         3663 Zend/zend_API.c 		ALLOC_PERMANENT_ZVAL(constant);
constant         3665 Zend/zend_API.c 		ALLOC_ZVAL(constant);
constant         3667 Zend/zend_API.c 	ZVAL_BOOL(constant, value);
constant         3668 Zend/zend_API.c 	INIT_PZVAL(constant);
constant         3669 Zend/zend_API.c 	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
constant         3675 Zend/zend_API.c 	zval *constant;
constant         3678 Zend/zend_API.c 		ALLOC_PERMANENT_ZVAL(constant);
constant         3680 Zend/zend_API.c 		ALLOC_ZVAL(constant);
constant         3682 Zend/zend_API.c 	ZVAL_DOUBLE(constant, value);
constant         3683 Zend/zend_API.c 	INIT_PZVAL(constant);
constant         3684 Zend/zend_API.c 	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
constant         3690 Zend/zend_API.c 	zval *constant;
constant         3693 Zend/zend_API.c 		ALLOC_PERMANENT_ZVAL(constant);
constant         3694 Zend/zend_API.c 		ZVAL_STRINGL(constant, zend_strndup(value, value_length), value_length, 0);
constant         3696 Zend/zend_API.c 		ALLOC_ZVAL(constant);
constant         3697 Zend/zend_API.c 		ZVAL_STRINGL(constant, value, value_length, 1);
constant         3699 Zend/zend_API.c 	INIT_PZVAL(constant);
constant         3700 Zend/zend_API.c 	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
constant         1912 Zend/zend_builtin_functions.c static int add_constant_info(zend_constant *constant, void *arg TSRMLS_DC)
constant         1917 Zend/zend_builtin_functions.c 	if (!constant->name) {
constant         1923 Zend/zend_builtin_functions.c 	*const_val = constant->value;
constant         1926 Zend/zend_builtin_functions.c 	add_assoc_zval_ex(name_array, constant->name, constant->name_len, const_val);
constant           34 Zend/zend_compile.c 	(op_array)->literals[op].constant
constant           42 Zend/zend_compile.c 			target.constant = zend_add_literal(CG(active_op_array), &(src)->u.constant TSRMLS_CC); \
constant           51 Zend/zend_compile.c 			(target)->u.constant = CONSTANT(src.constant); \
constant          391 Zend/zend_compile.c 	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
constant          418 Zend/zend_compile.c 	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
constant          455 Zend/zend_compile.c 	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
constant          489 Zend/zend_compile.c 	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
constant          555 Zend/zend_compile.c 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
constant          561 Zend/zend_compile.c 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
constant          567 Zend/zend_compile.c 		op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \
constant          573 Zend/zend_compile.c 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
constant          670 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
constant          671 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
constant          674 Zend/zend_compile.c 		hash = str_hash(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
constant          675 Zend/zend_compile.c 		if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) &&
constant          676 Zend/zend_compile.c 		    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
constant          677 Zend/zend_compile.c 		      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
constant          681 Zend/zend_compile.c 			result->u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC);
constant          682 Zend/zend_compile.c 			Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name;
constant          704 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline_ptr->op1.constant);
constant          705 Zend/zend_compile.c 		if (zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) {
constant          733 Zend/zend_compile.c 	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
constant          748 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline.op1.constant);
constant          749 Zend/zend_compile.c 		GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
constant          752 Zend/zend_compile.c 			opline.op2.constant =
constant          753 Zend/zend_compile.c 				zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
constant          773 Zend/zend_compile.c 			CALCULATE_LITERAL_HASH(opline.op1.constant);
constant          774 Zend/zend_compile.c 			GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
constant          777 Zend/zend_compile.c 				opline.op2.constant =
constant          778 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
constant          788 Zend/zend_compile.c 				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant);
constant          792 Zend/zend_compile.c 				opline_ptr->op2.constant =
constant          793 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
constant          834 Zend/zend_compile.c 	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
constant          838 Zend/zend_compile.c 		ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline.op2.constant)), Z_STRLEN(CONSTANT(opline.op2.constant))+1, index, numeric = 1);
constant          840 Zend/zend_compile.c 			zval_dtor(&CONSTANT(opline.op2.constant));
constant          841 Zend/zend_compile.c 			ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
constant          843 Zend/zend_compile.c 			CALCULATE_LITERAL_HASH(opline.op2.constant);
constant          887 Zend/zend_compile.c 		Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
constant          893 Zend/zend_compile.c 	if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
constant          894 Zend/zend_compile.c 		if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
constant          895 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
constant          897 Zend/zend_compile.c 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
constant          905 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
constant          908 Zend/zend_compile.c 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
constant          909 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
constant          918 Zend/zend_compile.c 		&& (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
constant          920 Zend/zend_compile.c 		&& (Z_HASH_P(&CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
constant          921 Zend/zend_compile.c 		&& (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
constant          922 Zend/zend_compile.c 		&& !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) {
constant          954 Zend/zend_compile.c 				CALCULATE_LITERAL_HASH(opline->op1.constant);
constant         1329 Zend/zend_compile.c 					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STRVAL(CONSTANT(opline_ptr->op1.constant)), Z_STRLEN(CONSTANT(opline_ptr->op1.constant)), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
constant         1330 Zend/zend_compile.c 					Z_TYPE(CONSTANT(opline_ptr->op1.constant)) = IS_NULL;
constant         1332 Zend/zend_compile.c 					zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
constant         1406 Zend/zend_compile.c 	if (Z_STRLEN(op2->u.constant) > 1) {
constant         1409 Zend/zend_compile.c 	} else if (Z_STRLEN(op2->u.constant) == 1) {
constant         1410 Zend/zend_compile.c 		int ch = *Z_STRVAL(op2->u.constant);
constant         1413 Zend/zend_compile.c 		efree(Z_STRVAL(op2->u.constant));
constant         1414 Zend/zend_compile.c 		ZVAL_LONG(&op2->u.constant, ch);
constant         1418 Zend/zend_compile.c 		efree(Z_STRVAL(op2->u.constant));
constant         1505 Zend/zend_compile.c 		zval_dtor(&op1->u.constant);
constant         1512 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
constant         1513 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
constant         1516 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
constant         1517 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
constant         1520 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
constant         1521 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
constant         1524 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
constant         1525 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
constant         1528 Zend/zend_compile.c 	if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
constant         1531 Zend/zend_compile.c 	return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
constant         1538 Zend/zend_compile.c 	char *name = Z_STRVAL(function_name->u.constant);
constant         1539 Zend/zend_compile.c 	int name_len = Z_STRLEN(function_name->u.constant);
constant         1548 Zend/zend_compile.c 			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
constant         1549 Zend/zend_compile.c 				zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
constant         1551 Zend/zend_compile.c 			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
constant         1553 Zend/zend_compile.c 		fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
constant         1558 Zend/zend_compile.c 		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
constant         1718 Zend/zend_compile.c 			tmp.u.constant = *CG(current_namespace);
constant         1719 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
constant         1721 Zend/zend_compile.c 			op_array.function_name = Z_STRVAL(tmp.u.constant);
constant         1722 Zend/zend_compile.c 			name_len = Z_STRLEN(tmp.u.constant);
constant         1723 Zend/zend_compile.c 			lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
constant         1730 Zend/zend_compile.c 		    zend_hash_find(CG(current_import_function), lcname, Z_STRLEN(function_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
constant         1734 Zend/zend_compile.c 			if (Z_STRLEN_PP(ns_name) != Z_STRLEN(function_name->u.constant) ||
constant         1735 Zend/zend_compile.c 				memcmp(tmp, lcname, Z_STRLEN(function_name->u.constant))) {
constant         1736 Zend/zend_compile.c 				zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
constant         1744 Zend/zend_compile.c 		opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
constant         1745 Zend/zend_compile.c 		Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
constant         1748 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline->op2.constant);
constant         1750 Zend/zend_compile.c 		zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
constant         1802 Zend/zend_compile.c 	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
constant         1811 Zend/zend_compile.c 	zend_del_literal(current_op_array, current_op->op2.constant);
constant         1871 Zend/zend_compile.c 	if (zend_is_auto_global(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant) TSRMLS_CC)) {
constant         1872 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
constant         1875 Zend/zend_compile.c 		var.u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), 0 TSRMLS_CC);
constant         1876 Zend/zend_compile.c 		Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name;
constant         1879 Zend/zend_compile.c 			Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
constant         1880 Zend/zend_compile.c 		    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
constant         1918 Zend/zend_compile.c 	cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC);
constant         1919 Zend/zend_compile.c 	cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
constant         1930 Zend/zend_compile.c 		if (class_type->u.constant.type != IS_NULL) {
constant         1931 Zend/zend_compile.c 			if (class_type->u.constant.type == IS_ARRAY) {
constant         1934 Zend/zend_compile.c 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
constant         1936 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
constant         1939 Zend/zend_compile.c 					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) {
constant         1943 Zend/zend_compile.c 			} else if (class_type->u.constant.type == IS_CALLABLE) {
constant         1946 Zend/zend_compile.c 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
constant         1948 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
constant         1957 Zend/zend_compile.c 				if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
constant         1960 Zend/zend_compile.c 				Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant) + 1, 1 TSRMLS_CC);
constant         1961 Zend/zend_compile.c 				cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
constant         1962 Zend/zend_compile.c 				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
constant         1964 Zend/zend_compile.c 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
constant         1966 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
constant         1983 Zend/zend_compile.c 	char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
constant         1997 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
constant         1998 Zend/zend_compile.c 	if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) ||
constant         2005 Zend/zend_compile.c 	efree(Z_STRVAL(function_name->u.constant));
constant         2006 Zend/zend_compile.c 	Z_STRVAL(function_name->u.constant) = lcname;
constant         2028 Zend/zend_compile.c 	if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1)
constant         2029 Zend/zend_compile.c 		&& !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
constant         2036 Zend/zend_compile.c 			name = CONSTANT(last_op->op2.constant);
constant         2041 Zend/zend_compile.c 			FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
constant         2042 Zend/zend_compile.c 			last_op->op2.constant =
constant         2044 Zend/zend_compile.c 			GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
constant         2049 Zend/zend_compile.c 		Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
constant         2057 Zend/zend_compile.c 			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC);
constant         2058 Zend/zend_compile.c 			GET_CACHE_SLOT(opline->op2.constant);
constant         2097 Zend/zend_compile.c 		opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
constant         2098 Zend/zend_compile.c 		GET_CACHE_SLOT(opline->op2.constant);
constant         2105 Zend/zend_compile.c 			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
constant         2106 Zend/zend_compile.c 			GET_CACHE_SLOT(opline->op2.constant);
constant         2125 Zend/zend_compile.c 	char *lookup_name, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
constant         2127 Zend/zend_compile.c 	if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
constant         2129 Zend/zend_compile.c 		memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
constant         2130 Zend/zend_compile.c 		--Z_STRLEN(element_name->u.constant);
constant         2139 Zend/zend_compile.c 		len = Z_STRLEN(element_name->u.constant)+1;
constant         2141 Zend/zend_compile.c 			lookup_name = estrndup(Z_STRVAL(element_name->u.constant), len);
constant         2143 Zend/zend_compile.c 			lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
constant         2147 Zend/zend_compile.c 			zval_dtor(&element_name->u.constant);
constant         2148 Zend/zend_compile.c 			element_name->u.constant = **ns;
constant         2149 Zend/zend_compile.c 			zval_copy_ctor(&element_name->u.constant);
constant         2158 Zend/zend_compile.c 		len = compound - Z_STRVAL(element_name->u.constant);
constant         2160 Zend/zend_compile.c 		lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
constant         2165 Zend/zend_compile.c 			tmp.u.constant = **ns;
constant         2166 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
constant         2168 Zend/zend_compile.c 			Z_STRLEN(element_name->u.constant) -= len;
constant         2169 Zend/zend_compile.c 			memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
constant         2181 Zend/zend_compile.c 		Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
constant         2182 Zend/zend_compile.c 		Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
constant         2183 Zend/zend_compile.c 		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
constant         2184 Zend/zend_compile.c 		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1);
constant         2185 Zend/zend_compile.c 		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
constant         2186 Zend/zend_compile.c 		str_efree(Z_STRVAL(element_name->u.constant));
constant         2210 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
constant         2218 Zend/zend_compile.c 				zval_dtor(&class_name->u.constant);
constant         2220 Zend/zend_compile.c 				ZVAL_STRINGL(&constant_name.u.constant, "__CLASS__", sizeof("__CLASS__")-1, 1);
constant         2223 Zend/zend_compile.c 					result->u.constant.type = IS_CONSTANT;
constant         2229 Zend/zend_compile.c 			zval_dtor(&class_name->u.constant);
constant         2231 Zend/zend_compile.c 			ZVAL_STRINGL(&class_name->u.constant, CG(active_class_entry)->name, CG(active_class_entry)->name_length, 1);
constant         2249 Zend/zend_compile.c 			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1);
constant         2271 Zend/zend_compile.c 	compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
constant         2274 Zend/zend_compile.c 		if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
constant         2276 Zend/zend_compile.c 			Z_STRLEN(class_name->u.constant) -= 1;
constant         2277 Zend/zend_compile.c 			memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1);
constant         2278 Zend/zend_compile.c 			Z_STRVAL(class_name->u.constant) = erealloc(
constant         2279 Zend/zend_compile.c 			Z_STRVAL(class_name->u.constant),
constant         2280 Zend/zend_compile.c 			Z_STRLEN(class_name->u.constant) + 1);
constant         2282 Zend/zend_compile.c 			if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
constant         2283 Zend/zend_compile.c 				zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
constant         2287 Zend/zend_compile.c 				len = compound - Z_STRVAL(class_name->u.constant);
constant         2288 Zend/zend_compile.c 				lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len);
constant         2293 Zend/zend_compile.c 					tmp.u.constant = **ns;
constant         2294 Zend/zend_compile.c 					zval_copy_ctor(&tmp.u.constant);
constant         2296 Zend/zend_compile.c 					Z_STRLEN(class_name->u.constant) -= len;
constant         2297 Zend/zend_compile.c 					memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
constant         2308 Zend/zend_compile.c 				tmp.u.constant = *CG(current_namespace);
constant         2309 Zend/zend_compile.c 				zval_copy_ctor(&tmp.u.constant);
constant         2316 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
constant         2319 Zend/zend_compile.c 		    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) {
constant         2321 Zend/zend_compile.c 			zval_dtor(&class_name->u.constant);
constant         2322 Zend/zend_compile.c 			class_name->u.constant = **ns;
constant         2323 Zend/zend_compile.c 			zval_copy_ctor(&class_name->u.constant);
constant         2327 Zend/zend_compile.c 			tmp.u.constant = *CG(current_namespace);
constant         2328 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
constant         2352 Zend/zend_compile.c 		fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
constant         2359 Zend/zend_compile.c 				zval_dtor(&class_name->u.constant);
constant         2364 Zend/zend_compile.c 				opline->op2.constant =
constant         2365 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC);
constant         2390 Zend/zend_compile.c 	if (zend_hash_add(CG(context).labels, Z_STRVAL(label->u.constant), Z_STRLEN(label->u.constant) + 1, (void**)&dest, sizeof(zend_label), NULL) == FAILURE) {
constant         2391 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
constant         2395 Zend/zend_compile.c 	zval_dtor(&label->u.constant);
constant         2408 Zend/zend_compile.c 		label = &CONSTANT_EX(op_array, opline->op2.constant);
constant         2499 Zend/zend_compile.c 		length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
constant         2500 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
constant         2501 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1);
constant         2502 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
constant         2503 Zend/zend_compile.c 		str_efree(Z_STRVAL(name->u.constant));
constant         2504 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = length;
constant         2506 Zend/zend_compile.c 		length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
constant         2507 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
constant         2508 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1);
constant         2509 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
constant         2510 Zend/zend_compile.c 		str_efree(Z_STRVAL(name->u.constant));
constant         2511 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = length;
constant         2523 Zend/zend_compile.c 		if (Z_TYPE(method_name->u.constant) != IS_STRING) {
constant         2526 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
constant         2527 Zend/zend_compile.c 		if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
constant         2529 Zend/zend_compile.c 			zval_dtor(&method_name->u.constant);
constant         2536 Zend/zend_compile.c 	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
constant         2549 Zend/zend_compile.c 		opline->op1.constant =
constant         2550 Zend/zend_compile.c 			zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
constant         2556 Zend/zend_compile.c 		opline->op2.constant =
constant         2557 Zend/zend_compile.c 			zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC);
constant         2559 Zend/zend_compile.c 			GET_CACHE_SLOT(opline->op2.constant);
constant         2561 Zend/zend_compile.c 			GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
constant         2587 Zend/zend_compile.c 		opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
constant         2595 Zend/zend_compile.c 			CALCULATE_LITERAL_HASH(opline->op1.constant);
constant         2596 Zend/zend_compile.c 			GET_CACHE_SLOT(opline->op1.constant);
constant         2607 Zend/zend_compile.c 				zval_dtor(&function_name->u.constant);
constant         2760 Zend/zend_compile.c 		opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &func_name TSRMLS_CC);
constant         2761 Zend/zend_compile.c 		GET_CACHE_SLOT(opline->op2.constant);
constant         3013 Zend/zend_compile.c 	    ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
constant         3028 Zend/zend_compile.c 	opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
constant         3030 Zend/zend_compile.c 	opline->op2.var = lookup_cv(CG(active_op_array), Z_STRVAL(catch_var->u.constant), Z_STRLEN(catch_var->u.constant), 0 TSRMLS_CC);
constant         3031 Zend/zend_compile.c 	Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name;
constant         4595 Zend/zend_compile.c 		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
constant         4596 Zend/zend_compile.c 		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
constant         4635 Zend/zend_compile.c 		method_ref->class_name = Z_STRVAL(class_name->u.constant);
constant         4636 Zend/zend_compile.c 		method_ref->cname_len  = Z_STRLEN(class_name->u.constant);
constant         4642 Zend/zend_compile.c 	method_ref->method_name = Z_STRVAL(method_name->u.constant);
constant         4643 Zend/zend_compile.c 	method_ref->mname_len   = Z_STRLEN(method_name->u.constant);
constant         4655 Zend/zend_compile.c 	if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
constant         4658 Zend/zend_compile.c 	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
constant         4661 Zend/zend_compile.c 	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
constant         4668 Zend/zend_compile.c 	trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
constant         4670 Zend/zend_compile.c 		trait_alias->alias = Z_STRVAL(alias->u.constant);
constant         4671 Zend/zend_compile.c 		trait_alias->alias_len = Z_STRLEN(alias->u.constant);
constant         4697 Zend/zend_compile.c 		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
constant         4698 Zend/zend_compile.c 		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
constant         4737 Zend/zend_compile.c 		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
constant         4738 Zend/zend_compile.c 		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
constant         4806 Zend/zend_compile.c 				parent_name = &CONSTANT(fetch_class_opline->op2.constant);
constant         4827 Zend/zend_compile.c 				zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
constant         4845 Zend/zend_compile.c 	zend_hash_quick_del(table, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)), Z_HASH_P(&CONSTANT(opline->op1.constant)));
constant         4846 Zend/zend_compile.c 	zend_del_literal(CG(active_op_array), opline->op1.constant);
constant         4847 Zend/zend_compile.c 	zend_del_literal(CG(active_op_array), opline->op2.constant);
constant         4973 Zend/zend_compile.c 		} else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
constant         5033 Zend/zend_compile.c 		zval_dtor(&switch_entry_ptr->cond.u.constant);
constant         5060 Zend/zend_compile.c 		zval_copy_ctor(&CONSTANT(opline->op1.constant));
constant         5137 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
constant         5141 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
constant         5146 Zend/zend_compile.c 	    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
constant         5155 Zend/zend_compile.c 		tmp.u.constant = *CG(current_namespace);
constant         5156 Zend/zend_compile.c 		zval_copy_ctor(&tmp.u.constant);
constant         5160 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
constant         5166 Zend/zend_compile.c 		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||
constant         5167 Zend/zend_compile.c 			memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {
constant         5168 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
constant         5175 Zend/zend_compile.c 	new_class_entry->name = zend_new_interned_string(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant) + 1, 1 TSRMLS_CC);
constant         5176 Zend/zend_compile.c 	new_class_entry->name_length = Z_STRLEN(class_name->u.constant);
constant         5203 Zend/zend_compile.c 	opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
constant         5204 Zend/zend_compile.c 	Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
constant         5221 Zend/zend_compile.c 	CALCULATE_LITERAL_HASH(opline->op2.constant);
constant         5223 Zend/zend_compile.c 	zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL);
constant         5318 Zend/zend_compile.c 							 Z_STRVAL(interface_name->u.constant),
constant         5322 Zend/zend_compile.c 	switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
constant         5326 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
constant         5338 Zend/zend_compile.c 	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC);
constant         5350 Zend/zend_compile.c 				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name);
constant         5354 Zend/zend_compile.c 	switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) {
constant         5358 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant));
constant         5370 Zend/zend_compile.c 	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC);
constant         5456 Zend/zend_compile.c 				   CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
constant         5459 Zend/zend_compile.c 	if (zend_hash_find(&CG(active_class_entry)->properties_info, Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, (void **) &existing_property_info)==SUCCESS) {
constant         5460 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
constant         5465 Zend/zend_compile.c 		*property = value->u.constant;
constant         5478 Zend/zend_compile.c 	zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant) + 1, 0 TSRMLS_CC), Z_STRLEN(var_name->u.constant), property, access_type, comment, comment_len TSRMLS_CC);
constant         5479 Zend/zend_compile.c 	efree(Z_STRVAL(var_name->u.constant));
constant         5495 Zend/zend_compile.c 	*property = value->u.constant;
constant         5497 Zend/zend_compile.c 	cname = zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, 0 TSRMLS_CC);
constant         5498 Zend/zend_compile.c 	hash = str_hash(cname, Z_STRLEN(var_name->u.constant));
constant         5499 Zend/zend_compile.c 	if (zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, hash, &property, sizeof(zval *), NULL) == FAILURE) {
constant         5501 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
constant         5529 Zend/zend_compile.c 			zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
constant         5553 Zend/zend_compile.c 			if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
constant         5554 Zend/zend_compile.c 				CALCULATE_LITERAL_HASH(opline_ptr->op2.constant);
constant         5555 Zend/zend_compile.c 				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
constant         5578 Zend/zend_compile.c 	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
constant         5579 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline.op2.constant);
constant         5580 Zend/zend_compile.c 		GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
constant         5709 Zend/zend_compile.c 		result->u.constant = c->value;
constant         5710 Zend/zend_compile.c 		zval_copy_ctor(&result->u.constant);
constant         5711 Zend/zend_compile.c 		INIT_PZVAL(&result->u.constant);
constant         5730 Zend/zend_compile.c 				type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
constant         5739 Zend/zend_compile.c 				result->u.constant.type = IS_CONSTANT | fetch_type;
constant         5743 Zend/zend_compile.c 				ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
constant         5755 Zend/zend_compile.c 					opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC);
constant         5760 Zend/zend_compile.c 				CALCULATE_LITERAL_HASH(opline->op2.constant);
constant         5762 Zend/zend_compile.c 					GET_CACHE_SLOT(opline->op2.constant);
constant         5764 Zend/zend_compile.c 					GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
constant         5775 Zend/zend_compile.c 			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
constant         5778 Zend/zend_compile.c 			if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
constant         5789 Zend/zend_compile.c 			result->u.constant.type = IS_CONSTANT | fetch_type;
constant         5792 Zend/zend_compile.c 			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
constant         5796 Zend/zend_compile.c 			if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
constant         5810 Zend/zend_compile.c 				opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
constant         5815 Zend/zend_compile.c 					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
constant         5817 Zend/zend_compile.c 					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
constant         5820 Zend/zend_compile.c 			GET_CACHE_SLOT(opline->op2.constant);
constant         5850 Zend/zend_compile.c 	CALCULATE_LITERAL_HASH(opline->op1.constant);
constant         5852 Zend/zend_compile.c 	GET_CACHE_SLOT(opline->op1.constant);
constant         5879 Zend/zend_compile.c 			if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
constant         5883 Zend/zend_compile.c 				ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
constant         5885 Zend/zend_compile.c 					zval_dtor(&CONSTANT(opline->op2.constant));
constant         5886 Zend/zend_compile.c 					ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
constant         5888 Zend/zend_compile.c 					CALCULATE_LITERAL_HASH(opline->op2.constant);
constant         5911 Zend/zend_compile.c 		if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
constant         5915 Zend/zend_compile.c 			ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
constant         5917 Zend/zend_compile.c 				zval_dtor(&CONSTANT(opline->op2.constant));
constant         5918 Zend/zend_compile.c 				ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
constant         5920 Zend/zend_compile.c 				CALCULATE_LITERAL_HASH(opline->op2.constant);
constant         6021 Zend/zend_compile.c 						zval_copy_ctor(&expr->u.constant);
constant         6101 Zend/zend_compile.c 		*tmp = static_assignment->u.constant;
constant         6112 Zend/zend_compile.c 	zend_hash_update(CG(active_op_array)->static_variables, Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)+1, &tmp, sizeof(zval *), NULL);
constant         6115 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
constant         6116 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
constant         6126 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline->op1.constant);
constant         6133 Zend/zend_compile.c 		zval_copy_ctor(&varname->u.constant);
constant         6154 Zend/zend_compile.c 	if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
constant         6155 Zend/zend_compile.c 	    memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
constant         6161 Zend/zend_compile.c 	ZVAL_NULL(&value.u.constant);
constant         6162 Zend/zend_compile.c 	Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
constant         6163 Zend/zend_compile.c 	Z_SET_REFCOUNT_P(&value.u.constant, 1);
constant         6164 Zend/zend_compile.c 	Z_UNSET_ISREF_P(&value.u.constant);
constant         6177 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
constant         6178 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
constant         6188 Zend/zend_compile.c 		CALCULATE_LITERAL_HASH(opline->op1.constant);
constant         6195 Zend/zend_compile.c 		zval_copy_ctor(&varname->u.constant);
constant         6241 Zend/zend_compile.c 	for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
constant         6547 Zend/zend_compile.c 	if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
constant         6548 Zend/zend_compile.c 		convert_to_long(&val->u.constant);
constant         6549 Zend/zend_compile.c 		CG(declarables).ticks = val->u.constant;
constant         6550 Zend/zend_compile.c 	} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
constant         6551 Zend/zend_compile.c 		if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
constant         6581 Zend/zend_compile.c 			convert_to_string(&val->u.constant);
constant         6582 Zend/zend_compile.c 			new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
constant         6584 Zend/zend_compile.c 				zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
constant         6599 Zend/zend_compile.c 		zval_dtor(&val->u.constant);
constant         6601 Zend/zend_compile.c 		zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
constant         6602 Zend/zend_compile.c 		zval_dtor(&val->u.constant);
constant         6604 Zend/zend_compile.c 	zval_dtor(&var->u.constant);
constant         6629 Zend/zend_compile.c 	Z_TYPE(result->u.constant) = IS_BOOL;
constant         6630 Zend/zend_compile.c 	Z_LVAL(result->u.constant) = 1;
constant         6910 Zend/zend_compile.c 	Z_TYPE(zendlval->u.constant) = IS_LONG;
constant         6911 Zend/zend_compile.c 	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
constant         6933 Zend/zend_compile.c 	INIT_PZVAL(&zendlval->u.constant);
constant         7042 Zend/zend_compile.c 		if (Z_TYPE(result->u.constant) == IS_STRING &&
constant         7043 Zend/zend_compile.c 		    Z_STRLEN(result->u.constant) == 0) {
constant         7048 Zend/zend_compile.c 				zval_dtor(&result->u.constant);
constant         7050 Zend/zend_compile.c 				tmp.u.constant = *CG(current_namespace);
constant         7051 Zend/zend_compile.c 				zval_copy_ctor(&tmp.u.constant);
constant         7057 Zend/zend_compile.c 		Z_TYPE(result->u.constant) = IS_STRING;
constant         7058 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = NULL;
constant         7059 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = 0;
constant         7106 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
constant         7107 Zend/zend_compile.c 		if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
constant         7109 Zend/zend_compile.c 		    ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
constant         7111 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
constant         7120 Zend/zend_compile.c 		*CG(current_namespace) = name->u.constant;
constant         7168 Zend/zend_compile.c 	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
constant         7170 Zend/zend_compile.c 		name = &new_name->u.constant;
constant         7245 Zend/zend_compile.c 	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
constant         7247 Zend/zend_compile.c 		name = &new_name->u.constant;
constant         7350 Zend/zend_compile.c 	if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
constant         7351 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
constant         7359 Zend/zend_compile.c 		tmp.u.constant = *CG(current_namespace);
constant         7360 Zend/zend_compile.c 		Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
constant         7367 Zend/zend_compile.c 	    zend_hash_find(CG(current_import_const), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
constant         7371 Zend/zend_compile.c 		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(name->u.constant) ||
constant         7372 Zend/zend_compile.c 			memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
constant         7373 Zend/zend_compile.c 			zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant));
constant         7384 Zend/zend_compile.c 	zend_hash_add(&CG(const_filenames), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, CG(compiled_filename), strlen(CG(compiled_filename))+1, NULL);
constant         7432 Zend/zend_compile.c 		result->u.constant = *ast->u.val;
constant         7435 Zend/zend_compile.c 		zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
constant         7438 Zend/zend_compile.c 		Z_TYPE(result->u.constant) = IS_CONSTANT_AST;
constant         7439 Zend/zend_compile.c 		Z_AST(result->u.constant) = ast;
constant           36 Zend/zend_compile.h #define FREE_PNODE(znode)	zval_dtor(&znode->u.constant);
constant           70 Zend/zend_compile.h 	zval       constant;
constant           79 Zend/zend_compile.h 	zend_uint      constant;
constant           94 Zend/zend_compile.h 		zval constant; /* replaced by literal/zv */
constant          442 Zend/zend_constants.c 	if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
constant          444 Zend/zend_constants.c 		if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
constant          448 Zend/zend_constants.c 				if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
constant          450 Zend/zend_constants.c 					if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
constant          454 Zend/zend_constants.c 						if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
constant          461 Zend/zend_constants.c 				if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
constant          614 Zend/zend_execute.c 		zval constant = *default_value;
constant          615 Zend/zend_execute.c 		zval *constant_ptr = &constant;
constant          618 Zend/zend_execute.c 		if (Z_TYPE(constant) == IS_NULL) {
constant          621 Zend/zend_execute.c 		zval_dtor(&constant);
constant          919 Zend/zend_execute_API.c 		lc_name = Z_STRVAL(key->constant);
constant          920 Zend/zend_execute_API.c 		lc_length = Z_STRLEN(key->constant) + 1;
constant         1155 Zend/zend_execute_API.c 	ret_opline->op1.constant = zend_add_literal(CG(active_op_array), &EG(uninitialized_zval) TSRMLS_CC);
constant         1167 Zend/zend_execute_API.c 			opline->op1.zv = &CG(active_op_array)->literals[opline->op1.constant].constant;
constant         1170 Zend/zend_execute_API.c 			opline->op2.zv = &CG(active_op_array)->literals[opline->op2.constant].constant;
constant          574 Zend/zend_language_parser.y 	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_ARRAY; }
constant          575 Zend/zend_language_parser.y 	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_CALLABLE; }
constant          581 Zend/zend_language_parser.y 		'(' ')'	{ Z_LVAL($$.u.constant) = 0; }
constant          689 Zend/zend_language_parser.y 		/* empty */					{ Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */
constant          694 Zend/zend_language_parser.y 		';' /* abstract method */		{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
constant          695 Zend/zend_language_parser.y 	|	'{' inner_statement_list '}'	{ Z_LVAL($$.u.constant) = 0;	}
constant          700 Zend/zend_language_parser.y 	|	T_VAR							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
constant          704 Zend/zend_language_parser.y 		/* empty */							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
constant          705 Zend/zend_language_parser.y 	|	non_empty_member_modifiers			{ $$ = $1;  if (!(Z_LVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_LVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } }
constant          710 Zend/zend_language_parser.y 	|	non_empty_member_modifiers member_modifier	{ Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); }
constant          714 Zend/zend_language_parser.y 		T_PUBLIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
constant          715 Zend/zend_language_parser.y 	|	T_PROTECTED				{ Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; }
constant          716 Zend/zend_language_parser.y 	|	T_PRIVATE				{ Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; }
constant          717 Zend/zend_language_parser.y 	|	T_STATIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; }
constant          718 Zend/zend_language_parser.y 	|	T_ABSTRACT				{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
constant          719 Zend/zend_language_parser.y 	|	T_FINAL					{ Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; }
constant          741 Zend/zend_language_parser.y 		/* empty */			{ $$.op_type = IS_CONST;  Z_TYPE($$.u.constant) = IS_BOOL;  Z_LVAL($$.u.constant) = 1; }
constant          915 Zend/zend_language_parser.y 		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1, 1);}
constant          917 Zend/zend_language_parser.y 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
constant          923 Zend/zend_language_parser.y 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
constant          960 Zend/zend_language_parser.y 		/* empty */	{ ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; }
constant          967 Zend/zend_language_parser.y 		/* empty */	{ Z_LVAL($$.u.constant) = 0; }
constant          984 Zend/zend_language_parser.y 	|	T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; }
constant          998 Zend/zend_language_parser.y 	|	namespace_name 		{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
constant          999 Zend/zend_language_parser.y 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
constant         1000 Zend/zend_language_parser.y 	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
constant         1047 Zend/zend_language_parser.y 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); }
constant         1062 Zend/zend_language_parser.y 		/* empty */ { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
constant         1206 Zend/zend_language_parser.y 		'$' { Z_LVAL($$.u.constant) = 1; }
constant         1207 Zend/zend_language_parser.y 	|	simple_indirect_reference '$' { Z_LVAL($$.u.constant)++; }
constant          567 Zend/zend_language_scanner.c 	INIT_PZVAL(&retval_znode.u.constant);
constant          568 Zend/zend_language_scanner.c 	ZVAL_LONG(&retval_znode.u.constant, 1);
constant         1047 Zend/zend_object_handlers.c 		lc_method_name = Z_STRVAL(key->constant);
constant         1187 Zend/zend_object_handlers.c 		lc_function_name = Z_STRVAL(key->constant);
constant          387 Zend/zend_opcode.c 			zval_dtor(&literal->constant);
constant          685 Zend/zend_opcode.c 				nest_levels = Z_LVAL(op_array->literals[opline->op2.constant].constant);
constant          698 Zend/zend_opcode.c 				if (Z_TYPE(op_array->literals[opline->op2.constant].constant) != IS_LONG) {
constant          699 Zend/zend_opcode.c 					zend_uint num = opline->op2.constant;
constant          700 Zend/zend_opcode.c 					opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
constant          702 Zend/zend_opcode.c 					opline->op2.constant = num;					
constant          754 Zend/zend_opcode.c 			opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
constant          757 Zend/zend_opcode.c 			opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
constant         2798 Zend/zend_vm_def.h 	} else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
constant         2800 Zend/zend_vm_def.h 		if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
constant         1601 Zend/zend_vm_execute.h 	} else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
constant         1603 Zend/zend_vm_execute.h 		if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
constant         1370 ext/opcache/Optimizer/block_pass.c 						last_op->op1.constant = zend_optimizer_add_literal(op_array, &zv TSRMLS_CC);
constant         1406 ext/opcache/Optimizer/block_pass.c 						last_op->op1.constant = zend_optimizer_add_literal(op_array, &zv TSRMLS_CC);
constant           56 ext/opcache/Optimizer/compact_literals.c                                        int             constant,
constant           66 ext/opcache/Optimizer/compact_literals.c 	if (Z_TYPE(op_array->literals[constant].constant) == IS_STRING &&
constant           68 ext/opcache/Optimizer/compact_literals.c 		LITERAL_INFO_OBJ(constant, kind, 1, slots, related, op_array->this_var);
constant           70 ext/opcache/Optimizer/compact_literals.c 		LITERAL_INFO(constant, kind, 0, slots, related);
constant           77 ext/opcache/Optimizer/compact_literals.c                                          int             constant,
constant           84 ext/opcache/Optimizer/compact_literals.c 		LITERAL_INFO_CLASS(constant, kind, 1, slots, related, op.constant);
constant           86 ext/opcache/Optimizer/compact_literals.c 		LITERAL_INFO(constant, kind, 0, slots, related);
constant          112 ext/opcache/Optimizer/compact_literals.c 					LITERAL_INFO(opline->op1.constant, LITERAL_FUNC, 1, 1, 1);
constant          116 ext/opcache/Optimizer/compact_literals.c 						LITERAL_INFO(opline->op2.constant, LITERAL_FUNC, 1, 1, 2);
constant          120 ext/opcache/Optimizer/compact_literals.c 					LITERAL_INFO(opline->op2.constant, LITERAL_FUNC, 1, 1, 3);
constant          128 ext/opcache/Optimizer/compact_literals.c 							opline->op2.constant,
constant          135 ext/opcache/Optimizer/compact_literals.c 						LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2);
constant          142 ext/opcache/Optimizer/compact_literals.c 							opline->op2.constant,
constant          148 ext/opcache/Optimizer/compact_literals.c 					LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2);
constant          153 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op2.constant, LITERAL_CONST, 1, 1, 5);
constant          155 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op2.constant, LITERAL_CONST, 1, 1, 3);
constant          159 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2);
constant          165 ext/opcache/Optimizer/compact_literals.c 							opline->op2.constant,
constant          180 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1);
constant          184 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 1, 1, 2);
constant          191 ext/opcache/Optimizer/compact_literals.c 								opline->op1.constant,
constant          201 ext/opcache/Optimizer/compact_literals.c 						LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 1, 1, 2);
constant          222 ext/opcache/Optimizer/compact_literals.c 							opline->op2.constant,
constant          244 ext/opcache/Optimizer/compact_literals.c 								opline->op2.constant,
constant          248 ext/opcache/Optimizer/compact_literals.c 							LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1, 0, 1);
constant          254 ext/opcache/Optimizer/compact_literals.c 						LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1);
constant          257 ext/opcache/Optimizer/compact_literals.c 						LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1, 0, 1);
constant          272 ext/opcache/Optimizer/compact_literals.c 				zval zv = op_array->literals[i].constant;
constant          273 ext/opcache/Optimizer/compact_literals.c 				zend_make_printable_zval(&op_array->literals[i].constant, &zv, &use_copy);
constant          290 ext/opcache/Optimizer/compact_literals.c 				zval_dtor(&op_array->literals[i].constant);
constant          293 ext/opcache/Optimizer/compact_literals.c 			switch (Z_TYPE(op_array->literals[i].constant)) {
constant          306 ext/opcache/Optimizer/compact_literals.c 					if (Z_LVAL(op_array->literals[i].constant)) {
constant          329 ext/opcache/Optimizer/compact_literals.c 					if (zend_hash_index_find(&hash, Z_LVAL(op_array->literals[i].constant), (void**)&pos) == SUCCESS) {
constant          333 ext/opcache/Optimizer/compact_literals.c 						zend_hash_index_update(&hash, Z_LVAL(op_array->literals[i].constant), (void**)&j, sizeof(int), NULL);
constant          342 ext/opcache/Optimizer/compact_literals.c 					if (zend_hash_find(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double), (void**)&pos) == SUCCESS) {
constant          346 ext/opcache/Optimizer/compact_literals.c 						zend_hash_add(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double), (void**)&j, sizeof(int), NULL);
constant          358 ext/opcache/Optimizer/compact_literals.c 							key_len = MAX_LENGTH_OF_LONG + sizeof("->") + Z_STRLEN(op_array->literals[i].constant);
constant          360 ext/opcache/Optimizer/compact_literals.c 							key_len = snprintf(key, key_len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i].constant));
constant          362 ext/opcache/Optimizer/compact_literals.c 							zval *class_name = &op_array->literals[(info[i].u.num < i) ? map[info[i].u.num] : info[i].u.num].constant;
constant          363 ext/opcache/Optimizer/compact_literals.c 							key_len = Z_STRLEN_P(class_name) + sizeof("::") + Z_STRLEN(op_array->literals[i].constant);
constant          368 ext/opcache/Optimizer/compact_literals.c 								Z_STRVAL(op_array->literals[i].constant),
constant          369 ext/opcache/Optimizer/compact_literals.c 								Z_STRLEN(op_array->literals[i].constant) + 1);
constant          371 ext/opcache/Optimizer/compact_literals.c 							key = Z_STRVAL(op_array->literals[i].constant);
constant          372 ext/opcache/Optimizer/compact_literals.c 							key_len = Z_STRLEN(op_array->literals[i].constant)+1;
constant          379 ext/opcache/Optimizer/compact_literals.c 					   	Z_TYPE(op_array->literals[i].constant) == Z_TYPE(op_array->literals[*pos].constant) &&
constant          386 ext/opcache/Optimizer/compact_literals.c 						zval_dtor(&op_array->literals[i].constant);
constant          390 ext/opcache/Optimizer/compact_literals.c 							zval_dtor(&op_array->literals[i].constant);
constant          406 ext/opcache/Optimizer/compact_literals.c 							if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) {
constant          407 ext/opcache/Optimizer/compact_literals.c 								op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant));
constant          409 ext/opcache/Optimizer/compact_literals.c 								op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1);
constant          422 ext/opcache/Optimizer/compact_literals.c 								if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) {
constant          423 ext/opcache/Optimizer/compact_literals.c 									op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant));
constant          425 ext/opcache/Optimizer/compact_literals.c 									op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1);
constant          453 ext/opcache/Optimizer/compact_literals.c 				opline->op1.constant = map[opline->op1.constant];
constant          456 ext/opcache/Optimizer/compact_literals.c 				opline->op2.constant = map[opline->op2.constant];
constant          469 ext/opcache/Optimizer/compact_literals.c 				zval zv = op_array->literals[i].constant;
constant          470 ext/opcache/Optimizer/compact_literals.c 				zend_make_printable_zval(&op_array->literals[i].constant, &zv, &use_copy);
constant           28 ext/opcache/Optimizer/optimize_func_calls.c 					zval *function_name = &op_array->literals[opline->op2.constant + 1].constant;
constant           56 ext/opcache/Optimizer/optimize_func_calls.c 					opline->op1.constant = fcall->op2.constant + 1;
constant           57 ext/opcache/Optimizer/optimize_func_calls.c 					op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
constant           60 ext/opcache/Optimizer/optimize_func_calls.c 						literal_dtor(&op_array->literals[fcall->op2.constant + 2].constant);
constant           72 ext/opcache/Optimizer/optimize_func_calls.c 					opline->op1.constant = fcall->op2.constant + 1;
constant           73 ext/opcache/Optimizer/optimize_func_calls.c 					op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
constant          281 ext/opcache/Optimizer/pass1_5.c 								Z_STRVAL(op_array->literals[opline->op1.constant + 1].constant), 
constant          282 ext/opcache/Optimizer/pass1_5.c 								Z_STRLEN(op_array->literals[opline->op1.constant].constant) + 1, 
constant          283 ext/opcache/Optimizer/pass1_5.c 								Z_HASH_P(&op_array->literals[opline->op1.constant + 1].constant),
constant           98 ext/opcache/Optimizer/zend_optimizer.c 	op_array->literals[i].constant = *zv;
constant          101 ext/opcache/Optimizer/zend_optimizer.c 	Z_SET_REFCOUNT(op_array->literals[i].constant, 2);
constant          102 ext/opcache/Optimizer/zend_optimizer.c 	Z_SET_ISREF(op_array->literals[i].constant);
constant          109 ext/opcache/Optimizer/zend_optimizer.c 		op.constant = zend_optimizer_add_literal(op_array, &_c TSRMLS_CC); \
constant          115 ext/opcache/Optimizer/zend_optimizer.c 		op.constant = zend_optimizer_add_literal(op_array, &_c TSRMLS_CC); \
constant          130 ext/opcache/Optimizer/zend_optimizer.c # define LITERAL_LONG(op, val) ZVAL_LONG(&op.u.constant, val)
constant          132 ext/opcache/Optimizer/zend_optimizer.c # define LITERAL_BOOL(op, val) ZVAL_BOOL(&op.u.constant, val)
constant          157 ext/opcache/Optimizer/zend_optimizer.c 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
constant          159 ext/opcache/Optimizer/zend_optimizer.c 					op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
constant          162 ext/opcache/Optimizer/zend_optimizer.c 					op_array->literals[opline->op1.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op1.constant+1].constant), Z_STRLEN(op_array->literals[opline->op1.constant+1].constant) + 1);
constant          166 ext/opcache/Optimizer/zend_optimizer.c 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
constant          168 ext/opcache/Optimizer/zend_optimizer.c 					op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
constant          171 ext/opcache/Optimizer/zend_optimizer.c 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
constant          176 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
constant          190 ext/opcache/Optimizer/zend_optimizer.c 	opline->op2.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
constant          207 ext/opcache/Optimizer/zend_optimizer.c 				op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot++;
constant          210 ext/opcache/Optimizer/zend_optimizer.c 				op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
constant          216 ext/opcache/Optimizer/zend_optimizer.c 				op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
constant          232 ext/opcache/Optimizer/zend_optimizer.c 				op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
constant          247 ext/opcache/Optimizer/zend_optimizer.c 					op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
constant          290 ext/opcache/Optimizer/zend_optimizer.c 						op_array->literals[opline->op2.constant].constant = *val;
constant          553 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.constant = opline->op1.literal - op_array->literals;
constant          556 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.constant = opline->op2.literal - op_array->literals;
constant          594 ext/opcache/Optimizer/zend_optimizer.c 			opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
constant          597 ext/opcache/Optimizer/zend_optimizer.c 			opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
constant         1506 ext/opcache/ZendAccelerator.c  	     ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
constant         1507 ext/opcache/ZendAccelerator.c  	      (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
constant         1665 ext/opcache/ZendAccelerator.c  			    ((*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_INCLUDE_ONCE &&
constant         1666 ext/opcache/ZendAccelerator.c  			     (*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_REQUIRE_ONCE)) {
constant         1847 ext/opcache/ZendAccelerator.c                 (opline->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
constant         1848 ext/opcache/ZendAccelerator.c                  opline->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE)) {
constant         1858 ext/opcache/ZendAccelerator.c 					filename_len = Z_STRLEN(opline->op1.u.constant);
constant         1949 ext/opcache/ZendAccelerator.c               ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
constant         1950 ext/opcache/ZendAccelerator.c                (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
constant         2014 ext/opcache/ZendAccelerator.c               ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
constant         2015 ext/opcache/ZendAccelerator.c                (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
constant          370 ext/opcache/ZendAccelerator.h # define ZEND_OP1_LITERAL(opline)	(op_array)->literals[(opline)->op1.constant].constant
constant          374 ext/opcache/ZendAccelerator.h # define ZEND_OP2_LITERAL(opline)	(op_array)->literals[(opline)->op2.constant].constant
constant          388 ext/opcache/ZendAccelerator.h # define ZEND_OP1_CONST(opline)		(opline)->op1.u.constant
constant          389 ext/opcache/ZendAccelerator.h # define ZEND_OP1_LITERAL(opline)	(opline)->op1.u.constant
constant          392 ext/opcache/ZendAccelerator.h # define ZEND_OP2_CONST(opline)		(opline)->op2.u.constant
constant          393 ext/opcache/ZendAccelerator.h # define ZEND_OP2_LITERAL(opline)	(opline)->op2.u.constant
constant          303 ext/opcache/zend_accelerator_module.c 	if (zend_hash_find(EG(class_table), Z_STRVAL(EX(opline)->op2.u.constant), Z_STRLEN(EX(opline)->op2.u.constant) + 1, (void **)&pce) == FAILURE ||
constant          304 ext/opcache/zend_accelerator_module.c 	    (zend_hash_find(EG(class_table), Z_STRVAL(EX(opline)->op1.u.constant), Z_STRLEN(EX(opline)->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
constant          987 ext/opcache/zend_accelerator_util_funcs.c 			if (zend_lookup_class(Z_STRVAL(op_array->opcodes[opline_num - 1].op2.u.constant), Z_STRLEN(op_array->opcodes[opline_num - 1].op2.u.constant), &pce TSRMLS_CC) == SUCCESS) {
constant          266 ext/opcache/zend_persist.c 				zend_persist_zval(&p->constant TSRMLS_CC);
constant          267 ext/opcache/zend_persist.c 				zend_protect_zval(&p->constant TSRMLS_CC);
constant          288 ext/opcache/zend_persist.c 				zend_persist_zval(&opline->op1.u.constant TSRMLS_CC);
constant          289 ext/opcache/zend_persist.c 				zend_protect_zval(&opline->op1.u.constant TSRMLS_CC);
constant          296 ext/opcache/zend_persist.c 				zend_persist_zval(&opline->op2.u.constant TSRMLS_CC);
constant          297 ext/opcache/zend_persist.c 				zend_protect_zval(&opline->op2.u.constant TSRMLS_CC);
constant          177 ext/opcache/zend_persist_calc.c 			ADD_SIZE(zend_persist_zval_calc(&p->constant TSRMLS_CC));
constant          191 ext/opcache/zend_persist_calc.c 				ADD_SIZE(zend_persist_zval_calc(&opline->op1.u.constant TSRMLS_CC));
constant          194 ext/opcache/zend_persist_calc.c 				ADD_SIZE(zend_persist_zval_calc(&opline->op2.u.constant TSRMLS_CC));
constant         1054 ext/reflection/php_reflection.c static int _extension_const_string(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
constant         1061 ext/reflection/php_reflection.c 	if (constant->module_number  == module->module_number) {
constant         1062 ext/reflection/php_reflection.c 		_const_string(str, constant->name, &constant->value, indent TSRMLS_CC);
constant         5359 ext/reflection/php_reflection.c static int _addconstant(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
constant         5365 ext/reflection/php_reflection.c 	if (number == constant->module_number) {
constant         5367 ext/reflection/php_reflection.c 		*const_val = constant->value;
constant         5370 ext/reflection/php_reflection.c 		add_assoc_zval_ex(retval, constant->name, constant->name_len, const_val);
constant         2674 ext/standard/basic_functions.c 	PHP_FE(constant,														arginfo_constant)
constant         3828 ext/standard/basic_functions.c PHP_FUNCTION(constant)
constant           46 ext/standard/basic_functions.h PHP_FUNCTION(constant);
constant          232 sapi/phpdbg/phpdbg_info.c 			if (Z_TYPE(ops->literals[literal].constant) != IS_NULL) {
constant          235 sapi/phpdbg/phpdbg_info.c 					&ops->literals[literal].constant, 0);