Move swizzles out of ir_dereference and into their own class.

Also turn generate_swizzle into a static "create" method of the new
class; we'll want to use it for the IR reader as well.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>

1 files changed, 12 insertions, 107 deletions

diff --git a/hir_field_selection.cpp b/hir_field_selection.cpp
index 41dbd42d3b..76c4868361 100644
--- a/hir_field_selection.cpp
+++ b/hir_field_selection.cpp
@@ -28,107 +28,15 @@
 #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, ir_dereference *deref,
-		 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.
-    */
-   static const 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.
-    */
-   static const 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 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;
-
-   const unsigned base = base_idx[str[0] - 'a'];
-
-
-   for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
-      /* 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[i] - 'a'] - base;
-      if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
-	 return false;
-   }
-
-   if (str[i] != '\0')
-	 return false;
-
-   deref->set_swizzle(swiz_idx[0], swiz_idx[1], swiz_idx[2], swiz_idx[3], i);
-   return true;
-}
-
-
 struct ir_rvalue *
 _mesa_ast_field_selection_to_hir(const ast_expression *expr,
 				 exec_list *instructions,
 				 struct _mesa_glsl_parse_state *state)
 {
+   ir_rvalue *result = NULL;
    ir_rvalue *op;
-   ir_dereference *deref;
-   YYLTYPE loc;
-
 
    op = expr->subexpressions[0]->hir(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 deref;
 
    /* 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
@@ -136,21 +44,18 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr,
     * by the base type of the thing to which the field selection operator is
     * being applied.
     */
-   loc = expr->get_location();
-   if (op->type->is_vector()) {
-      if (generate_swizzle(expr->primary_expression.identifier, 
-			   deref, 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 =
-	    glsl_type::get_instance(op->type->base_type,
-				    deref->selector.swizzle.num_components,
-				    1);
+   YYLTYPE loc = expr->get_location();
+   if (op->type == glsl_error_type) {
+      /* 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'",
@@ -164,5 +69,5 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr,
 		       expr->primary_expression.identifier);
    }
 
-   return deref;
+   return result ? result : ir_call::get_error_instruction();
 }