Lines Matching defs:result
48 * As a result, my preference is to put as little C code as possible in the
196 * a link error will result.
396 /* "All arithmetic binary operators result in the same fundamental type
496 * component-wise on their operands. These result with the same type
509 * \brief Return the result type of a bit-logic operation.
656 * are vectors of the same size, the result is computed component-wise."
714 /* "The result is scalar Boolean."
720 * \brief Return the result type of a bit-shift operation.
1142 ir_rvalue *e0, *e1, *result;
1148 result = do_comparison(mem_ctx, operation, e0, e1);
1151 cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
1153 cmp = result;
1164 ir_rvalue *e0, *e1, *result;
1171 result = do_comparison(mem_ctx, operation, e0, e1);
1174 cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
1176 cmp = result;
1406 ir_rvalue *result = NULL;
1426 op[0], op[1], &result, needs_rvalue, false,
1438 result = op[0];
1448 result = new(ctx) ir_expression(operations[this->oper], type,
1464 result = new(ctx) ir_expression(operations[this->oper], type,
1476 result = new(ctx) ir_expression(operations[this->oper], type,
1491 result = new(ctx) ir_expression(operations[this->oper], type,
1505 /* The relational operators must either generate an error or result
1520 result = new(ctx) ir_expression(operations[this->oper], type,
1533 * operate on all types. They result in a scalar Boolean. If
1567 result = new(ctx) ir_constant(false);
1569 result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
1570 assert(result->type == glsl_type::bool_type);
1580 result = new(ctx) ir_expression(operations[this->oper], type,
1598 result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);
1609 result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
1630 result = new(ctx) ir_dereference_variable(tmp);
1643 result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
1664 result = new(ctx) ir_dereference_variable(tmp);
1674 * expressions and result in a Boolean expression."
1681 result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
1689 result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
1707 result = ir_rvalue::error_value(ctx);
1729 &result, needs_rvalue, false,
1749 result = ir_rvalue::error_value(ctx);
1773 &result, needs_rvalue, false,
1788 result = ir_rvalue::error_value(ctx);
1800 &result, needs_rvalue, false,
1816 result = ir_rvalue::error_value(ctx);
1836 &result, needs_rvalue, false,
1846 * first expression, which must result in a scalar Boolean."
1915 result = cond_val->value.b[0] ? op[1] : op[2];
1944 result = new(ctx) ir_dereference_variable(tmp);
1967 &result, needs_rvalue, false,
1982 result = ir_rvalue::error_value(ctx);
1995 result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
2009 result = _mesa_ast_field_selection_to_hir(this, instructions, state);
2023 result = _mesa_ast_array_index_to_hir(ctx, state, op[0], op[1],
2026 if (result->type->is_error())
2059 result = new(ctx) ir_dereference_variable(var);
2063 && result->variable_referenced()->data.assigned != true
2086 * is specified. This will result in a compile-time error."
2099 result = ir_rvalue::error_value(ctx);
2106 result = new(ctx) ir_constant(this->primary_expression.int_constant);
2110 result = new(ctx) ir_constant(this->primary_expression.uint_constant);
2114 result = new(ctx) ir_constant(this->primary_expression.float_constant);
2118 result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
2122 result = new(ctx) ir_constant(this->primary_expression.double_constant);
2126 result = new(ctx) ir_constant(this->primary_expression.uint64_constant);
2130 result = new(ctx) ir_constant(this->primary_expression.int64_constant);
2178 result = ast->hir(instructions, state);
2187 type = NULL; /* use result->type, not type. */
2188 assert(error_emitted || (result != NULL || !needs_rvalue));
2190 if (result && result->type->is_error() && !error_emitted)
2193 return result;
4522 ir_rvalue *result = NULL;
4648 * RESOLUTION: The result of a sequence operator is not a
4712 &result, true, true,
4714 initializer_type = result->type;
4736 * already match exactly. As a result, the type assignment
4749 return result;
4957 ir_rvalue *result = NULL;
5745 result = process_initializer(var,
5875 return result;
7283 * qualifiers will result in an error.
8002 * using std430 on a uniform block will result in a compile-time error."
8314 * declaration, or a compilation error will result.