u                  31 Zend/zend_ast.c 	ast->u.val = (zval*)(ast + 1);
u                  32 Zend/zend_ast.c 	INIT_PZVAL_COPY(ast->u.val, zv);
u                  41 Zend/zend_ast.c 	(&ast->u.child)[0] = op0;
u                  50 Zend/zend_ast.c 	(&ast->u.child)[0] = op0;
u                  51 Zend/zend_ast.c 	(&ast->u.child)[1] = op1;
u                  60 Zend/zend_ast.c 	(&ast->u.child)[0] = op0;
u                  61 Zend/zend_ast.c 	(&ast->u.child)[1] = op1;
u                  62 Zend/zend_ast.c 	(&ast->u.child)[2] = op2;
u                  79 Zend/zend_ast.c 	(&(*ast)->u.child)[(*ast)->children++] = op;
u                  92 Zend/zend_ast.c 		return !IS_CONSTANT_TYPE(Z_TYPE_P(ast->u.val));
u                  95 Zend/zend_ast.c 			if ((&ast->u.child)[i]) {
u                  96 Zend/zend_ast.c 				if (!zend_ast_is_ct_constant((&ast->u.child)[i])) {
u                 111 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 112 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 118 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 119 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 125 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 126 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 132 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 133 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 139 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 140 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 146 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 147 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 153 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 154 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 160 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 161 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 167 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 168 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 174 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 175 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 181 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 182 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 188 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 189 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 195 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 200 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 205 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 206 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 212 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 213 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 219 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 220 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 226 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 227 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 233 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 234 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 240 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 241 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 247 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 248 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 256 Zend/zend_ast.c 				if (IS_CONSTANT_TYPE(Z_TYPE_P(ast->u.val))) {
u                 257 Zend/zend_ast.c 					zval_update_constant_ex(&ast->u.val, 1, scope TSRMLS_CC);
u                 259 Zend/zend_ast.c 				*result = *ast->u.val;
u                 262 Zend/zend_ast.c 				*result = *ast->u.val;
u                 270 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 272 Zend/zend_ast.c 				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 281 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 285 Zend/zend_ast.c 				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 292 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 294 Zend/zend_ast.c 				if (!(&ast->u.child)[1]) {
u                 297 Zend/zend_ast.c 					zend_ast_evaluate(result, (&ast->u.child)[1], scope TSRMLS_CC);
u                 301 Zend/zend_ast.c 				zend_ast_evaluate(result, (&ast->u.child)[2], scope TSRMLS_CC);
u                 307 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
u                 313 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
u                 326 Zend/zend_ast.c 					if ((has_key = !!(&ast->u.child)[i])) {
u                 327 Zend/zend_ast.c 						zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC);
u                 329 Zend/zend_ast.c 					zend_ast_evaluate(expr, (&ast->u.child)[i+1], scope TSRMLS_CC);
u                 335 Zend/zend_ast.c 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
u                 336 Zend/zend_ast.c 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
u                 355 Zend/zend_ast.c 		zend_ast *copy = zend_ast_create_constant(ast->u.val);
u                 356 Zend/zend_ast.c 		zval_copy_ctor(copy->u.val);
u                 364 Zend/zend_ast.c 			(&new->u.child)[i] = zend_ast_copy((&ast->u.child)[i]);
u                 376 Zend/zend_ast.c 		zval_dtor(ast->u.val);
u                 379 Zend/zend_ast.c 			if ((&ast->u.child)[i]) {
u                 380 Zend/zend_ast.c 				zend_ast_destroy((&ast->u.child)[i]);
u                  45 Zend/zend_ast.h 	} u;
u                  42 Zend/zend_compile.c 			target.constant = zend_add_literal(CG(active_op_array), &(src)->u.constant TSRMLS_CC); \
u                  44 Zend/zend_compile.c 			target = (src)->u.op; \
u                  51 Zend/zend_compile.c 			(target)->u.constant = CONSTANT(src.constant); \
u                  53 Zend/zend_compile.c 			(target)->u.op = src; \
u                 670 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
u                 671 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
u                 674 Zend/zend_compile.c 		hash = str_hash(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
u                 675 Zend/zend_compile.c 		if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) &&
u                 676 Zend/zend_compile.c 		    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
u                 677 Zend/zend_compile.c 		      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
u                 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);
u                 682 Zend/zend_compile.c 			Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name;
u                 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)) {
u                 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))) {
u                 747 Zend/zend_compile.c 		LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0);
u                 753 Zend/zend_compile.c 				zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
u                 778 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
u                 793 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
u                 887 Zend/zend_compile.c 		Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
u                 893 Zend/zend_compile.c 	if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
u                 894 Zend/zend_compile.c 		if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
u                 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));
u                 897 Zend/zend_compile.c 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
u                 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));
u                 908 Zend/zend_compile.c 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
u                 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));
u                 944 Zend/zend_compile.c 			    opline->op1.var == value->u.op.var) {
u                 952 Zend/zend_compile.c 					CG(active_op_array)->vars[value->u.op.var].name,
u                 953 Zend/zend_compile.c 					CG(active_op_array)->vars[value->u.op.var].name_len, 1);
u                 968 Zend/zend_compile.c 		if (variable->u.op.var == CG(active_op_array)->this_var) {
u                 980 Zend/zend_compile.c 			    last_op->result.var == variable->u.op.var) {
u                1038 Zend/zend_compile.c 		if (lvar->u.op.var == CG(active_op_array)->this_var) {
u                1107 Zend/zend_compile.c 	close_bracket_token->u.op.opline_num = while_cond_op_number;
u                1121 Zend/zend_compile.c 	opline->op1.opline_num = while_token->u.op.opline_num;
u                1126 Zend/zend_compile.c 	CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                1128 Zend/zend_compile.c 	do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC);
u                1141 Zend/zend_compile.c 	second_semicolon_token->u.op.opline_num = for_cond_op_number;
u                1151 Zend/zend_compile.c 	opline->op1.opline_num = cond_start->u.op.opline_num;
u                1152 Zend/zend_compile.c 	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
u                1167 Zend/zend_compile.c 	opline->op1.opline_num = second_semicolon_token->u.op.opline_num+1;
u                1168 Zend/zend_compile.c 	CG(active_op_array)->opcodes[second_semicolon_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                1172 Zend/zend_compile.c 	do_end_loop(second_semicolon_token->u.op.opline_num+1, 0 TSRMLS_CC);
u                1239 Zend/zend_compile.c 	closing_bracket_token->u.op.opline_num = if_cond_op_number;
u                1262 Zend/zend_compile.c 	CG(active_op_array)->opcodes[closing_bracket_token->u.op.opline_num].op2.opline_num = if_end_op_number+1;
u                1336 Zend/zend_compile.c 				    variable->u.op.var == this_var) {
u                1338 Zend/zend_compile.c 					variable->u.op.var = CG(active_op_array)->this_var;
u                1406 Zend/zend_compile.c 	if (Z_STRLEN(op2->u.constant) > 1) {
u                1409 Zend/zend_compile.c 	} else if (Z_STRLEN(op2->u.constant) == 1) {
u                1410 Zend/zend_compile.c 		int ch = *Z_STRVAL(op2->u.constant);
u                1413 Zend/zend_compile.c 		efree(Z_STRVAL(op2->u.constant));
u                1414 Zend/zend_compile.c 		ZVAL_LONG(&op2->u.constant, ch);
u                1418 Zend/zend_compile.c 		efree(Z_STRVAL(op2->u.constant));
u                1469 Zend/zend_compile.c 			&& opline->result.var == op1->u.op.var) {
u                1488 Zend/zend_compile.c 				    && opline->op1.var == op1->u.op.var) {
u                1495 Zend/zend_compile.c 					&& opline->result.var == op1->u.op.var) {
u                1505 Zend/zend_compile.c 		zval_dtor(&op1->u.constant);
u                1512 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
u                1513 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
u                1516 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
u                1517 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
u                1520 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
u                1521 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
u                1524 Zend/zend_compile.c 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
u                1525 Zend/zend_compile.c 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
u                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)) {
u                1531 Zend/zend_compile.c 	return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
u                1538 Zend/zend_compile.c 	char *name = Z_STRVAL(function_name->u.constant);
u                1539 Zend/zend_compile.c 	int name_len = Z_STRLEN(function_name->u.constant);
u                1540 Zend/zend_compile.c 	int function_begin_line = function_token->u.op.opline_num;
u                1548 Zend/zend_compile.c 			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
u                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));
u                1551 Zend/zend_compile.c 			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
u                1553 Zend/zend_compile.c 		fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
u                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));
u                1561 Zend/zend_compile.c 	function_token->u.op_array = CG(active_op_array);
u                1718 Zend/zend_compile.c 			tmp.u.constant = *CG(current_namespace);
u                1719 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
u                1721 Zend/zend_compile.c 			op_array.function_name = Z_STRVAL(tmp.u.constant);
u                1722 Zend/zend_compile.c 			name_len = Z_STRLEN(tmp.u.constant);
u                1723 Zend/zend_compile.c 			lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
u                1730 Zend/zend_compile.c 		    zend_hash_find(CG(current_import_function), lcname, Z_STRLEN(function_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
u                1734 Zend/zend_compile.c 			if (Z_STRLEN_PP(ns_name) != Z_STRLEN(function_name->u.constant) ||
u                1735 Zend/zend_compile.c 				memcmp(tmp, lcname, Z_STRLEN(function_name->u.constant))) {
u                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));
u                1802 Zend/zend_compile.c 	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
u                1807 Zend/zend_compile.c 	result->u.op.var = get_temporary_variable(current_op_array);
u                1856 Zend/zend_compile.c 	CG(active_op_array) = function_token->u.op_array;
u                1871 Zend/zend_compile.c 	if (zend_is_auto_global(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant) TSRMLS_CC)) {
u                1872 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
u                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);
u                1876 Zend/zend_compile.c 		Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name;
u                1878 Zend/zend_compile.c 		if (CG(active_op_array)->vars[var.u.op.var].hash_value == THIS_HASHVAL &&
u                1879 Zend/zend_compile.c 			Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
u                1880 Zend/zend_compile.c 		    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
u                1885 Zend/zend_compile.c 			CG(active_op_array)->this_var = var.u.op.var;
u                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);
u                1919 Zend/zend_compile.c 	cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
u                1930 Zend/zend_compile.c 		if (class_type->u.constant.type != IS_NULL) {
u                1931 Zend/zend_compile.c 			if (class_type->u.constant.type == IS_ARRAY) {
u                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"))) {
u                1936 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
u                1939 Zend/zend_compile.c 					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) {
u                1943 Zend/zend_compile.c 			} else if (class_type->u.constant.type == IS_CALLABLE) {
u                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"))) {
u                1948 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
u                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))) {
u                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);
u                1961 Zend/zend_compile.c 				cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
u                1962 Zend/zend_compile.c 				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
u                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"))) {
u                1966 Zend/zend_compile.c 					} else if (IS_CONSTANT_TYPE(Z_TYPE(initialization->u.constant))) {
u                1983 Zend/zend_compile.c 	char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
u                1997 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
u                1998 Zend/zend_compile.c 	if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) ||
u                2005 Zend/zend_compile.c 	efree(Z_STRVAL(function_name->u.constant));
u                2006 Zend/zend_compile.c 	Z_STRVAL(function_name->u.constant) = lcname;
u                2049 Zend/zend_compile.c 		Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
u                2057 Zend/zend_compile.c 			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &left_bracket->u.constant TSRMLS_CC);
u                2097 Zend/zend_compile.c 		opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
u                2105 Zend/zend_compile.c 			opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC);
u                2125 Zend/zend_compile.c 	char *lookup_name, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
u                2127 Zend/zend_compile.c 	if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
u                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));
u                2130 Zend/zend_compile.c 		--Z_STRLEN(element_name->u.constant);
u                2139 Zend/zend_compile.c 		len = Z_STRLEN(element_name->u.constant)+1;
u                2141 Zend/zend_compile.c 			lookup_name = estrndup(Z_STRVAL(element_name->u.constant), len);
u                2143 Zend/zend_compile.c 			lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
u                2147 Zend/zend_compile.c 			zval_dtor(&element_name->u.constant);
u                2148 Zend/zend_compile.c 			element_name->u.constant = **ns;
u                2149 Zend/zend_compile.c 			zval_copy_ctor(&element_name->u.constant);
u                2158 Zend/zend_compile.c 		len = compound - Z_STRVAL(element_name->u.constant);
u                2160 Zend/zend_compile.c 		lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
u                2165 Zend/zend_compile.c 			tmp.u.constant = **ns;
u                2166 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
u                2168 Zend/zend_compile.c 			Z_STRLEN(element_name->u.constant) -= len;
u                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);
u                2181 Zend/zend_compile.c 		Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
u                2182 Zend/zend_compile.c 		Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
u                2183 Zend/zend_compile.c 		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
u                2184 Zend/zend_compile.c 		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1);
u                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);
u                2186 Zend/zend_compile.c 		str_efree(Z_STRVAL(element_name->u.constant));
u                2210 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
u                2218 Zend/zend_compile.c 				zval_dtor(&class_name->u.constant);
u                2220 Zend/zend_compile.c 				ZVAL_STRINGL(&constant_name.u.constant, "__CLASS__", sizeof("__CLASS__")-1, 1);
u                2223 Zend/zend_compile.c 					result->u.constant.type = IS_CONSTANT;
u                2229 Zend/zend_compile.c 			zval_dtor(&class_name->u.constant);
u                2231 Zend/zend_compile.c 			ZVAL_STRINGL(&class_name->u.constant, CG(active_class_entry)->name, CG(active_class_entry)->name_length, 1);
u                2249 Zend/zend_compile.c 			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1);
u                2271 Zend/zend_compile.c 	compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
u                2274 Zend/zend_compile.c 		if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
u                2276 Zend/zend_compile.c 			Z_STRLEN(class_name->u.constant) -= 1;
u                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);
u                2278 Zend/zend_compile.c 			Z_STRVAL(class_name->u.constant) = erealloc(
u                2279 Zend/zend_compile.c 			Z_STRVAL(class_name->u.constant),
u                2280 Zend/zend_compile.c 			Z_STRLEN(class_name->u.constant) + 1);
u                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))) {
u                2283 Zend/zend_compile.c 				zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
u                2287 Zend/zend_compile.c 				len = compound - Z_STRVAL(class_name->u.constant);
u                2288 Zend/zend_compile.c 				lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len);
u                2293 Zend/zend_compile.c 					tmp.u.constant = **ns;
u                2294 Zend/zend_compile.c 					zval_copy_ctor(&tmp.u.constant);
u                2296 Zend/zend_compile.c 					Z_STRLEN(class_name->u.constant) -= len;
u                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);
u                2308 Zend/zend_compile.c 				tmp.u.constant = *CG(current_namespace);
u                2309 Zend/zend_compile.c 				zval_copy_ctor(&tmp.u.constant);
u                2316 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
u                2319 Zend/zend_compile.c 		    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) {
u                2321 Zend/zend_compile.c 			zval_dtor(&class_name->u.constant);
u                2322 Zend/zend_compile.c 			class_name->u.constant = **ns;
u                2323 Zend/zend_compile.c 			zval_copy_ctor(&class_name->u.constant);
u                2327 Zend/zend_compile.c 			tmp.u.constant = *CG(current_namespace);
u                2328 Zend/zend_compile.c 			zval_copy_ctor(&tmp.u.constant);
u                2352 Zend/zend_compile.c 		fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
u                2359 Zend/zend_compile.c 				zval_dtor(&class_name->u.constant);
u                2365 Zend/zend_compile.c 					zend_add_class_name_literal(CG(active_op_array), &class_name->u.constant TSRMLS_CC);
u                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) {
u                2391 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
u                2395 Zend/zend_compile.c 	zval_dtor(&label->u.constant);
u                2499 Zend/zend_compile.c 		length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
u                2500 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
u                2501 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1);
u                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);
u                2503 Zend/zend_compile.c 		str_efree(Z_STRVAL(name->u.constant));
u                2504 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = length;
u                2506 Zend/zend_compile.c 		length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
u                2507 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
u                2508 Zend/zend_compile.c 		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1);
u                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);
u                2510 Zend/zend_compile.c 		str_efree(Z_STRVAL(name->u.constant));
u                2511 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = length;
u                2523 Zend/zend_compile.c 		if (Z_TYPE(method_name->u.constant) != IS_STRING) {
u                2526 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
u                2527 Zend/zend_compile.c 		if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
u                2529 Zend/zend_compile.c 			zval_dtor(&method_name->u.constant);
u                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))) {
u                2550 Zend/zend_compile.c 			zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
u                2557 Zend/zend_compile.c 			zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC);
u                2587 Zend/zend_compile.c 		opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
u                2607 Zend/zend_compile.c 				zval_dtor(&function_name->u.constant);
u                2937 Zend/zend_compile.c 	open_parentheses->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                2966 Zend/zend_compile.c 	if (last_additional_catch->u.op.opline_num == -1) {
u                2967 Zend/zend_compile.c 		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].result.num = 1;
u                2968 Zend/zend_compile.c 		CG(active_op_array)->opcodes[first_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
u                2970 Zend/zend_compile.c 		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].result.num = 1;
u                2971 Zend/zend_compile.c 		CG(active_op_array)->opcodes[last_additional_catch->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
u                2979 Zend/zend_compile.c 	try_token->u.op.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC);
u                2988 Zend/zend_compile.c 	finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                2992 Zend/zend_compile.c 	opline->op1.opline_num = finally_token->u.op.opline_num + 1;
u                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))) {
u                3022 Zend/zend_compile.c 		first_catch->u.op.opline_num = catch_op_number;
u                3028 Zend/zend_compile.c 	opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
u                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);
u                3031 Zend/zend_compile.c 	Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name;
u                3034 Zend/zend_compile.c 	catch_token->u.op.opline_num = catch_op_number;
u                3052 Zend/zend_compile.c 	CG(active_op_array)->opcodes[catch_token->u.op.opline_num].extended_value = get_next_op_number(CG(active_op_array));
u                3058 Zend/zend_compile.c 		zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC);
u                3071 Zend/zend_compile.c 		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1;
u                3072 Zend/zend_compile.c 		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array));
u                3080 Zend/zend_compile.c 		CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
u                4635 Zend/zend_compile.c 		method_ref->class_name = Z_STRVAL(class_name->u.constant);
u                4636 Zend/zend_compile.c 		method_ref->cname_len  = Z_STRLEN(class_name->u.constant);
u                4642 Zend/zend_compile.c 	method_ref->method_name = Z_STRVAL(method_name->u.constant);
u                4643 Zend/zend_compile.c 	method_ref->mname_len   = Z_STRLEN(method_name->u.constant);
u                4645 Zend/zend_compile.c 	result->u.op.ptr = method_ref;
u                4655 Zend/zend_compile.c 	if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
u                4658 Zend/zend_compile.c 	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
u                4661 Zend/zend_compile.c 	} else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
u                4667 Zend/zend_compile.c 	trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
u                4668 Zend/zend_compile.c 	trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
u                4670 Zend/zend_compile.c 		trait_alias->alias = Z_STRVAL(alias->u.constant);
u                4671 Zend/zend_compile.c 		trait_alias->alias_len = Z_STRLEN(alias->u.constant);
u                4684 Zend/zend_compile.c 	trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
u                4685 Zend/zend_compile.c 	trait_precedence->exclude_from_classes = (zend_class_entry**) trait_list->u.op.ptr;
u                4886 Zend/zend_compile.c 	op_token->u.op.opline_num = next_op_number;
u                4902 Zend/zend_compile.c 	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                4921 Zend/zend_compile.c 	op_token->u.op.opline_num = next_op_number;
u                4937 Zend/zend_compile.c 	CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                4954 Zend/zend_compile.c 	opline->op2.opline_num = do_token->u.op.opline_num;
u                4957 Zend/zend_compile.c 	do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC);
u                4973 Zend/zend_compile.c 		} else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
u                5018 Zend/zend_compile.c 		CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
u                5033 Zend/zend_compile.c 		zval_dtor(&switch_entry_ptr->cond.u.constant);
u                5069 Zend/zend_compile.c 	case_token->u.op.opline_num = next_op_number;
u                5075 Zend/zend_compile.c 	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
u                5087 Zend/zend_compile.c 	result->u.op.opline_num = next_op_number;
u                5089 Zend/zend_compile.c 	switch (CG(active_op_array)->opcodes[case_token->u.op.opline_num].opcode) {
u                5091 Zend/zend_compile.c 			CG(active_op_array)->opcodes[case_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
u                5094 Zend/zend_compile.c 			CG(active_op_array)->opcodes[case_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                5111 Zend/zend_compile.c 	default_token->u.op.opline_num = next_op_number;
u                5119 Zend/zend_compile.c 	CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
u                5137 Zend/zend_compile.c 	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
u                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));
u                5146 Zend/zend_compile.c 	    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
u                5155 Zend/zend_compile.c 		tmp.u.constant = *CG(current_namespace);
u                5156 Zend/zend_compile.c 		zval_copy_ctor(&tmp.u.constant);
u                5160 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
u                5166 Zend/zend_compile.c 		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||
u                5167 Zend/zend_compile.c 			memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {
u                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));
u                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);
u                5176 Zend/zend_compile.c 	new_class_entry->name_length = Z_STRLEN(class_name->u.constant);
u                5180 Zend/zend_compile.c 	new_class_entry->info.user.line_start = class_token->u.op.opline_num;
u                5214 Zend/zend_compile.c 		opline->extended_value = parent_class_name->u.op.var;
u                5318 Zend/zend_compile.c 							 Z_STRVAL(interface_name->u.constant),
u                5322 Zend/zend_compile.c 	switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
u                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));
u                5338 Zend/zend_compile.c 	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC);
u                5350 Zend/zend_compile.c 				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name);
u                5354 Zend/zend_compile.c 	switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) {
u                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));
u                5370 Zend/zend_compile.c 	opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC);
u                5456 Zend/zend_compile.c 				   CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
u                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) {
u                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));
u                5465 Zend/zend_compile.c 		*property = value->u.constant;
u                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);
u                5479 Zend/zend_compile.c 	efree(Z_STRVAL(var_name->u.constant));
u                5495 Zend/zend_compile.c 	*property = value->u.constant;
u                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);
u                5498 Zend/zend_compile.c 	hash = str_hash(cname, Z_STRLEN(var_name->u.constant));
u                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) {
u                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));
u                5521 Zend/zend_compile.c 		if (object->u.op.var == CG(active_op_array)->this_var) {
u                5632 Zend/zend_compile.c 	new_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                5655 Zend/zend_compile.c 	CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                5656 Zend/zend_compile.c 	GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result);
u                5709 Zend/zend_compile.c 		result->u.constant = c->value;
u                5710 Zend/zend_compile.c 		zval_copy_ctor(&result->u.constant);
u                5711 Zend/zend_compile.c 		INIT_PZVAL(&result->u.constant);
u                5730 Zend/zend_compile.c 				type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
u                5739 Zend/zend_compile.c 				result->u.constant.type = IS_CONSTANT | fetch_type;
u                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))) {
u                5755 Zend/zend_compile.c 					opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC);
u                5775 Zend/zend_compile.c 			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
u                5778 Zend/zend_compile.c 			if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
u                5789 Zend/zend_compile.c 			result->u.constant.type = IS_CONSTANT | fetch_type;
u                5792 Zend/zend_compile.c 			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
u                5796 Zend/zend_compile.c 			if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
u                5810 Zend/zend_compile.c 				opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
u                5815 Zend/zend_compile.c 					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
u                5817 Zend/zend_compile.c 					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
u                6021 Zend/zend_compile.c 						zval_copy_ctor(&expr->u.constant);
u                6101 Zend/zend_compile.c 		*tmp = static_assignment->u.constant;
u                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);
u                6115 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
u                6116 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
u                6133 Zend/zend_compile.c 		zval_copy_ctor(&varname->u.constant);
u                6154 Zend/zend_compile.c 	if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
u                6155 Zend/zend_compile.c 	    memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
u                6161 Zend/zend_compile.c 	ZVAL_NULL(&value.u.constant);
u                6162 Zend/zend_compile.c 	Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
u                6163 Zend/zend_compile.c 	Z_SET_REFCOUNT_P(&value.u.constant, 1);
u                6164 Zend/zend_compile.c 	Z_UNSET_ISREF_P(&value.u.constant);
u                6177 Zend/zend_compile.c 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
u                6178 Zend/zend_compile.c 			convert_to_string(&varname->u.constant);
u                6195 Zend/zend_compile.c 		zval_copy_ctor(&varname->u.constant);
u                6241 Zend/zend_compile.c 	for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
u                6376 Zend/zend_compile.c 		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                6389 Zend/zend_compile.c 		open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                6393 Zend/zend_compile.c 	foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                6409 Zend/zend_compile.c 	as_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                6433 Zend/zend_compile.c 	opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num];
u                6460 Zend/zend_compile.c 		CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE;
u                6462 Zend/zend_compile.c 		zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num];
u                6463 Zend/zend_compile.c 		zend_op	*end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num];
u                6502 Zend/zend_compile.c 		opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1];
u                6522 Zend/zend_compile.c 	opline->op1.opline_num = as_token->u.op.opline_num;
u                6526 Zend/zend_compile.c 	CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */
u                6527 Zend/zend_compile.c 	CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */
u                6529 Zend/zend_compile.c 	do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC);
u                6547 Zend/zend_compile.c 	if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
u                6548 Zend/zend_compile.c 		convert_to_long(&val->u.constant);
u                6549 Zend/zend_compile.c 		CG(declarables).ticks = val->u.constant;
u                6550 Zend/zend_compile.c 	} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
u                6551 Zend/zend_compile.c 		if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
u                6581 Zend/zend_compile.c 			convert_to_string(&val->u.constant);
u                6582 Zend/zend_compile.c 			new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
u                6584 Zend/zend_compile.c 				zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
u                6599 Zend/zend_compile.c 		zval_dtor(&val->u.constant);
u                6601 Zend/zend_compile.c 		zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
u                6602 Zend/zend_compile.c 		zval_dtor(&val->u.constant);
u                6604 Zend/zend_compile.c 	zval_dtor(&var->u.constant);
u                6614 Zend/zend_compile.c 	if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
u                6629 Zend/zend_compile.c 	Z_TYPE(result->u.constant) = IS_BOOL;
u                6630 Zend/zend_compile.c 	Z_LVAL(result->u.constant) = 1;
u                6675 Zend/zend_compile.c 	jmp_token->u.op.opline_num = op_number;
u                6688 Zend/zend_compile.c 			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR;
u                6689 Zend/zend_compile.c 			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR;
u                6704 Zend/zend_compile.c 	CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
u                6731 Zend/zend_compile.c 	CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
u                6745 Zend/zend_compile.c 	colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
u                6761 Zend/zend_compile.c 			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR;
u                6762 Zend/zend_compile.c 			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR;
u                6774 Zend/zend_compile.c 	CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
u                6910 Zend/zend_compile.c 	Z_TYPE(zendlval->u.constant) = IS_LONG;
u                6911 Zend/zend_compile.c 	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
u                6933 Zend/zend_compile.c 	INIT_PZVAL(&zendlval->u.constant);
u                7042 Zend/zend_compile.c 		if (Z_TYPE(result->u.constant) == IS_STRING &&
u                7043 Zend/zend_compile.c 		    Z_STRLEN(result->u.constant) == 0) {
u                7048 Zend/zend_compile.c 				zval_dtor(&result->u.constant);
u                7050 Zend/zend_compile.c 				tmp.u.constant = *CG(current_namespace);
u                7051 Zend/zend_compile.c 				zval_copy_ctor(&tmp.u.constant);
u                7057 Zend/zend_compile.c 		Z_TYPE(result->u.constant) = IS_STRING;
u                7058 Zend/zend_compile.c 		Z_STRVAL(result->u.constant) = NULL;
u                7059 Zend/zend_compile.c 		Z_STRLEN(result->u.constant) = 0;
u                7106 Zend/zend_compile.c 		lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
u                7107 Zend/zend_compile.c 		if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
u                7109 Zend/zend_compile.c 		    ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
u                7111 Zend/zend_compile.c 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
u                7120 Zend/zend_compile.c 		*CG(current_namespace) = name->u.constant;
u                7168 Zend/zend_compile.c 	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
u                7170 Zend/zend_compile.c 		name = &new_name->u.constant;
u                7245 Zend/zend_compile.c 	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
u                7247 Zend/zend_compile.c 		name = &new_name->u.constant;
u                7350 Zend/zend_compile.c 	if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
u                7351 Zend/zend_compile.c 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
u                7359 Zend/zend_compile.c 		tmp.u.constant = *CG(current_namespace);
u                7360 Zend/zend_compile.c 		Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
u                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) {
u                7371 Zend/zend_compile.c 		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(name->u.constant) ||
u                7372 Zend/zend_compile.c 			memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
u                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));
u                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);
u                7432 Zend/zend_compile.c 		result->u.constant = *ast->u.val;
u                7435 Zend/zend_compile.c 		zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
u                7438 Zend/zend_compile.c 		Z_TYPE(result->u.constant) = IS_CONSTANT_AST;
u                7439 Zend/zend_compile.c 		Z_AST(result->u.constant) = ast;
u                  36 Zend/zend_compile.h #define FREE_PNODE(znode)	zval_dtor(&znode->u.constant);
u                  97 Zend/zend_compile.h 	} u;
u                 100 Zend/zend_execute.c #define PZVAL_UNLOCK_EX(z, f, u) zend_pzval_unlock_func(z, f, u TSRMLS_CC)
u                 181 Zend/zend_gc.c 			newRoot->u.pz = zv;
u                 235 Zend/zend_gc.c 			newRoot->u.handlers = Z_OBJ_HT_P(zv);
u                 246 Zend/zend_gc.c 	gc_root_buffer* root_buffer = GC_ADDRESS(((zval_gc_info*)zv)->u.buffered);
u                 255 Zend/zend_gc.c 			GC_G(next_to_free) = ((zval_gc_info*)zv)->u.next;
u                 261 Zend/zend_gc.c 	((zval_gc_info*)zv)->u.buffered = NULL;
u                 487 Zend/zend_gc.c 					Z_OBJ_HT(z) = current->u.handlers;
u                 495 Zend/zend_gc.c 			if (GC_ZVAL_GET_COLOR(current->u.pz) == GC_PURPLE) {
u                 496 Zend/zend_gc.c 				zval_mark_grey(current->u.pz TSRMLS_CC);
u                 498 Zend/zend_gc.c 				GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
u                 619 Zend/zend_gc.c 			Z_OBJ_HT(z) = current->u.handlers;
u                 622 Zend/zend_gc.c 			zval_scan(current->u.pz TSRMLS_CC);
u                 633 Zend/zend_gc.c 	if (((zval_gc_info*)(pz))->u.buffered == (gc_root_buffer*)GC_WHITE) {
u                 654 Zend/zend_gc.c 						((zval_gc_info*)pz)->u.next = GC_G(zval_to_free);
u                 687 Zend/zend_gc.c 		((zval_gc_info*)pz)->u.next = GC_G(zval_to_free);
u                 762 Zend/zend_gc.c 				Z_OBJ_HT(z) = current->u.handlers;
u                 766 Zend/zend_gc.c 			GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
u                 767 Zend/zend_gc.c 			zval_collect_white(current->u.pz TSRMLS_CC);
u                 816 Zend/zend_gc.c 			p = p->u.next;
u                 822 Zend/zend_gc.c 			GC_G(next_to_free) = p->u.next;
u                 845 Zend/zend_gc.c 			q = p->u.next;
u                  64 Zend/zend_gc.h 	((zval_gc_info*)(z))->u.buffered = NULL
u                  66 Zend/zend_gc.h 	GC_ADDRESS(((zval_gc_info*)(v))->u.buffered)
u                  68 Zend/zend_gc.h 	GC_SET_ADDRESS(((zval_gc_info*)(v))->u.buffered, (a))
u                  70 Zend/zend_gc.h 	GC_GET_COLOR(((zval_gc_info*)(v))->u.buffered)
u                  72 Zend/zend_gc.h 	GC_SET_COLOR(((zval_gc_info*)(v))->u.buffered, (c))
u                  74 Zend/zend_gc.h 	GC_SET_BLACK(((zval_gc_info*)(v))->u.buffered)
u                  76 Zend/zend_gc.h 	GC_SET_PURPLE(((zval_gc_info*)(v))->u.buffered)
u                  88 Zend/zend_gc.h 	} u;
u                  96 Zend/zend_gc.h 	} u;
u                 159 Zend/zend_gc.h 	if (GC_ADDRESS(((zval_gc_info*)z)->u.buffered)) {	\
u                 374 Zend/zend_language_parser.y 	|	/* empty */ { $$.u.op.opline_num = -1; }
u                 383 Zend/zend_language_parser.y 	T_CATCH '(' fully_qualified_class_name { $$.u.op.opline_num = get_next_op_number(CG(active_op_array)); } T_VARIABLE ')' { zend_do_begin_catch(&$1, &$3, &$5, NULL TSRMLS_CC); } '{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
u                 436 Zend/zend_language_parser.y 		T_CLASS			{ $$.u.op.opline_num = CG(zend_lineno); $$.EA = 0; }
u                 437 Zend/zend_language_parser.y 	|	T_ABSTRACT T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
u                 438 Zend/zend_language_parser.y 	|	T_TRAIT { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_TRAIT; }
u                 439 Zend/zend_language_parser.y 	|	T_FINAL T_CLASS { $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_FINAL_CLASS; }
u                 448 Zend/zend_language_parser.y 	T_INTERFACE		{ $$.u.op.opline_num = CG(zend_lineno); $$.EA = ZEND_ACC_INTERFACE; }
u                 574 Zend/zend_language_parser.y 	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_ARRAY; }
u                 575 Zend/zend_language_parser.y 	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_CALLABLE; }
u                 581 Zend/zend_language_parser.y 		'(' ')'	{ Z_LVAL($$.u.constant) = 0; }
u                 670 Zend/zend_language_parser.y 		fully_qualified_class_name									{ zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STRVAL($1.u.constant) TSRMLS_CC); }
u                 689 Zend/zend_language_parser.y 		/* empty */					{ Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */
u                 694 Zend/zend_language_parser.y 		';' /* abstract method */		{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
u                 695 Zend/zend_language_parser.y 	|	'{' inner_statement_list '}'	{ Z_LVAL($$.u.constant) = 0;	}
u                 700 Zend/zend_language_parser.y 	|	T_VAR							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
u                 704 Zend/zend_language_parser.y 		/* empty */							{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
u                 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; } }
u                 710 Zend/zend_language_parser.y 	|	non_empty_member_modifiers member_modifier	{ Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); }
u                 714 Zend/zend_language_parser.y 		T_PUBLIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; }
u                 715 Zend/zend_language_parser.y 	|	T_PROTECTED				{ Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; }
u                 716 Zend/zend_language_parser.y 	|	T_PRIVATE				{ Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; }
u                 717 Zend/zend_language_parser.y 	|	T_STATIC				{ Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; }
u                 718 Zend/zend_language_parser.y 	|	T_ABSTRACT				{ Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; }
u                 719 Zend/zend_language_parser.y 	|	T_FINAL					{ Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; }
u                 741 Zend/zend_language_parser.y 		/* empty */			{ $$.op_type = IS_CONST;  Z_TYPE($$.u.constant) = IS_BOOL;  Z_LVAL($$.u.constant) = 1; }
u                 880 Zend/zend_language_parser.y 	T_FUNCTION { $$.u.op.opline_num = CG(zend_lineno); }
u                 896 Zend/zend_language_parser.y 		namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$1, 1 TSRMLS_CC); }
u                 898 Zend/zend_language_parser.y 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $1.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$1.u.constant);  zend_do_build_namespace_name(&$1, &$1, &$3 TSRMLS_CC); $$.u.op.opline_num = zend_do_begin_function_call(&$1, 0 TSRMLS_CC); }
u                 900 Zend/zend_language_parser.y 	|	T_NS_SEPARATOR namespace_name { $$.u.op.opline_num = zend_do_begin_function_call(&$2, 0 TSRMLS_CC); }
u                 902 Zend/zend_language_parser.y 	|	class_name T_PAAMAYIM_NEKUDOTAYIM variable_name { $$.u.op.opline_num = zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); }
u                 915 Zend/zend_language_parser.y 		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1, 1);}
u                 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); }
u                 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); }
u                 960 Zend/zend_language_parser.y 		/* empty */	{ ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; }
u                 967 Zend/zend_language_parser.y 		/* empty */	{ Z_LVAL($$.u.constant) = 0; }
u                 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; }
u                 996 Zend/zend_language_parser.y 		common_scalar	{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
u                 997 Zend/zend_language_parser.y 	|	static_class_name_scalar	{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
u                 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); }
u                 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); }
u                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); }
u                1003 Zend/zend_language_parser.y 	|	static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
u                1004 Zend/zend_language_parser.y 	|	T_CLASS_C			{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
u                1009 Zend/zend_language_parser.y 		static_scalar_value '[' static_scalar_value ']' { $$.u.ast = zend_ast_create_binary(ZEND_FETCH_DIM_R, $1.u.ast, $3.u.ast); }
u                1010 Zend/zend_language_parser.y 	|	static_scalar_value '+' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_ADD, $1.u.ast, $3.u.ast); }
u                1011 Zend/zend_language_parser.y 	|	static_scalar_value '-' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SUB, $1.u.ast, $3.u.ast); }
u                1012 Zend/zend_language_parser.y 	|	static_scalar_value '*' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MUL, $1.u.ast, $3.u.ast); }
u                1013 Zend/zend_language_parser.y 	|	static_scalar_value T_POW static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_POW, $1.u.ast, $3.u.ast); }
u                1014 Zend/zend_language_parser.y 	|	static_scalar_value '/' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_DIV, $1.u.ast, $3.u.ast); }
u                1015 Zend/zend_language_parser.y 	|	static_scalar_value '%' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MOD, $1.u.ast, $3.u.ast); }
u                1016 Zend/zend_language_parser.y 	|	'!' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BOOL_NOT, $2.u.ast); }
u                1017 Zend/zend_language_parser.y 	|	'~' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_BW_NOT, $2.u.ast); }
u                1018 Zend/zend_language_parser.y 	|	static_scalar_value '|' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_OR, $1.u.ast, $3.u.ast); }
u                1019 Zend/zend_language_parser.y 	|	static_scalar_value '&' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_AND, $1.u.ast, $3.u.ast); }
u                1020 Zend/zend_language_parser.y 	|	static_scalar_value '^' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BW_XOR, $1.u.ast, $3.u.ast); }
u                1021 Zend/zend_language_parser.y 	|	static_scalar_value T_SL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SL, $1.u.ast, $3.u.ast); }
u                1022 Zend/zend_language_parser.y 	|	static_scalar_value T_SR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SR, $1.u.ast, $3.u.ast); }
u                1023 Zend/zend_language_parser.y 	|	static_scalar_value '.' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_CONCAT, $1.u.ast, $3.u.ast); }
u                1024 Zend/zend_language_parser.y 	|	static_scalar_value T_LOGICAL_XOR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_XOR, $1.u.ast, $3.u.ast); }
u                1025 Zend/zend_language_parser.y 	|	static_scalar_value T_LOGICAL_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); }
u                1026 Zend/zend_language_parser.y 	|	static_scalar_value T_LOGICAL_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); }
u                1027 Zend/zend_language_parser.y 	|	static_scalar_value T_BOOLEAN_AND static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_AND, $1.u.ast, $3.u.ast); }
u                1028 Zend/zend_language_parser.y 	|	static_scalar_value T_BOOLEAN_OR static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_BOOL_OR, $1.u.ast, $3.u.ast); }
u                1029 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_IDENTICAL, $1.u.ast, $3.u.ast); }
u                1030 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_NOT_IDENTICAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_IDENTICAL, $1.u.ast, $3.u.ast); }
u                1031 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_EQUAL, $1.u.ast, $3.u.ast); }
u                1032 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_NOT_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_NOT_EQUAL, $1.u.ast, $3.u.ast); }
u                1033 Zend/zend_language_parser.y 	|	static_scalar_value '<' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $1.u.ast, $3.u.ast); }
u                1034 Zend/zend_language_parser.y 	|	static_scalar_value '>' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER, $3.u.ast, $1.u.ast); }
u                1035 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_SMALLER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $1.u.ast, $3.u.ast); }
u                1036 Zend/zend_language_parser.y 	|	static_scalar_value T_IS_GREATER_OR_EQUAL static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_IS_SMALLER_OR_EQUAL, $3.u.ast, $1.u.ast); }
u                1037 Zend/zend_language_parser.y 	|	static_scalar_value '?' ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, NULL, $4.u.ast); }
u                1038 Zend/zend_language_parser.y 	|	static_scalar_value '?' static_scalar_value ':' static_scalar_value { $$.u.ast = zend_ast_create_ternary(ZEND_SELECT, $1.u.ast, $3.u.ast, $5.u.ast); }
u                1039 Zend/zend_language_parser.y 	|	'+' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_PLUS, $2.u.ast); }
u                1040 Zend/zend_language_parser.y 	|	'-' static_scalar_value { $$.u.ast = zend_ast_create_unary(ZEND_UNARY_MINUS, $2.u.ast); }
u                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); }
u                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); }
u                1072 Zend/zend_language_parser.y 		non_empty_static_array_pair_list ',' static_scalar_value T_DOUBLE_ARROW static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); zend_ast_dynamic_add(&$$.u.ast, $5.u.ast); }
u                1073 Zend/zend_language_parser.y 	|	non_empty_static_array_pair_list ',' static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
u                1074 Zend/zend_language_parser.y 	|	static_scalar_value T_DOUBLE_ARROW static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
u                1075 Zend/zend_language_parser.y 	|	static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); }
u                1206 Zend/zend_language_parser.y 		'$' { Z_LVAL($$.u.constant) = 1; }
u                1207 Zend/zend_language_parser.y 	|	simple_indirect_reference '$' { Z_LVAL($$.u.constant)++; }
u                 567 Zend/zend_language_scanner.c 	INIT_PZVAL(&retval_znode.u.constant);
u                 568 Zend/zend_language_scanner.c 	ZVAL_LONG(&retval_znode.u.constant, 1);
u                 182 ext/bcmath/libbcmath/src/recmul.c _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
u                 194 ext/bcmath/libbcmath/src/recmul.c     _bc_simp_mul (u, ulen, v, vlen, prod, full_scale);
u                 204 ext/bcmath/libbcmath/src/recmul.c     u0 = new_sub_num (ulen,0, u->n_value);
u                 206 ext/bcmath/libbcmath/src/recmul.c     u1 = new_sub_num (ulen-n, 0, u->n_value);
u                 207 ext/bcmath/libbcmath/src/recmul.c     u0 = new_sub_num (n, 0, u->n_value+ulen-n);
u                 133 ext/dba/libcdb/cdb.c 	uint32 u;
u                 136 ext/dba/libcdb/cdb.c 		u = cdb_hash(key, len);
u                 137 ext/dba/libcdb/cdb.c 		if (cdb_read(c, buf, 8, (u << 3) & 2047 TSRMLS_CC) == -1) 
u                 143 ext/dba/libcdb/cdb.c 		c->khash = u;
u                 144 ext/dba/libcdb/cdb.c 		u >>= 8;
u                 145 ext/dba/libcdb/cdb.c 		u %= c->hslots;
u                 146 ext/dba/libcdb/cdb.c 		u <<= 3;
u                 147 ext/dba/libcdb/cdb.c 		c->kpos = c->hpos + u;
u                 160 ext/dba/libcdb/cdb.c 		uint32_unpack(buf, &u);
u                 161 ext/dba/libcdb/cdb.c 		if (u == c->khash) {
u                 164 ext/dba/libcdb/cdb.c 			uint32_unpack(buf, &u);
u                 165 ext/dba/libcdb/cdb.c 			if (u == len)
u                 143 ext/dba/libcdb/cdb_make.c 	uint32 u;
u                 161 ext/dba/libcdb/cdb_make.c 		u = c->count[i] * 2;
u                 162 ext/dba/libcdb/cdb_make.c 		if (u > memsize)
u                 163 ext/dba/libcdb/cdb_make.c 		memsize = u;
u                 167 ext/dba/libcdb/cdb_make.c 	u = (uint32) 0 - (uint32) 1;
u                 168 ext/dba/libcdb/cdb_make.c 	u /= sizeof(struct cdb_hp);
u                 169 ext/dba/libcdb/cdb_make.c 	if (memsize > u) {
u                 180 ext/dba/libcdb/cdb_make.c 	u = 0;
u                 182 ext/dba/libcdb/cdb_make.c 		u += c->count[i]; /* bounded by numentries, so no overflow */
u                 183 ext/dba/libcdb/cdb_make.c 		c->start[i] = u;
u                 199 ext/dba/libcdb/cdb_make.c 		for (u = 0;u < len;++u)
u                 200 ext/dba/libcdb/cdb_make.c 			c->hash[u].h = c->hash[u].p = 0;
u                 203 ext/dba/libcdb/cdb_make.c 		for (u = 0;u < count;++u) {
u                 211 ext/dba/libcdb/cdb_make.c 		for (u = 0;u < len;++u) {
u                 212 ext/dba/libcdb/cdb_make.c 			uint32_pack(buf, c->hash[u].h);
u                 213 ext/dba/libcdb/cdb_make.c 			uint32_pack(buf + 4, c->hash[u].p);
u                 737 ext/ereg/regex/regcomp.c 	register const unsigned char *u;
u                 752 ext/ereg/regex/regcomp.c 	u = cp->chars;
u                 753 ext/ereg/regex/regcomp.c 	while ((c = *u++) != '\0')
u                 755 ext/ereg/regex/regcomp.c 	for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
u                 756 ext/ereg/regex/regcomp.c 		MCadd(p, cs, u);
u                1349 ext/exif/exif.c 	unsigned            u;
u                1743 ext/exif/exif.c 						info_value->u = php_ifd_get16u(vptr, motorola_intel);
u                1747 ext/exif/exif.c 						info_value->u = php_ifd_get32u(vptr, motorola_intel);
u                2033 ext/exif/exif.c 										add_assoc_long(tmpi, name, (int)info_value->u);
u                2035 ext/exif/exif.c 										add_index_long(array, ap, (int)info_value->u);
u                2378 ext/exif/exif.c 		*value_ptr = info_data->value.u;
u                2393 ext/exif/exif.c 					php_ifd_set16u(data_ptr, info_value->u, motorola_intel);
u                2397 ext/exif/exif.c 					php_ifd_set32u(data_ptr, info_value->u, motorola_intel);
u                  78 ext/fileinfo/libmagic/cdf.c 	uint32_t u;
u                  81 ext/fileinfo/libmagic/cdf.c #define NEED_SWAP	(cdf_bo.u == (uint32_t)0x01020304)
u                  30 ext/fileinfo/libmagic/elfclass.h 	u.l = 1;
u                  32 ext/fileinfo/libmagic/elfclass.h 	swap = (u.c[sizeof(int32_t) - 1] + 1) != elfhdr.e_ident[EI_DATA];
u                 881 ext/gd/libgd/gd_interpolation.c 	unsigned int u = 0;
u                 892 ext/gd/libgd/gd_interpolation.c     for (u = 0 ; u < line_length ; u++) {
u                 893 ext/gd/libgd/gd_interpolation.c         res->ContribRow[u].Weights = (double *) gdMalloc(windows_size * sizeof(double));
u                 900 ext/gd/libgd/gd_interpolation.c 	unsigned int u;
u                 901 ext/gd/libgd/gd_interpolation.c 	for (u = 0; u < p->LineLength; u++)  {
u                 902 ext/gd/libgd/gd_interpolation.c 		gdFree(p->ContribRow[u].Weights);
u                 914 ext/gd/libgd/gd_interpolation.c 	unsigned int u;
u                 927 ext/gd/libgd/gd_interpolation.c     for (u = 0; u < line_size; u++) {
u                 928 ext/gd/libgd/gd_interpolation.c         const double dCenter = (double)u / scale_d;
u                 935 ext/gd/libgd/gd_interpolation.c         res->ContribRow[u].Left = iLeft;
u                 936 ext/gd/libgd/gd_interpolation.c         res->ContribRow[u].Right = iRight;
u                 948 ext/gd/libgd/gd_interpolation.c             dTotalWeight += (res->ContribRow[u].Weights[iSrc-iLeft] =  scale_f_d * (*pFilter)(scale_f_d * (dCenter - (double)iSrc)));
u                 958 ext/gd/libgd/gd_interpolation.c                 res->ContribRow[u].Weights[iSrc-iLeft] /= dTotalWeight;
u                 991 ext/gd/libgd/gd_interpolation.c 	unsigned int u;
u                1007 ext/gd/libgd/gd_interpolation.c 	for (u = 0; u < dst_height - 1; u++) {
u                1008 ext/gd/libgd/gd_interpolation.c 		_gdScaleRow(pSrc, src_width, pDst, dst_width, u, contrib);
u                1038 ext/gd/libgd/gd_interpolation.c 	unsigned int u;
u                1051 ext/gd/libgd/gd_interpolation.c 	for (u = 0; u < dst_width - 1; u++) {
u                1052 ext/gd/libgd/gd_interpolation.c 		_gdScaleCol(pSrc, src_width, pDst, dst_width, dst_height, u, contrib);
u                 354 ext/gd/libgd/gd_rotate.c 	int u, iShear, newx, newy;
u                 403 ext/gd/libgd/gd_rotate.c 	for (u = 0; u < dst1->sy; u++) {
u                 405 ext/gd/libgd/gd_rotate.c 			dShear = ((double)(u + 0.5)) * dTan;
u                 407 ext/gd/libgd/gd_rotate.c 			dShear = ((double)(u - dst1->sy) + 0.5) * dTan;
u                 411 ext/gd/libgd/gd_rotate.c 		gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack, ignoretransparent);
u                 457 ext/gd/libgd/gd_rotate.c 	for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) {
u                 459 ext/gd/libgd/gd_rotate.c 		gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), clrBack, ignoretransparent);
u                 495 ext/gd/libgd/gd_rotate.c 	for (u = 0; u < dst3->sy; u++, dOffset += dTan) {
u                 497 ext/gd/libgd/gd_rotate.c 		gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), clrBack, ignoretransparent);
u                 151 ext/gd/libgd/webpimg.c static void ToRGB(int y, int u, int v, uint32* const dst) {
u                 153 ext/gd/libgd/webpimg.c   const int g_off = (kVToG[v] + kUToG[u]) >> RGB_FRAC;
u                 154 ext/gd/libgd/webpimg.c   const int b_off = kUToB[u];
u                  61 ext/hash/hash_gost.c #define X(w, u, v) \
u                  62 ext/hash/hash_gost.c 	w[0] = u[0] ^ v[0]; \
u                  63 ext/hash/hash_gost.c 	w[1] = u[1] ^ v[1]; \
u                  64 ext/hash/hash_gost.c 	w[2] = u[2] ^ v[2]; \
u                  65 ext/hash/hash_gost.c 	w[3] = u[3] ^ v[3]; \
u                  66 ext/hash/hash_gost.c 	w[4] = u[4] ^ v[4]; \
u                  67 ext/hash/hash_gost.c 	w[5] = u[5] ^ v[5]; \
u                  68 ext/hash/hash_gost.c 	w[6] = u[6] ^ v[6]; \
u                  69 ext/hash/hash_gost.c 	w[7] = u[7] ^ v[7];
u                 129 ext/hash/hash_gost.c #define SHIFT12(u, m, s) \
u                 130 ext/hash/hash_gost.c 	u[0] = m[0] ^ s[6]; \
u                 131 ext/hash/hash_gost.c 	u[1] = m[1] ^ s[7]; \
u                 132 ext/hash/hash_gost.c 	u[2] = m[2] ^ (s[0] << 16) ^ (s[0] >> 16) ^ (s[0] & 0xffff) ^ \
u                 135 ext/hash/hash_gost.c 	u[3] = m[3] ^ (s[0] & 0xffff) ^ (s[0] << 16) ^ (s[1] & 0xffff) ^ \
u                 139 ext/hash/hash_gost.c 	u[4] = m[4] ^ \
u                 144 ext/hash/hash_gost.c 	u[5] = m[5] ^ (s[0] << 16) ^ (s[0] >> 16) ^ (s[0] & 0xffff0000) ^ \
u                 148 ext/hash/hash_gost.c 	u[6] = m[6] ^ s[0] ^ (s[1] >> 16) ^ (s[2] << 16) ^ s[3] ^ (s[3] >> 16) ^ \
u                 151 ext/hash/hash_gost.c 	u[7] = m[7] ^ (s[0] & 0xffff0000) ^ (s[0] << 16) ^ (s[1] & 0xffff) ^ \
u                 156 ext/hash/hash_gost.c #define SHIFT16(h, v, u) \
u                 157 ext/hash/hash_gost.c 	v[0] = h[0] ^ (u[1] << 16) ^ (u[0] >> 16); \
u                 158 ext/hash/hash_gost.c 	v[1] = h[1] ^ (u[2] << 16) ^ (u[1] >> 16); \
u                 159 ext/hash/hash_gost.c 	v[2] = h[2] ^ (u[3] << 16) ^ (u[2] >> 16); \
u                 160 ext/hash/hash_gost.c 	v[3] = h[3] ^ (u[4] << 16) ^ (u[3] >> 16); \
u                 161 ext/hash/hash_gost.c 	v[4] = h[4] ^ (u[5] << 16) ^ (u[4] >> 16); \
u                 162 ext/hash/hash_gost.c 	v[5] = h[5] ^ (u[6] << 16) ^ (u[5] >> 16); \
u                 163 ext/hash/hash_gost.c 	v[6] = h[6] ^ (u[7] << 16) ^ (u[6] >> 16); \
u                 164 ext/hash/hash_gost.c 	v[7] = h[7] ^ (u[0] & 0xffff0000) ^ (u[0] << 16) ^ (u[7] >> 16) ^ \
u                 165 ext/hash/hash_gost.c 		(u[1] & 0xffff0000) ^ (u[1] << 16) ^ (u[6] << 16) ^ (u[7] & 0xffff0000);
u                 198 ext/hash/hash_gost.c 	X(w, u, v); \
u                 203 ext/hash/hash_gost.c 		A(u, l, r); \
u                 205 ext/hash/hash_gost.c 			C(u); \
u                 213 ext/hash/hash_gost.c 	php_hash_uint32 l, r, t, key[8], u[8], v[8], w[8], s[8], *h = context->state, *m = data;
u                 215 ext/hash/hash_gost.c 	memcpy(u, context->state, sizeof(u));
u                 221 ext/hash/hash_gost.c 	SHIFT12(u, m, s);
u                 222 ext/hash/hash_gost.c 	SHIFT16(h, v, u);
u                  36 ext/intl/collator/collator_is_numeric.c 	const UChar *u = nptr, *nstart;
u                  37 ext/intl/collator/collator_is_numeric.c 	UChar c = *u;
u                  42 ext/intl/collator/collator_is_numeric.c 		c = *++u;
u                  44 ext/intl/collator/collator_is_numeric.c 	nstart = u;
u                  47 ext/intl/collator/collator_is_numeric.c 		c = *++u;
u                  52 ext/intl/collator/collator_is_numeric.c 		c = *++u;
u                  56 ext/intl/collator/collator_is_numeric.c 		c = *++u;
u                  59 ext/intl/collator/collator_is_numeric.c 			c = *++u;
u                  64 ext/intl/collator/collator_is_numeric.c 		const UChar *e = u;
u                  67 ext/intl/collator/collator_is_numeric.c 		c = *++u;
u                  69 ext/intl/collator/collator_is_numeric.c 			c = *++u;
u                  74 ext/intl/collator/collator_is_numeric.c 			c = *++u;
u                  78 ext/intl/collator/collator_is_numeric.c 			u = e;
u                  84 ext/intl/collator/collator_is_numeric.c 		int length = u - nstart;
u                  95 ext/intl/collator/collator_is_numeric.c 		while (nstart < u) {
u                 107 ext/intl/collator/collator_is_numeric.c 			*endptr = (UChar *)u;
u                 500 ext/mbstring/oniguruma/regexec.c     int x = STATE_CHECK_POS(stk->u.state.pstr, stk->u.state.state_check);\
u                 507 ext/mbstring/oniguruma/regexec.c   stk->u.state.pcode     = (pat);\
u                 508 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr      = (s);\
u                 509 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr_prev = (sprev);\
u                 510 ext/mbstring/oniguruma/regexec.c   stk->u.state.state_check = 0;\
u                 516 ext/mbstring/oniguruma/regexec.c   stk->u.state.pcode = (pat);\
u                 517 ext/mbstring/oniguruma/regexec.c   stk->u.state.state_check = 0;\
u                 524 ext/mbstring/oniguruma/regexec.c   stk->u.state.pcode     = (pat);\
u                 525 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr      = (s);\
u                 526 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr_prev = (sprev);\
u                 527 ext/mbstring/oniguruma/regexec.c   stk->u.state.state_check = ((state_check_buff != NULL) ? (snum) : 0);\
u                 535 ext/mbstring/oniguruma/regexec.c     stk->u.state.pstr = (s);\
u                 536 ext/mbstring/oniguruma/regexec.c     stk->u.state.state_check = (snum);\
u                 548 ext/mbstring/oniguruma/regexec.c   stk->u.state.pcode     = (pat);\
u                 549 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr      = (s);\
u                 550 ext/mbstring/oniguruma/regexec.c   stk->u.state.pstr_prev = (sprev);\
u                 556 ext/mbstring/oniguruma/regexec.c   stk->u.state.pcode = (pat);\
u                 571 ext/mbstring/oniguruma/regexec.c   stk->u.repeat.num    = (id);\
u                 572 ext/mbstring/oniguruma/regexec.c   stk->u.repeat.pcode  = (pat);\
u                 573 ext/mbstring/oniguruma/regexec.c   stk->u.repeat.count  = 0;\
u                 580 ext/mbstring/oniguruma/regexec.c   stk->u.repeat_inc.si  = (sindex);\
u                 587 ext/mbstring/oniguruma/regexec.c   stk->u.mem.num      = (mnum);\
u                 588 ext/mbstring/oniguruma/regexec.c   stk->u.mem.pstr     = (s);\
u                 589 ext/mbstring/oniguruma/regexec.c   stk->u.mem.start    = mem_start_stk[mnum];\
u                 590 ext/mbstring/oniguruma/regexec.c   stk->u.mem.end      = mem_end_stk[mnum];\
u                 599 ext/mbstring/oniguruma/regexec.c   stk->u.mem.num    = (mnum);\
u                 600 ext/mbstring/oniguruma/regexec.c   stk->u.mem.pstr   = (s);\
u                 601 ext/mbstring/oniguruma/regexec.c   stk->u.mem.start  = mem_start_stk[mnum];\
u                 602 ext/mbstring/oniguruma/regexec.c   stk->u.mem.end    = mem_end_stk[mnum];\
u                 610 ext/mbstring/oniguruma/regexec.c   stk->u.mem.num = (mnum);\
u                 620 ext/mbstring/oniguruma/regexec.c       && k->u.mem.num == (mnum)) {\
u                 623 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
u                 633 ext/mbstring/oniguruma/regexec.c     if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
u                 634 ext/mbstring/oniguruma/regexec.c       if (level == 0) (start) = k->u.mem.pstr;\
u                 637 ext/mbstring/oniguruma/regexec.c     else if (k->type == STK_MEM_END && k->u.mem.num == (mnum)) {\
u                 640 ext/mbstring/oniguruma/regexec.c         (end) = k->u.mem.pstr;\
u                 651 ext/mbstring/oniguruma/regexec.c   stk->u.null_check.num  = (cnum);\
u                 652 ext/mbstring/oniguruma/regexec.c   stk->u.null_check.pstr = (s);\
u                 659 ext/mbstring/oniguruma/regexec.c   stk->u.null_check.num  = (cnum);\
u                 666 ext/mbstring/oniguruma/regexec.c   stk->u.call_frame.ret_addr = (pat);\
u                 708 ext/mbstring/oniguruma/regexec.c         mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 709 ext/mbstring/oniguruma/regexec.c         mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 720 ext/mbstring/oniguruma/regexec.c         mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 721 ext/mbstring/oniguruma/regexec.c         mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 724 ext/mbstring/oniguruma/regexec.c         STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
u                 727 ext/mbstring/oniguruma/regexec.c         mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 728 ext/mbstring/oniguruma/regexec.c         mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 742 ext/mbstring/oniguruma/regexec.c       mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 743 ext/mbstring/oniguruma/regexec.c       mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 746 ext/mbstring/oniguruma/regexec.c       STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
u                 749 ext/mbstring/oniguruma/regexec.c       mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 750 ext/mbstring/oniguruma/regexec.c       mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 762 ext/mbstring/oniguruma/regexec.c       mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 763 ext/mbstring/oniguruma/regexec.c       mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 766 ext/mbstring/oniguruma/regexec.c       STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
u                 769 ext/mbstring/oniguruma/regexec.c       mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
u                 770 ext/mbstring/oniguruma/regexec.c       mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
u                 812 ext/mbstring/oniguruma/regexec.c       if (k->u.null_check.num == (id)) {\
u                 813 ext/mbstring/oniguruma/regexec.c         (isnull) = (k->u.null_check.pstr == (s));\
u                 827 ext/mbstring/oniguruma/regexec.c       if (k->u.null_check.num == (id)) {\
u                 829 ext/mbstring/oniguruma/regexec.c           (isnull) = (k->u.null_check.pstr == (s));\
u                 847 ext/mbstring/oniguruma/regexec.c       if (k->u.null_check.num == (id)) {\
u                 848 ext/mbstring/oniguruma/regexec.c         if (k->u.null_check.pstr != (s)) {\
u                 857 ext/mbstring/oniguruma/regexec.c               if (k->u.mem.end == INVALID_STACK_INDEX) {\
u                 860 ext/mbstring/oniguruma/regexec.c               if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
u                 861 ext/mbstring/oniguruma/regexec.c                 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
u                 863 ext/mbstring/oniguruma/regexec.c                 endp = (UChar* )k->u.mem.end;\
u                 864 ext/mbstring/oniguruma/regexec.c               if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
u                 887 ext/mbstring/oniguruma/regexec.c       if (k->u.null_check.num == (id)) {\
u                 889 ext/mbstring/oniguruma/regexec.c           if (k->u.null_check.pstr != (s)) {\
u                 898 ext/mbstring/oniguruma/regexec.c                 if (k->u.mem.end == INVALID_STACK_INDEX) {\
u                 901 ext/mbstring/oniguruma/regexec.c                 if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
u                 902 ext/mbstring/oniguruma/regexec.c                   endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
u                 904 ext/mbstring/oniguruma/regexec.c                   endp = (UChar* )k->u.mem.end;\
u                 905 ext/mbstring/oniguruma/regexec.c                 if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
u                 923 ext/mbstring/oniguruma/regexec.c       if (k->u.null_check.num == (id)) level++;\
u                 936 ext/mbstring/oniguruma/regexec.c         if (k->u.repeat.num == (id)) {\
u                 954 ext/mbstring/oniguruma/regexec.c         (addr) = k->u.call_frame.ret_addr;\
u                1046 ext/mbstring/oniguruma/regexec.c       n = k->u.mem.num;
u                1052 ext/mbstring/oniguruma/regexec.c         child->beg = (int )(k->u.mem.pstr - str);
u                1060 ext/mbstring/oniguruma/regexec.c         child->end = (int )(k->u.mem.pstr - str);
u                1064 ext/mbstring/oniguruma/regexec.c       if (k->u.mem.num == node->group) {
u                1065 ext/mbstring/oniguruma/regexec.c         node->end = (int )(k->u.mem.pstr - str);
u                1111 ext/mbstring/oniguruma/regexec.c 	if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
u                1112 ext/mbstring/oniguruma/regexec.c 	  pstart = k->u.mem.pstr;
u                1135 ext/mbstring/oniguruma/regexec.c 	if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
u                1136 ext/mbstring/oniguruma/regexec.c 	  pend = k->u.mem.pstr;
u                1342 ext/mbstring/oniguruma/regexec.c 		  rmt[i].rm_so = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
u                1347 ext/mbstring/oniguruma/regexec.c 				? STACK_AT(mem_end_stk[i])->u.mem.pstr
u                1362 ext/mbstring/oniguruma/regexec.c 		  region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
u                1367 ext/mbstring/oniguruma/regexec.c 				  ? STACK_AT(mem_end_stk[i])->u.mem.pstr
u                2119 ext/mbstring/oniguruma/regexec.c 	mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr);
u                2151 ext/mbstring/oniguruma/regexec.c 	  pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
u                2156 ext/mbstring/oniguruma/regexec.c 		? STACK_AT(mem_end_stk[mem])->u.mem.pstr
u                2183 ext/mbstring/oniguruma/regexec.c 	  pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
u                2188 ext/mbstring/oniguruma/regexec.c 		? STACK_AT(mem_end_stk[mem])->u.mem.pstr
u                2215 ext/mbstring/oniguruma/regexec.c 	    pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
u                2220 ext/mbstring/oniguruma/regexec.c 		  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
u                2254 ext/mbstring/oniguruma/regexec.c 	    pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
u                2259 ext/mbstring/oniguruma/regexec.c 		  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
u                2541 ext/mbstring/oniguruma/regexec.c       stkp->u.repeat.count++;
u                2542 ext/mbstring/oniguruma/regexec.c       if (stkp->u.repeat.count >= reg->repeat_range[mem].upper) {
u                2545 ext/mbstring/oniguruma/regexec.c       else if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
u                2547 ext/mbstring/oniguruma/regexec.c         p = STACK_AT(si)->u.repeat.pcode; /* Don't use stkp after PUSH. */
u                2550 ext/mbstring/oniguruma/regexec.c         p = stkp->u.repeat.pcode;
u                2571 ext/mbstring/oniguruma/regexec.c       stkp->u.repeat.count++;
u                2572 ext/mbstring/oniguruma/regexec.c       if (stkp->u.repeat.count < reg->repeat_range[mem].upper) {
u                2573 ext/mbstring/oniguruma/regexec.c         if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
u                2574 ext/mbstring/oniguruma/regexec.c           UChar* pcode = stkp->u.repeat.pcode;
u                2580 ext/mbstring/oniguruma/regexec.c           p = stkp->u.repeat.pcode;
u                2584 ext/mbstring/oniguruma/regexec.c       else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) {
u                2608 ext/mbstring/oniguruma/regexec.c 	s     = stkp->u.state.pstr;
u                2609 ext/mbstring/oniguruma/regexec.c 	sprev = stkp->u.state.pstr_prev;
u                2698 ext/mbstring/oniguruma/regexec.c       p     = stk->u.state.pcode;
u                2699 ext/mbstring/oniguruma/regexec.c       s     = stk->u.state.pstr;
u                2700 ext/mbstring/oniguruma/regexec.c       sprev = stk->u.state.pstr_prev;
u                2703 ext/mbstring/oniguruma/regexec.c       if (stk->u.state.state_check != 0) {
u                 730 ext/mbstring/oniguruma/regint.h   } u;
u                2313 ext/mbstring/oniguruma/regparse.c   } u;
u                2395 ext/mbstring/oniguruma/regparse.c   tok->u.repeat.lower = low;
u                2396 ext/mbstring/oniguruma/regparse.c   tok->u.repeat.upper = up;
u                2926 ext/mbstring/oniguruma/regparse.c   tok->u.c  = c;
u                2943 ext/mbstring/oniguruma/regparse.c     tok->u.c = c;
u                2947 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_WORD;
u                2948 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                2952 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_WORD;
u                2953 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                2957 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT;
u                2958 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                2962 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT;
u                2963 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                2967 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_SPACE;
u                2968 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                2972 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_SPACE;
u                2973 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                2978 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT;
u                2979 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                2984 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT;
u                2985 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                2995 ext/mbstring/oniguruma/regparse.c 	tok->u.prop.not = (c == 'P' ? 1 : 0);
u                3000 ext/mbstring/oniguruma/regparse.c 	    tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
u                3026 ext/mbstring/oniguruma/regparse.c 	  tok->u.code = (OnigCodePoint )num;
u                3041 ext/mbstring/oniguruma/regparse.c 	tok->u.c  = num;
u                3057 ext/mbstring/oniguruma/regparse.c 	tok->u.code = (OnigCodePoint )num;
u                3073 ext/mbstring/oniguruma/regparse.c 	tok->u.c  = num;
u                3081 ext/mbstring/oniguruma/regparse.c       if (tok->u.c != num) {
u                3082 ext/mbstring/oniguruma/regparse.c 	tok->u.code = (OnigCodePoint )num;
u                3153 ext/mbstring/oniguruma/regparse.c     tok->u.c = c;
u                3159 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 0;
u                3160 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = REPEAT_INFINITE;
u                3167 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 1;
u                3168 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = REPEAT_INFINITE;
u                3175 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 0;
u                3176 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = 1;
u                3181 ext/mbstring/oniguruma/regparse.c 	tok->u.repeat.greedy     = 0;
u                3182 ext/mbstring/oniguruma/regparse.c 	tok->u.repeat.possessive = 0;
u                3192 ext/mbstring/oniguruma/regparse.c 	  tok->u.repeat.greedy     = 1;
u                3193 ext/mbstring/oniguruma/regparse.c 	  tok->u.repeat.possessive = 1;
u                3196 ext/mbstring/oniguruma/regparse.c 	  tok->u.repeat.greedy     = 1;
u                3197 ext/mbstring/oniguruma/regparse.c 	  tok->u.repeat.possessive = 0;
u                3234 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_WORD;
u                3235 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                3241 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_WORD;
u                3242 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                3248 ext/mbstring/oniguruma/regparse.c       tok->u.anchor = ANCHOR_WORD_BOUND;
u                3254 ext/mbstring/oniguruma/regparse.c       tok->u.anchor = ANCHOR_NOT_WORD_BOUND;
u                3261 ext/mbstring/oniguruma/regparse.c       tok->u.anchor = ANCHOR_WORD_BEGIN;
u                3267 ext/mbstring/oniguruma/regparse.c       tok->u.anchor = ANCHOR_WORD_END;
u                3274 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_SPACE;
u                3275 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                3281 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_SPACE;
u                3282 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                3288 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT;
u                3289 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                3295 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT;
u                3296 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                3302 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT;
u                3303 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 0;
u                3309 ext/mbstring/oniguruma/regparse.c       tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT;
u                3310 ext/mbstring/oniguruma/regparse.c       tok->u.prop.not   = 1;
u                3317 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = ANCHOR_BEGIN_BUF;
u                3323 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = ANCHOR_SEMI_END_BUF;
u                3330 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = ANCHOR_END_BUF;
u                3336 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = ANCHOR_BEGIN_POSITION;
u                3365 ext/mbstring/oniguruma/regparse.c 	  tok->u.code = (OnigCodePoint )num;
u                3380 ext/mbstring/oniguruma/regparse.c 	tok->u.c  = num;
u                3396 ext/mbstring/oniguruma/regparse.c 	tok->u.code = (OnigCodePoint )num;
u                3417 ext/mbstring/oniguruma/regparse.c 	tok->u.backref.num     = 1;
u                3418 ext/mbstring/oniguruma/regparse.c 	tok->u.backref.ref1    = num;
u                3419 ext/mbstring/oniguruma/regparse.c 	tok->u.backref.by_name = 0;
u                3421 ext/mbstring/oniguruma/regparse.c 	tok->u.backref.exist_level = 0;
u                3445 ext/mbstring/oniguruma/regparse.c 	tok->u.c  = num;
u                3466 ext/mbstring/oniguruma/regparse.c 				    env, &back_num, &tok->u.backref.level);
u                3467 ext/mbstring/oniguruma/regparse.c 	  if (r == 1) tok->u.backref.exist_level = 1;
u                3468 ext/mbstring/oniguruma/regparse.c 	  else        tok->u.backref.exist_level = 0;
u                3487 ext/mbstring/oniguruma/regparse.c 	    tok->u.backref.by_name = 0;
u                3488 ext/mbstring/oniguruma/regparse.c 	    tok->u.backref.num  = 1;
u                3489 ext/mbstring/oniguruma/regparse.c 	    tok->u.backref.ref1 = back_num;
u                3508 ext/mbstring/oniguruma/regparse.c 	    tok->u.backref.by_name = 1;
u                3510 ext/mbstring/oniguruma/regparse.c 	      tok->u.backref.num  = 1;
u                3511 ext/mbstring/oniguruma/regparse.c 	      tok->u.backref.ref1 = backs[0];
u                3514 ext/mbstring/oniguruma/regparse.c 	      tok->u.backref.num  = num;
u                3515 ext/mbstring/oniguruma/regparse.c 	      tok->u.backref.refs = backs;
u                3538 ext/mbstring/oniguruma/regparse.c 	  tok->u.call.name     = prev;
u                3539 ext/mbstring/oniguruma/regparse.c 	  tok->u.call.name_end = name_end;
u                3540 ext/mbstring/oniguruma/regparse.c 	  tok->u.call.gnum     = gnum;
u                3560 ext/mbstring/oniguruma/regparse.c 	tok->u.prop.not = (c == 'P' ? 1 : 0);
u                3565 ext/mbstring/oniguruma/regparse.c 	    tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
u                3578 ext/mbstring/oniguruma/regparse.c       if (tok->u.c != num) {
u                3580 ext/mbstring/oniguruma/regparse.c 	tok->u.code = (OnigCodePoint )num;
u                3589 ext/mbstring/oniguruma/regparse.c     tok->u.c = c;
u                3625 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 0;
u                3626 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = REPEAT_INFINITE;
u                3636 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 1;
u                3637 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = REPEAT_INFINITE;
u                3647 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.lower = 0;
u                3648 ext/mbstring/oniguruma/regparse.c       tok->u.repeat.upper = 1;
u                3704 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = (IS_SINGLELINE(env->option)
u                3711 ext/mbstring/oniguruma/regparse.c       tok->u.subtype = (IS_SINGLELINE(env->option)
u                4034 ext/mbstring/oniguruma/regparse.c   if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);
u                4192 ext/mbstring/oniguruma/regparse.c   if (r == TK_CHAR && tok->u.c == '^' && tok->escaped == 0) {
u                4221 ext/mbstring/oniguruma/regparse.c       len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c);
u                4233 ext/mbstring/oniguruma/regparse.c       v = (OnigCodePoint )tok->u.c;
u                4246 ext/mbstring/oniguruma/regparse.c 	buf[0] = tok->u.c;
u                4254 ext/mbstring/oniguruma/regparse.c 	  buf[i] = tok->u.c;
u                4285 ext/mbstring/oniguruma/regparse.c 	v = (OnigCodePoint )tok->u.c;
u                4294 ext/mbstring/oniguruma/regparse.c       v = tok->u.code;
u                4315 ext/mbstring/oniguruma/regparse.c 	v = (OnigCodePoint )tok->u.c;
u                4323 ext/mbstring/oniguruma/regparse.c       r = add_ctype_to_cc(cc, tok->u.prop.ctype, tok->u.prop.not, env);
u                4337 ext/mbstring/oniguruma/regparse.c 	r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env);
u                4362 ext/mbstring/oniguruma/regparse.c 	v = (OnigCodePoint )tok->u.c;
u                5107 ext/mbstring/oniguruma/regparse.c       *np = node_new_str_raw_char((UChar )tok->u.c);
u                5137 ext/mbstring/oniguruma/regparse.c 	r = node_str_cat_char(*np, (UChar )tok->u.c);
u                5148 ext/mbstring/oniguruma/regparse.c       int num = ONIGENC_CODE_TO_MBC(env->enc, tok->u.code, buf);
u                5179 ext/mbstring/oniguruma/regparse.c       switch (tok->u.prop.ctype) {
u                5181 ext/mbstring/oniguruma/regparse.c 	*np = node_new_ctype(tok->u.prop.ctype, tok->u.prop.not);
u                5195 ext/mbstring/oniguruma/regparse.c           r = ONIGENC_GET_CTYPE_CODE_RANGE(env->enc, tok->u.prop.ctype,
u                5204 ext/mbstring/oniguruma/regparse.c             key.not  = tok->u.prop.not;
u                5205 ext/mbstring/oniguruma/regparse.c             key.type = tok->u.prop.ctype;
u                5225 ext/mbstring/oniguruma/regparse.c             *np = node_new_cclass_by_codepoint_range(tok->u.prop.not,
u                5246 ext/mbstring/oniguruma/regparse.c             add_ctype_to_cc(cc, tok->u.prop.ctype, 0, env);
u                5247 ext/mbstring/oniguruma/regparse.c             if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);
u                5315 ext/mbstring/oniguruma/regparse.c     len = tok->u.backref.num;
u                5317 ext/mbstring/oniguruma/regparse.c 		   (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)),
u                5318 ext/mbstring/oniguruma/regparse.c 			   tok->u.backref.by_name,
u                5320 ext/mbstring/oniguruma/regparse.c 			   tok->u.backref.exist_level,
u                5321 ext/mbstring/oniguruma/regparse.c 			   tok->u.backref.level,
u                5330 ext/mbstring/oniguruma/regparse.c       int gnum = tok->u.call.gnum;
u                5337 ext/mbstring/oniguruma/regparse.c       *np = node_new_call(tok->u.call.name, tok->u.call.name_end, gnum);
u                5345 ext/mbstring/oniguruma/regparse.c     *np = onig_node_new_anchor(tok->u.anchor);
u                5378 ext/mbstring/oniguruma/regparse.c       qn = node_new_quantifier(tok->u.repeat.lower, tok->u.repeat.upper,
u                5381 ext/mbstring/oniguruma/regparse.c       NQTFR(qn)->greedy = tok->u.repeat.greedy;
u                5388 ext/mbstring/oniguruma/regparse.c       if (tok->u.repeat.possessive != 0) {
u                  66 ext/mbstring/oniguruma/regparse.h #define NTYPE(node)             ((node)->u.base.type)
u                  67 ext/mbstring/oniguruma/regparse.h #define SET_NTYPE(node, ntype)   (node)->u.base.type = (ntype)
u                  69 ext/mbstring/oniguruma/regparse.h #define NSTR(node)         (&((node)->u.str))
u                  70 ext/mbstring/oniguruma/regparse.h #define NCCLASS(node)      (&((node)->u.cclass))
u                  71 ext/mbstring/oniguruma/regparse.h #define NCTYPE(node)       (&((node)->u.ctype))
u                  72 ext/mbstring/oniguruma/regparse.h #define NBREF(node)        (&((node)->u.bref))
u                  73 ext/mbstring/oniguruma/regparse.h #define NQTFR(node)        (&((node)->u.qtfr))
u                  74 ext/mbstring/oniguruma/regparse.h #define NENCLOSE(node)     (&((node)->u.enclose))
u                  75 ext/mbstring/oniguruma/regparse.h #define NANCHOR(node)      (&((node)->u.anchor))
u                  76 ext/mbstring/oniguruma/regparse.h #define NCONS(node)        (&((node)->u.cons))
u                  77 ext/mbstring/oniguruma/regparse.h #define NCALL(node)        (&((node)->u.call))
u                  99 ext/mbstring/oniguruma/regparse.h #define NSTRING_LEN(node)             ((node)->u.str.end - (node)->u.str.s)
u                 100 ext/mbstring/oniguruma/regparse.h #define NSTRING_SET_RAW(node)          (node)->u.str.flag |= NSTR_RAW
u                 101 ext/mbstring/oniguruma/regparse.h #define NSTRING_CLEAR_RAW(node)        (node)->u.str.flag &= ~NSTR_RAW
u                 102 ext/mbstring/oniguruma/regparse.h #define NSTRING_SET_AMBIG(node)        (node)->u.str.flag |= NSTR_AMBIG
u                 104 ext/mbstring/oniguruma/regparse.h   (node)->u.str.flag |= NSTR_DONT_GET_OPT_INFO
u                 105 ext/mbstring/oniguruma/regparse.h #define NSTRING_IS_RAW(node)          (((node)->u.str.flag & NSTR_RAW)   != 0)
u                 106 ext/mbstring/oniguruma/regparse.h #define NSTRING_IS_AMBIG(node)        (((node)->u.str.flag & NSTR_AMBIG) != 0)
u                 108 ext/mbstring/oniguruma/regparse.h   (((node)->u.str.flag & NSTR_DONT_GET_OPT_INFO) != 0)
u                 135 ext/mbstring/oniguruma/regparse.h #define SET_ENCLOSE_STATUS(node,f)      (node)->u.enclose.state |=  (f)
u                 136 ext/mbstring/oniguruma/regparse.h #define CLEAR_ENCLOSE_STATUS(node,f)    (node)->u.enclose.state &= ~(f)
u                 150 ext/mbstring/oniguruma/regparse.h #define SET_CALL_RECURSION(node)       (node)->u.call.state |= NST_RECURSION
u                 267 ext/mbstring/oniguruma/regparse.h   } u;
u                  42 ext/mysqli/mysqli_libmysql.h #define mysqli_change_user_silent(c, u, p, d, p_len)   mysql_change_user((c), (u), (p), (d))
u                  44 ext/mysqli/mysqli_mysqlnd.h #define mysqli_change_user_silent(c, u, p, d, p_len)   mysqlnd_change_user_ex((c), (u), (p), (d), TRUE, (size_t)(p_len))
u                 549 ext/opcache/Optimizer/block_pass.c # define VAR_NUM_EX(op) ((op).op_type == IS_TMP_VAR || (op).op_type == IS_VAR? VAR_NUM((op).u.var) : (op).u.var)
u                 551 ext/opcache/Optimizer/block_pass.c # define VAR_SOURCE(op) Tsource[VAR_NUM(op.u.var)]
u                1861 ext/opcache/Optimizer/block_pass.c 		   !defined_here[VAR_NUM(op.u.var)] && !used_ext[VAR_NUM(op.u.var)]) {	\
u                1862 ext/opcache/Optimizer/block_pass.c 			used_ext[VAR_NUM(op.u.var)] = 1;									\
u                1866 ext/opcache/Optimizer/block_pass.c # define NEVER_USED(op) ((op.op_type == IS_VAR || op.op_type == IS_TMP_VAR) && !usage[VAR_NUM(op.u.var)]) /* !used_ext[op.u.var] && */
u                  33 ext/opcache/Optimizer/compact_literals.c 	} u;
u                  45 ext/opcache/Optimizer/compact_literals.c 		info[n].u.num = (_num); \
u                  50 ext/opcache/Optimizer/compact_literals.c 		info[n].u.num = (_num); \
u                 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));
u                 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;
u                 130 ext/opcache/Optimizer/zend_optimizer.c # define LITERAL_LONG(op, val) ZVAL_LONG(&op.u.constant, val)
u                 132 ext/opcache/Optimizer/zend_optimizer.c # define LITERAL_BOOL(op, val) ZVAL_BOOL(&op.u.constant, val)
u                  50 ext/opcache/Optimizer/zend_optimizer_internal.h # define RESULT_USED(op)	((op->result.op_type == IS_VAR && (op->result.u.EA.type & EXT_TYPE_UNUSED) == 0) || (op->result.op_type == IS_TMP_VAR))
u                  51 ext/opcache/Optimizer/zend_optimizer_internal.h # define RESULT_UNUSED(op)	((op->result.op_type == IS_VAR) && (op->result.u.EA.type == EXT_TYPE_UNUSED))
u                  52 ext/opcache/Optimizer/zend_optimizer_internal.h # define SAME_VAR(op1, op2) 	(((op1.op_type == IS_VAR && op2.op_type == IS_VAR) || (op1.op_type == IS_TMP_VAR && op2.op_type == IS_TMP_VAR)) && op1.u.var == op2.u.var)
u                1506 ext/opcache/ZendAccelerator.c  	     ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
u                1507 ext/opcache/ZendAccelerator.c  	      (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
u                1665 ext/opcache/ZendAccelerator.c  			    ((*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_INCLUDE_ONCE &&
u                1666 ext/opcache/ZendAccelerator.c  			     (*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_REQUIRE_ONCE)) {
u                1847 ext/opcache/ZendAccelerator.c                 (opline->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
u                1848 ext/opcache/ZendAccelerator.c                  opline->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE)) {
u                1858 ext/opcache/ZendAccelerator.c 					filename_len = Z_STRLEN(opline->op1.u.constant);
u                1949 ext/opcache/ZendAccelerator.c               ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
u                1950 ext/opcache/ZendAccelerator.c                (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
u                2014 ext/opcache/ZendAccelerator.c               ((*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_INCLUDE_ONCE ||
u                2015 ext/opcache/ZendAccelerator.c                (*EG(opline_ptr))->op2.u.constant.value.lval == ZEND_REQUIRE_ONCE))) {
u                 385 ext/opcache/ZendAccelerator.h # define ZEND_RESULT(opline)		(opline)->result.u
u                 387 ext/opcache/ZendAccelerator.h # define ZEND_OP1(opline)			(opline)->op1.u
u                 388 ext/opcache/ZendAccelerator.h # define ZEND_OP1_CONST(opline)		(opline)->op1.u.constant
u                 389 ext/opcache/ZendAccelerator.h # define ZEND_OP1_LITERAL(opline)	(opline)->op1.u.constant
u                 391 ext/opcache/ZendAccelerator.h # define ZEND_OP2(opline)			(opline)->op2.u
u                 392 ext/opcache/ZendAccelerator.h # define ZEND_OP2_CONST(opline)		(opline)->op2.u.constant
u                 393 ext/opcache/ZendAccelerator.h # define ZEND_OP2_LITERAL(opline)	(opline)->op2.u.constant
u                 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 ||
u                 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 &&
u                 235 ext/opcache/zend_accelerator_util_funcs.c 		node->u.val = (zval*)(node + 1);
u                 236 ext/opcache/zend_accelerator_util_funcs.c 		*node->u.val = *ast->u.val;
u                 237 ext/opcache/zend_accelerator_util_funcs.c 		if ((Z_TYPE_P(ast->u.val) & IS_CONSTANT_TYPE_MASK) >= IS_ARRAY) {
u                 238 ext/opcache/zend_accelerator_util_funcs.c 			switch ((Z_TYPE_P(ast->u.val) & IS_CONSTANT_TYPE_MASK)) {
u                 241 ext/opcache/zend_accelerator_util_funcs.c 					Z_STRVAL_P(node->u.val) = (char *) interned_estrndup(Z_STRVAL_P(ast->u.val), Z_STRLEN_P(ast->u.val));
u                 247 ext/opcache/zend_accelerator_util_funcs.c 					if (ast->u.val->value.ht && ast->u.val->value.ht != &EG(symbol_table)) {
u                 248 ext/opcache/zend_accelerator_util_funcs.c 						ALLOC_HASHTABLE(node->u.val->value.ht);
u                 249 ext/opcache/zend_accelerator_util_funcs.c 						zend_hash_clone_zval(node->u.val->value.ht, ast->u.val->value.ht, 0);
u                 253 ext/opcache/zend_accelerator_util_funcs.c 					Z_AST_P(node->u.val) = zend_ast_clone(Z_AST_P(ast->u.val) TSRMLS_CC);
u                 262 ext/opcache/zend_accelerator_util_funcs.c 			if ((&ast->u.child)[i]) {
u                 263 ext/opcache/zend_accelerator_util_funcs.c 				(&node->u.child)[i] = zend_ast_clone((&ast->u.child)[i] TSRMLS_CC);
u                 265 ext/opcache/zend_accelerator_util_funcs.c 				(&node->u.child)[i] = NULL;
u                 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) {
u                 990 ext/opcache/zend_accelerator_util_funcs.c 			opline_num = op_array->opcodes[opline_num].result.u.opline_num;
u                 150 ext/opcache/zend_persist.c 		node->u.val = (zval*)(node + 1);
u                 151 ext/opcache/zend_persist.c 		zend_persist_zval(node->u.val TSRMLS_CC);
u                 155 ext/opcache/zend_persist.c 			if ((&node->u.child)[i]) {
u                 156 ext/opcache/zend_persist.c 				(&node->u.child)[i] = zend_persist_ast((&node->u.child)[i] TSRMLS_CC);
u                 288 ext/opcache/zend_persist.c 				zend_persist_zval(&opline->op1.u.constant TSRMLS_CC);
u                 289 ext/opcache/zend_persist.c 				zend_protect_zval(&opline->op1.u.constant TSRMLS_CC);
u                 296 ext/opcache/zend_persist.c 				zend_persist_zval(&opline->op2.u.constant TSRMLS_CC);
u                 297 ext/opcache/zend_persist.c 				zend_protect_zval(&opline->op2.u.constant TSRMLS_CC);
u                 333 ext/opcache/zend_persist.c 							opline_num = &new_opcodes[*opline_num].result.u.opline_num;
u                 337 ext/opcache/zend_persist.c 						opline->result.u.opline_num = -1;
u                 105 ext/opcache/zend_persist_calc.c 		ADD_SIZE(zend_persist_zval_calc(ast->u.val TSRMLS_CC));
u                 109 ext/opcache/zend_persist_calc.c 			if ((&ast->u.child)[i]) {
u                 110 ext/opcache/zend_persist_calc.c 				ADD_SIZE(zend_persist_ast_calc((&ast->u.child)[i] TSRMLS_CC));
u                 191 ext/opcache/zend_persist_calc.c 				ADD_SIZE(zend_persist_zval_calc(&opline->op1.u.constant TSRMLS_CC));
u                 194 ext/opcache/zend_persist_calc.c 				ADD_SIZE(zend_persist_zval_calc(&opline->op2.u.constant TSRMLS_CC));
u                 260 ext/pcre/pcrelib/pcre_jit_compile.c   } u;
u                7075 ext/pcre/pcrelib/pcre_jit_compile.c     BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);
u                7117 ext/pcre/pcrelib/pcre_jit_compile.c       if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
u                7126 ext/pcre/pcrelib/pcre_jit_compile.c         braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));
u                7166 ext/pcre/pcrelib/pcre_jit_compile.c   if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
u                7177 ext/pcre/pcrelib/pcre_jit_compile.c       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
u                7198 ext/pcre/pcrelib/pcre_jit_compile.c       if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
u                7210 ext/pcre/pcrelib/pcre_jit_compile.c     stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
u                7232 ext/pcre/pcrelib/pcre_jit_compile.c     init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
u                7277 ext/pcre/pcrelib/pcre_jit_compile.c     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
u                7299 ext/pcre/pcrelib/pcre_jit_compile.c     add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_ZERO));
u                7305 ext/pcre/pcrelib/pcre_jit_compile.c     BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
u                7368 ext/pcre/pcrelib/pcre_jit_compile.c     BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
u                7378 ext/pcre/pcrelib/pcre_jit_compile.c   match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
u                7497 ext/pcre/pcrelib/pcre_jit_compile.c     if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)
u                7518 ext/pcre/pcrelib/pcre_jit_compile.c   BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);
u                8908 ext/pcre/pcrelib/pcre_jit_compile.c   has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;
u                8921 ext/pcre/pcrelib/pcre_jit_compile.c   needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;
u                8922 ext/pcre/pcrelib/pcre_jit_compile.c   CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;
u                8961 ext/pcre/pcrelib/pcre_jit_compile.c       if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
u                8966 ext/pcre/pcrelib/pcre_jit_compile.c         CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
u                9016 ext/pcre/pcrelib/pcre_jit_compile.c   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
u                9067 ext/pcre/pcrelib/pcre_jit_compile.c     assert = CURRENT_AS(bracket_backtrack)->u.assert;
u                9075 ext/pcre/pcrelib/pcre_jit_compile.c     set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());
u                9077 ext/pcre/pcrelib/pcre_jit_compile.c   else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)
u                9081 ext/pcre/pcrelib/pcre_jit_compile.c     set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());
u                9120 ext/pcre/pcrelib/pcre_jit_compile.c       match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
u                9208 ext/pcre/pcrelib/pcre_jit_compile.c     assert = CURRENT_AS(bracket_backtrack)->u.assert;
u                9251 ext/pcre/pcrelib/pcre_jit_compile.c   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
u                9254 ext/pcre/pcrelib/pcre_jit_compile.c     stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
u                9265 ext/pcre/pcrelib/pcre_jit_compile.c   if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
u                9266 ext/pcre/pcrelib/pcre_jit_compile.c     OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_backtrack)->u.framesize * sizeof(sljit_sw));
u                 469 ext/pcre/pcrelib/sljit/sljitLir.c 		jump->u.label = label;
u                 478 ext/pcre/pcrelib/sljit/sljitLir.c 		jump->u.target = target;
u                 291 ext/pcre/pcrelib/sljit/sljitLir.h 	} u;
u                 404 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		diff = ((sljit_sw)jump->u.target - (sljit_sw)(code_ptr + 2));
u                 407 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)(code_ptr + 2));
u                 429 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		diff = ((sljit_sw)jump->u.target - (sljit_sw)code_ptr);
u                 432 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 		diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)code_ptr);
u                 737 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 				SLJIT_ASSERT(((sljit_sw)jump->u.label->addr - (sljit_sw)(buf_ptr + 2)) <= 0x01ffffff && ((sljit_sw)jump->u.label->addr - (sljit_sw)(buf_ptr + 2)) >= -0x02000000);
u                 738 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 				*buf_ptr |= (((sljit_sw)jump->u.label->addr - (sljit_sw)(buf_ptr + 2)) >> 2) & 0x00ffffff;
u                 741 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 				SLJIT_ASSERT(((sljit_sw)jump->u.target - (sljit_sw)(buf_ptr + 2)) <= 0x01ffffff && ((sljit_sw)jump->u.target - (sljit_sw)(buf_ptr + 2)) >= -0x02000000);
u                 742 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 				*buf_ptr |= (((sljit_sw)jump->u.target - (sljit_sw)(buf_ptr + 2)) >> 2) & 0x00ffffff;
u                 750 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 			inline_set_jump_addr((sljit_uw)code_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
u                 753 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 			inline_set_jump_addr((sljit_uw)buf_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
u                 764 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 			*buf_ptr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                 766 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 			inline_set_jump_addr((sljit_uw)buf_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
u                2462 ext/pcre/pcrelib/sljit/sljitNativeARM_32.c 	jump->u.target = srcw;
u                 165 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 		target_addr = jump->u.target;
u                 168 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 		target_addr = (sljit_uw)(code + jump->u.label->size);
u                 279 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                1960 ext/pcre/pcrelib/sljit/sljitNativeARM_64.c 	jump->u.target = srcw;
u                 233 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		if (!(jump->u.target & 0x1))
u                 235 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		diff = ((sljit_sw)jump->u.target - (sljit_sw)(code_ptr + 2)) >> 1;
u                 239 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)(code_ptr + 2)) >> 1;
u                 287 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		modify_imm32_const((sljit_uh*)jump->addr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target);
u                 292 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		SLJIT_ASSERT(jump->u.target & 0x1);
u                 293 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		diff = ((sljit_sw)jump->u.target - (sljit_sw)(jump->addr + 4)) >> 1;
u                 296 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 		diff = ((sljit_sw)(jump->u.label->addr) - (sljit_sw)(jump->addr + 4)) >> 1;
u                1968 ext/pcre/pcrelib/sljit/sljitNativeARM_T2_32.c 	jump->u.target = srcw;
u                 237 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		target_addr = jump->u.target;
u                 240 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		target_addr = (sljit_uw)(code + jump->u.label->size);
u                 436 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                1987 ext/pcre/pcrelib/sljit/sljitNativeMIPS_common.c 		jump->u.target = srcw;
u                 263 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		target_addr = jump->u.target;
u                 266 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		target_addr = (sljit_uw)(code + jump->u.label->size);
u                 436 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                2187 ext/pcre/pcrelib/sljit/sljitNativePPC_common.c 		jump->u.target = srcw;
u                 209 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		target_addr = jump->u.target;
u                 212 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		target_addr = (sljit_uw)(code + jump->u.label->size);
u                 348 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                1350 ext/pcre/pcrelib/sljit/sljitNativeSPARC_common.c 		jump->u.target = srcw;
u                 913 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		target_addr = jump->u.target;
u                 916 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		target_addr = (sljit_uw)(code + jump->u.label->size);
u                1076 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
u                2369 ext/pcre/pcrelib/sljit/sljitNativeTILEGX_64.c 		jump->u.target = srcw;
u                  60 ext/pcre/pcrelib/sljit/sljitNativeX86_32.c 		*(sljit_sw*)code_ptr = jump->u.target - (jump->addr + 4);
u                  58 ext/pcre/pcrelib/sljit/sljitNativeX86_64.c 		*(sljit_sw*)code_ptr = jump->u.target;
u                 401 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		label_addr = (sljit_uw)(code + jump->u.label->size);
u                 403 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		label_addr = jump->u.target;
u                 529 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 			SLJIT_ASSERT((sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb))) >= -128 && (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb))) <= 127);
u                 530 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 			*(sljit_ub*)jump->addr = (sljit_ub)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb)));
u                 534 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				*(sljit_sw*)jump->addr = (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sw)));
u                 536 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				SLJIT_ASSERT((sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_si))) >= HALFWORD_MIN && (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_si))) <= HALFWORD_MAX);
u                 537 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				*(sljit_si*)jump->addr = (sljit_si)(jump->u.label->addr - (jump->addr + sizeof(sljit_si)));
u                 542 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				*(sljit_sw*)jump->addr = (sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_sw)));
u                 544 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				SLJIT_ASSERT((sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_si))) >= HALFWORD_MIN && (sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_si))) <= HALFWORD_MAX);
u                 545 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 				*(sljit_si*)jump->addr = (sljit_si)(jump->u.target - (jump->addr + sizeof(sljit_si)));
u                 551 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 			*(sljit_sw*)jump->addr = jump->u.label->addr;
u                2632 ext/pcre/pcrelib/sljit/sljitNativeX86_common.c 		jump->u.target = srcw;
u                 378 ext/phar/phar_object.c 	char *e = *entry + 1, *u = NULL, *u1 = NULL, *saveu = NULL;
u                 391 ext/phar/phar_object.c 			if (u) {
u                 392 ext/phar/phar_object.c 				u[0] = '/';
u                 393 ext/phar/phar_object.c 				*ru = estrndup(u, u_len+1);
u                 395 ext/phar/phar_object.c 				u[0] = '\0';
u                 404 ext/phar/phar_object.c 		if (u) {
u                 406 ext/phar/phar_object.c 			u[0] = '/';
u                 407 ext/phar/phar_object.c 			saveu = u;
u                 409 ext/phar/phar_object.c 			u = u1;
u                 410 ext/phar/phar_object.c 			if (!u) {
u                 414 ext/phar/phar_object.c 			u = strrchr(e, '/');
u                 415 ext/phar/phar_object.c 			if (!u) {
u                 423 ext/phar/phar_object.c 		u[0] = '\0';
u                 424 ext/phar/phar_object.c 		u_len = strlen(u + 1);
u                1497 ext/phar/phar_object.c 						fname_len = spprintf(&fname, 0, "%s%c%s", test, DEFAULT_SLASH, intern->u.dir.entry.d_name);
u                 618 ext/posix/posix.c 	struct utsname u;
u                 622 ext/posix/posix.c 	if (uname(&u) < 0) {
u                 629 ext/posix/posix.c 	add_assoc_string(return_value, "sysname",  u.sysname,  1);
u                 630 ext/posix/posix.c 	add_assoc_string(return_value, "nodename", u.nodename, 1);
u                 631 ext/posix/posix.c 	add_assoc_string(return_value, "release",  u.release,  1);
u                 632 ext/posix/posix.c 	add_assoc_string(return_value, "version",  u.version,  1);
u                 633 ext/posix/posix.c 	add_assoc_string(return_value, "machine",  u.machine,  1);
u                 636 ext/posix/posix.c 	add_assoc_string(return_value, "domainname", u.domainname, 1);
u                1379 ext/soap/php_encoding.c 			if (model->u.element->name) {
u                1380 ext/soap/php_encoding.c 				xmlNodePtr node = get_node(data->children, model->u.element->name);
u                1388 ext/soap/php_encoding.c 						if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) {
u                1389 ext/soap/php_encoding.c 							soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, r_node->children->content);
u                1391 ext/soap/php_encoding.c 						val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
u                1392 ext/soap/php_encoding.c 					} else if (model->u.element->fixed) {
u                1394 ext/soap/php_encoding.c 						xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
u                1395 ext/soap/php_encoding.c 						val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
u                1397 ext/soap/php_encoding.c 					} else if (model->u.element->def && !model->u.element->nillable) {
u                1399 ext/soap/php_encoding.c 						xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
u                1400 ext/soap/php_encoding.c 						val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
u                1403 ext/soap/php_encoding.c 						val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
u                1405 ext/soap/php_encoding.c 					if ((node = get_node(node->next, model->u.element->name)) != NULL) {
u                1413 ext/soap/php_encoding.c 								if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) {
u                1414 ext/soap/php_encoding.c 									soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, node->children->content);
u                1416 ext/soap/php_encoding.c 								val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
u                1417 ext/soap/php_encoding.c 							} else if (model->u.element->fixed) {
u                1419 ext/soap/php_encoding.c 								xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
u                1420 ext/soap/php_encoding.c 								val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
u                1422 ext/soap/php_encoding.c 							} else if (model->u.element->def && !model->u.element->nillable) {
u                1424 ext/soap/php_encoding.c 								xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
u                1425 ext/soap/php_encoding.c 								val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
u                1428 ext/soap/php_encoding.c 								val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
u                1431 ext/soap/php_encoding.c 						} while ((node = get_node(node->next, model->u.element->name)) != NULL);
u                1433 ext/soap/php_encoding.c 					} else if ((Z_TYPE_P(val) != IS_NULL || !model->u.element->nillable) &&
u                1443 ext/soap/php_encoding.c 					set_zval_property(ret, model->u.element->name, val TSRMLS_CC);
u                1454 ext/soap/php_encoding.c 			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
u                1455 ext/soap/php_encoding.c 			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
u                1461 ext/soap/php_encoding.c 				zend_hash_move_forward_ex(model->u.content, &pos);
u                1469 ext/soap/php_encoding.c 			model_to_zval_object(ret, model->u.group->model, data, sdl TSRMLS_CC);
u                1704 ext/soap/php_encoding.c 			data = get_zval_property(object, model->u.element->name TSRMLS_CC);
u                1707 ext/soap/php_encoding.c 			    !model->u.element->nillable &&
u                1713 ext/soap/php_encoding.c 				enc = model->u.element->encode;
u                1722 ext/soap/php_encoding.c 						if (Z_TYPE_PP(val) == IS_NULL && model->u.element->nillable) {
u                1729 ext/soap/php_encoding.c 							    model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
u                1730 ext/soap/php_encoding.c 								soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
u                1733 ext/soap/php_encoding.c 						xmlNodeSetName(property, BAD_CAST(model->u.element->name));
u                1735 ext/soap/php_encoding.c 						    model->u.element->namens &&
u                1736 ext/soap/php_encoding.c 						    model->u.element->form == XSD_FORM_QUALIFIED) {
u                1737 ext/soap/php_encoding.c 							xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
u                1743 ext/soap/php_encoding.c 					if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) {
u                1752 ext/soap/php_encoding.c 						    model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
u                1753 ext/soap/php_encoding.c 							soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
u                1756 ext/soap/php_encoding.c 					xmlNodeSetName(property, BAD_CAST(model->u.element->name));
u                1758 ext/soap/php_encoding.c 					    model->u.element->namens &&
u                1759 ext/soap/php_encoding.c 					    model->u.element->form == XSD_FORM_QUALIFIED) {
u                1760 ext/soap/php_encoding.c 						xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
u                1765 ext/soap/php_encoding.c 			} else if (strict && model->u.element->nillable && model->min_occurs > 0) {
u                1766 ext/soap/php_encoding.c 				property = xmlNewNode(NULL, BAD_CAST(model->u.element->name));
u                1770 ext/soap/php_encoding.c 				    model->u.element->namens &&
u                1771 ext/soap/php_encoding.c 				    model->u.element->form == XSD_FORM_QUALIFIED) {
u                1772 ext/soap/php_encoding.c 					xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
u                1780 ext/soap/php_encoding.c 					soap_error1(E_ERROR,  "Encoding: object has no '%s' property", model->u.element->name);
u                1824 ext/soap/php_encoding.c 			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
u                1825 ext/soap/php_encoding.c 			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
u                1832 ext/soap/php_encoding.c 				zend_hash_move_forward_ex(model->u.content, &pos);
u                1841 ext/soap/php_encoding.c 			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
u                1842 ext/soap/php_encoding.c 			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
u                1849 ext/soap/php_encoding.c 				zend_hash_move_forward_ex(model->u.content, &pos);
u                1854 ext/soap/php_encoding.c 			return model_to_xml_object(node, model->u.group->model, object, style, strict && model->min_occurs > 0 TSRMLS_CC);
u                1867 ext/soap/php_encoding.c 			  return model->u.element;
u                1878 ext/soap/php_encoding.c 			if (zend_hash_num_elements(model->u.content) != 1) {
u                1881 ext/soap/php_encoding.c 			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
u                1882 ext/soap/php_encoding.c 			zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos);
u                1886 ext/soap/php_encoding.c 			return model_array_element(model->u.group->model);
u                1020 ext/soap/php_schema.c 	newModel->u.content = emalloc(sizeof(HashTable));
u                1021 ext/soap/php_schema.c 	zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
u                1025 ext/soap/php_schema.c 		zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
u                1099 ext/soap/php_schema.c 			newModel->u.group_ref = estrdup(key.c);
u                1106 ext/soap/php_schema.c 			newModel->u.content = emalloc(sizeof(HashTable));
u                1107 ext/soap/php_schema.c 			zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
u                1136 ext/soap/php_schema.c 			zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
u                1196 ext/soap/php_schema.c 	newModel->u.content = emalloc(sizeof(HashTable));
u                1197 ext/soap/php_schema.c 	zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
u                1201 ext/soap/php_schema.c 		zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
u                1246 ext/soap/php_schema.c 	newModel->u.content = emalloc(sizeof(HashTable));
u                1247 ext/soap/php_schema.c 	zend_hash_init(newModel->u.content, 0, NULL, delete_model, 0);
u                1251 ext/soap/php_schema.c 		zend_hash_next_index_insert(model->u.content,&newModel,sizeof(sdlContentModelPtr), NULL);
u                1301 ext/soap/php_schema.c 		zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
u                1576 ext/soap/php_schema.c 			newModel->u.element = newType;
u                1581 ext/soap/php_schema.c 			zend_hash_next_index_insert(model->u.content, &newModel, sizeof(sdlContentModelPtr), NULL);
u                2189 ext/soap/php_schema.c 			if (ctx->sdl->groups && zend_hash_find(ctx->sdl->groups, model->u.group_ref, strlen(model->u.group_ref)+1, (void**)&tmp) == SUCCESS) {
u                2191 ext/soap/php_schema.c 				efree(model->u.group_ref);
u                2193 ext/soap/php_schema.c 				model->u.group = (*tmp);
u                2195 ext/soap/php_schema.c 				soap_error1(E_ERROR, "Parsing Schema: unresolved group 'ref' attribute '%s'", model->u.group_ref);
u                2204 ext/soap/php_schema.c 				zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
u                2205 ext/soap/php_schema.c 				while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
u                2208 ext/soap/php_schema.c 					zend_hash_move_forward_ex(model->u.content, &pos);
u                2220 ext/soap/php_schema.c 			zend_hash_internal_pointer_reset(model->u.content);
u                2221 ext/soap/php_schema.c 			while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
u                2223 ext/soap/php_schema.c 				zend_hash_move_forward(model->u.content);
u                2350 ext/soap/php_schema.c 			zend_hash_destroy(tmp->u.content);
u                2351 ext/soap/php_schema.c 			efree(tmp->u.content);
u                2354 ext/soap/php_schema.c 			efree(tmp->u.group_ref);
u                2372 ext/soap/php_schema.c 			zend_hash_destroy(tmp->u.content);
u                2373 ext/soap/php_schema.c 			free(tmp->u.content);
u                2376 ext/soap/php_schema.c 			free(tmp->u.group_ref);
u                1295 ext/soap/php_sdl.c 			model->u.element = elements[i];
u                1301 ext/soap/php_sdl.c 			model->u.content = emalloc(sizeof(HashTable));
u                1302 ext/soap/php_sdl.c 			zend_hash_init(model->u.content, i, NULL, delete_model, 0);
u                1305 ext/soap/php_sdl.c 				zend_hash_next_index_insert(model->u.content,&x,sizeof(sdlContentModelPtr),NULL);
u                1310 ext/soap/php_sdl.c 			model->u.group_ref = sdl_deserialize_string(in);
u                1314 ext/soap/php_sdl.c 			model->u.group = types[i];
u                1879 ext/soap/php_sdl.c 			sdl_serialize_type_ref(model->u.element, tmp_elements, out);
u                1885 ext/soap/php_sdl.c 				int i = zend_hash_num_elements(model->u.content);
u                1888 ext/soap/php_sdl.c 				zend_hash_internal_pointer_reset(model->u.content);
u                1889 ext/soap/php_sdl.c 				while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
u                1891 ext/soap/php_sdl.c 					zend_hash_move_forward(model->u.content);
u                1896 ext/soap/php_sdl.c 			sdl_serialize_string(model->u.group_ref,out);
u                1899 ext/soap/php_sdl.c 			sdl_serialize_type_ref(model->u.group, tmp_types, out);
u                2682 ext/soap/php_sdl.c 			if (pmodel->u.element) {
u                2683 ext/soap/php_sdl.c 				make_persistent_sdl_type_ref(&pmodel->u.element, ptr_map, bp_types);
u                2690 ext/soap/php_sdl.c 			pmodel->u.content = malloc(sizeof(HashTable));
u                2691 ext/soap/php_sdl.c 			zend_hash_init(pmodel->u.content, zend_hash_num_elements(model->u.content), NULL, delete_model_persistent, 1);
u                2693 ext/soap/php_sdl.c 			zend_hash_internal_pointer_reset(model->u.content);
u                2694 ext/soap/php_sdl.c 			while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
u                2696 ext/soap/php_sdl.c 				zend_hash_next_index_insert(pmodel->u.content, (void*)&pcontent, sizeof(sdlContentModelPtr), NULL);
u                2697 ext/soap/php_sdl.c 				zend_hash_move_forward(model->u.content);
u                2702 ext/soap/php_sdl.c 			if (pmodel->u.group_ref) {
u                2703 ext/soap/php_sdl.c 				pmodel->u.group_ref = strdup(pmodel->u.group_ref);
u                2708 ext/soap/php_sdl.c 			if (pmodel->u.group) {
u                2709 ext/soap/php_sdl.c 				make_persistent_sdl_type_ref(&pmodel->u.group, ptr_map, bp_types);
u                 174 ext/soap/php_sdl.h 	} u;
u                4676 ext/soap/soap.c 			type_to_string(model->u.element, buf, level);
u                4690 ext/soap/soap.c 			zend_hash_internal_pointer_reset(model->u.content);
u                4691 ext/soap/soap.c 			while (zend_hash_get_current_data(model->u.content, (void**)&tmp) == SUCCESS) {
u                4693 ext/soap/soap.c 				zend_hash_move_forward(model->u.content);
u                4698 ext/soap/soap.c 			model_to_string(model->u.group->model, buf, level);
u                  65 ext/spl/spl_directory.c 	if (intern->u.file.current_line) {
u                  66 ext/spl/spl_directory.c 		efree(intern->u.file.current_line);
u                  67 ext/spl/spl_directory.c 		intern->u.file.current_line = NULL;
u                  69 ext/spl/spl_directory.c 	if (intern->u.file.current_zval) {
u                  70 ext/spl/spl_directory.c 		zval_ptr_dtor(&intern->u.file.current_zval);
u                  71 ext/spl/spl_directory.c 		intern->u.file.current_zval = NULL;
u                  95 ext/spl/spl_directory.c 		if (intern->u.dir.dirp) {
u                  96 ext/spl/spl_directory.c 			php_stream_close(intern->u.dir.dirp);
u                  97 ext/spl/spl_directory.c 			intern->u.dir.dirp = NULL;
u                  99 ext/spl/spl_directory.c 		if (intern->u.dir.sub_path) {
u                 100 ext/spl/spl_directory.c 			efree(intern->u.dir.sub_path);
u                 104 ext/spl/spl_directory.c 		if (intern->u.file.stream) {
u                 105 ext/spl/spl_directory.c 			if (intern->u.file.zcontext) {
u                 108 ext/spl/spl_directory.c 			if (!intern->u.file.stream->is_persistent) {
u                 109 ext/spl/spl_directory.c 				php_stream_free(intern->u.file.stream, PHP_STREAM_FREE_CLOSE);
u                 111 ext/spl/spl_directory.c 				php_stream_free(intern->u.file.stream, PHP_STREAM_FREE_CLOSE_PERSISTENT);
u                 113 ext/spl/spl_directory.c 			if (intern->u.file.open_mode) {
u                 114 ext/spl/spl_directory.c 				efree(intern->u.file.open_mode);
u                 190 ext/spl/spl_directory.c 		if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
u                 191 ext/spl/spl_directory.c 			return php_glob_stream_get_path(intern->u.dir.dirp, 0, len);
u                 218 ext/spl/spl_directory.c 			                                 slash, intern->u.dir.entry.d_name);
u                 225 ext/spl/spl_directory.c 	if (!intern->u.dir.dirp || !php_stream_readdir(intern->u.dir.dirp, &intern->u.dir.entry)) {
u                 226 ext/spl/spl_directory.c 		intern->u.dir.entry.d_name[0] = '\0';
u                 250 ext/spl/spl_directory.c 	intern->u.dir.dirp = php_stream_opendir(path, REPORT_ERRORS, FG(default_context));
u                 257 ext/spl/spl_directory.c 	intern->u.dir.index = 0;
u                 259 ext/spl/spl_directory.c 	if (EG(exception) || intern->u.dir.dirp == NULL) {
u                 260 ext/spl/spl_directory.c 		intern->u.dir.entry.d_name[0] = '\0';
u                 269 ext/spl/spl_directory.c 		} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
u                 282 ext/spl/spl_directory.c 		intern->u.file.open_mode = NULL;
u                 288 ext/spl/spl_directory.c 	intern->u.file.context = php_stream_context_from_zval(intern->u.file.zcontext, 0);
u                 289 ext/spl/spl_directory.c 	intern->u.file.stream = php_stream_open_wrapper_ex(intern->file_name, intern->u.file.open_mode, (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, intern->u.file.context);
u                 291 ext/spl/spl_directory.c 	if (!intern->file_name_len || !intern->u.file.stream) {
u                 296 ext/spl/spl_directory.c 		intern->u.file.open_mode = NULL;
u                 300 ext/spl/spl_directory.c 	if (intern->u.file.zcontext) {
u                 301 ext/spl/spl_directory.c 		zend_list_addref(Z_RESVAL_P(intern->u.file.zcontext));
u                 308 ext/spl/spl_directory.c 	intern->orig_path = estrndup(intern->u.file.stream->orig_path, strlen(intern->u.file.stream->orig_path));
u                 311 ext/spl/spl_directory.c 	intern->u.file.open_mode = estrndup(intern->u.file.open_mode, intern->u.file.open_mode_len);
u                 314 ext/spl/spl_directory.c 	ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream));
u                 315 ext/spl/spl_directory.c 	Z_SET_REFCOUNT(intern->u.file.zresource, 1);
u                 317 ext/spl/spl_directory.c 	intern->u.file.delimiter = ',';
u                 318 ext/spl/spl_directory.c 	intern->u.file.enclosure = '"';
u                 319 ext/spl/spl_directory.c 	intern->u.file.escape = '\\';
u                 321 ext/spl/spl_directory.c 	zend_hash_find(&intern->std.ce->function_table, "getcurrentline", sizeof("getcurrentline"), (void **) &intern->u.file.func_getCurr);
u                 362 ext/spl/spl_directory.c 		for(index = 0; index < source->u.dir.index; ++index) {
u                 365 ext/spl/spl_directory.c 			} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
u                 367 ext/spl/spl_directory.c 		intern->u.dir.index = index;
u                 481 ext/spl/spl_directory.c 		if (!source->u.dir.entry.d_name[0]) {
u                 534 ext/spl/spl_directory.c 			intern->u.file.open_mode = "r";
u                 535 ext/spl/spl_directory.c 			intern->u.file.open_mode_len = 1;
u                 538 ext/spl/spl_directory.c 					&intern->u.file.open_mode, &intern->u.file.open_mode_len, 
u                 539 ext/spl/spl_directory.c 					&use_include_path, &intern->u.file.zcontext) == FAILURE) {
u                 541 ext/spl/spl_directory.c 				intern->u.file.open_mode = NULL;
u                 578 ext/spl/spl_directory.c 		if (intern->u.dir.entry.d_name[0]) {
u                 631 ext/spl/spl_directory.c 		if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
u                 639 ext/spl/spl_directory.c 		if (intern->u.dir.sub_path) {
u                 640 ext/spl/spl_directory.c 			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
u                 648 ext/spl/spl_directory.c 		add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.file.open_mode, intern->u.file.open_mode_len, 1);
u                 651 ext/spl/spl_directory.c 		stmp[0] = intern->u.file.delimiter;
u                 655 ext/spl/spl_directory.c 		stmp[0] = intern->u.file.enclosure;
u                 669 ext/spl/spl_directory.c 	if (fsobj->u.dir.entry.d_name[0] == '\0' && fsobj->orig_path == NULL) {
u                 735 ext/spl/spl_directory.c 	intern->u.dir.is_recursive = instanceof_function(intern->std.ce, spl_ce_RecursiveDirectoryIterator TSRMLS_CC) ? 1 : 0;
u                 759 ext/spl/spl_directory.c 	intern->u.dir.index = 0;
u                 760 ext/spl/spl_directory.c 	if (intern->u.dir.dirp) {
u                 761 ext/spl/spl_directory.c 		php_stream_rewinddir(intern->u.dir.dirp);
u                 777 ext/spl/spl_directory.c 	if (intern->u.dir.dirp) {
u                 778 ext/spl/spl_directory.c 		RETURN_LONG(intern->u.dir.index);
u                 807 ext/spl/spl_directory.c 	intern->u.dir.index++;
u                 810 ext/spl/spl_directory.c 	} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
u                 830 ext/spl/spl_directory.c 	if (intern->u.dir.index > pos) {
u                 832 ext/spl/spl_directory.c 		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_rewind, "rewind", &retval);
u                 839 ext/spl/spl_directory.c 	while (intern->u.dir.index < pos) {
u                 841 ext/spl/spl_directory.c 		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_valid, "valid", &retval);
u                 851 ext/spl/spl_directory.c 		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_next, "next", &retval);
u                 868 ext/spl/spl_directory.c 	RETURN_BOOL(intern->u.dir.entry.d_name[0] != '\0');
u                 920 ext/spl/spl_directory.c 	RETURN_STRING(intern->u.dir.entry.d_name, 1);
u                 979 ext/spl/spl_directory.c 	php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0, &fname, &flen TSRMLS_CC);
u                1038 ext/spl/spl_directory.c 	php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), suffix, slen, &fname, &flen TSRMLS_CC);
u                1075 ext/spl/spl_directory.c 		RETURN_STRING(intern->u.dir.entry.d_name, 1);
u                1116 ext/spl/spl_directory.c 	RETURN_BOOL(spl_filesystem_is_dot(intern->u.dir.entry.d_name));
u                1308 ext/spl/spl_directory.c 	if (intern->type == SPL_FS_DIR && !intern->file_name && intern->u.dir.entry.d_name[0]) {
u                1452 ext/spl/spl_directory.c 	intern->u.dir.index = 0;
u                1453 ext/spl/spl_directory.c 	if (intern->u.dir.dirp) {
u                1454 ext/spl/spl_directory.c 		php_stream_rewinddir(intern->u.dir.dirp);
u                1458 ext/spl/spl_directory.c 	} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
u                1500 ext/spl/spl_directory.c 	if (spl_filesystem_is_invalid_or_dot(intern->u.dir.entry.d_name)) {
u                1540 ext/spl/spl_directory.c 		if (intern->u.dir.sub_path && intern->u.dir.sub_path[0]) {
u                1541 ext/spl/spl_directory.c 			subdir->u.dir.sub_path_len = spprintf(&subdir->u.dir.sub_path, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
u                1543 ext/spl/spl_directory.c 			subdir->u.dir.sub_path_len = strlen(intern->u.dir.entry.d_name);
u                1544 ext/spl/spl_directory.c 			subdir->u.dir.sub_path = estrndup(intern->u.dir.entry.d_name, subdir->u.dir.sub_path_len);
u                1563 ext/spl/spl_directory.c 	if (intern->u.dir.sub_path) {
u                1564 ext/spl/spl_directory.c 		RETURN_STRINGL(intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
u                1584 ext/spl/spl_directory.c 	if (intern->u.dir.sub_path) {
u                1585 ext/spl/spl_directory.c 		len = spprintf(&sub_name, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
u                1588 ext/spl/spl_directory.c 		RETURN_STRING(intern->u.dir.entry.d_name, 1);
u                1620 ext/spl/spl_directory.c 	if (intern->u.dir.dirp && php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
u                1621 ext/spl/spl_directory.c 		RETURN_LONG(php_glob_stream_get_count(intern->u.dir.dirp, NULL));
u                1697 ext/spl/spl_directory.c 	return object->u.dir.entry.d_name[0] != '\0' ? SUCCESS : FAILURE;
u                1715 ext/spl/spl_directory.c 	ZVAL_LONG(key, object->u.dir.index);
u                1724 ext/spl/spl_directory.c 	object->u.dir.index++;
u                1738 ext/spl/spl_directory.c 	object->u.dir.index = 0;
u                1739 ext/spl/spl_directory.c 	if (object->u.dir.dirp) {
u                1740 ext/spl/spl_directory.c 		php_stream_rewinddir(object->u.dir.dirp);
u                1794 ext/spl/spl_directory.c 		ZVAL_STRING(key, object->u.dir.entry.d_name, 1);
u                1808 ext/spl/spl_directory.c 	object->u.dir.index++;
u                1811 ext/spl/spl_directory.c 	} while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
u                1829 ext/spl/spl_directory.c 	object->u.dir.index = 0;
u                1830 ext/spl/spl_directory.c 	if (object->u.dir.dirp) {
u                1831 ext/spl/spl_directory.c 		php_stream_rewinddir(object->u.dir.dirp);
u                1835 ext/spl/spl_directory.c 	} while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
u                1906 ext/spl/spl_directory.c 				ZVAL_STRING(retval_ptr, intern->u.dir.entry.d_name, 1);
u                1910 ext/spl/spl_directory.c 				ZVAL_STRING(writeobj, intern->u.dir.entry.d_name, 1);
u                2059 ext/spl/spl_directory.c 	long line_add = (intern->u.file.current_line || intern->u.file.current_zval) ? 1 : 0;
u                2063 ext/spl/spl_directory.c 	if (php_stream_eof(intern->u.file.stream)) {
u                2070 ext/spl/spl_directory.c 	if (intern->u.file.max_line_len > 0) {
u                2071 ext/spl/spl_directory.c 		buf = safe_emalloc((intern->u.file.max_line_len + 1), sizeof(char), 0);
u                2072 ext/spl/spl_directory.c 		if (php_stream_get_line(intern->u.file.stream, buf, intern->u.file.max_line_len + 1, &line_len) == NULL) {
u                2079 ext/spl/spl_directory.c 		buf = php_stream_get_line(intern->u.file.stream, NULL, 0, &line_len);
u                2083 ext/spl/spl_directory.c 		intern->u.file.current_line = estrdup("");
u                2084 ext/spl/spl_directory.c 		intern->u.file.current_line_len = 0;
u                2091 ext/spl/spl_directory.c 		intern->u.file.current_line = buf;
u                2092 ext/spl/spl_directory.c 		intern->u.file.current_line_len = line_len;
u                2094 ext/spl/spl_directory.c 	intern->u.file.current_line_num += line_add;
u                2104 ext/spl/spl_directory.c 	zval * zresource_ptr = &intern->u.file.zresource, *retval = NULL;
u                2166 ext/spl/spl_directory.c 	} while (ret == SUCCESS && !intern->u.file.current_line_len && SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_SKIP_EMPTY));
u                2169 ext/spl/spl_directory.c 		size_t buf_len = intern->u.file.current_line_len;
u                2170 ext/spl/spl_directory.c 		char *buf = estrndup(intern->u.file.current_line, buf_len);
u                2172 ext/spl/spl_directory.c 		if (intern->u.file.current_zval) {
u                2173 ext/spl/spl_directory.c 			zval_ptr_dtor(&intern->u.file.current_zval);
u                2175 ext/spl/spl_directory.c 		ALLOC_INIT_ZVAL(intern->u.file.current_zval);
u                2177 ext/spl/spl_directory.c 		php_fgetcsv(intern->u.file.stream, delimiter, enclosure, escape, buf_len, buf, intern->u.file.current_zval TSRMLS_CC);
u                2183 ext/spl/spl_directory.c 			ZVAL_ZVAL(return_value, intern->u.file.current_zval, 1, 0);
u                2195 ext/spl/spl_directory.c 	if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || intern->u.file.func_getCurr->common.scope != spl_ce_SplFileObject) {
u                2196 ext/spl/spl_directory.c 		if (php_stream_eof(intern->u.file.stream)) {
u                2203 ext/spl/spl_directory.c 			return spl_filesystem_file_read_csv(intern, intern->u.file.delimiter, intern->u.file.enclosure, intern->u.file.escape, NULL TSRMLS_CC);
u                2205 ext/spl/spl_directory.c 			zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.file.func_getCurr, "getCurrentLine", &retval);
u                2208 ext/spl/spl_directory.c 			if (intern->u.file.current_line || intern->u.file.current_zval) {
u                2209 ext/spl/spl_directory.c 				intern->u.file.current_line_num++;
u                2213 ext/spl/spl_directory.c 				intern->u.file.current_line = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
u                2214 ext/spl/spl_directory.c 				intern->u.file.current_line_len = Z_STRLEN_P(retval);
u                2216 ext/spl/spl_directory.c 				MAKE_STD_ZVAL(intern->u.file.current_zval);
u                2217 ext/spl/spl_directory.c 				ZVAL_ZVAL(intern->u.file.current_zval, retval, 1, 0);
u                2231 ext/spl/spl_directory.c 	if (intern->u.file.current_line) {
u                2232 ext/spl/spl_directory.c 		return intern->u.file.current_line_len == 0;
u                2233 ext/spl/spl_directory.c 	} else if (intern->u.file.current_zval) {
u                2234 ext/spl/spl_directory.c 		switch(Z_TYPE_P(intern->u.file.current_zval)) {
u                2236 ext/spl/spl_directory.c 			return Z_STRLEN_P(intern->u.file.current_zval) == 0;
u                2239 ext/spl/spl_directory.c 			&& zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 1) {
u                2240 ext/spl/spl_directory.c 				zval ** first = Z_ARRVAL_P(intern->u.file.current_zval)->pListHead->pData;
u                2244 ext/spl/spl_directory.c 			return zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 0;
u                2271 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2275 ext/spl/spl_directory.c 	if (-1 == php_stream_rewind(intern->u.file.stream)) {
u                2279 ext/spl/spl_directory.c 		intern->u.file.current_line_num = 0;
u                2299 ext/spl/spl_directory.c 	intern->u.file.open_mode = NULL;
u                2300 ext/spl/spl_directory.c 	intern->u.file.open_mode_len = 0;
u                2304 ext/spl/spl_directory.c 			&intern->u.file.open_mode, &intern->u.file.open_mode_len, 
u                2305 ext/spl/spl_directory.c 			&use_include_path, &intern->u.file.zcontext) == FAILURE) {		
u                2306 ext/spl/spl_directory.c 		intern->u.file.open_mode = NULL;
u                2312 ext/spl/spl_directory.c 	if (intern->u.file.open_mode == NULL) {
u                2313 ext/spl/spl_directory.c 		intern->u.file.open_mode = "r";
u                2314 ext/spl/spl_directory.c 		intern->u.file.open_mode_len = 1;
u                2318 ext/spl/spl_directory.c 		tmp_path_len = strlen(intern->u.file.stream->orig_path);
u                2320 ext/spl/spl_directory.c 		if (tmp_path_len > 1 && IS_SLASH_AT(intern->u.file.stream->orig_path, tmp_path_len-1)) {
u                2324 ext/spl/spl_directory.c 		tmp_path = estrndup(intern->u.file.stream->orig_path, tmp_path_len);
u                2340 ext/spl/spl_directory.c 		intern->_path = estrndup(intern->u.file.stream->orig_path, intern->_path_len);
u                2373 ext/spl/spl_directory.c 	intern->u.file.open_mode = "wb";
u                2374 ext/spl/spl_directory.c 	intern->u.file.open_mode_len = 1;
u                2375 ext/spl/spl_directory.c 	intern->u.file.zcontext = NULL;
u                2407 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2412 ext/spl/spl_directory.c 	RETURN_BOOL(php_stream_eof(intern->u.file.stream));
u                2426 ext/spl/spl_directory.c 		RETURN_BOOL(intern->u.file.current_line || intern->u.file.current_zval);
u                2428 ext/spl/spl_directory.c 		if(!intern->u.file.stream) {
u                2431 ext/spl/spl_directory.c 		RETVAL_BOOL(!php_stream_eof(intern->u.file.stream));
u                2445 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2453 ext/spl/spl_directory.c 	RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
u                2466 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2471 ext/spl/spl_directory.c 	if (!intern->u.file.current_line && !intern->u.file.current_zval) {
u                2474 ext/spl/spl_directory.c 	if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || !intern->u.file.current_zval)) {
u                2475 ext/spl/spl_directory.c 		RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
u                2476 ext/spl/spl_directory.c 	} else if (intern->u.file.current_zval) {
u                2477 ext/spl/spl_directory.c 		RETURN_ZVAL(intern->u.file.current_zval, 1, 0);
u                2496 ext/spl/spl_directory.c 	RETURN_LONG(intern->u.file.current_line_num);
u                2513 ext/spl/spl_directory.c 	intern->u.file.current_line_num++;
u                2557 ext/spl/spl_directory.c 	intern->u.file.max_line_len = max_len;
u                2570 ext/spl/spl_directory.c 	RETURN_LONG((long)intern->u.file.max_line_len);
u                2608 ext/spl/spl_directory.c 	char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
u                2614 ext/spl/spl_directory.c 		if(!intern->u.file.stream) {
u                2655 ext/spl/spl_directory.c 	char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
u                2688 ext/spl/spl_directory.c 		ret = php_fputcsv(intern->u.file.stream, fields, delimiter, enclosure, escape TSRMLS_CC);
u                2730 ext/spl/spl_directory.c 		intern->u.file.delimiter = delimiter;
u                2731 ext/spl/spl_directory.c 		intern->u.file.enclosure = enclosure;
u                2732 ext/spl/spl_directory.c 		intern->u.file.escape    = escape;
u                2746 ext/spl/spl_directory.c 	delimiter[0] = intern->u.file.delimiter;
u                2748 ext/spl/spl_directory.c 	enclosure[0] = intern->u.file.enclosure;
u                2767 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2772 ext/spl/spl_directory.c 	RETURN_BOOL(!php_stream_flush(intern->u.file.stream));
u                2782 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2787 ext/spl/spl_directory.c 	ret = php_stream_tell(intern->u.file.stream);
u                2807 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2813 ext/spl/spl_directory.c 	RETURN_LONG(php_stream_seek(intern->u.file.stream, pos, whence));
u                2824 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2831 ext/spl/spl_directory.c 	result = php_stream_getc(intern->u.file.stream);
u                2837 ext/spl/spl_directory.c 			intern->u.file.current_line_num++;
u                2854 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2859 ext/spl/spl_directory.c 	if (intern->u.file.max_line_len > 0) {
u                2860 ext/spl/spl_directory.c 		ZVAL_LONG(arg2, intern->u.file.max_line_len);
u                2866 ext/spl/spl_directory.c 	intern->u.file.current_line_num++;
u                2879 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2884 ext/spl/spl_directory.c 	RETURN_LONG(php_stream_passthru(intern->u.file.stream));
u                2893 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2899 ext/spl/spl_directory.c 	intern->u.file.current_line_num++;
u                2918 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2930 ext/spl/spl_directory.c 	RETURN_LONG(php_stream_write(intern->u.file.stream, str, str_len));
u                2942 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2953 ext/spl/spl_directory.c 	Z_STRLEN_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length);
u                2976 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                2981 ext/spl/spl_directory.c 	if (!php_stream_truncate_supported(intern->u.file.stream)) {
u                2986 ext/spl/spl_directory.c 	RETURN_BOOL(0 == php_stream_truncate_set_size(intern->u.file.stream, size));
u                2999 ext/spl/spl_directory.c 	if(!intern->u.file.stream) {
u                3011 ext/spl/spl_directory.c 	while(intern->u.file.current_line_num < line_pos) {
u                 104 ext/spl/spl_directory.h 	} u;
u                1459 ext/spl/spl_iterators.c 			intern->u.limit.offset = 0; /* start at beginning */
u                1460 ext/spl/spl_iterators.c 			intern->u.limit.count = -1; /* get all */
u                1461 ext/spl/spl_iterators.c 			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|ll", &zobject, ce_inner, &intern->u.limit.offset, &intern->u.limit.count) == FAILURE) {
u                1465 ext/spl/spl_iterators.c 			if (intern->u.limit.offset < 0) {
u                1470 ext/spl/spl_iterators.c 			if (intern->u.limit.count < 0 && intern->u.limit.count != -1) {
u                1489 ext/spl/spl_iterators.c 			intern->u.caching.flags |= flags & CIT_PUBLIC;
u                1490 ext/spl/spl_iterators.c 			MAKE_STD_ZVAL(intern->u.caching.zcache);
u                1491 ext/spl/spl_iterators.c 			array_init(intern->u.caching.zcache);
u                1538 ext/spl/spl_iterators.c 			spl_instantiate(spl_ce_ArrayIterator, &intern->u.append.zarrayit, 1 TSRMLS_CC);
u                1539 ext/spl/spl_iterators.c 			zend_call_method_with_0_params(&intern->u.append.zarrayit, spl_ce_ArrayIterator, &spl_ce_ArrayIterator->constructor, "__construct", NULL);
u                1540 ext/spl/spl_iterators.c 			intern->u.append.iterator = spl_ce_ArrayIterator->get_iterator(spl_ce_ArrayIterator, intern->u.append.zarrayit, 0 TSRMLS_CC);
u                1550 ext/spl/spl_iterators.c 			intern->u.regex.use_flags = ZEND_NUM_ARGS() >= 5;
u                1551 ext/spl/spl_iterators.c 			intern->u.regex.flags = 0;
u                1552 ext/spl/spl_iterators.c 			intern->u.regex.preg_flags = 0;
u                1553 ext/spl/spl_iterators.c 			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|lll", &zobject, ce_inner, &regex, &regex_len, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) {
u                1562 ext/spl/spl_iterators.c 			intern->u.regex.mode = mode;
u                1563 ext/spl/spl_iterators.c 			intern->u.regex.regex = estrndup(regex, regex_len);
u                1564 ext/spl/spl_iterators.c 			intern->u.regex.regex_len = regex_len;
u                1565 ext/spl/spl_iterators.c 			intern->u.regex.pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC);
u                1566 ext/spl/spl_iterators.c 			if (intern->u.regex.pce == NULL) {
u                1571 ext/spl/spl_iterators.c 			intern->u.regex.pce->refcount++;
u                1589 ext/spl/spl_iterators.c 			intern->u.cbfilter = cfi;
u                1670 ext/spl/spl_iterators.c 		if (intern->u.caching.zstr) {
u                1671 ext/spl/spl_iterators.c 			zval_ptr_dtor(&intern->u.caching.zstr);
u                1672 ext/spl/spl_iterators.c 			intern->u.caching.zstr = NULL;
u                1674 ext/spl/spl_iterators.c 		if (intern->u.caching.zchildren) {
u                1675 ext/spl/spl_iterators.c 			zval_ptr_dtor(&intern->u.caching.zchildren);
u                1676 ext/spl/spl_iterators.c 			intern->u.caching.zchildren = NULL;
u                1974 ext/spl/spl_iterators.c 		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, intern->u.cbfilter->fci.function_name TSRMLS_CC);
u                2000 ext/spl/spl_iterators.c 	zend_fcall_info        *fci = &intern->u.cbfilter->fci;
u                2001 ext/spl/spl_iterators.c 	zend_fcall_info_cache  *fcc = &intern->u.cbfilter->fcc;
u                2054 ext/spl/spl_iterators.c 	if (intern->u.regex.flags & REGIT_USE_KEY) {
u                2069 ext/spl/spl_iterators.c 	switch (intern->u.regex.mode)
u                2073 ext/spl/spl_iterators.c 		count = pcre_exec(intern->u.regex.pce->re, intern->u.regex.pce->extra, subject, subject_len, 0, 0, NULL, 0);
u                2085 ext/spl/spl_iterators.c 		php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount, 
u                2086 ext/spl/spl_iterators.c 			intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC);
u                2097 ext/spl/spl_iterators.c 		php_pcre_split_impl(intern->u.regex.pce, subject, subject_len, intern->current.data, -1, intern->u.regex.preg_flags TSRMLS_CC);
u                2110 ext/spl/spl_iterators.c 		result = php_pcre_replace_impl(intern->u.regex.pce, subject, subject_len, replacement, 0, &result_len, -1, &count TSRMLS_CC);
u                2112 ext/spl/spl_iterators.c 		if (intern->u.regex.flags & REGIT_USE_KEY) {
u                2128 ext/spl/spl_iterators.c 	if (intern->u.regex.flags & REGIT_INVERTED) {
u                2147 ext/spl/spl_iterators.c 	RETURN_STRINGL(intern->u.regex.regex, intern->u.regex.regex_len, 1);
u                2162 ext/spl/spl_iterators.c 	RETURN_LONG(intern->u.regex.mode);
u                2183 ext/spl/spl_iterators.c 	intern->u.regex.mode = mode;
u                2198 ext/spl/spl_iterators.c 	RETURN_LONG(intern->u.regex.flags);
u                2214 ext/spl/spl_iterators.c 	intern->u.regex.flags = flags;
u                2229 ext/spl/spl_iterators.c 	if (intern->u.regex.use_flags) {
u                2230 ext/spl/spl_iterators.c 		RETURN_LONG(intern->u.regex.preg_flags);
u                2249 ext/spl/spl_iterators.c 	intern->u.regex.preg_flags = preg_flags;
u                2250 ext/spl/spl_iterators.c 	intern->u.regex.use_flags = 1;
u                2284 ext/spl/spl_iterators.c 		ZVAL_STRING(regex, intern->u.regex.regex, 1);
u                2285 ext/spl/spl_iterators.c 		ZVAL_LONG(mode, intern->u.regex.mode);
u                2286 ext/spl/spl_iterators.c 		ZVAL_LONG(flags, intern->u.regex.flags);
u                2287 ext/spl/spl_iterators.c 		ZVAL_LONG(preg_flags, intern->u.regex.preg_flags);
u                2359 ext/spl/spl_iterators.c 		object->u.append.iterator->funcs->dtor(object->u.append.iterator TSRMLS_CC);
u                2360 ext/spl/spl_iterators.c 		if (object->u.append.zarrayit) {
u                2361 ext/spl/spl_iterators.c 			zval_ptr_dtor(&object->u.append.zarrayit);
u                2366 ext/spl/spl_iterators.c 		if (object->u.caching.zcache) {
u                2367 ext/spl/spl_iterators.c 			zval_ptr_dtor(&object->u.caching.zcache);
u                2368 ext/spl/spl_iterators.c 			object->u.caching.zcache = NULL;
u                2374 ext/spl/spl_iterators.c 		if (object->u.regex.pce) {
u                2375 ext/spl/spl_iterators.c 			object->u.regex.pce->refcount--;
u                2377 ext/spl/spl_iterators.c 		if (object->u.regex.regex) {
u                2378 ext/spl/spl_iterators.c 			efree(object->u.regex.regex);
u                2384 ext/spl/spl_iterators.c 		if (object->u.cbfilter) {
u                2385 ext/spl/spl_iterators.c 			if (object->u.cbfilter->fci.function_name) {
u                2386 ext/spl/spl_iterators.c 				zval_ptr_dtor(&object->u.cbfilter->fci.function_name);
u                2388 ext/spl/spl_iterators.c 			if (object->u.cbfilter->fci.object_ptr) {
u                2389 ext/spl/spl_iterators.c 				zval_ptr_dtor(&object->u.cbfilter->fci.object_ptr);
u                2391 ext/spl/spl_iterators.c 			efree(object->u.cbfilter);
u                2530 ext/spl/spl_iterators.c 	if (intern->u.limit.count != -1 && intern->current.pos >= intern->u.limit.offset + intern->u.limit.count) {
u                2542 ext/spl/spl_iterators.c 	if (pos < intern->u.limit.offset) {
u                2543 ext/spl/spl_iterators.c 		zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is below the offset %ld", pos, intern->u.limit.offset);
u                2546 ext/spl/spl_iterators.c 	if (pos >= intern->u.limit.offset + intern->u.limit.count && intern->u.limit.count != -1) {
u                2547 ext/spl/spl_iterators.c 		zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is behind offset %ld plus count %ld", pos, intern->u.limit.offset, intern->u.limit.count);
u                2592 ext/spl/spl_iterators.c 	spl_limit_it_seek(intern, intern->u.limit.offset TSRMLS_CC);
u                2604 ext/spl/spl_iterators.c 	RETURN_BOOL((intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) && intern->current.data);
u                2616 ext/spl/spl_iterators.c 	if (intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) {
u                2680 ext/spl/spl_iterators.c 	return intern->u.caching.flags & CIT_VALID ? SUCCESS : FAILURE;
u                2691 ext/spl/spl_iterators.c 		intern->u.caching.flags |= CIT_VALID;
u                2693 ext/spl/spl_iterators.c 		if (intern->u.caching.flags & CIT_FULL_CACHE) {
u                2700 ext/spl/spl_iterators.c 			array_set_zval_key(HASH_OF(intern->u.caching.zcache), key, zcacheval);
u                2712 ext/spl/spl_iterators.c 				if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
u                2724 ext/spl/spl_iterators.c 						if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
u                2732 ext/spl/spl_iterators.c 						ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC);
u                2733 ext/spl/spl_iterators.c 						spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, 1, zchildren, &zflags TSRMLS_CC);
u                2739 ext/spl/spl_iterators.c 					if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
u                2747 ext/spl/spl_iterators.c 		if (intern->u.caching.flags & (CIT_TOSTRING_USE_INNER|CIT_CALL_TOSTRING)) {
u                2750 ext/spl/spl_iterators.c 			ALLOC_ZVAL(intern->u.caching.zstr);
u                2751 ext/spl/spl_iterators.c 			if (intern->u.caching.flags & CIT_TOSTRING_USE_INNER) {
u                2752 ext/spl/spl_iterators.c 				*intern->u.caching.zstr = *intern->inner.zobject;
u                2754 ext/spl/spl_iterators.c 				*intern->u.caching.zstr = *intern->current.data;
u                2756 ext/spl/spl_iterators.c 			zend_make_printable_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
u                2758 ext/spl/spl_iterators.c 				*intern->u.caching.zstr = expr_copy;
u                2759 ext/spl/spl_iterators.c 				INIT_PZVAL(intern->u.caching.zstr);
u                2760 ext/spl/spl_iterators.c 				zval_copy_ctor(intern->u.caching.zstr);
u                2763 ext/spl/spl_iterators.c 				INIT_PZVAL(intern->u.caching.zstr);
u                2764 ext/spl/spl_iterators.c 				zval_copy_ctor(intern->u.caching.zstr);
u                2769 ext/spl/spl_iterators.c 		intern->u.caching.flags &= ~CIT_VALID;
u                2776 ext/spl/spl_iterators.c 	zend_hash_clean(HASH_OF(intern->u.caching.zcache));
u                2855 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT|CIT_TOSTRING_USE_INNER)))	{
u                2859 ext/spl/spl_iterators.c 	if (intern->u.caching.flags & CIT_TOSTRING_USE_KEY) {
u                2863 ext/spl/spl_iterators.c 	} else if (intern->u.caching.flags & CIT_TOSTRING_USE_CURRENT) {
u                2868 ext/spl/spl_iterators.c 	if (intern->u.caching.zstr) {
u                2869 ext/spl/spl_iterators.c 		RETURN_STRINGL(Z_STRVAL_P(intern->u.caching.zstr), Z_STRLEN_P(intern->u.caching.zstr), 1);
u                2886 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                2896 ext/spl/spl_iterators.c 	zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL);
u                2911 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                2920 ext/spl/spl_iterators.c 	if (zend_symtable_find(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, (void**)&value) == FAILURE) {
u                2939 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                2948 ext/spl/spl_iterators.c 	zend_symtable_del(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1);
u                2962 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                2971 ext/spl/spl_iterators.c 	RETURN_BOOL(zend_symtable_exists(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1));
u                2987 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                2992 ext/spl/spl_iterators.c 	RETURN_ZVAL(intern->u.caching.zcache, 1, 0);
u                3008 ext/spl/spl_iterators.c 	RETURN_LONG(intern->u.caching.flags);
u                3029 ext/spl/spl_iterators.c 	if ((intern->u.caching.flags & CIT_CALL_TOSTRING) != 0 && (flags & CIT_CALL_TOSTRING) == 0) {
u                3033 ext/spl/spl_iterators.c 	if ((intern->u.caching.flags & CIT_TOSTRING_USE_INNER) != 0 && (flags & CIT_TOSTRING_USE_INNER) == 0) {
u                3037 ext/spl/spl_iterators.c 	if ((flags & CIT_FULL_CACHE) != 0 && (intern->u.caching.flags & CIT_FULL_CACHE) == 0) {
u                3039 ext/spl/spl_iterators.c 		zend_hash_clean(HASH_OF(intern->u.caching.zcache));
u                3041 ext/spl/spl_iterators.c 	intern->u.caching.flags = (intern->u.caching.flags & ~CIT_PUBLIC) | (flags & CIT_PUBLIC);
u                3057 ext/spl/spl_iterators.c 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
u                3062 ext/spl/spl_iterators.c 	RETURN_LONG(zend_hash_num_elements(HASH_OF(intern->u.caching.zcache)));
u                3124 ext/spl/spl_iterators.c 	RETURN_BOOL(intern->u.caching.zchildren);
u                3139 ext/spl/spl_iterators.c 	if (intern->u.caching.zchildren) {
u                3140 ext/spl/spl_iterators.c 		RETURN_ZVAL(intern->u.caching.zchildren, 1, 0);
u                3384 ext/spl/spl_iterators.c 	if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) == SUCCESS) {
u                3387 ext/spl/spl_iterators.c 		intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC);
u                3403 ext/spl/spl_iterators.c 		intern->u.append.iterator->funcs->move_forward(intern->u.append.iterator TSRMLS_CC);
u                3438 ext/spl/spl_iterators.c 	spl_array_iterator_append(intern->u.append.zarrayit, it TSRMLS_CC);
u                3441 ext/spl/spl_iterators.c 		if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) != SUCCESS) {
u                3442 ext/spl/spl_iterators.c 			intern->u.append.iterator->funcs->rewind(intern->u.append.iterator TSRMLS_CC);
u                3463 ext/spl/spl_iterators.c 	intern->u.append.iterator->funcs->rewind(intern->u.append.iterator TSRMLS_CC);
u                3512 ext/spl/spl_iterators.c 	spl_array_iterator_key(intern->u.append.zarrayit, return_value TSRMLS_CC);
u                3527 ext/spl/spl_iterators.c 	RETURN_ZVAL(intern->u.append.zarrayit, 1, 0);
u                 167 ext/spl/spl_iterators.h 	} u;
u                11932 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                12066 ext/sqlite3/libsqlite/sqlite3.c     } u;
u                12865 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                14673 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                17929 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                17986 ext/sqlite3/libsqlite/sqlite3.c   u32 next = mem3.aPool[i].u.list.next;
u                17987 ext/sqlite3/libsqlite/sqlite3.c   u32 prev = mem3.aPool[i].u.list.prev;
u                17992 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[prev].u.list.next = next;
u                17995 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[next].u.list.prev = prev;
u                17997 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i].u.list.next = 0;
u                17998 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i].u.list.prev = 0;
u                18008 ext/sqlite3/libsqlite/sqlite3.c   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
u                18010 ext/sqlite3/libsqlite/sqlite3.c   size = mem3.aPool[i-1].u.hdr.size4x/4;
u                18011 ext/sqlite3/libsqlite/sqlite3.c   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
u                18027 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i].u.list.next = *pRoot;
u                18028 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i].u.list.prev = 0;
u                18030 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[*pRoot].u.list.prev = i;
u                18043 ext/sqlite3/libsqlite/sqlite3.c   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
u                18044 ext/sqlite3/libsqlite/sqlite3.c   size = mem3.aPool[i-1].u.hdr.size4x/4;
u                18045 ext/sqlite3/libsqlite/sqlite3.c   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
u                18094 ext/sqlite3/libsqlite/sqlite3.c   assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
u                18095 ext/sqlite3/libsqlite/sqlite3.c   assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
u                18096 ext/sqlite3/libsqlite/sqlite3.c   x = mem3.aPool[i-1].u.hdr.size4x;
u                18097 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
u                18098 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
u                18099 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
u                18123 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
u                18124 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
u                18125 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
u                18127 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
u                18128 ext/sqlite3/libsqlite/sqlite3.c     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
u                18129 ext/sqlite3/libsqlite/sqlite3.c     mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
u                18158 ext/sqlite3/libsqlite/sqlite3.c     iNext = mem3.aPool[i].u.list.next;
u                18159 ext/sqlite3/libsqlite/sqlite3.c     size = mem3.aPool[i-1].u.hdr.size4x;
u                18163 ext/sqlite3/libsqlite/sqlite3.c       assert( i > mem3.aPool[i-1].u.hdr.prevSize );
u                18164 ext/sqlite3/libsqlite/sqlite3.c       prev = i - mem3.aPool[i-1].u.hdr.prevSize;
u                18166 ext/sqlite3/libsqlite/sqlite3.c         iNext = mem3.aPool[prev].u.list.next;
u                18170 ext/sqlite3/libsqlite/sqlite3.c       x = mem3.aPool[prev-1].u.hdr.size4x & 2;
u                18171 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
u                18172 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[prev+size-1].u.hdr.prevSize = size;
u                18219 ext/sqlite3/libsqlite/sqlite3.c     for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
u                18220 ext/sqlite3/libsqlite/sqlite3.c       if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
u                18281 ext/sqlite3/libsqlite/sqlite3.c   assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
u                18282 ext/sqlite3/libsqlite/sqlite3.c   size = mem3.aPool[i-1].u.hdr.size4x/4;
u                18284 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i-1].u.hdr.size4x &= ~1;
u                18285 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i+size-1].u.hdr.prevSize = size;
u                18286 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
u                18291 ext/sqlite3/libsqlite/sqlite3.c     while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
u                18292 ext/sqlite3/libsqlite/sqlite3.c       size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
u                18296 ext/sqlite3/libsqlite/sqlite3.c       x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
u                18297 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
u                18298 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
u                18300 ext/sqlite3/libsqlite/sqlite3.c     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
u                18301 ext/sqlite3/libsqlite/sqlite3.c     while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
u                18303 ext/sqlite3/libsqlite/sqlite3.c       mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
u                18304 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
u                18305 ext/sqlite3/libsqlite/sqlite3.c       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
u                18319 ext/sqlite3/libsqlite/sqlite3.c   assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
u                18320 ext/sqlite3/libsqlite/sqlite3.c   return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
u                18405 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
u                18406 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
u                18407 ext/sqlite3/libsqlite/sqlite3.c   mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
u                18445 ext/sqlite3/libsqlite/sqlite3.c     size = mem3.aPool[i-1].u.hdr.size4x;
u                18451 ext/sqlite3/libsqlite/sqlite3.c     if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
u                18456 ext/sqlite3/libsqlite/sqlite3.c     if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
u                18471 ext/sqlite3/libsqlite/sqlite3.c     for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
u                18473 ext/sqlite3/libsqlite/sqlite3.c               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
u                18480 ext/sqlite3/libsqlite/sqlite3.c     for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
u                18482 ext/sqlite3/libsqlite/sqlite3.c               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
u                23944 ext/sqlite3/libsqlite/sqlite3.c   u64 u = 0;
u                23974 ext/sqlite3/libsqlite/sqlite3.c     u = u*10 + c - '0';
u                23976 ext/sqlite3/libsqlite/sqlite3.c   if( u>LARGEST_INT64 ){
u                23979 ext/sqlite3/libsqlite/sqlite3.c     *pNum = -(i64)u;
u                23981 ext/sqlite3/libsqlite/sqlite3.c     *pNum = (i64)u;
u                23992 ext/sqlite3/libsqlite/sqlite3.c     assert( u<=LARGEST_INT64 );
u                23999 ext/sqlite3/libsqlite/sqlite3.c       assert( u<=LARGEST_INT64 );
u                24007 ext/sqlite3/libsqlite/sqlite3.c       assert( u-1==LARGEST_INT64 );
u                24030 ext/sqlite3/libsqlite/sqlite3.c     u64 u = 0;
u                24034 ext/sqlite3/libsqlite/sqlite3.c       u = u*16 + sqlite3HexToInt(z[k]);
u                24036 ext/sqlite3/libsqlite/sqlite3.c     memcpy(pOut, &u, 8);
u                24070 ext/sqlite3/libsqlite/sqlite3.c     u32 u = 0;
u                24074 ext/sqlite3/libsqlite/sqlite3.c       u = u*16 + sqlite3HexToInt(zNum[i]);
u                24076 ext/sqlite3/libsqlite/sqlite3.c     if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
u                24077 ext/sqlite3/libsqlite/sqlite3.c       memcpy(pValue, &u, 4);
u                38950 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                38980 ext/sqlite3/libsqlite/sqlite3.c     p = p->u.apSub[bin];
u                38986 ext/sqlite3/libsqlite/sqlite3.c     return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
u                38989 ext/sqlite3/libsqlite/sqlite3.c     while( p->u.aHash[h] ){
u                38990 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.aHash[h]==i ) return 1;
u                39018 ext/sqlite3/libsqlite/sqlite3.c     if( p->u.apSub[bin]==0 ){
u                39019 ext/sqlite3/libsqlite/sqlite3.c       p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
u                39020 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM;
u                39022 ext/sqlite3/libsqlite/sqlite3.c     p = p->u.apSub[bin];
u                39025 ext/sqlite3/libsqlite/sqlite3.c     p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
u                39032 ext/sqlite3/libsqlite/sqlite3.c   if( !p->u.aHash[h] ){
u                39042 ext/sqlite3/libsqlite/sqlite3.c     if( p->u.aHash[h]==i ) return SQLITE_OK;
u                39045 ext/sqlite3/libsqlite/sqlite3.c   } while( p->u.aHash[h] );
u                39053 ext/sqlite3/libsqlite/sqlite3.c     u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
u                39057 ext/sqlite3/libsqlite/sqlite3.c       memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
u                39058 ext/sqlite3/libsqlite/sqlite3.c       memset(p->u.apSub, 0, sizeof(p->u.apSub));
u                39070 ext/sqlite3/libsqlite/sqlite3.c   p->u.aHash[h] = i;
u                39087 ext/sqlite3/libsqlite/sqlite3.c     p = p->u.apSub[bin];
u                39093 ext/sqlite3/libsqlite/sqlite3.c     p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
u                39097 ext/sqlite3/libsqlite/sqlite3.c     memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
u                39098 ext/sqlite3/libsqlite/sqlite3.c     memset(p->u.aHash, 0, sizeof(p->u.aHash));
u                39104 ext/sqlite3/libsqlite/sqlite3.c         while( p->u.aHash[h] ){
u                39108 ext/sqlite3/libsqlite/sqlite3.c         p->u.aHash[h] = aiValues[j];
u                39122 ext/sqlite3/libsqlite/sqlite3.c       sqlite3BitvecDestroy(p->u.apSub[i]);
u                41553 ext/sqlite3/libsqlite/sqlite3.c # define sqlite3WalFrames(u,v,w,x,y,z)           0
u                41554 ext/sqlite3/libsqlite/sqlite3.c # define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
u                42874 ext/sqlite3/libsqlite/sqlite3.c   u32 u;                     /* Unsigned loop counter */
u                42892 ext/sqlite3/libsqlite/sqlite3.c   for(u=0; u<len; u++){
u                42893 ext/sqlite3/libsqlite/sqlite3.c     cksum -= zMaster[u];
u                44305 ext/sqlite3/libsqlite/sqlite3.c   u32 u;                   /* Unsigned loop counter */
u                44406 ext/sqlite3/libsqlite/sqlite3.c     for(u=0; u<nRec; u++){
u                63311 ext/sqlite3/libsqlite/sqlite3.c     nByte = pMem->n + pMem->u.nZero;
u                63319 ext/sqlite3/libsqlite/sqlite3.c     memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
u                63320 ext/sqlite3/libsqlite/sqlite3.c     pMem->n += pMem->u.nZero;
u                63392 ext/sqlite3/libsqlite/sqlite3.c     sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
u                63395 ext/sqlite3/libsqlite/sqlite3.c     sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r);
u                63418 ext/sqlite3/libsqlite/sqlite3.c     assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
u                63449 ext/sqlite3/libsqlite/sqlite3.c     sqlite3VdbeMemFinalize(p, p->u.pDef);
u                63458 ext/sqlite3/libsqlite/sqlite3.c     sqlite3RowSetClear(p->u.pRowSet);
u                63460 ext/sqlite3/libsqlite/sqlite3.c     VdbeFrame *pFrame = p->u.pFrame;
u                63550 ext/sqlite3/libsqlite/sqlite3.c     return pMem->u.i;
u                63552 ext/sqlite3/libsqlite/sqlite3.c     return doubleToInt64(pMem->u.r);
u                63573 ext/sqlite3/libsqlite/sqlite3.c     return pMem->u.r;
u                63575 ext/sqlite3/libsqlite/sqlite3.c     return (double)pMem->u.i;
u                63598 ext/sqlite3/libsqlite/sqlite3.c   ix = doubleToInt64(pMem->u.r);
u                63610 ext/sqlite3/libsqlite/sqlite3.c   if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
u                63611 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = ix;
u                63624 ext/sqlite3/libsqlite/sqlite3.c   pMem->u.i = sqlite3VdbeIntValue(pMem);
u                63637 ext/sqlite3/libsqlite/sqlite3.c   pMem->u.r = sqlite3VdbeRealValue(pMem);
u                63654 ext/sqlite3/libsqlite/sqlite3.c     if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
u                63657 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.r = sqlite3VdbeRealValue(pMem);
u                63756 ext/sqlite3/libsqlite/sqlite3.c   pMem->u.nZero = n;
u                63768 ext/sqlite3/libsqlite/sqlite3.c   pMem->u.i = val;
u                63780 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = val;
u                63793 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.r = val;
u                63815 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc);
u                63816 ext/sqlite3/libsqlite/sqlite3.c     assert( pMem->u.pRowSet!=0 );
u                63830 ext/sqlite3/libsqlite/sqlite3.c       n += p->u.nZero;
u                64267 ext/sqlite3/libsqlite/sqlite3.c   nName = sqlite3Strlen30(p->u.zToken);
u                64268 ext/sqlite3/libsqlite/sqlite3.c   pFunc = sqlite3FindFunction(db, p->u.zToken, nName, nVal, enc, 0);
u                64370 ext/sqlite3/libsqlite/sqlite3.c     u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
u                64395 ext/sqlite3/libsqlite/sqlite3.c       sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
u                64397 ext/sqlite3/libsqlite/sqlite3.c       zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
u                64417 ext/sqlite3/libsqlite/sqlite3.c         pVal->u.r = -pVal->u.r;
u                64418 ext/sqlite3/libsqlite/sqlite3.c       }else if( pVal->u.i==SMALLEST_INT64 ){
u                64419 ext/sqlite3/libsqlite/sqlite3.c         pVal->u.r = -(double)SMALLEST_INT64;
u                64422 ext/sqlite3/libsqlite/sqlite3.c         pVal->u.i = -pVal->u.i;
u                64433 ext/sqlite3/libsqlite/sqlite3.c     assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
u                64434 ext/sqlite3/libsqlite/sqlite3.c     assert( pExpr->u.zToken[1]=='\'' );
u                64437 ext/sqlite3/libsqlite/sqlite3.c     zVal = &pExpr->u.zToken[2];
u                64775 ext/sqlite3/libsqlite/sqlite3.c       return p->n + p->u.nZero;
u                65889 ext/sqlite3/libsqlite/sqlite3.c         sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
u                65891 ext/sqlite3/libsqlite/sqlite3.c         sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->u.r);
u                66199 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = i;                                /* Program counter */
u                66230 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = pOp->p1;                          /* P1 */
u                66234 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = pOp->p2;                          /* P2 */
u                66238 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = pOp->p3;                          /* P3 */
u                67675 ext/sqlite3/libsqlite/sqlite3.c     i64 i = pMem->u.i;
u                67676 ext/sqlite3/libsqlite/sqlite3.c     u64 u;
u                67678 ext/sqlite3/libsqlite/sqlite3.c       u = ~i;
u                67680 ext/sqlite3/libsqlite/sqlite3.c       u = i;
u                67682 ext/sqlite3/libsqlite/sqlite3.c     if( u<=127 ){
u                67683 ext/sqlite3/libsqlite/sqlite3.c       return ((i&1)==i && file_format>=4) ? 8+(u32)u : 1;
u                67685 ext/sqlite3/libsqlite/sqlite3.c     if( u<=32767 ) return 2;
u                67686 ext/sqlite3/libsqlite/sqlite3.c     if( u<=8388607 ) return 3;
u                67687 ext/sqlite3/libsqlite/sqlite3.c     if( u<=2147483647 ) return 4;
u                67688 ext/sqlite3/libsqlite/sqlite3.c     if( u<=MAX_6BYTE ) return 5;
u                67698 ext/sqlite3/libsqlite/sqlite3.c     n += pMem->u.nZero;
u                67754 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                67757 ext/sqlite3/libsqlite/sqlite3.c   u.r = in;
u                67758 ext/sqlite3/libsqlite/sqlite3.c   t = u.i[0];
u                67759 ext/sqlite3/libsqlite/sqlite3.c   u.i[0] = u.i[1];
u                67760 ext/sqlite3/libsqlite/sqlite3.c   u.i[1] = t;
u                67761 ext/sqlite3/libsqlite/sqlite3.c   return u.r;
u                67789 ext/sqlite3/libsqlite/sqlite3.c       assert( sizeof(v)==sizeof(pMem->u.r) );
u                67790 ext/sqlite3/libsqlite/sqlite3.c       memcpy(&v, &pMem->u.r, sizeof(v));
u                67793 ext/sqlite3/libsqlite/sqlite3.c       v = pMem->u.i;
u                67806 ext/sqlite3/libsqlite/sqlite3.c     assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
u                67846 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.i = *(i64*)&x;
u                67848 ext/sqlite3/libsqlite/sqlite3.c     testcase( pMem->u.i<0 );
u                67864 ext/sqlite3/libsqlite/sqlite3.c     assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
u                67866 ext/sqlite3/libsqlite/sqlite3.c     memcpy(&pMem->u.r, &x, sizeof(x));
u                67867 ext/sqlite3/libsqlite/sqlite3.c     pMem->flags = sqlite3IsNaN(pMem->u.r) ? MEM_Null : MEM_Real;
u                67887 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = ONE_BYTE_INT(buf);
u                67889 ext/sqlite3/libsqlite/sqlite3.c       testcase( pMem->u.i<0 );
u                67895 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = TWO_BYTE_INT(buf);
u                67897 ext/sqlite3/libsqlite/sqlite3.c       testcase( pMem->u.i<0 );
u                67903 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = THREE_BYTE_INT(buf);
u                67905 ext/sqlite3/libsqlite/sqlite3.c       testcase( pMem->u.i<0 );
u                67911 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = FOUR_BYTE_INT(buf);
u                67913 ext/sqlite3/libsqlite/sqlite3.c       testcase( pMem->u.i<0 );
u                67919 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
u                67921 ext/sqlite3/libsqlite/sqlite3.c       testcase( pMem->u.i<0 );
u                67934 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = serial_type-8;
u                68012 ext/sqlite3/libsqlite/sqlite3.c   u16 u;                          /* Unsigned loop counter */
u                68020 ext/sqlite3/libsqlite/sqlite3.c   u = 0;
u                68031 ext/sqlite3/libsqlite/sqlite3.c     if( (++u)>=p->nField ) break;
u                68033 ext/sqlite3/libsqlite/sqlite3.c   assert( u<=pKeyInfo->nField + 1 );
u                68034 ext/sqlite3/libsqlite/sqlite3.c   p->nField = u;
u                68259 ext/sqlite3/libsqlite/sqlite3.c       if( pMem1->u.i < pMem2->u.i ) return -1;
u                68260 ext/sqlite3/libsqlite/sqlite3.c       if( pMem1->u.i > pMem2->u.i ) return 1;
u                68264 ext/sqlite3/libsqlite/sqlite3.c       r1 = pMem1->u.r;
u                68266 ext/sqlite3/libsqlite/sqlite3.c       r1 = (double)pMem1->u.i;
u                68271 ext/sqlite3/libsqlite/sqlite3.c       r2 = pMem2->u.r;
u                68273 ext/sqlite3/libsqlite/sqlite3.c       r2 = (double)pMem2->u.i;
u                68430 ext/sqlite3/libsqlite/sqlite3.c         double rhs = (double)pRhs->u.i;
u                68432 ext/sqlite3/libsqlite/sqlite3.c         if( mem1.u.r<rhs ){
u                68434 ext/sqlite3/libsqlite/sqlite3.c         }else if( mem1.u.r>rhs ){
u                68439 ext/sqlite3/libsqlite/sqlite3.c         i64 rhs = pRhs->u.i;
u                68456 ext/sqlite3/libsqlite/sqlite3.c         double rhs = pRhs->u.r;
u                68460 ext/sqlite3/libsqlite/sqlite3.c           lhs = mem1.u.r;
u                68462 ext/sqlite3/libsqlite/sqlite3.c           lhs = (double)mem1.u.i;
u                68585 ext/sqlite3/libsqlite/sqlite3.c   i64 v = pPKey2->aMem[0].u.i;
u                68828 ext/sqlite3/libsqlite/sqlite3.c   *rowid = v.u.i;
u                69668 ext/sqlite3/libsqlite/sqlite3.c     pMem->u.pDef = p->pFunc;
u                70288 ext/sqlite3/libsqlite/sqlite3.c       rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
u                70292 ext/sqlite3/libsqlite/sqlite3.c       rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
u                70297 ext/sqlite3/libsqlite/sqlite3.c         rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
u                70685 ext/sqlite3/libsqlite/sqlite3.c         sqlite3XPrintf(&out, 0, "%lld", pVar->u.i);
u                70687 ext/sqlite3/libsqlite/sqlite3.c         sqlite3XPrintf(&out, 0, "%!.15g", pVar->u.r);
u                70718 ext/sqlite3/libsqlite/sqlite3.c         sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero);
u                70992 ext/sqlite3/libsqlite/sqlite3.c     pRec->u.i = iValue;
u                70995 ext/sqlite3/libsqlite/sqlite3.c     pRec->u.r = rValue;
u                71083 ext/sqlite3/libsqlite/sqlite3.c   if( sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc)==0 ){
u                71086 ext/sqlite3/libsqlite/sqlite3.c   if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==SQLITE_OK ){
u                71153 ext/sqlite3/libsqlite/sqlite3.c       sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
u                71202 ext/sqlite3/libsqlite/sqlite3.c     printf(" si:%lld", p->u.i);
u                71204 ext/sqlite3/libsqlite/sqlite3.c     printf(" i:%lld", p->u.i);
u                71207 ext/sqlite3/libsqlite/sqlite3.c     printf(" r:%g", p->u.r);
u                71620 ext/sqlite3/libsqlite/sqlite3.c   pIn1->u.i = (int)(pOp-aOp);
u                71638 ext/sqlite3/libsqlite/sqlite3.c   pOp = &aOp[pIn1->u.i];
u                71660 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = pOp->p3 - 1;
u                71678 ext/sqlite3/libsqlite/sqlite3.c   assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
u                71679 ext/sqlite3/libsqlite/sqlite3.c   pCaller = &aOp[pIn1->u.i];
u                71705 ext/sqlite3/libsqlite/sqlite3.c   pcDest = (int)pIn1->u.i;
u                71706 ext/sqlite3/libsqlite/sqlite3.c   pIn1->u.i = (int)(pOp - aOp);
u                71831 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = pOp->p1;
u                71844 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = *pOp->p4.pI64;
u                71859 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.r = *pOp->p4.pReal;
u                71924 ext/sqlite3/libsqlite/sqlite3.c     if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
u                72296 ext/sqlite3/libsqlite/sqlite3.c     iA = pIn1->u.i;
u                72297 ext/sqlite3/libsqlite/sqlite3.c     iB = pIn2->u.i;
u                72316 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = iB;
u                72343 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = rB;
u                72349 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.r = rB;
u                72534 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = iA;
u                72551 ext/sqlite3/libsqlite/sqlite3.c   pIn1->u.i += pOp->p2;
u                72820 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = res;
u                72979 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = v1;
u                72998 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = !sqlite3VdbeIntValue(pIn1);
u                73016 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
u                73503 ext/sqlite3/libsqlite/sqlite3.c         nZero += pRec->u.nZero;
u                73504 ext/sqlite3/libsqlite/sqlite3.c         len -= pRec->u.nZero;
u                73564 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.nZero = nZero;
u                73589 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = nEntry;
u                73992 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = iMeta;
u                74018 ext/sqlite3/libsqlite/sqlite3.c   rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i);
u                74021 ext/sqlite3/libsqlite/sqlite3.c     pDb->pSchema->schema_cookie = (int)pIn3->u.i;
u                74025 ext/sqlite3/libsqlite/sqlite3.c     pDb->pSchema->file_format = (u8)pIn3->u.i;
u                74159 ext/sqlite3/libsqlite/sqlite3.c     p2 = (int)pIn2->u.i;
u                74501 ext/sqlite3/libsqlite/sqlite3.c       if( pIn3->u.r<(double)iKey ){
u                74510 ext/sqlite3/libsqlite/sqlite3.c       else if( pIn3->u.r>(double)iKey ){
u                74790 ext/sqlite3/libsqlite/sqlite3.c   iKey = pIn3->u.i;
u                74814 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
u                74915 ext/sqlite3/libsqlite/sqlite3.c       if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
u                74919 ext/sqlite3/libsqlite/sqlite3.c       if( v<pMem->u.i+1 ){
u                74920 ext/sqlite3/libsqlite/sqlite3.c         v = pMem->u.i + 1;
u                74922 ext/sqlite3/libsqlite/sqlite3.c       pMem->u.i = v;
u                74949 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = v;
u                75026 ext/sqlite3/libsqlite/sqlite3.c     iKey = pKey->u.i;
u                75042 ext/sqlite3/libsqlite/sqlite3.c     nZero = pData->u.nZero;
u                75322 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = v;
u                75694 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = rowid;
u                75824 ext/sqlite3/libsqlite/sqlite3.c     pOut->u.i = iMoved;
u                75869 ext/sqlite3/libsqlite/sqlite3.c       aMem[pOp->p3].u.i += nChange;
u                75942 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = pgno;
u                76101 ext/sqlite3/libsqlite/sqlite3.c                                  (int)pnErr->u.i, &nErr);
u                76103 ext/sqlite3/libsqlite/sqlite3.c   pnErr->u.i -= nErr;
u                76134 ext/sqlite3/libsqlite/sqlite3.c   sqlite3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i);
u                76150 ext/sqlite3/libsqlite/sqlite3.c    || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0
u                76208 ext/sqlite3/libsqlite/sqlite3.c     exists = sqlite3RowSetTest(pIn1->u.pRowSet, iSet, pIn3->u.i);
u                76213 ext/sqlite3/libsqlite/sqlite3.c     sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
u                76294 ext/sqlite3/libsqlite/sqlite3.c     pRt->u.pFrame = pFrame;
u                76319 ext/sqlite3/libsqlite/sqlite3.c     pFrame = pRt->u.pFrame;
u                76441 ext/sqlite3/libsqlite/sqlite3.c   if( pIn1->u.i<pIn2->u.i){
u                76442 ext/sqlite3/libsqlite/sqlite3.c     pIn1->u.i = pIn2->u.i;
u                76461 ext/sqlite3/libsqlite/sqlite3.c   VdbeBranchTaken( pIn1->u.i>0, 2);
u                76462 ext/sqlite3/libsqlite/sqlite3.c   if( pIn1->u.i>0 ) goto jump_to_p2;
u                76475 ext/sqlite3/libsqlite/sqlite3.c   pIn1->u.i += pOp->p3;
u                76476 ext/sqlite3/libsqlite/sqlite3.c   VdbeBranchTaken(pIn1->u.i<0, 2);
u                76477 ext/sqlite3/libsqlite/sqlite3.c   if( pIn1->u.i<0 ) goto jump_to_p2;
u                76491 ext/sqlite3/libsqlite/sqlite3.c   VdbeBranchTaken(pIn1->u.i<0, 2);
u                76492 ext/sqlite3/libsqlite/sqlite3.c   if( pIn1->u.i ){
u                76493 ext/sqlite3/libsqlite/sqlite3.c      pIn1->u.i += pOp->p3;
u                76508 ext/sqlite3/libsqlite/sqlite3.c   pIn1->u.i--;
u                76509 ext/sqlite3/libsqlite/sqlite3.c   VdbeBranchTaken(pIn1->u.i==0, 2);
u                76510 ext/sqlite3/libsqlite/sqlite3.c   if( pIn1->u.i==0 ) goto jump_to_p2;
u                76525 ext/sqlite3/libsqlite/sqlite3.c   VdbeBranchTaken(pIn1->u.i==0, 2);
u                76526 ext/sqlite3/libsqlite/sqlite3.c   if( (pIn1->u.i++)==0 ) goto jump_to_p2;
u                76996 ext/sqlite3/libsqlite/sqlite3.c   nArg = (int)pArgc->u.i;
u                76997 ext/sqlite3/libsqlite/sqlite3.c   iQuery = (int)pQuery->u.i;
u                77224 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
u                77250 ext/sqlite3/libsqlite/sqlite3.c   pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
u                77485 ext/sqlite3/libsqlite/sqlite3.c   v->aVar[0].u.i = iRow;
u                78345 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                78924 ext/sqlite3/libsqlite/sqlite3.c     pNext = p->u.pNext;
u                79252 ext/sqlite3/libsqlite/sqlite3.c       pp = &p1->u.pNext;
u                79253 ext/sqlite3/libsqlite/sqlite3.c       p1 = p1->u.pNext;
u                79256 ext/sqlite3/libsqlite/sqlite3.c       pp = &p2->u.pNext;
u                79257 ext/sqlite3/libsqlite/sqlite3.c       p2 = p2->u.pNext;
u                79306 ext/sqlite3/libsqlite/sqlite3.c         assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
u                79307 ext/sqlite3/libsqlite/sqlite3.c         pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
u                79310 ext/sqlite3/libsqlite/sqlite3.c       pNext = p->u.pNext;
u                79313 ext/sqlite3/libsqlite/sqlite3.c     p->u.pNext = 0;
u                79475 ext/sqlite3/libsqlite/sqlite3.c       pNext = p->u.pNext;
u                79734 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
u                79740 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.pNext = pSorter->list.pList;
u                80520 ext/sqlite3/libsqlite/sqlite3.c     pSorter->list.pList = pFree->u.pNext;
u                80521 ext/sqlite3/libsqlite/sqlite3.c     pFree->u.pNext = 0;
u                81327 ext/sqlite3/libsqlite/sqlite3.c   if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
u                81335 ext/sqlite3/libsqlite/sqlite3.c     w.u.n = N;
u                81406 ext/sqlite3/libsqlite/sqlite3.c     if( pEList->a[iCol].u.x.iAlias==0 ){
u                81407 ext/sqlite3/libsqlite/sqlite3.c       pEList->a[iCol].u.x.iAlias = (u16)(++pParse->nAlias);
u                81409 ext/sqlite3/libsqlite/sqlite3.c     pDup->iTable = pEList->a[iCol].u.x.iAlias;
u                81412 ext/sqlite3/libsqlite/sqlite3.c     pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
u                81425 ext/sqlite3/libsqlite/sqlite3.c   if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
u                81427 ext/sqlite3/libsqlite/sqlite3.c     pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
u                81885 ext/sqlite3/libsqlite/sqlite3.c   sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
u                81906 ext/sqlite3/libsqlite/sqlite3.c   pNC = pWalker->u.pNC;
u                81947 ext/sqlite3/libsqlite/sqlite3.c       return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
u                81963 ext/sqlite3/libsqlite/sqlite3.c         zTable = pExpr->pLeft->u.zToken;
u                81964 ext/sqlite3/libsqlite/sqlite3.c         zColumn = pRight->u.zToken;
u                81967 ext/sqlite3/libsqlite/sqlite3.c         zDb = pExpr->pLeft->u.zToken;
u                81968 ext/sqlite3/libsqlite/sqlite3.c         zTable = pRight->pLeft->u.zToken;
u                81969 ext/sqlite3/libsqlite/sqlite3.c         zColumn = pRight->pRight->u.zToken;
u                81990 ext/sqlite3/libsqlite/sqlite3.c       zId = pExpr->u.zToken;
u                82126 ext/sqlite3/libsqlite/sqlite3.c     char *zCol = pE->u.zToken;
u                82287 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.iValue = iCol;
u                82298 ext/sqlite3/libsqlite/sqlite3.c         pItem->u.x.iOrderByCol = (u16)iCol;
u                82347 ext/sqlite3/libsqlite/sqlite3.c     if( pItem->u.x.iOrderByCol ){
u                82348 ext/sqlite3/libsqlite/sqlite3.c       if( pItem->u.x.iOrderByCol>pEList->nExpr ){
u                82352 ext/sqlite3/libsqlite/sqlite3.c       resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
u                82402 ext/sqlite3/libsqlite/sqlite3.c         pItem->u.x.iOrderByCol = (u16)iCol;
u                82414 ext/sqlite3/libsqlite/sqlite3.c       pItem->u.x.iOrderByCol = (u16)iCol;
u                82419 ext/sqlite3/libsqlite/sqlite3.c     pItem->u.x.iOrderByCol = 0;
u                82425 ext/sqlite3/libsqlite/sqlite3.c         pItem->u.x.iOrderByCol = j+1;
u                82452 ext/sqlite3/libsqlite/sqlite3.c   pOuterNC = pWalker->u.pNC;
u                82717 ext/sqlite3/libsqlite/sqlite3.c   w.u.pNC = pNC;
u                82757 ext/sqlite3/libsqlite/sqlite3.c   w.u.pNC = pOuterNC;
u                82848 ext/sqlite3/libsqlite/sqlite3.c     return sqlite3AffinityType(pExpr->u.zToken, 0);
u                82936 ext/sqlite3/libsqlite/sqlite3.c       pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
u                83274 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.iValue = iValue;
u                83277 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.zToken = (char*)&pNew[1];
u                83279 ext/sqlite3/libsqlite/sqlite3.c         if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
u                83280 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.zToken[pToken->n] = 0;
u                83283 ext/sqlite3/libsqlite/sqlite3.c           sqlite3Dequote(pNew->u.zToken);
u                83459 ext/sqlite3/libsqlite/sqlite3.c   z = pExpr->u.zToken;
u                83527 ext/sqlite3/libsqlite/sqlite3.c   assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
u                83533 ext/sqlite3/libsqlite/sqlite3.c     if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
u                83619 ext/sqlite3/libsqlite/sqlite3.c   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
u                83620 ext/sqlite3/libsqlite/sqlite3.c     nByte += sqlite3Strlen30(p->u.zToken)+1;
u                83684 ext/sqlite3/libsqlite/sqlite3.c       if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
u                83685 ext/sqlite3/libsqlite/sqlite3.c         nToken = sqlite3Strlen30(p->u.zToken) + 1;
u                83705 ext/sqlite3/libsqlite/sqlite3.c         char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
u                83706 ext/sqlite3/libsqlite/sqlite3.c         memcpy(zToken, p->u.zToken, nToken);
u                83810 ext/sqlite3/libsqlite/sqlite3.c     pItem->u = pOldItem->u;
u                84118 ext/sqlite3/libsqlite/sqlite3.c       if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
u                84154 ext/sqlite3/libsqlite/sqlite3.c   w.u.iCur = iCur;
u                84217 ext/sqlite3/libsqlite/sqlite3.c            || sqlite3GetInt32(p->u.zToken, &rc)==0 );
u                84220 ext/sqlite3/libsqlite/sqlite3.c     *pValue = p->u.iValue;
u                85057 ext/sqlite3/libsqlite/sqlite3.c     int i = pExpr->u.iValue;
u                85064 ext/sqlite3/libsqlite/sqlite3.c     const char *z = pExpr->u.zToken;
u                85438 ext/sqlite3/libsqlite/sqlite3.c       codeReal(v, pExpr->u.zToken, 0, target);
u                85444 ext/sqlite3/libsqlite/sqlite3.c       sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
u                85457 ext/sqlite3/libsqlite/sqlite3.c       assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
u                85458 ext/sqlite3/libsqlite/sqlite3.c       assert( pExpr->u.zToken[1]=='\'' );
u                85459 ext/sqlite3/libsqlite/sqlite3.c       z = &pExpr->u.zToken[2];
u                85469 ext/sqlite3/libsqlite/sqlite3.c       assert( pExpr->u.zToken!=0 );
u                85470 ext/sqlite3/libsqlite/sqlite3.c       assert( pExpr->u.zToken[0]!=0 );
u                85472 ext/sqlite3/libsqlite/sqlite3.c       if( pExpr->u.zToken[1]!=0 ){
u                85473 ext/sqlite3/libsqlite/sqlite3.c         assert( pExpr->u.zToken[0]=='?' 
u                85474 ext/sqlite3/libsqlite/sqlite3.c              || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
u                85496 ext/sqlite3/libsqlite/sqlite3.c                         sqlite3AffinityType(pExpr->u.zToken, 0));
u                85575 ext/sqlite3/libsqlite/sqlite3.c         codeReal(v, pLeft->u.zToken, 1, target);
u                85580 ext/sqlite3/libsqlite/sqlite3.c         tempX.u.iValue = 0;
u                85618 ext/sqlite3/libsqlite/sqlite3.c         sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
u                85643 ext/sqlite3/libsqlite/sqlite3.c       zId = pExpr->u.zToken;
u                85975 ext/sqlite3/libsqlite/sqlite3.c             v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
u                85979 ext/sqlite3/libsqlite/sqlite3.c                               pExpr->affinity, pExpr->u.zToken, 0, 0);
u                86007 ext/sqlite3/libsqlite/sqlite3.c      pItem->u.iConstExprReg = regDest;
u                86040 ext/sqlite3/libsqlite/sqlite3.c           return pItem->u.iConstExprReg;
u                86148 ext/sqlite3/libsqlite/sqlite3.c         sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue);
u                86150 ext/sqlite3/libsqlite/sqlite3.c         sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken);
u                86156 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
u                86161 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
u                86170 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
u                86176 ext/sqlite3/libsqlite/sqlite3.c                           pExpr->u.zToken, pExpr->iColumn);
u                86184 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"AS %Q", pExpr->u.zToken);
u                86189 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
u                86195 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
u                86230 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView, "COLLATE %Q", pExpr->u.zToken);
u                86245 ext/sqlite3/libsqlite/sqlite3.c                              pExpr->op2, pExpr->u.zToken);
u                86247 ext/sqlite3/libsqlite/sqlite3.c         sqlite3TreeViewLine(pView, "FUNCTION %Q", pExpr->u.zToken);
u                86325 ext/sqlite3/libsqlite/sqlite3.c       sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
u                86799 ext/sqlite3/libsqlite/sqlite3.c     if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
u                86813 ext/sqlite3/libsqlite/sqlite3.c   if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken ){
u                86814 ext/sqlite3/libsqlite/sqlite3.c     if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
u                86924 ext/sqlite3/libsqlite/sqlite3.c     struct SrcCount *p = pWalker->u.pSrcCount;
u                86951 ext/sqlite3/libsqlite/sqlite3.c   w.u.pSrcCount = &cnt;
u                86998 ext/sqlite3/libsqlite/sqlite3.c   NameContext *pNC = pWalker->u.pNC;
u                87098 ext/sqlite3/libsqlite/sqlite3.c                    pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
u                87141 ext/sqlite3/libsqlite/sqlite3.c   w.u.pNC = pNC;
u                88336 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                88365 ext/sqlite3/libsqlite/sqlite3.c     sqlite3DbFree(db, p->u.aRowid);
u                88376 ext/sqlite3/libsqlite/sqlite3.c   if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
u                88377 ext/sqlite3/libsqlite/sqlite3.c   p->u.aRowid = sqlite3DbMallocRaw(db, n);
u                88378 ext/sqlite3/libsqlite/sqlite3.c   if( p->u.aRowid ){
u                88380 ext/sqlite3/libsqlite/sqlite3.c     memcpy(p->u.aRowid, pData, n);
u                88392 ext/sqlite3/libsqlite/sqlite3.c   if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
u                88394 ext/sqlite3/libsqlite/sqlite3.c   p->u.iRowid = iRowid;
u                88411 ext/sqlite3/libsqlite/sqlite3.c     sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
u                88413 ext/sqlite3/libsqlite/sqlite3.c     sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
u                88941 ext/sqlite3/libsqlite/sqlite3.c         sqlite3_result_int64(context, pS->u.iRowid);
u                88943 ext/sqlite3/libsqlite/sqlite3.c         sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid,
u                90297 ext/sqlite3/libsqlite/sqlite3.c       zAuthArg = pAuthArg->u.zToken;
u                91022 ext/sqlite3/libsqlite/sqlite3.c           sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
u                93828 ext/sqlite3/libsqlite/sqlite3.c       nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
u                93897 ext/sqlite3/libsqlite/sqlite3.c       zColl = pListItem->pExpr->u.zToken;
u                98093 ext/sqlite3/libsqlite/sqlite3.c   pDef = sqlite3FindFunction(db, pExpr->u.zToken, 
u                98094 ext/sqlite3/libsqlite/sqlite3.c                              sqlite3Strlen30(pExpr->u.zToken),
u                107406 ext/sqlite3/libsqlite/sqlite3.c                           regResult + pSO->a[i].u.x.iOrderByCol - 1,
u                108093 ext/sqlite3/libsqlite/sqlite3.c         zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
u                108361 ext/sqlite3/libsqlite/sqlite3.c         pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
u                109305 ext/sqlite3/libsqlite/sqlite3.c         assert( pItem->u.x.iOrderByCol>0 );
u                109306 ext/sqlite3/libsqlite/sqlite3.c         if( pItem->u.x.iOrderByCol==i ) break;
u                109312 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.iValue = i;
u                109314 ext/sqlite3/libsqlite/sqlite3.c         if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
u                109330 ext/sqlite3/libsqlite/sqlite3.c       assert( pItem->u.x.iOrderByCol>0 );
u                109333 ext/sqlite3/libsqlite/sqlite3.c       testcase( pItem->u.x.iOrderByCol > p->pEList->nExpr );
u                109334 ext/sqlite3/libsqlite/sqlite3.c       aPermute[i] = pItem->u.x.iOrderByCol - 1;
u                109917 ext/sqlite3/libsqlite/sqlite3.c         if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
u                110134 ext/sqlite3/libsqlite/sqlite3.c         pOrderBy->a[i].u.x.iOrderByCol = 0;
u                110220 ext/sqlite3/libsqlite/sqlite3.c       const char *zFunc = pExpr->u.zToken;
u                110743 ext/sqlite3/libsqlite/sqlite3.c           zTName = pE->pLeft->u.zToken;
u                111520 ext/sqlite3/libsqlite/sqlite3.c         pItem->u.x.iAlias = 0;
u                111523 ext/sqlite3/libsqlite/sqlite3.c         pItem->u.x.iAlias = 0;
u                115808 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                115853 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                115976 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                116350 ext/sqlite3/libsqlite/sqlite3.c       whereOrInfoDelete(db, a->u.pOrInfo);
u                116352 ext/sqlite3/libsqlite/sqlite3.c       whereAndInfoDelete(db, a->u.pAndInfo);
u                116626 ext/sqlite3/libsqlite/sqlite3.c          && pTerm->u.leftColumn==iColumn
u                116858 ext/sqlite3/libsqlite/sqlite3.c     z = pRight->u.zToken;
u                116869 ext/sqlite3/libsqlite/sqlite3.c       if( pPrefix ) pPrefix->u.zToken[cnt] = 0;
u                116874 ext/sqlite3/libsqlite/sqlite3.c         if( *pisComplete && pRight->u.zToken[1] ){
u                116914 ext/sqlite3/libsqlite/sqlite3.c   if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){
u                116957 ext/sqlite3/libsqlite/sqlite3.c   if( N<pTerm->u.pAndInfo->wc.nTerm ){
u                116958 ext/sqlite3/libsqlite/sqlite3.c     return &pTerm->u.pAndInfo->wc.a[N];
u                117133 ext/sqlite3/libsqlite/sqlite3.c   pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
u                117159 ext/sqlite3/libsqlite/sqlite3.c         pOrTerm->u.pAndInfo = pAndInfo;
u                117272 ext/sqlite3/libsqlite/sqlite3.c         iColumn = pOrTerm->u.leftColumn;
u                117293 ext/sqlite3/libsqlite/sqlite3.c         }else if( pOrTerm->u.leftColumn!=iColumn ){
u                117326 ext/sqlite3/libsqlite/sqlite3.c         assert( pOrTerm->u.leftColumn==iColumn );
u                117428 ext/sqlite3/libsqlite/sqlite3.c       pTerm->u.leftColumn = pLeft->iColumn;
u                117462 ext/sqlite3/libsqlite/sqlite3.c       pNew->u.leftColumn = pLeft->iColumn;
u                117556 ext/sqlite3/libsqlite/sqlite3.c       for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
u                117557 ext/sqlite3/libsqlite/sqlite3.c         pStr1->u.zToken[i] = sqlite3Toupper(c);
u                117558 ext/sqlite3/libsqlite/sqlite3.c         pStr2->u.zToken[i] = sqlite3Tolower(c);
u                117564 ext/sqlite3/libsqlite/sqlite3.c       pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
u                117629 ext/sqlite3/libsqlite/sqlite3.c       pNewTerm->u.leftColumn = pLeft->iColumn;
u                117670 ext/sqlite3/libsqlite/sqlite3.c       pNewTerm->u.leftColumn = pLeft->iColumn;
u                117854 ext/sqlite3/libsqlite/sqlite3.c   if( pTerm->u.leftColumn<0 ) return 0;
u                117855 ext/sqlite3/libsqlite/sqlite3.c   aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
u                117922 ext/sqlite3/libsqlite/sqlite3.c       int iCol = pTerm->u.leftColumn;
u                117942 ext/sqlite3/libsqlite/sqlite3.c   pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol;
u                117968 ext/sqlite3/libsqlite/sqlite3.c   pLoop->u.btree.pIndex = pIdx;
u                117975 ext/sqlite3/libsqlite/sqlite3.c       int iCol = pTerm->u.leftColumn;
u                117982 ext/sqlite3/libsqlite/sqlite3.c         pIdx->aiColumn[n] = pTerm->u.leftColumn;
u                117989 ext/sqlite3/libsqlite/sqlite3.c   assert( (u32)n==pLoop->u.btree.nEq );
u                118129 ext/sqlite3/libsqlite/sqlite3.c     pIdxCons[j].iColumn = pTerm->u.leftColumn;
u                118462 ext/sqlite3/libsqlite/sqlite3.c   Index *p = pLoop->u.btree.pIndex;
u                118463 ext/sqlite3/libsqlite/sqlite3.c   int nEq = pLoop->u.btree.nEq;
u                118580 ext/sqlite3/libsqlite/sqlite3.c   Index *p = pLoop->u.btree.pIndex;
u                118581 ext/sqlite3/libsqlite/sqlite3.c   int nEq = pLoop->u.btree.nEq;
u                118752 ext/sqlite3/libsqlite/sqlite3.c   Index *p = pBuilder->pNew->u.btree.pIndex;
u                118753 ext/sqlite3/libsqlite/sqlite3.c   int nEq = pBuilder->pNew->u.btree.nEq;
u                118817 ext/sqlite3/libsqlite/sqlite3.c   Index *p = pBuilder->pNew->u.btree.pIndex;
u                118982 ext/sqlite3/libsqlite/sqlite3.c       && pLoop->u.btree.pIndex!=0
u                118983 ext/sqlite3/libsqlite/sqlite3.c       && pLoop->u.btree.pIndex->aSortOrder[iEq]
u                119002 ext/sqlite3/libsqlite/sqlite3.c     if( pLevel->u.in.nIn==0 ){
u                119005 ext/sqlite3/libsqlite/sqlite3.c     pLevel->u.in.nIn++;
u                119006 ext/sqlite3/libsqlite/sqlite3.c     pLevel->u.in.aInLoop =
u                119007 ext/sqlite3/libsqlite/sqlite3.c        sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
u                119008 ext/sqlite3/libsqlite/sqlite3.c                               sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
u                119009 ext/sqlite3/libsqlite/sqlite3.c     pIn = pLevel->u.in.aInLoop;
u                119011 ext/sqlite3/libsqlite/sqlite3.c       pIn += pLevel->u.in.nIn - 1;
u                119021 ext/sqlite3/libsqlite/sqlite3.c       pLevel->u.in.nIn = 0;
u                119095 ext/sqlite3/libsqlite/sqlite3.c   nEq = pLoop->u.btree.nEq;
u                119097 ext/sqlite3/libsqlite/sqlite3.c   pIdx = pLoop->u.btree.pIndex;
u                119103 ext/sqlite3/libsqlite/sqlite3.c   nReg = pLoop->u.btree.nEq + nExtraReg;
u                119208 ext/sqlite3/libsqlite/sqlite3.c   Index *pIndex = pLoop->u.btree.pIndex;
u                119209 ext/sqlite3/libsqlite/sqlite3.c   u16 nEq = pLoop->u.btree.nEq;
u                119277 ext/sqlite3/libsqlite/sqlite3.c             || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0))
u                119295 ext/sqlite3/libsqlite/sqlite3.c       assert( pLoop->u.btree.pIndex!=0 );
u                119296 ext/sqlite3/libsqlite/sqlite3.c       pIdx = pLoop->u.btree.pIndex;
u                119334 ext/sqlite3/libsqlite/sqlite3.c                   pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
u                119350 ext/sqlite3/libsqlite/sqlite3.c # define explainOneScan(u,v,w,x,y,z) 0
u                119371 ext/sqlite3/libsqlite/sqlite3.c   if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0  &&  pLoop->u.btree.pIndex!=0 ){
u                119372 ext/sqlite3/libsqlite/sqlite3.c     zObj = pLoop->u.btree.pIndex->zName;
u                119510 ext/sqlite3/libsqlite/sqlite3.c     sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
u                119513 ext/sqlite3/libsqlite/sqlite3.c                       pLoop->u.vtab.idxStr,
u                119514 ext/sqlite3/libsqlite/sqlite3.c                       pLoop->u.vtab.needFree ? P4_MPRINTF : P4_STATIC);
u                119516 ext/sqlite3/libsqlite/sqlite3.c     pLoop->u.vtab.needFree = 0;
u                119518 ext/sqlite3/libsqlite/sqlite3.c       if( (pLoop->u.vtab.omitMask>>j)&1 ){
u                119538 ext/sqlite3/libsqlite/sqlite3.c     assert( pLoop->u.btree.nEq==1 );
u                119693 ext/sqlite3/libsqlite/sqlite3.c     u16 nEq = pLoop->u.btree.nEq;     /* Number of == or IN terms */
u                119710 ext/sqlite3/libsqlite/sqlite3.c     pIdx = pLoop->u.btree.pIndex;
u                119987 ext/sqlite3/libsqlite/sqlite3.c     pOrWc = &pTerm->u.pOrInfo->wc;
u                120179 ext/sqlite3/libsqlite/sqlite3.c            && (ii==0 || pSubLoop->u.btree.pIndex==pCov)
u                120180 ext/sqlite3/libsqlite/sqlite3.c            && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
u                120183 ext/sqlite3/libsqlite/sqlite3.c             pCov = pSubLoop->u.btree.pIndex;
u                120194 ext/sqlite3/libsqlite/sqlite3.c     pLevel->u.pCovidx = pCov;
u                120282 ext/sqlite3/libsqlite/sqlite3.c     pAlt = findTerm(pWC, iCur, pTerm->u.leftColumn, notReady, WO_EQ|WO_IN, 0);
u                120358 ext/sqlite3/libsqlite/sqlite3.c     if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
u                120364 ext/sqlite3/libsqlite/sqlite3.c       sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
u                120370 ext/sqlite3/libsqlite/sqlite3.c     if( p->u.vtab.idxStr ){
u                120372 ext/sqlite3/libsqlite/sqlite3.c                 p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask);
u                120374 ext/sqlite3/libsqlite/sqlite3.c       z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask);
u                120410 ext/sqlite3/libsqlite/sqlite3.c     if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
u                120411 ext/sqlite3/libsqlite/sqlite3.c       sqlite3_free(p->u.vtab.idxStr);
u                120412 ext/sqlite3/libsqlite/sqlite3.c       p->u.vtab.needFree = 0;
u                120413 ext/sqlite3/libsqlite/sqlite3.c       p->u.vtab.idxStr = 0;
u                120414 ext/sqlite3/libsqlite/sqlite3.c     }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
u                120415 ext/sqlite3/libsqlite/sqlite3.c       sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
u                120416 ext/sqlite3/libsqlite/sqlite3.c       sqlite3DbFree(db, p->u.btree.pIndex);
u                120417 ext/sqlite3/libsqlite/sqlite3.c       p->u.btree.pIndex = 0;
u                120453 ext/sqlite3/libsqlite/sqlite3.c     memset(&pTo->u, 0, sizeof(pTo->u));
u                120459 ext/sqlite3/libsqlite/sqlite3.c     pFrom->u.vtab.needFree = 0;
u                120461 ext/sqlite3/libsqlite/sqlite3.c     pFrom->u.btree.pIndex = 0;
u                120483 ext/sqlite3/libsqlite/sqlite3.c         sqlite3DbFree(db, pLevel->u.in.aInLoop);
u                120760 ext/sqlite3/libsqlite/sqlite3.c     Index *pIndex = p->u.btree.pIndex;
u                120762 ext/sqlite3/libsqlite/sqlite3.c       p->u.btree.pIndex = 0;
u                120903 ext/sqlite3/libsqlite/sqlite3.c   assert( pNew->u.btree.nEq<pProbe->nColumn );
u                120904 ext/sqlite3/libsqlite/sqlite3.c   iCol = pProbe->aiColumn[pNew->u.btree.nEq];
u                120908 ext/sqlite3/libsqlite/sqlite3.c   saved_nEq = pNew->u.btree.nEq;
u                120937 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.btree.nEq = saved_nEq;
u                120964 ext/sqlite3/libsqlite/sqlite3.c       if( iCol<0 || (nInMul==0 && pNew->u.btree.nEq==pProbe->nKeyCol-1) ){
u                121011 ext/sqlite3/libsqlite/sqlite3.c       int nEq = ++pNew->u.btree.nEq;
u                121025 ext/sqlite3/libsqlite/sqlite3.c          && pNew->u.btree.nEq<=pProbe->nSampleCol
u                121082 ext/sqlite3/libsqlite/sqlite3.c      && pNew->u.btree.nEq<pProbe->nColumn
u                121092 ext/sqlite3/libsqlite/sqlite3.c   pNew->u.btree.nEq = saved_nEq;
u                121116 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.btree.nEq++;
u                121127 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.btree.nEq = saved_nEq;
u                121315 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.btree.nEq = 1;
u                121317 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.btree.pIndex = 0;
u                121356 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.btree.nEq = 0;
u                121363 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.btree.pIndex = pProbe;
u                121475 ext/sqlite3/libsqlite/sqlite3.c   pNew->u.vtab.needFree = 0;
u                121534 ext/sqlite3/libsqlite/sqlite3.c     pNew->u.vtab.omitMask = 0;
u                121557 ext/sqlite3/libsqlite/sqlite3.c         if( iTerm<16 && pUsage[i].omit ) pNew->u.vtab.omitMask |= 1<<iTerm;
u                121578 ext/sqlite3/libsqlite/sqlite3.c       pNew->u.vtab.idxNum = pIdxInfo->idxNum;
u                121579 ext/sqlite3/libsqlite/sqlite3.c       pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
u                121581 ext/sqlite3/libsqlite/sqlite3.c       pNew->u.vtab.idxStr = pIdxInfo->idxStr;
u                121582 ext/sqlite3/libsqlite/sqlite3.c       pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
u                121588 ext/sqlite3/libsqlite/sqlite3.c       if( pNew->u.vtab.needFree ){
u                121589 ext/sqlite3/libsqlite/sqlite3.c         sqlite3_free(pNew->u.vtab.idxStr);
u                121590 ext/sqlite3/libsqlite/sqlite3.c         pNew->u.vtab.needFree = 0;
u                121627 ext/sqlite3/libsqlite/sqlite3.c      && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0 
u                121629 ext/sqlite3/libsqlite/sqlite3.c       WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
u                121642 ext/sqlite3/libsqlite/sqlite3.c           sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc;
u                121699 ext/sqlite3/libsqlite/sqlite3.c       memset(&pNew->u, 0, sizeof(pNew->u));
u                121851 ext/sqlite3/libsqlite/sqlite3.c       if( pLoop->u.vtab.isOrdered ) obSat = obDone;
u                121887 ext/sqlite3/libsqlite/sqlite3.c       }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){
u                121906 ext/sqlite3/libsqlite/sqlite3.c         if( j<pLoop->u.btree.nEq
u                121934 ext/sqlite3/libsqlite/sqlite3.c          && j>=pLoop->u.btree.nEq
u                122486 ext/sqlite3/libsqlite/sqlite3.c     pLoop->u.btree.nEq = 1;
u                122507 ext/sqlite3/libsqlite/sqlite3.c       pLoop->u.btree.nEq = j;
u                122508 ext/sqlite3/libsqlite/sqlite3.c       pLoop->u.btree.pIndex = pIdx;
u                122950 ext/sqlite3/libsqlite/sqlite3.c       Index *pIx = pLoop->u.btree.pIndex;
u                123070 ext/sqlite3/libsqlite/sqlite3.c     if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
u                123074 ext/sqlite3/libsqlite/sqlite3.c       for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
u                123086 ext/sqlite3/libsqlite/sqlite3.c       VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
u                123193 ext/sqlite3/libsqlite/sqlite3.c       pIdx = pLoop->u.btree.pIndex;
u                123195 ext/sqlite3/libsqlite/sqlite3.c       pIdx = pLevel->u.pCovidx;
u                151218 ext/sqlite3/libsqlite/sqlite3.c   u32 u;             /* Unsigned for byte-order conversions */
u                151247 ext/sqlite3/libsqlite/sqlite3.c   } u;
u                151342 ext/sqlite3/libsqlite/sqlite3.c   pCoord->u = (
u                151376 ext/sqlite3/libsqlite/sqlite3.c   i = pCoord->u;
u                151894 ext/sqlite3/libsqlite/sqlite3.c     memcpy(&c.u,a,4);                                           \
u                151895 ext/sqlite3/libsqlite/sqlite3.c     c.u = ((c.u>>24)&0xff)|((c.u>>8)&0xff00)|                   \
u                151896 ext/sqlite3/libsqlite/sqlite3.c           ((c.u&0xff)<<24)|((c.u&0xff00)<<8);                   \
u                151902 ext/sqlite3/libsqlite/sqlite3.c     memcpy(&c.u,a,4);                                           \
u                151908 ext/sqlite3/libsqlite/sqlite3.c     c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16)                     \
u                151943 ext/sqlite3/libsqlite/sqlite3.c     rc = pConstraint->u.xGeom((sqlite3_rtree_geometry*)pInfo,
u                151952 ext/sqlite3/libsqlite/sqlite3.c     rc = pConstraint->u.xQueryFunc(pInfo);
u                151987 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.rValue>=val ) return;
u                151995 ext/sqlite3/libsqlite/sqlite3.c       if( p->u.rValue<=val ) return;
u                152023 ext/sqlite3/libsqlite/sqlite3.c     case RTREE_LE: if( xN <= p->u.rValue ) return;  break;
u                152024 ext/sqlite3/libsqlite/sqlite3.c     case RTREE_LT: if( xN <  p->u.rValue ) return;  break;
u                152025 ext/sqlite3/libsqlite/sqlite3.c     case RTREE_GE: if( xN >= p->u.rValue ) return;  break;
u                152026 ext/sqlite3/libsqlite/sqlite3.c     case RTREE_GT: if( xN >  p->u.rValue ) return;  break;
u                152027 ext/sqlite3/libsqlite/sqlite3.c     default:       if( xN == p->u.rValue ) return;  break;
u                152478 ext/sqlite3/libsqlite/sqlite3.c     pCons->u.xGeom = pBlob->cb.xGeom;
u                152481 ext/sqlite3/libsqlite/sqlite3.c     pCons->u.xQueryFunc = pBlob->cb.xQueryFunc;
u                152563 ext/sqlite3/libsqlite/sqlite3.c             p->u.rValue = sqlite3_value_int64(argv[ii]);
u                152565 ext/sqlite3/libsqlite/sqlite3.c             p->u.rValue = sqlite3_value_double(argv[ii]);
u                 144 ext/standard/rand.c #define hiBit(u)      ((u) & 0x80000000U)  /* mask all but highest   bit of u */
u                 145 ext/standard/rand.c #define loBit(u)      ((u) & 0x00000001U)  /* mask all but lowest    bit of u */
u                 146 ext/standard/rand.c #define loBits(u)     ((u) & 0x7FFFFFFFU)  /* mask     the highest   bit of u */
u                 147 ext/standard/rand.c #define mixBits(u, v) (hiBit(u)|loBits(v)) /* move hi bit of u to hi bit of v */
u                 149 ext/standard/rand.c #define twist(m,u,v)  (m ^ (mixBits(u,v)>>1) ^ ((php_uint32)(-(php_int32)(loBit(u))) & 0x9908b0dfU))
u                 338 main/mergesort.c 	u_char *ai, *s, *t, *u, tmp;
u                 343 main/mergesort.c 			u = t - size;
u                 344 main/mergesort.c 			if (cmp(u, t TSRMLS_CC) <= 0)
u                 346 main/mergesort.c 			swap(u, t);
u                 175 sapi/caudium/caudium.c   value = low_mapping_string_lookup(headers->u.mapping, sind);
u                 190 sapi/caudium/caudium.c   return head->u.string->str;
u                 202 sapi/caudium/caudium.c   return head->u.integer;
u                 225 sapi/caudium/caudium.c     sent_bytes = Pike_sp[-1].u.integer;
u                 301 sapi/caudium/caudium.c     mappie.u.mapping = headermap;
u                 306 sapi/caudium/caudium.c     headermap = s_headermap->u.mapping;
u                 311 sapi/caudium/caudium.c        soldval->u.string->size_shift == 0) {
u                 313 sapi/caudium/caudium.c       hval = begin_shared_string(soldval->u.string->len + 1 + vallen);
u                 314 sapi/caudium/caudium.c       MEMCPY(hval->str, soldval->u.string->str, soldval->u.string->len);
u                 315 sapi/caudium/caudium.c       STR0(hval)[soldval->u.string->len] = '\0';
u                 316 sapi/caudium/caudium.c       MEMCPY(hval->str+soldval->u.string->len+1, value, vallen);
u                 323 sapi/caudium/caudium.c   hsval.u.string = hval;
u                 376 sapi/caudium/caudium.c     ref_push_mapping(s_headermap->u.mapping);
u                 413 sapi/caudium/caudium.c     MEMCPY(buf, Pike_sp[-1].u.string->str,
u                 414 sapi/caudium/caudium.c            (total_read = Pike_sp[-1].u.string->len));
u                 506 sapi/caudium/caudium.c     MY_MAPPING_LOOP(headers->u.mapping, i, k) {
u                 511 sapi/caudium/caudium.c 	php_register_variable(ind->u.string->str, val->u.string->str,
u                 726 sapi/caudium/caudium.c     int fd = fd_from_object(raw_fd->u.object);
u                 177 sapi/roxen/roxen.c   value = low_mapping_string_lookup(headers->u.mapping, sind);
u                 192 sapi/roxen/roxen.c   return head->u.string->str;
u                 204 sapi/roxen/roxen.c   return head->u.integer;
u                 230 sapi/roxen/roxen.c     sent_bytes = Pike_sp[-1].u.integer;
u                 306 sapi/roxen/roxen.c     mappie.u.mapping = headermap;
u                 310 sapi/roxen/roxen.c     headermap = s_headermap->u.mapping;
u                 313 sapi/roxen/roxen.c   hsval.u.string = hval;
u                 368 sapi/roxen/roxen.c     ref_push_mapping(s_headermap->u.mapping);
u                 407 sapi/roxen/roxen.c     MEMCPY(buf, Pike_sp[-1].u.string->str,
u                 408 sapi/roxen/roxen.c            (total_read = Pike_sp[-1].u.string->len));
u                 540 sapi/roxen/roxen.c     indices = mapping_indices(headers->u.mapping);
u                 543 sapi/roxen/roxen.c       val = low_mapping_lookup(headers->u.mapping, ind);
u                 547 sapi/roxen/roxen.c 	buf_len = MIN(511, ind->u.string->len);
u                 548 sapi/roxen/roxen.c 	strncpy(buf, ind->u.string->str, buf_len);
u                 552 sapi/roxen/roxen.c 	zvalue->value.str.len = val->u.string->len;
u                 553 sapi/roxen/roxen.c 	zvalue->value.str.val = estrndup(val->u.string->str, zvalue->value.str.len);
u                 659 sapi/roxen/roxen.c     int fd = fd_from_object(raw_fd->u.object);