Reimplement the _slang_alloc_statevar() function.

After several tries at making a table-based system for examining pre-defined
uniforms to find statevar indexes, give up and do it the simple way (lots of
strcmp() calls).  Not terribly elegant, but perfectly functional.

1 files changed, 274 insertions, 324 deletions

diff --git a/src/mesa/shader/slang/slang_builtin.c b/src/mesa/shader/slang/slang_builtin.c
index 71a102e45ce..08a4a6a7080 100644
--- a/src/mesa/shader/slang/slang_builtin.c
+++ b/src/mesa/shader/slang/slang_builtin.c
@@ -43,343 +43,285 @@
 #include "slang_print.h"
 
 
-
 /**
- * XXX we might consider moving much of this into the prog_statevars.c file
+ * Lookup GL state given a variable name, 0, 1 or 2 indexes and a field.
+ * Allocate room for the state in the given param list and return position
+ * in the list.
  */
-
-
-/**
- * Determine if 'name' is a state variable (pre-defined uniform).
- * If so, create a new program parameter for it, and return the
- * param's index.
- *
- * \param swizzleOut  returns the swizzle needed to access 'float' values
- * \return the state value's position in the parameter list, or -1 if error
- */
-GLint
-_slang_lookup_statevar(const char *name, GLint index,
-                       struct gl_program_parameter_list *paramList,
-                       GLuint *swizzleOut)
-{
-   struct state_info {
-      const char *Name;
-      const GLuint NumRows;  /** for matrices */
-      const GLuint Swizzle;
-      const GLint Indexes[STATE_LENGTH];
-   };
-   static const struct state_info state[] = {
-      { "gl_ModelViewMatrix", 4, SWIZZLE_NOOP,
-        { STATE_MODELVIEW_MATRIX, 0, 0, 0, 0, 0 } },
-      { "gl_NormalMatrix", 3, SWIZZLE_NOOP,
-        { STATE_MODELVIEW_MATRIX, 0, 0, 0, 0, 0 } },
-      { "gl_ProjectionMatrix", 4, SWIZZLE_NOOP,
-        { STATE_PROJECTION_MATRIX, 0, 0, 0, 0, 0 } },
-      { "gl_ModelViewProjectionMatrix", 4, SWIZZLE_NOOP,
-        { STATE_MVP_MATRIX, 0, 0, 0, 0, 0 } },
-      { "gl_TextureMatrix", 4, SWIZZLE_NOOP,
-        { STATE_TEXTURE_MATRIX, 0, 0, 0, 0, 0 } },
-      { "gl_NormalScale", 1, SWIZZLE_NOOP,
-        { STATE_INTERNAL, STATE_NORMAL_SCALE, 0, 0, 0, 0} },
-
-      /* For aggregate/structs we need entries for both the base name
-       * and base.field.
-       */
-      { "gl_DepthRange", 1, SWIZZLE_NOOP,
-        { STATE_DEPTH_RANGE, 0, 0, 0, 0, 0 } },
-      { "gl_DepthRange.near", 1, SWIZZLE_XXXX,
-        { STATE_DEPTH_RANGE, 0, 0, 0, 0, 0 } },
-      { "gl_DepthRange.far", 1, SWIZZLE_YYYY,
-        { STATE_DEPTH_RANGE, 0, 0, 0, 0, 0 } },
-      { "gl_DepthRange.diff", 1, SWIZZLE_ZZZZ,
-        { STATE_DEPTH_RANGE, 0, 0, 0, 0, 0 } },
-
-      { "gl_Point", 1, SWIZZLE_NOOP,
-        { STATE_POINT_SIZE, 0, 0, 0, 0, 0 } },
-      { "gl_Point.size", 1, SWIZZLE_XXXX,
-        { STATE_POINT_SIZE, 0, 0, 0, 0, 0 } },
-      { "gl_Point.sizeMin", 1, SWIZZLE_YYYY,
-        { STATE_POINT_SIZE, 0, 0, 0, 0, 0 } },
-      { "gl_Point.sizeMax", 1, SWIZZLE_ZZZZ,
-        { STATE_POINT_SIZE, 0, 0, 0, 0, 0 } },
-      { "gl_Point.fadeThresholdSize", 1, SWIZZLE_WWWW,
-        { STATE_POINT_SIZE, 0, 0, 0, 0, 0 } },
-      { "gl_Point.distanceConstantAttenuation", 1, SWIZZLE_XXXX,
-        { STATE_POINT_ATTENUATION, 0, 0, 0, 0, 0 } },
-      { "gl_Point.distanceLinearAttenuation", 1, SWIZZLE_YYYY,
-        { STATE_POINT_ATTENUATION, 0, 0, 0, 0, 0 } },
-      { "gl_Point.distanceQuadraticAttenuation", 1, SWIZZLE_ZZZZ,
-        { STATE_POINT_ATTENUATION, 0, 0, 0, 0, 0 } },
-
-      { "gl_FrontMaterial", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 0, STATE_EMISSION, 0, 0, 0 } },
-      { "gl_FrontMaterial.emission", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 0, STATE_EMISSION, 0, 0, 0 } },
-      { "gl_FrontMaterial.ambient", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 0, STATE_AMBIENT, 0, 0, 0 } },
-      { "gl_FrontMaterial.diffuse", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 0, STATE_DIFFUSE, 0, 0, 0 } },
-      { "gl_FrontMaterial.specular", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 0, STATE_SPECULAR, 0, 0, 0 } },
-      { "gl_FrontMaterial.shininess", 1, SWIZZLE_XXXX,
-        { STATE_MATERIAL, 0, STATE_SHININESS, 0, 0, 0 } },
-
-      { "gl_BackMaterial", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 1, STATE_EMISSION, 0, 0, 0 } },
-      { "gl_BackMaterial.emission", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 1, STATE_EMISSION, 0, 0, 0 } },
-      { "gl_BackMaterial.ambient", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 1, STATE_AMBIENT, 0, 0, 0 } },
-      { "gl_BackMaterial.diffuse", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 1, STATE_DIFFUSE, 0, 0, 0 } },
-      { "gl_BackMaterial.specular", 1, SWIZZLE_NOOP,
-        { STATE_MATERIAL, 1, STATE_SPECULAR, 0, 0, 0 } },
-      { "gl_BackMaterial.shininess", 1, SWIZZLE_XXXX,
-        { STATE_MATERIAL, 1, STATE_SHININESS, 0, 0, 0 } },
-
-      { "gl_LightModel", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_AMBIENT, 0, 0, 0, 0, 0 } },
-      { "gl_LightModel.ambient", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_AMBIENT, 0, 0, 0, 0, 0 } },
-
-      { "gl_FrontLightModelProduct", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_SCENECOLOR, 0, 0, 0, 0, 0 } },
-      { "gl_FrontLightModelProduct.sceneColor", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_SCENECOLOR, 0, 0, 0, 0, 0 } },
-
-      { "gl_BackLightModelProduct", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_SCENECOLOR, 1, 0, 0, 0, 0 } },
-      { "gl_BackLightModelProduct.sceneColor", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTMODEL_SCENECOLOR, 1, 0, 0, 0, 0 } },
-
-      { "gl_FrontLightProduct", 1, SWIZZLE_NOOP,
-        { STATE_LIGHTPROD, 0, STATE_AMBIENT, 0, 0, 0 } },
-
-
-      { "gl_Fog", 1, SWIZZLE_NOOP,
-        { STATE_FOG, STATE_FOG_COLOR, 0, 0, 0, 0 } },
-      { "gl_Fog.color", 1, SWIZZLE_NOOP,
-        { STATE_FOG, STATE_FOG_COLOR, 0, 0, 0, 0 } },
-      { "gl_Fog.density", 1, SWIZZLE_XXXX,
-        { STATE_FOG, STATE_FOG_PARAMS, 0, 0, 0, 0 } },
-      { "gl_Fog.start", 1, SWIZZLE_YYYY,
-        { STATE_FOG, STATE_FOG_PARAMS, 0, 0, 0, 0 } },
-      { "gl_Fog.end", 1, SWIZZLE_ZZZZ,
-        { STATE_FOG, STATE_FOG_PARAMS, 0, 0, 0, 0 } },
-      { "gl_Fog.scale", 1, SWIZZLE_WWWW,
-        { STATE_FOG, STATE_FOG_PARAMS, 0, 0, 0, 0 } },
-
-      { "gl_ClipPlane", 1, SWIZZLE_NOOP,
-        { STATE_CLIPPLANE, 0, 0, 0, 0, 0 } },
-
-      { NULL, 0, 0, {0, 0, 0, 0, 0, 0} }
-   };
-   GLuint i;
-
-   for (i = 0; state[i].Name; i++) {
-      if (strcmp(state[i].Name, name) == 0) {
-         /* found */
-         *swizzleOut = state[i].Swizzle;
-         if (paramList) {
-            if (state[i].NumRows > 1) {
-               /* a matrix */
-               GLuint j;
-               GLint pos[4], indexesCopy[STATE_LENGTH];
-               /* make copy of state tokens */
-               for (j = 0; j < STATE_LENGTH; j++)
-                  indexesCopy[j] = state[i].Indexes[j];
-               /* load rows */
-               for (j = 0; j < state[i].NumRows; j++) {
-                  indexesCopy[2] = indexesCopy[3] = j; /* jth row of matrix */
-                  pos[j] = _mesa_add_state_reference(paramList, indexesCopy);
-                  assert(pos[j] >= 0);
-               }
-               return pos[0];
-            }
-            else {
-               /* non-matrix state */
-               GLint pos
-                  = _mesa_add_state_reference(paramList, state[i].Indexes);
-               assert(pos >= 0);
-               return pos;
-            }
-         }
-      }
-   }
-   return -1;
-}
-
-
-GLint
-_slang_lookup_statevar_field(const char *base, const char *field,
-                             struct gl_program_parameter_list *paramList,
-                             GLuint *swizzleOut)
-{
-   GLint pos = -1;
-   const GLint len = _mesa_strlen(base)
-                   + _mesa_strlen(field) + 2;
-   char *name = (char *) _mesa_malloc(len);
-
-   if (!name)
-      return -1;
-
-   _mesa_strcpy(name, base);
-   /*_mesa_*/strcat(name, ".");
-   /*_mesa_*/strcat(name, field);
-   printf("FULL NAME: %s\n", name);
-
-   pos = _slang_lookup_statevar(name, 0, paramList, swizzleOut);
-
-   _mesa_free(name);
-
-   return pos;
-}
-
-
-struct field_info {
-   const char *Name;
-   gl_state_index Token;
-   GLint TokenPos;
-   GLuint Swizzle;
-};
-
-#define MT_FIELD { NULL, 0, -1, 0 }
-#define MAX_FIELDS 5
-#define INDEX_POS 1000
-
-struct state_uniform_info {
-   const char *Name;
-   gl_state_index StateTokens[2];
-   struct field_info Fields[MAX_FIELDS];
-};
-
-
-
-static const struct state_uniform_info Uniforms[] = {
-   { "gl_ModelViewMatrix", { STATE_MODELVIEW_MATRIX, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-   { "gl_ProjectionMatrix", { STATE_PROJECTION_MATRIX, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-   { "gl_ModelViewProjectionMatrix", { STATE_MVP_MATRIX, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-   { "gl_NormalMatrix", { STATE_MODELVIEW_MATRIX, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-   { "gl_TextureMatrix", { STATE_TEXTURE_MATRIX, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-
-   { "gl_ClipPlane", { STATE_CLIPPLANE, INDEX_POS },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD}
-   },
-
-   { "gl_DepthRange", { STATE_DEPTH_RANGE, 0 },
-     {
-        { "near", 0, -1, SWIZZLE_XXXX },
-        { "far", 0, -1, SWIZZLE_YYYY },
-        { "diff", 0, -1, SWIZZLE_ZZZZ },
-        MT_FIELD,
-        MT_FIELD
-     }
-   },
-
-   { "gl_Fog", { STATE_FOG, 0 },
-     {
-        { "color", STATE_FOG_COLOR, 1, SWIZZLE_NOOP },
-        { "density", STATE_FOG_PARAMS, 1, SWIZZLE_XXXX },
-        { "start", STATE_FOG_PARAMS, 1, SWIZZLE_YYYY },
-        { "end", STATE_FOG_PARAMS, 1, SWIZZLE_ZZZZ },
-        { "scale", STATE_FOG_PARAMS, 1, SWIZZLE_WWWW }
-     }
-   },
-
-   { NULL, { 0, 0 },
-     { MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD, MT_FIELD }
-   }
-};
-
-
 static GLint
-lookup_statevar(const char *var, GLint index, const char *field,
+lookup_statevar(const char *var, GLint index1, GLint index2, const char *field,
                 GLuint *swizzleOut,
                 struct gl_program_parameter_list *paramList)
 {
    gl_state_index tokens[STATE_LENGTH];
-   GLuint i, j;
-   GLint pos;
+   GLuint i;
+   GLboolean isMatrix = GL_FALSE;
 
    for (i = 0; i < STATE_LENGTH; i++) {
       tokens[i] = 0;
    }
+   *swizzleOut = SWIZZLE_NOOP;
 
-   for (i = 0; Uniforms[i].Name; i++) {
-      if (strcmp(var, Uniforms[i].Name) == 0) {
-         /* found the uniform */
-
-         for (j = 0; j < 2; j++) {
-            tokens[j] = Uniforms[i].StateTokens[j];
-            if (tokens[j] == INDEX_POS) {
-               /* replace INDEX_POS with actual array index */
-               assert(index >= 0);
-               tokens[j] = index;
-            }
-         }
-
-         if (field) {
-            /* extra work for var.field */
-            for (j = 0; j < MAX_FIELDS; j++) {
-               if (!Uniforms[i].Fields[j].Name) {
-                  /* field not found! */
-                  _mesa_problem(NULL, "field not found");
-                  return -1;
-               }
-               else if (strcmp(field, Uniforms[i].Fields[j].Name) == 0) {
-                  /* found the field */
-                  GLint tokenPos = Uniforms[i].Fields[j].TokenPos;
-                  if (tokenPos>= 0) {
-                     tokens[tokenPos] = Uniforms[i].Fields[j].Token;
-                  }
-                  *swizzleOut = Uniforms[i].Fields[j].Swizzle;
-                  break;
-               }
-
-            }
-         }
-
-         if (tokens[0] == STATE_MODELVIEW_MATRIX ||
-             tokens[0] == STATE_PROJECTION_MATRIX ||
-             tokens[0] == STATE_MVP_MATRIX ||
-             tokens[0] == STATE_TEXTURE_MATRIX ||
-             tokens[0] == STATE_PROGRAM_MATRIX) {
-            /* a matrix */
-            GLuint j;
-            GLint pos[4];
-            gl_state_index indexesCopy[STATE_LENGTH];
-            /* make copy of state tokens */
-            for (j = 0; j < STATE_LENGTH; j++)
-               indexesCopy[j] = tokens[j];
-            /* load rows */
-            for (j = 0; j < 4/*state[i].NumRows*/; j++) {
-               indexesCopy[2] = indexesCopy[3] = j; /* jth row of matrix */
-               pos[j] = _mesa_add_state_reference(paramList, (GLint*) indexesCopy);
-               assert(pos[j] >= 0);
-            }
-            return pos[0] + index;
-         }
+   if (strcmp(var, "gl_ModelViewMatrix") == 0) {
+      tokens[0] = STATE_MODELVIEW_MATRIX;
+      isMatrix = GL_TRUE;
+   }
+   else if (strcmp(var, "gl_ModelProjectionMatrix") == 0) {
+      tokens[0] = STATE_PROJECTION_MATRIX;
+      isMatrix = GL_TRUE;
+   }
+   else if (strcmp(var, "gl_ModelViewProjectionMatrix") == 0) {
+      tokens[0] = STATE_MVP_MATRIX;
+      isMatrix = GL_TRUE;
+   }
+   else if (strcmp(var, "gl_NormalMatrix") == 0) {
+      tokens[0] = STATE_MODELVIEW_MATRIX;
+      isMatrix = GL_TRUE;
+   }
+   else if (strcmp(var, "gl_TextureMatrix") == 0) {
+      tokens[0] = STATE_TEXTURE_MATRIX;
+      if (index2 >= 0)
+         tokens[1] = index2;
+      isMatrix = GL_TRUE;
+   }
+   else if (strcmp(var, "gl_DepthRange") == 0) {
+      tokens[0] = STATE_DEPTH_RANGE;
+      if (strcmp(field, "near") == 0) {
+         *swizzleOut = SWIZZLE_XXXX;
+      }
+      else if (strcmp(field, "far") == 0) {
+         *swizzleOut = SWIZZLE_YYYY;
+      }
+      else if (strcmp(field, "diff") == 0) {
+         *swizzleOut = SWIZZLE_ZZZZ;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_ClipPlane") == 0) {
+      tokens[0] = STATE_CLIPPLANE;
+      tokens[1] = index1;
+   }
+   else if (strcmp(var, "gl_FrontMaterial") == 0 ||
+            strcmp(var, "gl_BackMaterial") == 0) {
+      tokens[0] = STATE_MATERIAL;
+      if (strcmp(var, "gl_FrontMaterial") == 0)
+         tokens[1] = 0;
+      else
+         tokens[1] = 1;
+      if (strcmp(field, "emission") == 0) {
+         tokens[2] = STATE_EMISSION;
+      }
+      else if (strcmp(field, "ambient") == 0) {
+         tokens[2] = STATE_AMBIENT;
+      }
+      else if (strcmp(field, "diffuse") == 0) {
+         tokens[2] = STATE_DIFFUSE;
+      }
+      else if (strcmp(field, "specular") == 0) {
+         tokens[2] = STATE_SPECULAR;
+      }
+      else if (strcmp(field, "shininess") == 0) {
+         tokens[2] = STATE_SHININESS;
+         *swizzleOut = SWIZZLE_XXXX;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_LightSource") == 0) {
+      tokens[0] = STATE_LIGHT;
+      tokens[1] = index1;
+      if (strcmp(field, "ambient") == 0) {
+         tokens[2] = STATE_AMBIENT;
+      }
+      else if (strcmp(field, "diffuse") == 0) {
+         tokens[2] = STATE_DIFFUSE;
+      }
+      else if (strcmp(field, "specular") == 0) {
+         tokens[2] = STATE_SPECULAR;
+      }
+      else if (strcmp(field, "position") == 0) {
+         tokens[2] = STATE_POSITION;
+      }
+      else if (strcmp(field, "halfVector") == 0) {
+         tokens[2] = STATE_HALF_VECTOR;
+      }
+      else if (strcmp(field, "spotDirection") == 0) {
+         tokens[2] = STATE_SPOT_DIRECTION;
+      }
+      else if (strcmp(field, "spotCosCutoff") == 0) {
+         tokens[2] = STATE_SPOT_DIRECTION;
+         *swizzleOut = SWIZZLE_WWWW;
+      }
+      else if (strcmp(field, "spotCutoff") == 0) {
+         tokens[2] = STATE_SPOT_CUTOFF;
+         *swizzleOut = SWIZZLE_XXXX;
+      }
+      else if (strcmp(field, "spotExponent") == 0) {
+         tokens[2] = STATE_ATTENUATION;
+         *swizzleOut = SWIZZLE_WWWW;
+      }
+      else if (strcmp(field, "constantAttenuation") == 0) {
+         tokens[2] = STATE_ATTENUATION;
+         *swizzleOut = SWIZZLE_XXXX;
+      }
+      else if (strcmp(field, "linearAttenuation") == 0) {
+         tokens[2] = STATE_ATTENUATION;
+         *swizzleOut = SWIZZLE_YYYY;
+      }
+      else if (strcmp(field, "quadraticAttenuation") == 0) {
+         tokens[2] = STATE_ATTENUATION;
+         *swizzleOut = SWIZZLE_ZZZZ;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_LightModel") == 0) {
+      if (strcmp(field, "ambient") == 0) {
+         tokens[0] = STATE_LIGHTMODEL_AMBIENT;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_FrontLightModelProduct") == 0) {
+      if (strcmp(field, "ambient") == 0) {
+         tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
+         tokens[1] = 0;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_BackLightModelProduct") == 0) {
+      if (strcmp(field, "ambient") == 0) {
+         tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
+         tokens[1] = 1;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_FrontLightProduct") == 0 ||
+            strcmp(var, "gl_BackLightProduct") == 0) {
+      tokens[0] = STATE_LIGHTPROD;
+      tokens[1] = index1; /* light number */
+      if (strcmp(var, "gl_FrontLightProduct") == 0) {
+         tokens[2] = 0; /* front */
+      }
+      else {
+         tokens[2] = 1; /* back */
+      }
+      if (strcmp(field, "ambient") == 0) {
+         tokens[3] = STATE_AMBIENT;
+      }
+      else if (strcmp(field, "diffuset") == 0) {
+         tokens[3] = STATE_DIFFUSE;
+      }
+      else if (strcmp(field, "specular") == 0) {
+         tokens[3] = STATE_SPECULAR;
+      }
+      else {
+         return -1;
+      }
+   }
+   else if (strcmp(var, "gl_TextureEnvColor") == 0) {
+      tokens[0] = STATE_TEXENV_COLOR;
+      tokens[1] = index1;
+   }
+   else if (strcmp(var, "gl_EyePlaneS") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_EYE_S;
+   }
+   else if (strcmp(var, "gl_EyePlaneT") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_EYE_T;
+   }
+   else if (strcmp(var, "gl_EyePlaneR") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_EYE_R;
+   }
+   else if (strcmp(var, "gl_EyePlaneQ") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_EYE_Q;
+   }
+   else if (strcmp(var, "gl_ObjectPlaneS") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_OBJECT_S;
+   }
+   else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_OBJECT_T;
+   }
+   else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_OBJECT_T;
+   }
+   else if (strcmp(var, "gl_ObjectPlaneT") == 0) {
+      tokens[0] = STATE_TEXGEN;
+      tokens[1] = index1; /* tex unit */
+      tokens[2] = STATE_TEXGEN_OBJECT_T;
+   }
+   else if (strcmp(var, "gl_Fog") == 0) {
+      tokens[0] = STATE_FOG;
+      if (strcmp(field, "color") == 0) {
+         tokens[1] = STATE_FOG_COLOR;
+      }
+      else if (strcmp(field, "density") == 0) {
+         tokens[1] = STATE_FOG_PARAMS;
+         *swizzleOut = SWIZZLE_XXXX;
+      }
+      else if (strcmp(field, "start") == 0) {
+         tokens[1] = STATE_FOG_PARAMS;
+         *swizzleOut = SWIZZLE_YYYY;
+      }
+      else if (strcmp(field, "end") == 0) {
+         tokens[1] = STATE_FOG_PARAMS;
+         *swizzleOut = SWIZZLE_ZZZZ;
+      }
+      else if (strcmp(field, "scale") == 0) {
+         tokens[1] = STATE_FOG_PARAMS;
+         *swizzleOut = SWIZZLE_WWWW;
+      }
+      else {
+         return -1;
+      }
+   }
+   else {
+      return -1;
+   }
 
-         pos = _mesa_add_state_reference(paramList, (GLint *) tokens);
-         assert(pos >= 0);
-         return pos;
+   if (isMatrix) {
+      /* load all four columns of matrix */
+      GLint pos[4];
+      GLuint j;
+      for (j = 0; j < 4; j++) {
+         tokens[2] = tokens[3] = j; /* jth row of matrix */
+         pos[j] = _mesa_add_state_reference(paramList, (GLint *) tokens);
+         assert(pos[j] >= 0);
+         ASSERT(pos[j] >= 0);
       }
+      return pos[0] + index1;
+   }
+   else {
+      /* allocate a single register */
+      GLint pos = _mesa_add_state_reference(paramList, (GLint *) tokens);
+      ASSERT(pos >= 0);
+      return pos;
    }
-   return -1;
 }
 
 
-
 /**
  * Allocate storage for a pre-defined uniform (a GL state variable).
  * As a memory-saving optimization, we try to only allocate storage for
@@ -390,16 +332,17 @@ lookup_statevar(const char *var, GLint index, const char *field,
  *
  * Currently, all pre-defined uniforms are in one of these forms:
  *   var
- *   var[index]
+ *   var[i]
  *   var.field
- *   var[index].field
+ *   var[i].field
+ *   var[i][j]
  */
 GLint
 _slang_alloc_statevar(slang_ir_node *n,
                       struct gl_program_parameter_list *paramList)
 {
    const char *field = NULL, *var;
-   GLint index = -1, pos;
+   GLint index1 = -1, index2 = -1, pos;
    GLuint swizzle;
 
    if (n->Opcode == IR_FIELD) {
@@ -410,14 +353,21 @@ _slang_alloc_statevar(slang_ir_node *n,
    if (n->Opcode == IR_ELEMENT) {
       /* XXX can only handle constant indexes for now */
       assert(n->Children[1]->Opcode == IR_FLOAT);
-      index = (GLint) n->Children[1]->Value[0];
+      index1 = (GLint) n->Children[1]->Value[0];
+      n = n->Children[0];
+   }
+
+   if (n->Opcode == IR_ELEMENT) {
+      /* XXX can only handle constant indexes for now */
+      assert(n->Children[1]->Opcode == IR_FLOAT);
+      index2 = (GLint) n->Children[1]->Value[0];
       n = n->Children[0];
    }
 
    assert(n->Opcode == IR_VAR);
    var = (char *) n->Var->a_name;
 
-   pos = lookup_statevar(var, index, field, &swizzle, paramList);
+   pos = lookup_statevar(var, index1, index2, field, &swizzle, paramList);
    assert(pos >= 0);
    if (pos >= 0) {
       n->Store->Index = pos;