#include "glsl_types.h"
#include "ir.h"
-#define X 1
-#define R 5
-#define S 9
-#define I 13
-
-static bool
-generate_swizzle(const char *str, struct ir_swizzle_mask *swiz,
- unsigned vector_length)
-{
- /* For each possible swizzle character, this table encodes the value in
- * \c idx_map that represents the 0th element of the vector. For invalid
- * swizzle characters (e.g., 'k'), a special value is used that will allow
- * detection of errors.
- */
- unsigned char base_idx[26] = {
- /* a b c d e f g h i j k l m */
- R, R, I, I, I, I, R, I, I, I, I, I, I,
- /* n o p q r s t u v w x y z */
- I, I, S, S, R, S, S, I, I, X, X, X, X
- };
-
- /* Each valid swizzle character has an entry in the previous table. This
- * table encodes the base index encoded in the previous table plus the actual
- * index of the swizzle character. When processing swizzles, the first
- * character in the string is indexed in the previous table. Each character
- * in the string is indexed in this table, and the value found there has the
- * value form the first table subtracted. The result must be on the range
- * [0,3].
- *
- * For example, the string "wzyx" will get X from the first table. Each of
- * the charcaters will get X+3, X+2, X+1, and X+0 from this table. After
- * subtraction, the swizzle values are { 3, 2, 1, 0 }.
- *
- * The string "wzrg" will get X from the first table. Each of the characters
- * will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the
- * swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range
- * [0,3], the error is detected.
- */
- unsigned char idx_map[26] = {
- /* a b c d e f g h i j k l m */
- R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,
- /* n o p q r s t u v w x y z */
- 0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2
- };
-
- int swiz_idx[4] = { 0, 0, 0, 0 };
- unsigned base;
- unsigned dup_mask = 0;
- unsigned seen_mask = 0;
- unsigned i;
-
-
- /* Validate the first character in the swizzle string and look up the base
- * index value as described above.
- */
- if ((str[0] < 'a') || (str[0] > 'z'))
- return false;
-
- base = base_idx[str[0] - 'a'];
-
-
- for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
- unsigned bit;
-
- /* Validate the next character, and, as described above, convert it to a
- * swizzle index.
- */
- if ((str[i] < 'a') || (str[i] > 'z'))
- return false;
-
- swiz_idx[i] = idx_map[str[0] - 'a'] - base;
- if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
- return false;
-
-
- /* Track a bit-mask of the swizzle index values that have been seen. If
- * a value is seen more than once, set the "duplicate" flag.
- */
- bit = (1U << swiz_idx[i]);
- dup_mask |= seen_mask & bit;
- seen_mask |= bit;
- }
-
- if (str[i] != '\0')
- return false;
-
- swiz->x = swiz_idx[0];
- swiz->y = swiz_idx[1];
- swiz->z = swiz_idx[2];
- swiz->w = swiz_idx[3];
- swiz->num_components = i;
- swiz->has_duplicates = (dup_mask != 0);
-
- return true;
-}
-
-
-struct ir_instruction *
+struct ir_rvalue *
_mesa_ast_field_selection_to_hir(const ast_expression *expr,
- simple_node *instructions,
+ exec_list *instructions,
struct _mesa_glsl_parse_state *state)
{
- ir_instruction *op;
- ir_dereference *deref;
- YYLTYPE loc;
-
+ ir_rvalue *result = NULL;
+ ir_rvalue *op;
- op = _mesa_ast_to_hir(expr->subexpressions[0], instructions, state);
- deref = new ir_dereference(op);
-
- /* Initially assume that the resulting type of the field selection is an
- * error. This make the error paths below a bit easier to follow.
- */
- deref->type = glsl_error_type;
-
- /* If processing the thing being dereferenced generated an error, bail out
- * now. Doing so prevents spurious error messages from being logged below.
- */
- if (is_error_type(op->type))
- return (struct ir_instruction *) deref;
+ op = expr->subexpressions[0]->hir(instructions, state);
/* There are two kinds of field selection. There is the selection of a
* specific field from a structure, and there is the selection of a
* by the base type of the thing to which the field selection operator is
* being applied.
*/
- loc = expr->get_location();
- if (is_glsl_type_vector(op->type)) {
- if (generate_swizzle(expr->primary_expression.identifier,
- & deref->selector.swizzle,
- op->type->vector_elements)) {
- /* Based on the number of elements in the swizzle and the base type
- * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
- * generate the type of the resulting value.
- */
- deref->type =
- _mesa_glsl_get_vector_type(op->type->base_type,
- deref->selector.swizzle.num_components);
+ YYLTYPE loc = expr->get_location();
+ if (op->type->is_error()) {
+ /* silently propagate the error */
+ } else if (op->type->is_vector()) {
+ ir_swizzle *swiz = ir_swizzle::create(op,
+ expr->primary_expression.identifier,
+ op->type->vector_elements);
+ if (swiz != NULL) {
+ result = swiz;
} else {
/* FINISHME: Logging of error messages should be moved into
- * FINISHME: generate_swizzle. This allows the generation of more
+ * FINISHME: ir_swizzle::create. This allows the generation of more
* FINISHME: specific error messages.
*/
_mesa_glsl_error(& loc, state, "Invalid swizzle / mask `%s'",
expr->primary_expression.identifier);
}
- return (struct ir_instruction *) deref;
+ return result ? result : ir_call::get_error_instruction();
}