change all enum tokens to uppercase

16 files changed, 819 insertions, 817 deletions

diff --git a/src/mesa/shader/slang/slang_codegen.c b/src/mesa/shader/slang/slang_codegen.c
index c4535feac1..a36a2d7bc9 100644
--- a/src/mesa/shader/slang/slang_codegen.c
+++ b/src/mesa/shader/slang/slang_codegen.c
@@ -142,12 +142,12 @@ static GLboolean
 is_sampler_type(const slang_fully_specified_type *t)
 {
    switch (t->specifier.type) {
-   case slang_spec_sampler1D:
-   case slang_spec_sampler2D:
-   case slang_spec_sampler3D:
-   case slang_spec_samplerCube:
-   case slang_spec_sampler1DShadow:
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER1D:
+   case SLANG_SPEC_SAMPLER2D:
+   case SLANG_SPEC_SAMPLER3D:
+   case SLANG_SPEC_SAMPLERCUBE:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
       return GL_TRUE;
    default:
       return GL_FALSE;
@@ -167,49 +167,49 @@ GLuint
 _slang_sizeof_type_specifier(const slang_type_specifier *spec)
 {
    switch (spec->type) {
-   case slang_spec_void:
+   case SLANG_SPEC_VOID:
       abort();
       return 0;
-   case slang_spec_bool:
+   case SLANG_SPEC_BOOL:
       return 1;
-   case slang_spec_bvec2:
+   case SLANG_SPEC_BVEC2:
       return 2;
-   case slang_spec_bvec3:
+   case SLANG_SPEC_BVEC3:
       return 3;
-   case slang_spec_bvec4:
+   case SLANG_SPEC_BVEC4:
       return 4;
-   case slang_spec_int:
+   case SLANG_SPEC_INT:
       return 1;
-   case slang_spec_ivec2:
+   case SLANG_SPEC_IVEC2:
       return 2;
-   case slang_spec_ivec3:
+   case SLANG_SPEC_IVEC3:
       return 3;
-   case slang_spec_ivec4:
+   case SLANG_SPEC_IVEC4:
       return 4;
-   case slang_spec_float:
+   case SLANG_SPEC_FLOAT:
       return 1;
-   case slang_spec_vec2:
+   case SLANG_SPEC_VEC2:
       return 2;
-   case slang_spec_vec3:
+   case SLANG_SPEC_VEC3:
       return 3;
-   case slang_spec_vec4:
+   case SLANG_SPEC_VEC4:
       return 4;
-   case slang_spec_mat2:
+   case SLANG_SPEC_MAT2:
       return 2 * 2;
-   case slang_spec_mat3:
+   case SLANG_SPEC_MAT3:
       return 3 * 3;
-   case slang_spec_mat4:
+   case SLANG_SPEC_MAT4:
       return 4 * 4;
-   case slang_spec_sampler1D:
-   case slang_spec_sampler2D:
-   case slang_spec_sampler3D:
-   case slang_spec_samplerCube:
-   case slang_spec_sampler1DShadow:
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER1D:
+   case SLANG_SPEC_SAMPLER2D:
+   case SLANG_SPEC_SAMPLER3D:
+   case SLANG_SPEC_SAMPLERCUBE:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
       return 1; /* special case */
-   case slang_spec_struct:
+   case SLANG_SPEC_STRUCT:
       return _slang_sizeof_struct(spec->_struct);
-   case slang_spec_array:
+   case SLANG_SPEC_ARRAY:
       return 1; /* XXX */
    default:
       abort();
@@ -295,17 +295,17 @@ static GLint
 sampler_to_texture_index(const slang_type_specifier_type type)
 {
    switch (type) {
-   case slang_spec_sampler1D:
+   case SLANG_SPEC_SAMPLER1D:
       return TEXTURE_1D_INDEX;
-   case slang_spec_sampler2D:
+   case SLANG_SPEC_SAMPLER2D:
       return TEXTURE_2D_INDEX;
-   case slang_spec_sampler3D:
+   case SLANG_SPEC_SAMPLER3D:
       return TEXTURE_3D_INDEX;
-   case slang_spec_samplerCube:
+   case SLANG_SPEC_SAMPLERCUBE:
       return TEXTURE_CUBE_INDEX;
-   case slang_spec_sampler1DShadow:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
       return TEXTURE_1D_INDEX; /* XXX fix */
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
       return TEXTURE_2D_INDEX; /* XXX fix */
    default:
       return -1;
@@ -708,9 +708,9 @@ new_var(slang_assemble_ctx *A, slang_operation *oper, slang_atom name)
 static GLboolean
 slang_is_asm_function(const slang_function *fun)
 {
-   if (fun->body->type == slang_oper_block_no_new_scope &&
+   if (fun->body->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE &&
        fun->body->num_children == 1 &&
-       fun->body->children[0].type == slang_oper_asm) {
+       fun->body->children[0].type == SLANG_OPER_ASM) {
       return GL_TRUE;
    }
    return GL_FALSE;
@@ -729,7 +729,7 @@ slang_inline_asm_function(slang_assemble_ctx *A,
    GLuint i;
    slang_operation *inlined = slang_operation_new(1);
 
-   /*assert(oper->type == slang_oper_call);  or vec4_add, etc */
+   /*assert(oper->type == SLANG_OPER_CALL);  or vec4_add, etc */
    /*
    printf("Inline asm %s\n", (char*) fun->header.a_name);
    */
@@ -755,7 +755,7 @@ slang_inline_asm_function(slang_assemble_ctx *A,
 static void
 slang_resolve_variable(slang_operation *oper)
 {
-   if (oper->type != slang_oper_identifier)
+   if (oper->type != SLANG_OPER_IDENTIFIER)
       return;
    if (!oper->var) {
       oper->var = _slang_locate_variable(oper->locals,
@@ -768,7 +768,7 @@ slang_resolve_variable(slang_operation *oper)
 
 
 /**
- * Replace particular variables (slang_oper_identifier) with new expressions.
+ * Replace particular variables (SLANG_OPER_IDENTIFIER) with new expressions.
  */
 static void
 slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
@@ -776,7 +776,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
 		 slang_operation **substNew, GLboolean isLHS)
 {
    switch (oper->type) {
-   case slang_oper_variable_decl:
+   case SLANG_OPER_VARIABLE_DECL:
       {
          slang_variable *v = _slang_locate_variable(oper->locals,
                                                     oper->a_id, GL_TRUE);
@@ -793,7 +793,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
          }
       }
       break;
-   case slang_oper_identifier:
+   case SLANG_OPER_IDENTIFIER:
       assert(oper->num_children == 0);
       if (1/**!isLHS XXX FIX */) {
          slang_atom id = oper->a_id;
@@ -811,9 +811,9 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
 	 /* look for a substitution */
 	 for (i = 0; i < substCount; i++) {
 	    if (v == substOld[i]) {
-               /* OK, replace this slang_oper_identifier with a new expr */
+               /* OK, replace this SLANG_OPER_IDENTIFIER with a new expr */
 #if 0 /* DEBUG only */
-	       if (substNew[i]->type == slang_oper_identifier) {
+	       if (substNew[i]->type == SLANG_OPER_IDENTIFIER) {
                   assert(substNew[i]->var);
                   assert(substNew[i]->var->a_name);
 		  printf("Substitute %s with %s in id node %p\n",
@@ -833,7 +833,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
       }
       break;
 #if 1 /* XXX rely on default case below */
-   case slang_oper_return:
+   case SLANG_OPER_RETURN:
       /* do return replacement here too */
       assert(oper->num_children == 0 || oper->num_children == 1);
       if (oper->num_children == 1) {
@@ -846,23 +846,23 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
           */
          slang_operation *blockOper, *assignOper, *returnOper;
          blockOper = slang_operation_new(1);
-         blockOper->type = slang_oper_block_no_new_scope;
+         blockOper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
          blockOper->num_children = 2;
          blockOper->children = slang_operation_new(2);
          assignOper = blockOper->children + 0;
          returnOper = blockOper->children + 1;
 
-         assignOper->type = slang_oper_assign;
+         assignOper->type = SLANG_OPER_ASSIGN;
          assignOper->num_children = 2;
          assignOper->children = slang_operation_new(2);
-         assignOper->children[0].type = slang_oper_identifier;
+         assignOper->children[0].type = SLANG_OPER_IDENTIFIER;
          assignOper->children[0].a_id = slang_atom_pool_atom(A->atoms, "__retVal");
          assignOper->children[0].locals->outer_scope = oper->locals;
          assignOper->locals = oper->locals;
          slang_operation_copy(&assignOper->children[1],
                               &oper->children[0]);
 
-         returnOper->type = slang_oper_return;
+         returnOper->type = SLANG_OPER_RETURN;
          assert(returnOper->num_children == 0);
 
          /* do substitutions on the "__retVal = expr" sub-tree */
@@ -875,8 +875,8 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
       }
       break;
 #endif
-   case slang_oper_assign:
-   case slang_oper_subscript:
+   case SLANG_OPER_ASSIGN:
+   case SLANG_OPER_SUBSCRIPT:
       /* special case:
        * child[0] can't have substitutions but child[1] can.
        */
@@ -885,7 +885,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
       slang_substitute(A, &oper->children[1],
                        substCount, substOld, substNew, GL_FALSE);
       break;
-   case slang_oper_field:
+   case SLANG_OPER_FIELD:
       /* XXX NEW - test */
       slang_substitute(A, &oper->children[0],
                        substCount, substOld, substNew, GL_TRUE);
@@ -925,7 +925,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
    slang_operation **substNew;
    GLuint substCount, numCopyIn, i;
 
-   /*assert(oper->type == slang_oper_call); (or (matrix) multiply, etc) */
+   /*assert(oper->type == SLANG_OPER_CALL); (or (matrix) multiply, etc) */
    assert(fun->param_count == totalArgs);
 
    /* allocate temporary arrays */
@@ -953,7 +953,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
       slang_variable *resultVar;
 
       commaSeq = slang_operation_new(1);
-      commaSeq->type = slang_oper_sequence;
+      commaSeq->type = SLANG_OPER_SEQUENCE;
       assert(commaSeq->locals);
       commaSeq->locals->outer_scope = oper->locals->outer_scope;
       commaSeq->num_children = 3;
@@ -971,7 +971,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
 
       /* child[0] = __resultTmp declaration */
       declOper = &commaSeq->children[0];
-      declOper->type = slang_oper_variable_decl;
+      declOper->type = SLANG_OPER_VARIABLE_DECL;
       declOper->a_id = resultVar->a_name;
       declOper->locals->outer_scope = commaSeq->locals; /*** ??? **/
 
@@ -982,7 +982,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
 
       /* child[2] = __resultTmp reference */
       returnOper = &commaSeq->children[2];
-      returnOper->type = slang_oper_identifier;
+      returnOper->type = SLANG_OPER_IDENTIFIER;
       returnOper->a_id = resultVar->a_name;
       returnOper->locals->outer_scope = commaSeq->locals;
       declOper->locals->outer_scope = commaSeq->locals;
@@ -1013,8 +1013,8 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
              slang_type_qual_string(p->type.qualifier),
 	     (char *) p->a_name);
       */
-      if (p->type.qualifier == slang_qual_inout ||
-	  p->type.qualifier == slang_qual_out) {
+      if (p->type.qualifier == SLANG_QUAL_INOUT ||
+	  p->type.qualifier == SLANG_QUAL_OUT) {
 	 /* an output param */
          slang_operation *arg;
          if (i < numArgs)
@@ -1023,7 +1023,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
             arg = returnOper;
 	 paramMode[i] = SUBST;
 
-	 if (arg->type == slang_oper_identifier)
+	 if (arg->type == SLANG_OPER_IDENTIFIER)
             slang_resolve_variable(arg);
 
          /* replace parameter 'p' with argument 'arg' */
@@ -1031,10 +1031,10 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
 	 substNew[substCount] = arg; /* will get copied */
 	 substCount++;
       }
-      else if (p->type.qualifier == slang_qual_const) {
+      else if (p->type.qualifier == SLANG_QUAL_CONST) {
 	 /* a constant input param */
-	 if (args[i].type == slang_oper_identifier ||
-	     args[i].type == slang_oper_literal_float) {
+	 if (args[i].type == SLANG_OPER_IDENTIFIER ||
+	     args[i].type == SLANG_OPER_LITERAL_FLOAT) {
 	    /* replace all occurances of this parameter variable with the
 	     * actual argument variable or a literal.
 	     */
@@ -1058,8 +1058,8 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
    slang_operation_copy(inlined, fun->body);
 
    /*** XXX review this */
-   assert(inlined->type = slang_oper_block_no_new_scope);
-   inlined->type = slang_oper_block_new_scope;
+   assert(inlined->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE);
+   inlined->type = SLANG_OPER_BLOCK_NEW_SCOPE;
 
 #if 0
    printf("======================= orig body code ======================\n");
@@ -1092,7 +1092,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
          /*
          printf("COPY_IN %s from expr\n", (char*)p->a_name);
          */
-	 decl->type = slang_oper_variable_decl;
+	 decl->type = SLANG_OPER_VARIABLE_DECL;
          assert(decl->locals);
 	 decl->locals = fun->parameters;
 	 decl->a_id = p->a_name;
@@ -1114,7 +1114,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
       slang_operation *lab = slang_operation_insert(&inlined->num_children,
                                                     &inlined->children,
                                                     inlined->num_children);
-      lab->type = slang_oper_label;
+      lab->type = SLANG_OPER_LABEL;
       lab->a_id = slang_atom_pool_atom(A->atoms,
                                        (char *) A->CurFunction->end_label);
    }
@@ -1127,13 +1127,13 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
 	 slang_operation *ass = slang_operation_insert(&inlined->num_children,
 						       &inlined->children,
 						       inlined->num_children);
-	 ass->type = slang_oper_assign;
+	 ass->type = SLANG_OPER_ASSIGN;
 	 ass->num_children = 2;
 	 ass->locals = _slang_variable_scope_new(inlined->locals);
 	 assert(ass->locals);
 	 ass->children = slang_operation_new(2);
 	 ass->children[0] = args[i]; /*XXX copy */
-	 ass->children[1].type = slang_oper_identifier;
+	 ass->children[1].type = SLANG_OPER_IDENTIFIER;
 	 ass->children[1].a_id = p->a_name;
 	 ass->children[1].locals = _slang_variable_scope_new(ass->locals);
       }
@@ -1261,7 +1261,7 @@ _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
    slang_ir_node *kids[3], *n;
    GLuint j, firstOperand;
 
-   assert(oper->type == slang_oper_asm);
+   assert(oper->type == SLANG_OPER_ASM);
 
    info = slang_find_asm_info((char *) oper->a_id);
    if (!info) {
@@ -1301,7 +1301,7 @@ _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
       slang_ir_node *n0;
 
       dest_oper = &oper->children[0];
-      while /*if*/ (dest_oper->type == slang_oper_field) {
+      while /*if*/ (dest_oper->type == SLANG_OPER_FIELD) {
          /* writemask */
          writemask &= /*=*/make_writemask((char*) dest_oper->a_id);
          dest_oper = &dest_oper->children[0];
@@ -1326,8 +1326,8 @@ static GLboolean
 _slang_is_noop(const slang_operation *oper)
 {
    if (!oper ||
-       oper->type == slang_oper_void ||
-       (oper->num_children == 1 && oper->children[0].type == slang_oper_void))
+       oper->type == SLANG_OPER_VOID ||
+       (oper->num_children == 1 && oper->children[0].type == SLANG_OPER_VOID))
       return GL_TRUE;
    else
       return GL_FALSE;
@@ -1414,16 +1414,16 @@ _slang_gen_function_call_name(slang_assemble_ctx *A, const char *name,
 static GLboolean
 _slang_is_constant_cond(const slang_operation *oper, GLboolean *value)
 {
-   if (oper->type == slang_oper_literal_float ||
-       oper->type == slang_oper_literal_int ||
-       oper->type == slang_oper_literal_bool) {
+   if (oper->type == SLANG_OPER_LITERAL_FLOAT ||
+       oper->type == SLANG_OPER_LITERAL_INT ||
+       oper->type == SLANG_OPER_LITERAL_BOOL) {
       if (oper->literal[0])
          *value = GL_TRUE;
       else
          *value = GL_FALSE;
       return GL_TRUE;
    }
-   else if (oper->type == slang_oper_expression &&
+   else if (oper->type == SLANG_OPER_EXPRESSION &&
             oper->num_children == 1) {
       return _slang_is_constant_cond(&oper->children[0], value);
    }
@@ -1620,8 +1620,8 @@ is_operation_type(const const slang_operation *oper, slang_operation_type type)
 {
    if (oper->type == type)
       return GL_TRUE;
-   else if ((oper->type == slang_oper_block_new_scope ||
-             oper->type == slang_oper_block_no_new_scope) &&
+   else if ((oper->type == SLANG_OPER_BLOCK_NEW_SCOPE ||
+             oper->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE) &&
             oper->num_children == 1)
       return is_operation_type(&oper->children[0], type);
    else
@@ -1650,7 +1650,7 @@ _slang_gen_hl_if(slang_assemble_ctx * A, const slang_operation *oper)
    cond = _slang_gen_operation(A, &oper->children[0]);
    cond = new_cond(cond);
 
-   if (is_operation_type(&oper->children[1], slang_oper_break)) {
+   if (is_operation_type(&oper->children[1], SLANG_OPER_BREAK)) {
       /* Special case: generate a conditional break */
       ifBody = new_break_if(A->CurLoop, cond, GL_TRUE);
       if (haveElseClause) {
@@ -1659,7 +1659,7 @@ _slang_gen_hl_if(slang_assemble_ctx * A, const slang_operation *oper)
       }
       return ifBody;
    }
-   else if (is_operation_type(&oper->children[1], slang_oper_continue)) {
+   else if (is_operation_type(&oper->children[1], SLANG_OPER_CONTINUE)) {
       /* Special case: generate a conditional break */
       ifBody = new_cont_if(A->CurLoop, cond, GL_TRUE);
       if (haveElseClause) {
@@ -1744,7 +1744,7 @@ _slang_gen_select(slang_assemble_ctx *A, slang_operation *oper)
    slang_typeinfo type;
    int size;
 
-   assert(oper->type == slang_oper_select);
+   assert(oper->type == SLANG_OPER_SELECT);
    assert(oper->num_children == 3);
 
    /* size of x or y's type */
@@ -1811,13 +1811,13 @@ _slang_gen_logical_and(slang_assemble_ctx *A, slang_operation *oper)
    slang_ir_node *n;
 
    select = slang_operation_new(1);
-   select->type = slang_oper_select;
+   select->type = SLANG_OPER_SELECT;
    select->num_children = 3;
    select->children = slang_operation_new(3);
 
    slang_operation_copy(&select->children[0], &oper->children[0]);
    slang_operation_copy(&select->children[1], &oper->children[1]);
-   select->children[2].type = slang_oper_literal_bool;
+   select->children[2].type = SLANG_OPER_LITERAL_BOOL;
    ASSIGN_4V(select->children[2].literal, 0, 0, 0, 0);
    select->children[2].literal_size = 2;
 
@@ -1842,12 +1842,12 @@ _slang_gen_logical_or(slang_assemble_ctx *A, slang_operation *oper)
    slang_ir_node *n;
 
    select = slang_operation_new(1);
-   select->type = slang_oper_select;
+   select->type = SLANG_OPER_SELECT;
    select->num_children = 3;
    select->children = slang_operation_new(3);
 
    slang_operation_copy(&select->children[0], &oper->children[0]);
-   select->children[1].type = slang_oper_literal_bool;
+   select->children[1].type = SLANG_OPER_LITERAL_BOOL;
    ASSIGN_4V(select->children[2].literal, 1, 1, 1, 1);
    slang_operation_copy(&select->children[2], &oper->children[1]);
    select->children[2].literal_size = 2;
@@ -1871,7 +1871,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
 {
    if (oper->num_children == 0 ||
        (oper->num_children == 1 &&
-        oper->children[0].type == slang_oper_void)) {
+        oper->children[0].type == SLANG_OPER_VOID)) {
       /* Convert from:
        *   return;
        * To:
@@ -1880,7 +1880,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
       slang_ir_node *n;
       slang_operation gotoOp;
       slang_operation_construct(&gotoOp);
-      gotoOp.type = slang_oper_goto;
+      gotoOp.type = SLANG_OPER_GOTO;
       /* XXX don't call function? */
       gotoOp.a_id = slang_atom_pool_atom(A->atoms,
                                          (char *) A->CurFunction->end_label);
@@ -1914,7 +1914,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
 #endif
 
       block = slang_operation_new(1);
-      block->type = slang_oper_block_no_new_scope;
+      block->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
       block->num_children = 2;
       block->children = slang_operation_new(2);
       assert(block->locals);
@@ -1922,12 +1922,12 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
 
       /* child[0]: __retVal = expr; */
       assign = &block->children[0];
-      assign->type = slang_oper_assign;
+      assign->type = SLANG_OPER_ASSIGN;
       assign->locals->outer_scope = block->locals;
       assign->num_children = 2;
       assign->children = slang_operation_new(2);
       /* lhs (__retVal) */
-      assign->children[0].type = slang_oper_identifier;
+      assign->children[0].type = SLANG_OPER_IDENTIFIER;
       assign->children[0].a_id = a_retVal;
       assign->children[0].locals->outer_scope = assign->locals;
       /* rhs (expr) */
@@ -1936,7 +1936,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
 
       /* child[1]: goto __endOfFunction */
       jump = &block->children[1];
-      jump->type = slang_oper_goto;
+      jump->type = SLANG_OPER_GOTO;
       assert(A->CurFunction->end_label);
       /* XXX don't call function? */
       jump->a_id = slang_atom_pool_atom(A->atoms,
@@ -2150,8 +2150,8 @@ _slang_gen_swizzle(slang_ir_node *child, GLuint swizzle)
 static slang_ir_node *
 _slang_gen_assignment(slang_assemble_ctx * A, slang_operation *oper)
 {
-   if (oper->children[0].type == slang_oper_identifier &&
-       oper->children[1].type == slang_oper_call) {
+   if (oper->children[0].type == SLANG_OPER_IDENTIFIER &&
+       oper->children[1].type == SLANG_OPER_CALL) {
       /* Special case of:  x = f(a, b)
        * Replace with f(a, b, x)  (where x == hidden __retVal out param)
        *
@@ -2220,7 +2220,7 @@ _slang_gen_field(slang_assemble_ctx * A, slang_operation *oper)
       n = _slang_gen_swizzle(n, swizzle);
       return n;
    }
-   else if (ti.spec.type == slang_spec_float) {
+   else if (ti.spec.type == SLANG_SPEC_FLOAT) {
       const GLuint rows = 1;
       slang_swizzle swz;
       slang_ir_node *n;
@@ -2267,7 +2267,7 @@ _slang_gen_subscript(slang_assemble_ctx * A, slang_operation *oper)
       slang_ir_node *n;
 
       index = (GLint) oper->children[1].literal[0];
-      if (oper->children[1].type != slang_oper_literal_int ||
+      if (oper->children[1].type != SLANG_OPER_LITERAL_INT ||
           index >= max) {
          RETURN_ERROR("Invalid array index for vector type", 0);
       }
@@ -2321,15 +2321,15 @@ static slang_ir_node *
 _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
 {
    switch (oper->type) {
-   case slang_oper_block_new_scope:
+   case SLANG_OPER_BLOCK_NEW_SCOPE:
       {
          slang_ir_node *n;
 
          _slang_push_var_table(A->vartable);
 
-         oper->type = slang_oper_block_no_new_scope; /* temp change */
+         oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE; /* temp change */
          n = _slang_gen_operation(A, oper);
-         oper->type = slang_oper_block_new_scope; /* restore */
+         oper->type = SLANG_OPER_BLOCK_NEW_SCOPE; /* restore */
 
          _slang_pop_var_table(A->vartable);
 
@@ -2339,7 +2339,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
       }
       break;
 
-   case slang_oper_block_no_new_scope:
+   case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
       /* list of operations */
       if (oper->num_children > 0)
       {
@@ -2378,104 +2378,104 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
          return tree;
       }
       break;
-   case slang_oper_expression:
+   case SLANG_OPER_EXPRESSION:
       return _slang_gen_operation(A, &oper->children[0]);
 
-   case slang_oper_for:
+   case SLANG_OPER_FOR:
       return _slang_gen_for(A, oper);
-   case slang_oper_do:
+   case SLANG_OPER_DO:
       return _slang_gen_do(A, oper);
-   case slang_oper_while:
+   case SLANG_OPER_WHILE:
       return _slang_gen_while(A, oper);
-   case slang_oper_break:
+   case SLANG_OPER_BREAK:
       if (!A->CurLoop) {
          RETURN_ERROR("'break' not in loop", 0);
       }
       return new_break(A->CurLoop);
-   case slang_oper_continue:
+   case SLANG_OPER_CONTINUE:
       if (!A->CurLoop) {
          RETURN_ERROR("'continue' not in loop", 0);
       }
       return new_cont(A->CurLoop);
-   case slang_oper_discard:
+   case SLANG_OPER_DISCARD:
       return new_node0(IR_KILL);
 
-   case slang_oper_equal:
+   case SLANG_OPER_EQUAL:
       return new_node2(IR_SEQUAL,
                       _slang_gen_operation(A, &oper->children[0]),
                       _slang_gen_operation(A, &oper->children[1]));
-   case slang_oper_notequal:
+   case SLANG_OPER_NOTEQUAL:
       return new_node2(IR_SNEQUAL,
                       _slang_gen_operation(A, &oper->children[0]),
                       _slang_gen_operation(A, &oper->children[1]));
-   case slang_oper_greater:
+   case SLANG_OPER_GREATER:
       return new_node2(IR_SGT,
                       _slang_gen_operation(A, &oper->children[0]),
                       _slang_gen_operation(A, &oper->children[1]));
-   case slang_oper_less:
+   case SLANG_OPER_LESS:
       /* child[0] < child[1]  ---->   child[1] > child[0] */
       return new_node2(IR_SGT,
                       _slang_gen_operation(A, &oper->children[1]),
                       _slang_gen_operation(A, &oper->children[0]));
-   case slang_oper_greaterequal:
+   case SLANG_OPER_GREATERequal:
       return new_node2(IR_SGE,
                       _slang_gen_operation(A, &oper->children[0]),
                       _slang_gen_operation(A, &oper->children[1]));
-   case slang_oper_lessequal:
+   case SLANG_OPER_LESSequal:
       /* child[0] <= child[1]  ---->   child[1] >= child[0] */
       return new_node2(IR_SGE,
                       _slang_gen_operation(A, &oper->children[1]),
                       _slang_gen_operation(A, &oper->children[0]));
-   case slang_oper_add:
+   case SLANG_OPER_ADD:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "+", oper, NULL);
 	 return n;
       }
-   case slang_oper_subtract:
+   case SLANG_OPER_SUBTRACT:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "-", oper, NULL);
 	 return n;
       }
-   case slang_oper_multiply:
+   case SLANG_OPER_MULTIPLY:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
          n = _slang_gen_function_call_name(A, "*", oper, NULL);
 	 return n;
       }
-   case slang_oper_divide:
+   case SLANG_OPER_DIVIDE:
       {
          slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "/", oper, NULL);
 	 return n;
       }
-   case slang_oper_minus:
+   case SLANG_OPER_MINUS:
       {
          slang_ir_node *n;
          assert(oper->num_children == 1);
 	 n = _slang_gen_function_call_name(A, "-", oper, NULL);
 	 return n;
       }
-   case slang_oper_plus:
+   case SLANG_OPER_PLUS:
       /* +expr   --> do nothing */
       return _slang_gen_operation(A, &oper->children[0]);
-   case slang_oper_variable_decl:
+   case SLANG_OPER_VARIABLE_DECL:
       return _slang_gen_declaration(A, oper);
-   case slang_oper_assign:
+   case SLANG_OPER_ASSIGN:
       return _slang_gen_assignment(A, oper);
-   case slang_oper_addassign:
+   case SLANG_OPER_ADDASSIGN:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "+=", oper, &oper->children[0]);
 	 return n;
       }
-   case slang_oper_subassign:
+   case SLANG_OPER_SUBASSIGN:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
@@ -2483,42 +2483,42 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
 	 return n;
       }
       break;
-   case slang_oper_mulassign:
+   case SLANG_OPER_MULASSIGN:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "*=", oper, &oper->children[0]);
 	 return n;
       }
-   case slang_oper_divassign:
+   case SLANG_OPER_DIVASSIGN:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "/=", oper, &oper->children[0]);
 	 return n;
       }
-   case slang_oper_logicaland:
+   case SLANG_OPER_LOGICALAND:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_logical_and(A, oper);
 	 return n;
       }
-   case slang_oper_logicalor:
+   case SLANG_OPER_LOGICALOR:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_logical_or(A, oper);
 	 return n;
       }
-   case slang_oper_logicalxor:
+   case SLANG_OPER_LOGICALXOR:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 2);
 	 n = _slang_gen_function_call_name(A, "__logicalXor", oper, NULL);
 	 return n;
       }
-   case slang_oper_not:
+   case SLANG_OPER_NOT:
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 1);
@@ -2526,7 +2526,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
 	 return n;
       }
 
-   case slang_oper_select:  /* b ? x : y */
+   case SLANG_OPER_SELECT:  /* b ? x : y */
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 3);
@@ -2534,20 +2534,20 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
 	 return n;
       }
 
-   case slang_oper_asm:
+   case SLANG_OPER_ASM:
       return _slang_gen_asm(A, oper, NULL);
-   case slang_oper_call:
+   case SLANG_OPER_CALL:
       return _slang_gen_function_call_name(A, (const char *) oper->a_id,
                                            oper, NULL);
-   case slang_oper_return:
+   case SLANG_OPER_RETURN:
       return _slang_gen_return(A, oper);
-   case slang_oper_goto:
+   case SLANG_OPER_GOTO:
       return new_jump((char*) oper->a_id);
-   case slang_oper_label:
+   case SLANG_OPER_LABEL:
       return new_label((char*) oper->a_id);
-   case slang_oper_identifier:
+   case SLANG_OPER_IDENTIFIER:
       return _slang_gen_variable(A, oper);
-   case slang_oper_if:
+   case SLANG_OPER_IF:
       if (A->program->Target == GL_FRAGMENT_PROGRAM_ARB) {
          return _slang_gen_hl_if(A, oper);
       }
@@ -2555,39 +2555,39 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
          /* XXX update tnl executor */
          return _slang_gen_if(A, oper);
       }
-   case slang_oper_field:
+   case SLANG_OPER_FIELD:
       return _slang_gen_field(A, oper);
-   case slang_oper_subscript:
+   case SLANG_OPER_SUBSCRIPT:
       return _slang_gen_subscript(A, oper);
-   case slang_oper_literal_float:
+   case SLANG_OPER_LITERAL_FLOAT:
       /* fall-through */
-   case slang_oper_literal_int:
+   case SLANG_OPER_LITERAL_INT:
       /* fall-through */
-   case slang_oper_literal_bool:
+   case SLANG_OPER_LITERAL_BOOL:
       return new_float_literal(oper->literal);
 
-   case slang_oper_postincrement:   /* var++ */
+   case SLANG_OPER_POSTINCREMENT:   /* var++ */
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 1);
 	 n = _slang_gen_function_call_name(A, "__postIncr", oper, NULL);
 	 return n;
       }
-   case slang_oper_postdecrement:   /* var-- */
+   case SLANG_OPER_POSTDECREMENT:   /* var-- */
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 1);
 	 n = _slang_gen_function_call_name(A, "__postDecr", oper, NULL);
 	 return n;
       }
-   case slang_oper_preincrement:   /* ++var */
+   case SLANG_OPER_PREINCREMENT:   /* ++var */
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 1);
 	 n = _slang_gen_function_call_name(A, "++", oper, NULL);
 	 return n;
       }
-   case slang_oper_predecrement:   /* --var */
+   case SLANG_OPER_PREDECREMENT:   /* --var */
       {
 	 slang_ir_node *n;
          assert(oper->num_children == 1);
@@ -2595,7 +2595,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
 	 return n;
       }
 
-   case slang_oper_sequence:
+   case SLANG_OPER_SEQUENCE:
       {
          slang_ir_node *tree = NULL;
          GLuint i;
@@ -2606,9 +2606,9 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
          return tree;
       }
 
-   case slang_oper_none:
+   case SLANG_OPER_NONE:
       return NULL;
-   case slang_oper_void:
+   case SLANG_OPER_VOID:
       return NULL;
 
    default:
@@ -2658,7 +2658,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
       store = _slang_new_ir_storage(PROGRAM_SAMPLER, samplerUniform, texIndex);
       if (dbg) printf("SAMPLER ");
    }
-   else if (var->type.qualifier == slang_qual_uniform) {
+   else if (var->type.qualifier == SLANG_QUAL_UNIFORM) {
       /* Uniform variable */
       const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
       if (prog) {
@@ -2675,7 +2675,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
       }
       if (dbg) printf("UNIFORM ");
    }
-   else if (var->type.qualifier == slang_qual_varying) {
+   else if (var->type.qualifier == SLANG_QUAL_VARYING) {
       const GLint size = 4; /* XXX fix */
       if (prog) {
          /* user-defined varying */
@@ -2684,7 +2684,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
       }
       else {
          /* pre-defined varying, like gl_Color or gl_TexCoord */
-         if (type == slang_unit_fragment_builtin) {
+         if (type == SLANG_UNIT_FRAGMENT_BUILTIN) {
             GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB);
             assert(index >= 0);
             store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
@@ -2693,7 +2693,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
          else {
             GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
             assert(index >= 0);
-            assert(type == slang_unit_vertex_builtin);
+            assert(type == SLANG_UNIT_VERTEX_BUILTIN);
             store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
             assert(index < VERT_RESULT_MAX);
          }
@@ -2701,7 +2701,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
       }
       if (dbg) printf("VARYING ");
    }
-   else if (var->type.qualifier == slang_qual_attribute) {
+   else if (var->type.qualifier == SLANG_QUAL_ATTRIBUTE) {
       if (prog) {
          /* user-defined vertex attribute */
          const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
@@ -2721,27 +2721,27 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
       }
       if (dbg) printf("ATTRIB ");
    }
-   else if (var->type.qualifier == slang_qual_fixedinput) {
+   else if (var->type.qualifier == SLANG_QUAL_FIXEDINPUT) {
       GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB);
       GLint size = 4; /* XXX? */
       store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
       if (dbg) printf("INPUT ");
    }
-   else if (var->type.qualifier == slang_qual_fixedoutput) {
-      if (type == slang_unit_vertex_builtin) {
+   else if (var->type.qualifier == SLANG_QUAL_FIXEDOUTPUT) {
+      if (type == SLANG_UNIT_VERTEX_BUILTIN) {
          GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
          GLint size = 4; /* XXX? */
          store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
       }
       else {
-         assert(type == slang_unit_fragment_builtin);
+         assert(type == SLANG_UNIT_FRAGMENT_BUILTIN);
          GLint index = _slang_output_index(varName, GL_FRAGMENT_PROGRAM_ARB);
          GLint size = 4; /* XXX? */
          store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
       }
       if (dbg) printf("OUTPUT ");
    }
-   else if (var->type.qualifier == slang_qual_const && !prog) {
+   else if (var->type.qualifier == SLANG_QUAL_CONST && !prog) {
       /* pre-defined global constant, like gl_MaxLights */
       const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
       store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);
diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c
index f73fccf436..f7aa297bfa 100644
--- a/src/mesa/shader/slang/slang_compile.c
+++ b/src/mesa/shader/slang/slang_compile.c
@@ -358,7 +358,7 @@ parse_array_len(slang_parse_ctx * C, slang_output_ctx * O, GLuint * len)
 
    /* evaluate compile-time expression which is array size */
    _slang_simplify(&array_size, &space, C->atoms);
-   result = (array_size.type == slang_oper_literal_int);
+   result = (array_size.type == SLANG_OPER_LITERAL_INT);
 
    slang_operation_destruct(&array_size);
    return result;
@@ -388,7 +388,7 @@ convert_to_array(slang_parse_ctx * C, slang_variable * var,
 {
    /* sized array - mark it as array, copy the specifier to the array element and
     * parse the expression */
-   var->type.specifier.type = slang_spec_array;
+   var->type.specifier.type = SLANG_SPEC_ARRAY;
    var->type.specifier._array = (slang_type_specifier *)
       slang_alloc_malloc(sizeof(slang_type_specifier));
    if (var->type.specifier._array == NULL) {
@@ -540,25 +540,25 @@ parse_type_qualifier(slang_parse_ctx * C, slang_type_qualifier * qual)
 {
    switch (*C->I++) {
    case TYPE_QUALIFIER_NONE:
-      *qual = slang_qual_none;
+      *qual = SLANG_QUAL_NONE;
       break;
    case TYPE_QUALIFIER_CONST:
-      *qual = slang_qual_const;
+      *qual = SLANG_QUAL_CONST;
       break;
    case TYPE_QUALIFIER_ATTRIBUTE:
-      *qual = slang_qual_attribute;
+      *qual = SLANG_QUAL_ATTRIBUTE;
       break;
    case TYPE_QUALIFIER_VARYING:
-      *qual = slang_qual_varying;
+      *qual = SLANG_QUAL_VARYING;
       break;
    case TYPE_QUALIFIER_UNIFORM:
-      *qual = slang_qual_uniform;
+      *qual = SLANG_QUAL_UNIFORM;
       break;
    case TYPE_QUALIFIER_FIXEDOUTPUT:
-      *qual = slang_qual_fixedoutput;
+      *qual = SLANG_QUAL_FIXEDOUTPUT;
       break;
    case TYPE_QUALIFIER_FIXEDINPUT:
-      *qual = slang_qual_fixedinput;
+      *qual = SLANG_QUAL_FIXEDINPUT;
       break;
    default:
       return 0;
@@ -598,78 +598,78 @@ parse_type_specifier(slang_parse_ctx * C, slang_output_ctx * O,
 {
    switch (*C->I++) {
    case TYPE_SPECIFIER_VOID:
-      spec->type = slang_spec_void;
+      spec->type = SLANG_SPEC_VOID;
       break;
    case TYPE_SPECIFIER_BOOL:
-      spec->type = slang_spec_bool;
+      spec->type = SLANG_SPEC_BOOL;
       break;
    case TYPE_SPECIFIER_BVEC2:
-      spec->type = slang_spec_bvec2;
+      spec->type = SLANG_SPEC_BVEC2;
       break;
    case TYPE_SPECIFIER_BVEC3:
-      spec->type = slang_spec_bvec3;
+      spec->type = SLANG_SPEC_BVEC3;
       break;
    case TYPE_SPECIFIER_BVEC4:
-      spec->type = slang_spec_bvec4;
+      spec->type = SLANG_SPEC_BVEC4;
       break;
    case TYPE_SPECIFIER_INT:
-      spec->type = slang_spec_int;
+      spec->type = SLANG_SPEC_INT;
       break;
    case TYPE_SPECIFIER_IVEC2:
-      spec->type = slang_spec_ivec2;
+      spec->type = SLANG_SPEC_IVEC2;
       break;
    case TYPE_SPECIFIER_IVEC3:
-      spec->type = slang_spec_ivec3;
+      spec->type = SLANG_SPEC_IVEC3;
       break;
    case TYPE_SPECIFIER_IVEC4:
-      spec->type = slang_spec_ivec4;
+      spec->type = SLANG_SPEC_IVEC4;
       break;
    case TYPE_SPECIFIER_FLOAT:
-      spec->type = slang_spec_float;
+      spec->type = SLANG_SPEC_FLOAT;
       break;
    case TYPE_SPECIFIER_VEC2:
-      spec->type = slang_spec_vec2;
+      spec->type = SLANG_SPEC_VEC2;
       break;
    case TYPE_SPECIFIER_VEC3:
-      spec->type = slang_spec_vec3;
+      spec->type = SLANG_SPEC_VEC3;
       break;
    case TYPE_SPECIFIER_VEC4:
-      spec->type = slang_spec_vec4;
+      spec->type = SLANG_SPEC_VEC4;
       break;
    case TYPE_SPECIFIER_MAT2:
-      spec->type = slang_spec_mat2;
+      spec->type = SLANG_SPEC_MAT2;
       break;
    case TYPE_SPECIFIER_MAT3:
-      spec->type = slang_spec_mat3;
+      spec->type = SLANG_SPEC_MAT3;
       break;
    case TYPE_SPECIFIER_MAT4:
-      spec->type = slang_spec_mat4;
+      spec->type = SLANG_SPEC_MAT4;
       break;
    case TYPE_SPECIFIER_SAMPLER1D:
-      spec->type = slang_spec_sampler1D;
+      spec->type = SLANG_SPEC_SAMPLER1D;
       break;
    case TYPE_SPECIFIER_SAMPLER2D:
-      spec->type = slang_spec_sampler2D;
+      spec->type = SLANG_SPEC_SAMPLER2D;
       break;
    case TYPE_SPECIFIER_SAMPLER3D:
-      spec->type = slang_spec_sampler3D;
+      spec->type = SLANG_SPEC_SAMPLER3D;
       break;
    case TYPE_SPECIFIER_SAMPLERCUBE:
-      spec->type = slang_spec_samplerCube;
+      spec->type = SLANG_SPEC_SAMPLERCUBE;
       break;
    case TYPE_SPECIFIER_SAMPLER1DSHADOW:
-      spec->type = slang_spec_sampler1DShadow;
+      spec->type = SLANG_SPEC_SAMPLER1DSHADOW;
       break;
    case TYPE_SPECIFIER_SAMPLER2DSHADOW:
-      spec->type = slang_spec_sampler2DShadow;
+      spec->type = SLANG_SPEC_SAMPLER2DSHADOW;
       break;
    case TYPE_SPECIFIER_STRUCT:
-      spec->type = slang_spec_struct;
+      spec->type = SLANG_SPEC_STRUCT;
       if (!parse_struct(C, O, &spec->_struct))
          return 0;
       break;
    case TYPE_SPECIFIER_TYPENAME:
-      spec->type = slang_spec_struct;
+      spec->type = SLANG_SPEC_STRUCT;
       {
          slang_atom a_name;
          slang_struct *stru;
@@ -817,7 +817,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
    switch (*C->I++) {
    case OP_BLOCK_BEGIN_NO_NEW_SCOPE:
       /* parse child statements, do not create new variable scope */
-      oper->type = slang_oper_block_no_new_scope;
+      oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
       while (*C->I != OP_END)
          if (!parse_child_operation(C, O, oper, 1))
             return 0;
@@ -828,7 +828,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       {
          slang_output_ctx o = *O;
 
-         oper->type = slang_oper_block_new_scope;
+         oper->type = SLANG_OPER_BLOCK_NEW_SCOPE;
          o.vars = oper->locals;
          while (*C->I != OP_END)
             if (!parse_child_operation(C, &o, oper, 1))
@@ -840,7 +840,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       /* local variable declaration, individual declarators are stored as
        * children identifiers
        */
-      oper->type = slang_oper_block_no_new_scope;
+      oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
       {
          const unsigned int first_var = O->vars->num_variables;
 
@@ -861,7 +861,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
             }
             for (i = first_var; i < O->vars->num_variables; i++) {
                slang_operation *o = &oper->children[i - first_var];
-               o->type = slang_oper_variable_decl;
+               o->type = SLANG_OPER_VARIABLE_DECL;
                o->locals->outer_scope = O->vars;
                o->a_id = O->vars->variables[i]->a_name;
             }
@@ -872,7 +872,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       /* the __asm statement, parse the mnemonic and all its arguments
        * as expressions
        */
-      oper->type = slang_oper_asm;
+      oper->type = SLANG_OPER_ASM;
       oper->a_id = parse_identifier(C);
       if (oper->a_id == SLANG_ATOM_NULL)
          return 0;
@@ -883,26 +883,26 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       C->I++;
       break;
    case OP_BREAK:
-      oper->type = slang_oper_break;
+      oper->type = SLANG_OPER_BREAK;
       break;
    case OP_CONTINUE:
-      oper->type = slang_oper_continue;
+      oper->type = SLANG_OPER_CONTINUE;
       break;
    case OP_DISCARD:
-      oper->type = slang_oper_discard;
+      oper->type = SLANG_OPER_DISCARD;
       break;
    case OP_RETURN:
-      oper->type = slang_oper_return;
+      oper->type = SLANG_OPER_RETURN;
       if (!parse_child_operation(C, O, oper, 0))
          return 0;
       break;
    case OP_EXPRESSION:
-      oper->type = slang_oper_expression;
+      oper->type = SLANG_OPER_EXPRESSION;
       if (!parse_child_operation(C, O, oper, 0))
          return 0;
       break;
    case OP_IF:
-      oper->type = slang_oper_if;
+      oper->type = SLANG_OPER_IF;
       if (!parse_child_operation(C, O, oper, 0))
          return 0;
       if (!parse_child_operation(C, O, oper, 1))
@@ -914,7 +914,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       {
          slang_output_ctx o = *O;
 
-         oper->type = slang_oper_while;
+         oper->type = SLANG_OPER_WHILE;
          o.vars = oper->locals;
          if (!parse_child_operation(C, &o, oper, 1))
             return 0;
@@ -923,7 +923,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       }
       break;
    case OP_DO:
-      oper->type = slang_oper_do;
+      oper->type = SLANG_OPER_DO;
       if (!parse_child_operation(C, O, oper, 1))
          return 0;
       if (!parse_child_operation(C, O, oper, 0))
@@ -933,7 +933,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
       {
          slang_output_ctx o = *O;
 
-         oper->type = slang_oper_for;
+         oper->type = SLANG_OPER_FOR;
          o.vars = oper->locals;
          if (!parse_child_operation(C, &o, oper, 1))
             return 0;
@@ -986,7 +986,7 @@ static int
 is_constructor_name(const char *name, slang_atom a_name,
                     slang_struct_scope * structs)
 {
-   if (slang_type_specifier_type_from_string(name) != slang_spec_void)
+   if (slang_type_specifier_type_from_string(name) != SLANG_SPEC_VOID)
       return 1;
    return slang_struct_scope_find(structs, a_name, 1) != NULL;
 }
@@ -1022,10 +1022,10 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
 
       switch (op_code) {
       case OP_PUSH_VOID:
-         op->type = slang_oper_void;
+         op->type = SLANG_OPER_VOID;
          break;
       case OP_PUSH_BOOL:
-         op->type = slang_oper_literal_bool;
+         op->type = SLANG_OPER_LITERAL_BOOL;
          if (!parse_number(C, &number))
             return 0;
          op->literal[0] =
@@ -1035,7 +1035,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          op->literal_size = 1;
          break;
       case OP_PUSH_INT:
-         op->type = slang_oper_literal_int;
+         op->type = SLANG_OPER_LITERAL_INT;
          if (!parse_number(C, &number))
             return 0;
          op->literal[0] =
@@ -1045,7 +1045,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          op->literal_size = 1;
          break;
       case OP_PUSH_FLOAT:
-         op->type = slang_oper_literal_float;
+         op->type = SLANG_OPER_LITERAL_FLOAT;
          if (!parse_float(C, &op->literal[0]))
             return 0;
          op->literal[1] =
@@ -1054,38 +1054,38 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          op->literal_size = 1;
          break;
       case OP_PUSH_IDENTIFIER:
-         op->type = slang_oper_identifier;
+         op->type = SLANG_OPER_IDENTIFIER;
          op->a_id = parse_identifier(C);
          if (op->a_id == SLANG_ATOM_NULL)
             return 0;
          break;
       case OP_SEQUENCE:
-         op->type = slang_oper_sequence;
+         op->type = SLANG_OPER_SEQUENCE;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_ASSIGN:
-         op->type = slang_oper_assign;
+         op->type = SLANG_OPER_ASSIGN;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_ADDASSIGN:
-         op->type = slang_oper_addassign;
+         op->type = SLANG_OPER_ADDASSIGN;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_SUBASSIGN:
-         op->type = slang_oper_subassign;
+         op->type = SLANG_OPER_SUBASSIGN;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_MULASSIGN:
-         op->type = slang_oper_mulassign;
+         op->type = SLANG_OPER_MULASSIGN;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_DIVASSIGN:
-         op->type = slang_oper_divassign;
+         op->type = SLANG_OPER_DIVASSIGN;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
@@ -1096,22 +1096,22 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          /*case OP_XORASSIGN: */
          /*case OP_ANDASSIGN: */
       case OP_SELECT:
-         op->type = slang_oper_select;
+         op->type = SLANG_OPER_SELECT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 3))
             return 0;
          break;
       case OP_LOGICALOR:
-         op->type = slang_oper_logicalor;
+         op->type = SLANG_OPER_LOGICALOR;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_LOGICALXOR:
-         op->type = slang_oper_logicalxor;
+         op->type = SLANG_OPER_LOGICALXOR;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_LOGICALAND:
-         op->type = slang_oper_logicaland;
+         op->type = SLANG_OPER_LOGICALAND;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
@@ -1119,91 +1119,91 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          /*case OP_BITXOR: */
          /*case OP_BITAND: */
       case OP_EQUAL:
-         op->type = slang_oper_equal;
+         op->type = SLANG_OPER_EQUAL;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_NOTEQUAL:
-         op->type = slang_oper_notequal;
+         op->type = SLANG_OPER_NOTEQUAL;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_LESS:
-         op->type = slang_oper_less;
+         op->type = SLANG_OPER_LESS;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_GREATER:
-         op->type = slang_oper_greater;
+         op->type = SLANG_OPER_GREATER;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_LESSEQUAL:
-         op->type = slang_oper_lessequal;
+         op->type = SLANG_OPER_LESSequal;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_GREATEREQUAL:
-         op->type = slang_oper_greaterequal;
+         op->type = SLANG_OPER_GREATERequal;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
          /*case OP_LSHIFT: */
          /*case OP_RSHIFT: */
       case OP_ADD:
-         op->type = slang_oper_add;
+         op->type = SLANG_OPER_ADD;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_SUBTRACT:
-         op->type = slang_oper_subtract;
+         op->type = SLANG_OPER_SUBTRACT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_MULTIPLY:
-         op->type = slang_oper_multiply;
+         op->type = SLANG_OPER_MULTIPLY;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_DIVIDE:
-         op->type = slang_oper_divide;
+         op->type = SLANG_OPER_DIVIDE;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
          /*case OP_MODULUS: */
       case OP_PREINCREMENT:
-         op->type = slang_oper_preincrement;
+         op->type = SLANG_OPER_PREINCREMENT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
       case OP_PREDECREMENT:
-         op->type = slang_oper_predecrement;
+         op->type = SLANG_OPER_PREDECREMENT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
       case OP_PLUS:
-         op->type = slang_oper_plus;
+         op->type = SLANG_OPER_PLUS;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
       case OP_MINUS:
-         op->type = slang_oper_minus;
+         op->type = SLANG_OPER_MINUS;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
       case OP_NOT:
-         op->type = slang_oper_not;
+         op->type = SLANG_OPER_NOT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
          /*case OP_COMPLEMENT: */
       case OP_SUBSCRIPT:
-         op->type = slang_oper_subscript;
+         op->type = SLANG_OPER_SUBSCRIPT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
             return 0;
          break;
       case OP_CALL:
-         op->type = slang_oper_call;
+         op->type = SLANG_OPER_CALL;
          op->a_id = parse_identifier(C);
          if (op->a_id == SLANG_ATOM_NULL)
             return 0;
@@ -1224,7 +1224,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
          }
          break;
       case OP_FIELD:
-         op->type = slang_oper_field;
+         op->type = SLANG_OPER_FIELD;
          op->a_id = parse_identifier(C);
          if (op->a_id == SLANG_ATOM_NULL)
             return 0;
@@ -1232,12 +1232,12 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
             return 0;
          break;
       case OP_POSTINCREMENT:
-         op->type = slang_oper_postincrement;
+         op->type = SLANG_OPER_POSTINCREMENT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
       case OP_POSTDECREMENT:
-         op->type = slang_oper_postdecrement;
+         op->type = SLANG_OPER_POSTDECREMENT;
          if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
             return 0;
          break;
@@ -1273,23 +1273,23 @@ parse_parameter_declaration(slang_parse_ctx * C, slang_output_ctx * O,
       return 0;
    switch (*C->I++) {
    case PARAM_QUALIFIER_IN:
-      if (param->type.qualifier != slang_qual_const
-          && param->type.qualifier != slang_qual_none) {
+      if (param->type.qualifier != SLANG_QUAL_CONST
+          && param->type.qualifier != SLANG_QUAL_NONE) {
          slang_info_log_error(C->L, "Invalid type qualifier.");
          return 0;
       }
       break;
    case PARAM_QUALIFIER_OUT:
-      if (param->type.qualifier == slang_qual_none)
-         param->type.qualifier = slang_qual_out;
+      if (param->type.qualifier == SLANG_QUAL_NONE)
+         param->type.qualifier = SLANG_QUAL_OUT;
       else {
          slang_info_log_error(C->L, "Invalid type qualifier.");
          return 0;
       }
       break;
    case PARAM_QUALIFIER_INOUT:
-      if (param->type.qualifier == slang_qual_none)
-         param->type.qualifier = slang_qual_inout;
+      if (param->type.qualifier == SLANG_QUAL_NONE)
+         param->type.qualifier = SLANG_QUAL_INOUT;
       else {
          slang_info_log_error(C->L, "Invalid type qualifier.");
          return 0;
@@ -1439,14 +1439,14 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
       return 0;
    switch (*C->I++) {
    case FUNCTION_ORDINARY:
-      func->kind = slang_func_ordinary;
+      func->kind = SLANG_FUNC_ORDINARY;
       func->header.a_name = parse_identifier(C);
       if (func->header.a_name == SLANG_ATOM_NULL)
          return 0;
       break;
    case FUNCTION_CONSTRUCTOR:
-      func->kind = slang_func_constructor;
-      if (func->header.type.specifier.type == slang_spec_struct)
+      func->kind = SLANG_FUNC_CONSTRUCTOR;
+      if (func->header.type.specifier.type == SLANG_SPEC_STRUCT)
          return 0;
       func->header.a_name =
          slang_atom_pool_atom(C->atoms,
@@ -1458,7 +1458,7 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
       }
       break;
    case FUNCTION_OPERATOR:
-      func->kind = slang_func_operator;
+      func->kind = SLANG_FUNC_OPERATOR;
       func->header.a_name = parse_operator_name(C);
       if (func->header.a_name == SLANG_ATOM_NULL)
          return 0;
@@ -1487,7 +1487,7 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
       assert(a_retVal);
       p->a_name = a_retVal;
       p->type = func->header.type;
-      p->type.qualifier = slang_qual_out;
+      p->type.qualifier = SLANG_QUAL_OUT;
    }
 
    /* function formal parameters and local variables share the same
@@ -1546,7 +1546,7 @@ initialize_global(slang_assemble_ctx * A, slang_variable * var)
    /* construct the left side of assignment */
    if (!slang_operation_construct(&op_id))
       return GL_FALSE;
-   op_id.type = slang_oper_identifier;
+   op_id.type = SLANG_OPER_IDENTIFIER;
    op_id.a_id = var->a_name;
 
    /* put the variable into operation's scope */
@@ -1565,7 +1565,7 @@ initialize_global(slang_assemble_ctx * A, slang_variable * var)
       slang_operation_destruct(&op_id);
       return GL_FALSE;
    }
-   op_assign.type = slang_oper_assign;
+   op_assign.type = SLANG_OPER_ASSIGN;
    op_assign.children =
       (slang_operation *) slang_alloc_malloc(2 * sizeof(slang_operation));
    if (op_assign.children == NULL) {
@@ -1689,7 +1689,7 @@ parse_init_declarator(slang_parse_ctx * C, slang_output_ctx * O,
 
    /* allocate global address space for a variable with a known size */
    if (C->global_scope
-       && !(var->type.specifier.type == slang_spec_array
+       && !(var->type.specifier.type == SLANG_SPEC_ARRAY
             && var->array_len == 0)) {
       if (!calculate_var_size(C, O, var))
          return GL_FALSE;
@@ -1885,13 +1885,13 @@ parse_code_unit(slang_parse_ctx * C, slang_code_unit * unit,
    GLboolean success;
    GLuint maxRegs;
 
-   if (unit->type == slang_unit_fragment_builtin ||
-       unit->type == slang_unit_fragment_shader) {
+   if (unit->type == SLANG_UNIT_FRAGMENT_BUILTIN ||
+       unit->type == SLANG_UNIT_FRAGMENT_SHADER) {
       maxRegs = ctx->Const.FragmentProgram.MaxTemps;
    }
    else {
-      assert(unit->type == slang_unit_vertex_builtin ||
-             unit->type == slang_unit_vertex_shader);
+      assert(unit->type == SLANG_UNIT_VERTEX_BUILTIN ||
+             unit->type == SLANG_UNIT_VERTEX_SHADER);
       maxRegs = ctx->Const.VertexProgram.MaxTemps;
    }
 
@@ -2055,8 +2055,8 @@ compile_object(grammar * id, const char *source, slang_code_object * object,
    }
 
    /* set shader type - the syntax is slightly different for different shaders */
-   if (type == slang_unit_fragment_shader
-       || type == slang_unit_fragment_builtin)
+   if (type == SLANG_UNIT_FRAGMENT_SHADER
+       || type == SLANG_UNIT_FRAGMENT_BUILTIN)
       grammar_set_reg8(*id, (const byte *) "shader_type", 1);
    else
       grammar_set_reg8(*id, (const byte *) "shader_type", 2);
@@ -2065,33 +2065,33 @@ compile_object(grammar * id, const char *source, slang_code_object * object,
    grammar_set_reg8(*id, (const byte *) "parsing_builtin", 1);
 
    /* if parsing user-specified shader, load built-in library */
-   if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader) {
+   if (type == SLANG_UNIT_FRAGMENT_SHADER || type == SLANG_UNIT_VERTEX_SHADER) {
       /* compile core functionality first */
       if (!compile_binary(slang_core_gc,
                           &object->builtin[SLANG_BUILTIN_CORE],
-                          slang_unit_fragment_builtin, infolog,
+                          SLANG_UNIT_FRAGMENT_BUILTIN, infolog,
                           NULL, NULL, NULL))
          return GL_FALSE;
 
       /* compile common functions and variables, link to core */
       if (!compile_binary(slang_common_builtin_gc,
                           &object->builtin[SLANG_BUILTIN_COMMON],
-                          slang_unit_fragment_builtin, infolog, NULL,
+                          SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
                           &object->builtin[SLANG_BUILTIN_CORE], NULL))
          return GL_FALSE;
 
       /* compile target-specific functions and variables, link to common */
-      if (type == slang_unit_fragment_shader) {
+      if (type == SLANG_UNIT_FRAGMENT_SHADER) {
          if (!compile_binary(slang_fragment_builtin_gc,
                              &object->builtin[SLANG_BUILTIN_TARGET],
-                             slang_unit_fragment_builtin, infolog, NULL,
+                             SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
                              &object->builtin[SLANG_BUILTIN_COMMON], NULL))
             return GL_FALSE;
       }
-      else if (type == slang_unit_vertex_shader) {
+      else if (type == SLANG_UNIT_VERTEX_SHADER) {
          if (!compile_binary(slang_vertex_builtin_gc,
                              &object->builtin[SLANG_BUILTIN_TARGET],
-                             slang_unit_vertex_builtin, infolog, NULL,
+                             SLANG_UNIT_VERTEX_BUILTIN, infolog, NULL,
                              &object->builtin[SLANG_BUILTIN_COMMON], NULL))
             return GL_FALSE;
       }
@@ -2145,11 +2145,11 @@ _slang_compile(GLcontext *ctx, struct gl_shader *shader)
    slang_unit_type type;
 
    if (shader->Type == GL_VERTEX_SHADER) {
-      type = slang_unit_vertex_shader;
+      type = SLANG_UNIT_VERTEX_SHADER;
    }
    else {
       assert(shader->Type == GL_FRAGMENT_SHADER);
-      type = slang_unit_fragment_shader;
+      type = SLANG_UNIT_FRAGMENT_SHADER;
    }
 
    /* XXX temporary hack */
diff --git a/src/mesa/shader/slang/slang_compile.h b/src/mesa/shader/slang/slang_compile.h
index e7be7ef069..7abb92bd3b 100644
--- a/src/mesa/shader/slang/slang_compile.h
+++ b/src/mesa/shader/slang/slang_compile.h
@@ -39,17 +39,19 @@ extern "C" {
 
 typedef enum slang_unit_type_
 {
-	slang_unit_fragment_shader,
-	slang_unit_vertex_shader,
-	slang_unit_fragment_builtin,
-	slang_unit_vertex_builtin
+   SLANG_UNIT_FRAGMENT_SHADER,
+   SLANG_UNIT_VERTEX_SHADER,
+   SLANG_UNIT_FRAGMENT_BUILTIN,
+   SLANG_UNIT_VERTEX_BUILTIN
 } slang_unit_type;
 
+
 typedef struct slang_var_pool_
 {
-	GLuint next_addr;
+   GLuint next_addr;
 } slang_var_pool;
 
+
 typedef struct slang_code_unit_
 {
    slang_variable_scope vars;
@@ -59,6 +61,7 @@ typedef struct slang_code_unit_
    struct slang_code_object_ *object;
 } slang_code_unit;
 
+
 extern GLvoid
 _slang_code_unit_ctr (slang_code_unit *, struct slang_code_object_ *);
 
diff --git a/src/mesa/shader/slang/slang_compile_function.c b/src/mesa/shader/slang/slang_compile_function.c
index 00a85c2e7d..9b0bdaf406 100644
--- a/src/mesa/shader/slang/slang_compile_function.c
+++ b/src/mesa/shader/slang/slang_compile_function.c
@@ -71,7 +71,7 @@ slang_fixup_save(slang_fixup_table *fixups, GLuint address)
 int
 slang_function_construct(slang_function * func)
 {
-   func->kind = slang_func_ordinary;
+   func->kind = SLANG_FUNC_ORDINARY;
    if (!slang_variable_construct(&func->header))
       return 0;
 
@@ -133,7 +133,7 @@ slang_function_scope_destruct(slang_function_scope * scope)
 GLboolean
 _slang_function_has_return_value(const slang_function *fun)
 {
-   return fun->header.type.specifier.type != slang_spec_void;
+   return fun->header.type.specifier.type != SLANG_SPEC_VOID;
 }
 
 
@@ -179,7 +179,7 @@ slang_function_scope_find(slang_function_scope * funcs, slang_function * fun,
       slang_function *f = &funcs->functions[i];
       const GLuint haveRetValue = 0;
 #if 0
-         = (f->header.type.specifier.type != slang_spec_void);
+         = (f->header.type.specifier.type != SLANG_SPEC_VOID);
 #endif
       unsigned int j;
 
diff --git a/src/mesa/shader/slang/slang_compile_function.h b/src/mesa/shader/slang/slang_compile_function.h
index 99a6b2a034..b60b4a223f 100644
--- a/src/mesa/shader/slang/slang_compile_function.h
+++ b/src/mesa/shader/slang/slang_compile_function.h
@@ -36,9 +36,9 @@ struct slang_code_unit_;
  */
 typedef enum slang_function_kind_
 {
-   slang_func_ordinary,
-   slang_func_constructor,
-   slang_func_operator
+   SLANG_FUNC_ORDINARY,
+   SLANG_FUNC_CONSTRUCTOR,
+   SLANG_FUNC_OPERATOR
 } slang_function_kind;
 
 
diff --git a/src/mesa/shader/slang/slang_compile_operation.c b/src/mesa/shader/slang/slang_compile_operation.c
index 51a64ca30b..288de2d4bf 100644
--- a/src/mesa/shader/slang/slang_compile_operation.c
+++ b/src/mesa/shader/slang/slang_compile_operation.c
@@ -38,7 +38,7 @@
 GLboolean
 slang_operation_construct(slang_operation * oper)
 {
-   oper->type = slang_oper_none;
+   oper->type = SLANG_OPER_NONE;
    oper->children = NULL;
    oper->num_children = 0;
    oper->literal[0] = 0.0;
diff --git a/src/mesa/shader/slang/slang_compile_operation.h b/src/mesa/shader/slang/slang_compile_operation.h
index 3f5b1bb8f3..a59f968456 100644
--- a/src/mesa/shader/slang/slang_compile_operation.h
+++ b/src/mesa/shader/slang/slang_compile_operation.h
@@ -37,70 +37,70 @@ extern "C" {
  */
 typedef enum slang_operation_type_
 {
-   slang_oper_none,
-   slang_oper_block_no_new_scope,       /* "{" sequence "}" */
-   slang_oper_block_new_scope,  /* "{" sequence "}" */
-   slang_oper_variable_decl,    /* [type] [var] or [var] = [expr] */
-   slang_oper_asm,
-   slang_oper_break,            /* "break" statement */
-   slang_oper_continue,         /* "continue" statement */
-   slang_oper_discard,          /* "discard" (kill fragment) statement */
-   slang_oper_return,           /* "return" [expr]  */
-   slang_oper_goto,             /* jump to label */
-   slang_oper_label,            /* a jump target */
-   slang_oper_expression,       /* [expr] */
-   slang_oper_if,               /* "if" [0] then [1] else [2] */
-   slang_oper_while,            /* "while" [cond] [body] */
-   slang_oper_do,               /* "do" [body] "while" [cond] */
-   slang_oper_for,              /* "for" [init] [while] [incr] [body] */
-   slang_oper_void,             /* nop */
-   slang_oper_literal_bool,     /* "true" or "false" */
-   slang_oper_literal_int,      /* integer literal */
-   slang_oper_literal_float,    /* float literal */
-   slang_oper_identifier,       /* var name, func name, etc */
-   slang_oper_sequence,         /* [expr] "," [expr] "," etc */
-   slang_oper_assign,           /* [var] "=" [expr] */
-   slang_oper_addassign,        /* [var] "+=" [expr] */
-   slang_oper_subassign,        /* [var] "-=" [expr] */
-   slang_oper_mulassign,        /* [var] "*=" [expr] */
-   slang_oper_divassign,        /* [var] "/=" [expr] */
-   /*slang_oper_modassign, */
-   /*slang_oper_lshassign, */
-   /*slang_oper_rshassign, */
-   /*slang_oper_orassign, */
-   /*slang_oper_xorassign, */
-   /*slang_oper_andassign, */
-   slang_oper_select,           /* [expr] "?" [expr] ":" [expr] */
-   slang_oper_logicalor,        /* [expr] "||" [expr] */
-   slang_oper_logicalxor,       /* [expr] "^^" [expr] */
-   slang_oper_logicaland,       /* [expr] "&&" [expr] */
-   /*slang_oper_bitor, */
-   /*slang_oper_bitxor, */
-   /*slang_oper_bitand, */
-   slang_oper_equal,            /* [expr] "==" [expr] */
-   slang_oper_notequal,         /* [expr] "!=" [expr] */
-   slang_oper_less,             /* [expr] "<" [expr] */
-   slang_oper_greater,          /* [expr] ">" [expr] */
-   slang_oper_lessequal,        /* [expr] "<=" [expr] */
-   slang_oper_greaterequal,     /* [expr] ">=" [expr] */
-   /*slang_oper_lshift, */
-   /*slang_oper_rshift, */
-   slang_oper_add,              /* [expr] "+" [expr] */
-   slang_oper_subtract,         /* [expr] "-" [expr] */
-   slang_oper_multiply,         /* [expr] "*" [expr] */
-   slang_oper_divide,           /* [expr] "/" [expr] */
-   /*slang_oper_modulus, */
-   slang_oper_preincrement,     /* "++" [var] */
-   slang_oper_predecrement,     /* "--" [var] */
-   slang_oper_plus,             /* "-" [expr] */
-   slang_oper_minus,            /* "+" [expr] */
-   /*slang_oper_complement, */
-   slang_oper_not,              /* "!" [expr] */
-   slang_oper_subscript,        /* [expr] "[" [expr] "]" */
-   slang_oper_call,             /* [func name] [param] [param] [...] */
-   slang_oper_field,            /* i.e.: ".next" or ".xzy" or ".xxx" etc */
-   slang_oper_postincrement,    /* [var] "++" */
-   slang_oper_postdecrement     /* [var] "--" */
+   SLANG_OPER_NONE,
+   SLANG_OPER_BLOCK_NO_NEW_SCOPE,       /* "{" sequence "}" */
+   SLANG_OPER_BLOCK_NEW_SCOPE,  /* "{" sequence "}" */
+   SLANG_OPER_VARIABLE_DECL,    /* [type] [var] or [var] = [expr] */
+   SLANG_OPER_ASM,
+   SLANG_OPER_BREAK,            /* "break" statement */
+   SLANG_OPER_CONTINUE,         /* "continue" statement */
+   SLANG_OPER_DISCARD,          /* "discard" (kill fragment) statement */
+   SLANG_OPER_RETURN,           /* "return" [expr]  */
+   SLANG_OPER_GOTO,             /* jump to label */
+   SLANG_OPER_LABEL,            /* a jump target */
+   SLANG_OPER_EXPRESSION,       /* [expr] */
+   SLANG_OPER_IF,               /* "if" [0] then [1] else [2] */
+   SLANG_OPER_WHILE,            /* "while" [cond] [body] */
+   SLANG_OPER_DO,               /* "do" [body] "while" [cond] */
+   SLANG_OPER_FOR,              /* "for" [init] [while] [incr] [body] */
+   SLANG_OPER_VOID,             /* nop */
+   SLANG_OPER_LITERAL_BOOL,     /* "true" or "false" */
+   SLANG_OPER_LITERAL_INT,      /* integer literal */
+   SLANG_OPER_LITERAL_FLOAT,    /* float literal */
+   SLANG_OPER_IDENTIFIER,       /* var name, func name, etc */
+   SLANG_OPER_SEQUENCE,         /* [expr] "," [expr] "," etc */
+   SLANG_OPER_ASSIGN,           /* [var] "=" [expr] */
+   SLANG_OPER_ADDASSIGN,        /* [var] "+=" [expr] */
+   SLANG_OPER_SUBASSIGN,        /* [var] "-=" [expr] */
+   SLANG_OPER_MULASSIGN,        /* [var] "*=" [expr] */
+   SLANG_OPER_DIVASSIGN,        /* [var] "/=" [expr] */
+   /*SLANG_OPER_MODASSIGN, */
+   /*SLANG_OPER_LSHASSIGN, */
+   /*SLANG_OPER_RSHASSIGN, */
+   /*SLANG_OPER_ORASSIGN, */
+   /*SLANG_OPER_XORASSIGN, */
+   /*SLANG_OPER_ANDASSIGN, */
+   SLANG_OPER_SELECT,           /* [expr] "?" [expr] ":" [expr] */
+   SLANG_OPER_LOGICALOR,        /* [expr] "||" [expr] */
+   SLANG_OPER_LOGICALXOR,       /* [expr] "^^" [expr] */
+   SLANG_OPER_LOGICALAND,       /* [expr] "&&" [expr] */
+   /*SLANG_OPER_BITOR, */
+   /*SLANG_OPER_BITXOR, */
+   /*SLANG_OPER_BITAND, */
+   SLANG_OPER_EQUAL,            /* [expr] "==" [expr] */
+   SLANG_OPER_NOTEQUAL,         /* [expr] "!=" [expr] */
+   SLANG_OPER_LESS,             /* [expr] "<" [expr] */
+   SLANG_OPER_GREATER,          /* [expr] ">" [expr] */
+   SLANG_OPER_LESSequal,        /* [expr] "<=" [expr] */
+   SLANG_OPER_GREATERequal,     /* [expr] ">=" [expr] */
+   /*SLANG_OPER_LSHIFT, */
+   /*SLANG_OPER_RSHIFT, */
+   SLANG_OPER_ADD,              /* [expr] "+" [expr] */
+   SLANG_OPER_SUBTRACT,         /* [expr] "-" [expr] */
+   SLANG_OPER_MULTIPLY,         /* [expr] "*" [expr] */
+   SLANG_OPER_DIVIDE,           /* [expr] "/" [expr] */
+   /*SLANG_OPER_MODULUS, */
+   SLANG_OPER_PREINCREMENT,     /* "++" [var] */
+   SLANG_OPER_PREDECREMENT,     /* "--" [var] */
+   SLANG_OPER_PLUS,             /* "-" [expr] */
+   SLANG_OPER_MINUS,            /* "+" [expr] */
+   /*SLANG_OPER_COMPLEMENT, */
+   SLANG_OPER_NOT,              /* "!" [expr] */
+   SLANG_OPER_SUBSCRIPT,        /* [expr] "[" [expr] "]" */
+   SLANG_OPER_CALL,             /* [func name] [param] [param] [...] */
+   SLANG_OPER_FIELD,            /* i.e.: ".next" or ".xzy" or ".xxx" etc */
+   SLANG_OPER_POSTINCREMENT,    /* [var] "++" */
+   SLANG_OPER_POSTDECREMENT     /* [var] "--" */
 } slang_operation_type;
 
 
@@ -120,7 +120,7 @@ typedef struct slang_operation_
    GLuint literal_size;          /**< 1, 2, 3, or 4 */
    slang_atom a_id;              /**< type: asm, identifier, call, field */
    slang_variable_scope *locals; /**< local vars for scope */
-   struct slang_function_ *fun;  /**< If type == slang_oper_call */
+   struct slang_function_ *fun;  /**< If type == SLANG_OPER_CALL */
    struct slang_variable_ *var;  /**< If type == slang_oper_identier */
 } slang_operation;
 
diff --git a/src/mesa/shader/slang/slang_compile_struct.c b/src/mesa/shader/slang/slang_compile_struct.c
index 5033a6cb10..5d876b248a 100644
--- a/src/mesa/shader/slang/slang_compile_struct.c
+++ b/src/mesa/shader/slang/slang_compile_struct.c
@@ -160,7 +160,7 @@ int slang_struct_equal (const slang_struct *x, const slang_struct *y)
 			return 0;
 		if (!slang_type_specifier_equal (&varx->type.specifier, &vary->type.specifier))
 			return 0;
-		if (varx->type.specifier.type == slang_spec_array)
+		if (varx->type.specifier.type == SLANG_SPEC_ARRAY)
 			if (varx->array_len != vary->array_len)
 				return GL_FALSE;
 	}
diff --git a/src/mesa/shader/slang/slang_compile_variable.c b/src/mesa/shader/slang/slang_compile_variable.c
index 25fbc21f82..450ae16323 100644
--- a/src/mesa/shader/slang/slang_compile_variable.c
+++ b/src/mesa/shader/slang/slang_compile_variable.c
@@ -40,29 +40,29 @@ typedef struct
 } type_specifier_type_name;
 
 static const type_specifier_type_name type_specifier_type_names[] = {
-   {"void", slang_spec_void},
-   {"bool", slang_spec_bool},
-   {"bvec2", slang_spec_bvec2},
-   {"bvec3", slang_spec_bvec3},
-   {"bvec4", slang_spec_bvec4},
-   {"int", slang_spec_int},
-   {"ivec2", slang_spec_ivec2},
-   {"ivec3", slang_spec_ivec3},
-   {"ivec4", slang_spec_ivec4},
-   {"float", slang_spec_float},
-   {"vec2", slang_spec_vec2},
-   {"vec3", slang_spec_vec3},
-   {"vec4", slang_spec_vec4},
-   {"mat2", slang_spec_mat2},
-   {"mat3", slang_spec_mat3},
-   {"mat4", slang_spec_mat4},
-   {"sampler1D", slang_spec_sampler1D},
-   {"sampler2D", slang_spec_sampler2D},
-   {"sampler3D", slang_spec_sampler3D},
-   {"samplerCube", slang_spec_samplerCube},
-   {"sampler1DShadow", slang_spec_sampler1DShadow},
-   {"sampler2DShadow", slang_spec_sampler2DShadow},
-   {NULL, slang_spec_void}
+   {"void", SLANG_SPEC_VOID},
+   {"bool", SLANG_SPEC_BOOL},
+   {"bvec2", SLANG_SPEC_BVEC2},
+   {"bvec3", SLANG_SPEC_BVEC3},
+   {"bvec4", SLANG_SPEC_BVEC4},
+   {"int", SLANG_SPEC_INT},
+   {"ivec2", SLANG_SPEC_IVEC2},
+   {"ivec3", SLANG_SPEC_IVEC3},
+   {"ivec4", SLANG_SPEC_IVEC4},
+   {"float", SLANG_SPEC_FLOAT},
+   {"vec2", SLANG_SPEC_VEC2},
+   {"vec3", SLANG_SPEC_VEC3},
+   {"vec4", SLANG_SPEC_VEC4},
+   {"mat2", SLANG_SPEC_MAT2},
+   {"mat3", SLANG_SPEC_MAT3},
+   {"mat4", SLANG_SPEC_MAT4},
+   {"sampler1D", SLANG_SPEC_SAMPLER1D},
+   {"sampler2D", SLANG_SPEC_SAMPLER2D},
+   {"sampler3D", SLANG_SPEC_SAMPLER3D},
+   {"samplerCube", SLANG_SPEC_SAMPLERCUBE},
+   {"sampler1DShadow", SLANG_SPEC_SAMPLER1DSHADOW},
+   {"sampler2DShadow", SLANG_SPEC_SAMPLER2DSHADOW},
+   {NULL, SLANG_SPEC_VOID}
 };
 
 slang_type_specifier_type
@@ -94,7 +94,7 @@ slang_type_specifier_type_to_string(slang_type_specifier_type type)
 int
 slang_fully_specified_type_construct(slang_fully_specified_type * type)
 {
-   type->qualifier = slang_qual_none;
+   type->qualifier = SLANG_QUAL_NONE;
    slang_type_specifier_ctr(&type->specifier);
    return 1;
 }
@@ -333,49 +333,49 @@ static GLenum
 gl_type_from_specifier(const slang_type_specifier * type)
 {
    switch (type->type) {
-   case slang_spec_bool:
+   case SLANG_SPEC_BOOL:
       return GL_BOOL_ARB;
-   case slang_spec_bvec2:
+   case SLANG_SPEC_BVEC2:
       return GL_BOOL_VEC2_ARB;
-   case slang_spec_bvec3:
+   case SLANG_SPEC_BVEC3:
       return GL_BOOL_VEC3_ARB;
-   case slang_spec_bvec4:
+   case SLANG_SPEC_BVEC4:
       return GL_BOOL_VEC4_ARB;
-   case slang_spec_int:
+   case SLANG_SPEC_INT:
       return GL_INT;
-   case slang_spec_ivec2:
+   case SLANG_SPEC_IVEC2:
       return GL_INT_VEC2_ARB;
-   case slang_spec_ivec3:
+   case SLANG_SPEC_IVEC3:
       return GL_INT_VEC3_ARB;
-   case slang_spec_ivec4:
+   case SLANG_SPEC_IVEC4:
       return GL_INT_VEC4_ARB;
-   case slang_spec_float:
+   case SLANG_SPEC_FLOAT:
       return GL_FLOAT;
-   case slang_spec_vec2:
+   case SLANG_SPEC_VEC2:
       return GL_FLOAT_VEC2_ARB;
-   case slang_spec_vec3:
+   case SLANG_SPEC_VEC3:
       return GL_FLOAT_VEC3_ARB;
-   case slang_spec_vec4:
+   case SLANG_SPEC_VEC4:
       return GL_FLOAT_VEC4_ARB;
-   case slang_spec_mat2:
+   case SLANG_SPEC_MAT2:
       return GL_FLOAT_MAT2_ARB;
-   case slang_spec_mat3:
+   case SLANG_SPEC_MAT3:
       return GL_FLOAT_MAT3_ARB;
-   case slang_spec_mat4:
+   case SLANG_SPEC_MAT4:
       return GL_FLOAT_MAT4_ARB;
-   case slang_spec_sampler1D:
+   case SLANG_SPEC_SAMPLER1D:
       return GL_SAMPLER_1D_ARB;
-   case slang_spec_sampler2D:
+   case SLANG_SPEC_SAMPLER2D:
       return GL_SAMPLER_2D_ARB;
-   case slang_spec_sampler3D:
+   case SLANG_SPEC_SAMPLER3D:
       return GL_SAMPLER_3D_ARB;
-   case slang_spec_samplerCube:
+   case SLANG_SPEC_SAMPLERCUBE:
       return GL_SAMPLER_CUBE_ARB;
-   case slang_spec_sampler1DShadow:
+   case SLANG_SPEC_SAMPLER1DShadow:
       return GL_SAMPLER_1D_SHADOW_ARB;
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER2DShadow:
       return GL_SAMPLER_2D_SHADOW_ARB;
-   case slang_spec_array:
+   case SLANG_SPEC_ARRAy:
       return gl_type_from_specifier(type->_array);
    default:
       return GL_FLOAT;
diff --git a/src/mesa/shader/slang/slang_compile_variable.h b/src/mesa/shader/slang/slang_compile_variable.h
index 841f9840a6..d12cfd7a40 100644
--- a/src/mesa/shader/slang/slang_compile_variable.h
+++ b/src/mesa/shader/slang/slang_compile_variable.h
@@ -32,15 +32,15 @@ extern "C" {
 
 typedef enum slang_type_qualifier_
 {
-   slang_qual_none,
-   slang_qual_const,
-   slang_qual_attribute,
-   slang_qual_varying,
-   slang_qual_uniform,
-   slang_qual_out,
-   slang_qual_inout,
-   slang_qual_fixedoutput,      /* internal */
-   slang_qual_fixedinput        /* internal */
+   SLANG_QUAL_NONE,
+   SLANG_QUAL_CONST,
+   SLANG_QUAL_ATTRIBUTE,
+   SLANG_QUAL_VARYING,
+   SLANG_QUAL_UNIFORM,
+   SLANG_QUAL_OUT,
+   SLANG_QUAL_INOUT,
+   SLANG_QUAL_FIXEDOUTPUT,      /* internal */
+   SLANG_QUAL_FIXEDINPUT        /* internal */
 } slang_type_qualifier;
 
 extern slang_type_specifier_type
@@ -75,7 +75,7 @@ typedef struct slang_variable_
 {
    slang_fully_specified_type type; /**< Variable's data type */
    slang_atom a_name;               /**< The variable's name (char *) */
-   GLuint array_len;                /**< only if type == slang_spec_array */
+   GLuint array_len;                /**< only if type == SLANG_SPEC_ARRAy */
    struct slang_operation_ *initializer; /**< Optional initializer code */
    GLuint address;                  /**< Storage location */
    GLuint size;                     /**< Variable's size in bytes */
diff --git a/src/mesa/shader/slang/slang_print.c b/src/mesa/shader/slang/slang_print.c
index 7cfd87fb62..e53378e461 100644
--- a/src/mesa/shader/slang/slang_print.c
+++ b/src/mesa/shader/slang/slang_print.c
@@ -21,31 +21,31 @@ static void
 print_type(const slang_fully_specified_type *t)
 {
    switch (t->qualifier) {
-   case slang_qual_none:
+   case SLANG_QUAL_NONE:
       /*printf("");*/
       break;
-   case slang_qual_const:
+   case SLANG_QUAL_CONST:
       printf("const ");
       break;
-   case slang_qual_attribute:
+   case SLANG_QUAL_ATTRIBUTE:
       printf("attrib ");
       break;
-   case slang_qual_varying:
+   case SLANG_QUAL_VARYING:
       printf("varying ");
       break;
-   case slang_qual_uniform:
+   case SLANG_QUAL_UNIFORM:
       printf("uniform ");
       break;
-   case slang_qual_out:
+   case SLANG_QUAL_OUT:
       printf("output ");
       break;
-   case slang_qual_inout:
+   case SLANG_QUAL_INOUT:
       printf("inout ");
       break;
-   case slang_qual_fixedoutput:
+   case SLANG_QUAL_FIXEDOUTPUT:
       printf("fixedoutput");
       break;
-   case slang_qual_fixedinput:
+   case SLANG_QUAL_FIXEDINPUT:
       printf("fixedinput");
       break;
    default:
@@ -53,76 +53,76 @@ print_type(const slang_fully_specified_type *t)
    }
 
    switch (t->specifier.type) {
-   case slang_spec_void:
+   case SLANG_SPEC_VOID:
       printf("void");
       break;
-   case slang_spec_bool:
+   case SLANG_SPEC_BOOL:
       printf("bool");
       break;
-   case slang_spec_bvec2:
+   case SLANG_SPEC_BVEC2:
       printf("bvec2");
       break;
-   case slang_spec_bvec3:
+   case SLANG_SPEC_BVEC3:
       printf("bvec3");
       break;
-   case slang_spec_bvec4:
+   case SLANG_SPEC_BVEC4:
       printf("bvec4");
       break;
-   case slang_spec_int:
+   case SLANG_SPEC_INT:
       printf("int");
       break;
-   case slang_spec_ivec2:
+   case SLANG_SPEC_IVEC2:
       printf("ivec2");
       break;
-   case slang_spec_ivec3:
+   case SLANG_SPEC_IVEC3:
       printf("ivec3");
       break;
-   case slang_spec_ivec4:
+   case SLANG_SPEC_IVEC4:
       printf("ivec4");
       break;
-   case slang_spec_float:
+   case SLANG_SPEC_FLOAT:
       printf("float");
       break;
-   case slang_spec_vec2:
+   case SLANG_SPEC_VEC2:
       printf("vec2");
       break;
-   case slang_spec_vec3:
+   case SLANG_SPEC_VEC3:
       printf("vec3");
       break;
-   case slang_spec_vec4:
+   case SLANG_SPEC_VEC4:
       printf("vec4");
       break;
-   case slang_spec_mat2:
+   case SLANG_SPEC_MAT2:
       printf("mat2");
       break;
-   case slang_spec_mat3:
+   case SLANG_SPEC_MAT3:
       printf("mat3");
       break;
-   case slang_spec_mat4:
+   case SLANG_SPEC_MAT4:
       printf("mat4");
       break;
-   case slang_spec_sampler1D:
+   case SLANG_SPEC_SAMPLER1D:
       printf("sampler1D");
       break;
-   case slang_spec_sampler2D:
+   case SLANG_SPEC_SAMPLER2D:
       printf("sampler2D");
       break;
-   case slang_spec_sampler3D:
+   case SLANG_SPEC_SAMPLER3D:
       printf("sampler3D");
       break;
-   case slang_spec_samplerCube:
+   case SLANG_SPEC_SAMPLERCUBE:
       printf("samplerCube");
       break;
-   case slang_spec_sampler1DShadow:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
       printf("sampler1DShadow");
       break;
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
       printf("sampler2DShadow");
       break;
-   case slang_spec_struct:
+   case SLANG_SPEC_STRUCT:
       printf("struct");
       break;
-   case slang_spec_array:
+   case SLANG_SPEC_ARRAY:
       printf("array");
       break;
    default:
@@ -219,12 +219,12 @@ slang_print_tree(const slang_operation *op, int indent)
 
    switch (op->type) {
 
-   case slang_oper_none:
+   case SLANG_OPER_NONE:
       spaces(indent);
-      printf("slang_oper_none\n");
+      printf("SLANG_OPER_NONE\n");
       break;
 
-   case slang_oper_block_no_new_scope:
+   case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
       spaces(indent);
       printf("{ locals %p  outer %p\n", (void*)op->locals, (void*)op->locals->outer_scope);
       print_generic(op, NULL, indent+3);
@@ -232,7 +232,7 @@ slang_print_tree(const slang_operation *op, int indent)
       printf("}\n");
       break;
 
-   case slang_oper_block_new_scope:
+   case SLANG_OPER_BLOCK_NEW_SCOPE:
       spaces(indent);
       printf("{{ // new scope  locals %p\n", (void*)op->locals);
       print_generic(op, NULL, indent+3);
@@ -240,7 +240,7 @@ slang_print_tree(const slang_operation *op, int indent)
       printf("}}\n");
       break;
 
-   case slang_oper_variable_decl:
+   case SLANG_OPER_VARIABLE_DECL:
       assert(op->num_children == 0 || op->num_children == 1);
       {
          slang_variable *v;
@@ -282,52 +282,52 @@ slang_print_tree(const slang_operation *op, int indent)
       }
       break;
 
-   case slang_oper_asm:
+   case SLANG_OPER_ASM:
       spaces(indent);
       printf("ASM: %s\n", (char*) op->a_id);
       print_generic(op, NULL, indent+3);
       break;
 
-   case slang_oper_break:
+   case SLANG_OPER_BREAK:
       spaces(indent);
       printf("BREAK\n");
       break;
 
-   case slang_oper_continue:
+   case SLANG_OPER_CONTINUE:
       spaces(indent);
       printf("CONTINUE\n");
       break;
 
-   case slang_oper_discard:
+   case SLANG_OPER_DISCARD:
       spaces(indent);
       printf("DISCARD\n");
       break;
 
-   case slang_oper_return:
+   case SLANG_OPER_RETURN:
       spaces(indent);
       printf("RETURN\n");
       if (op->num_children > 0)
          slang_print_tree(&op->children[0], indent + 3);
       break;
 
-   case slang_oper_goto:
+   case SLANG_OPER_GOTO:
       spaces(indent);
       printf("GOTO %s\n", (char *) op->a_id);
       break;
 
-   case slang_oper_label:
+   case SLANG_OPER_LABEL:
       spaces(indent);
       printf("LABEL %s\n", (char *) op->a_id);
       break;
 
-   case slang_oper_expression:
+   case SLANG_OPER_EXPRESSION:
       spaces(indent);
       printf("EXPR:  locals %p\n", (void*) op->locals);
-      /*print_generic(op, "slang_oper_expression", indent);*/
+      /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
       slang_print_tree(&op->children[0], indent + 3);
       break;
 
-   case slang_oper_if:
+   case SLANG_OPER_IF:
       spaces(indent);
       printf("IF\n");
       slang_print_tree(&op->children[0], indent + 3);
@@ -341,7 +341,7 @@ slang_print_tree(const slang_operation *op, int indent)
       printf("ENDIF\n");
       break;
 
-   case slang_oper_while:
+   case SLANG_OPER_WHILE:
       assert(op->num_children == 2);
       spaces(indent);
       printf("WHILE cond:\n");
@@ -351,7 +351,7 @@ slang_print_tree(const slang_operation *op, int indent)
       slang_print_tree(&op->children[1], indent + 3);
       break;
 
-   case slang_oper_do:
+   case SLANG_OPER_DO:
       spaces(indent);
       printf("DO body:\n");
       slang_print_tree(&op->children[0], indent + 3);
@@ -360,7 +360,7 @@ slang_print_tree(const slang_operation *op, int indent)
       slang_print_tree(&op->children[1], indent + 3);
       break;
 
-   case slang_oper_for:
+   case SLANG_OPER_FOR:
       spaces(indent);
       printf("FOR init:\n");
       slang_print_tree(&op->children[0], indent + 3);
@@ -380,32 +380,32 @@ slang_print_tree(const slang_operation *op, int indent)
       */
       break;
 
-   case slang_oper_void:
+   case SLANG_OPER_VOID:
       spaces(indent);
       printf("(oper-void)\n");
       break;
 
-   case slang_oper_literal_bool:
+   case SLANG_OPER_LITERAL_BOOL:
       spaces(indent);
-      /*printf("slang_oper_literal_bool\n");*/
+      /*printf("SLANG_OPER_LITERAL_BOOL\n");*/
       printf("%s\n", op->literal[0] ? "TRUE" : "FALSE");
       break;
 
-   case slang_oper_literal_int:
+   case SLANG_OPER_LITERAL_INT:
       spaces(indent);
-      /*printf("slang_oper_literal_int\n");*/
+      /*printf("SLANG_OPER_LITERAL_INT\n");*/
       printf("(%d %d %d %d)\n", (int) op->literal[0], (int) op->literal[1],
              (int) op->literal[2], (int) op->literal[3]);
       break;
 
-   case slang_oper_literal_float:
+   case SLANG_OPER_LITERAL_FLOAT:
       spaces(indent);
-      /*printf("slang_oper_literal_float\n");*/
+      /*printf("SLANG_OPER_LITERAL_FLOAT\n");*/
       printf("(%f %f %f %f)\n", op->literal[0], op->literal[1], op->literal[2],
              op->literal[3]);
       break;
 
-   case slang_oper_identifier:
+   case SLANG_OPER_IDENTIFIER:
       spaces(indent);
       if (op->var && op->var->a_name)
          printf("VAR %s  (in scope %p)\n", (char *) op->var->a_name,
@@ -415,49 +415,49 @@ slang_print_tree(const slang_operation *op, int indent)
                 (void *) find_scope(op->locals, op->a_id));
       break;
 
-   case slang_oper_sequence:
+   case SLANG_OPER_SEQUENCE:
       print_generic(op, "COMMA-SEQ", indent+3);
       break;
 
-   case slang_oper_assign:
+   case SLANG_OPER_ASSIGN:
       spaces(indent);
       printf("ASSIGNMENT  locals %p\n", (void*)op->locals);
       print_binary(op, ":=", indent);
       break;
 
-   case slang_oper_addassign:
+   case SLANG_OPER_ADDASSIGN:
       spaces(indent);
       printf("ASSIGN\n");
       print_binary(op, "+=", indent);
       break;
 
-   case slang_oper_subassign:
+   case SLANG_OPER_SUBASSIGN:
       spaces(indent);
       printf("ASSIGN\n");
       print_binary(op, "-=", indent);
       break;
 
-   case slang_oper_mulassign:
+   case SLANG_OPER_MULASSIGN:
       spaces(indent);
       printf("ASSIGN\n");
       print_binary(op, "*=", indent);
       break;
 
-   case slang_oper_divassign:
+   case SLANG_OPER_DIVASSIGN:
       spaces(indent);
       printf("ASSIGN\n");
       print_binary(op, "/=", indent);
       break;
 
-	/*slang_oper_modassign,*/
-	/*slang_oper_lshassign,*/
-	/*slang_oper_rshassign,*/
-	/*slang_oper_orassign,*/
-	/*slang_oper_xorassign,*/
-	/*slang_oper_andassign,*/
-   case slang_oper_select:
+	/*SLANG_OPER_MODASSIGN,*/
+	/*SLANG_OPER_LSHASSIGN,*/
+	/*SLANG_OPER_RSHASSIGN,*/
+	/*SLANG_OPER_ORASSIGN,*/
+	/*SLANG_OPER_XORASSIGN,*/
+	/*SLANG_OPER_ANDASSIGN,*/
+   case SLANG_OPER_SELECT:
       spaces(indent);
-      printf("slang_oper_select n=%d\n", op->num_children);
+      printf("SLANG_OPER_SELECT n=%d\n", op->num_children);
       assert(op->num_children == 3);
       slang_print_tree(&op->children[0], indent+3);
       spaces(indent);
@@ -468,100 +468,100 @@ slang_print_tree(const slang_operation *op, int indent)
       slang_print_tree(&op->children[2], indent+3);
       break;
 
-   case slang_oper_logicalor:
+   case SLANG_OPER_LOGICALOR:
       print_binary(op, "||", indent);
       break;
 
-   case slang_oper_logicalxor:
+   case SLANG_OPER_LOGICALXOR:
       print_binary(op, "^^", indent);
       break;
 
-   case slang_oper_logicaland:
+   case SLANG_OPER_LOGICALAND:
       print_binary(op, "&&", indent);
       break;
 
-   /*slang_oper_bitor*/
-   /*slang_oper_bitxor*/
-   /*slang_oper_bitand*/
-   case slang_oper_equal:
+   /*SLANG_OPER_BITOR*/
+   /*SLANG_OPER_BITXOR*/
+   /*SLANG_OPER_BITAND*/
+   case SLANG_OPER_EQUAL:
       print_binary(op, "==", indent);
       break;
 
-   case slang_oper_notequal:
+   case SLANG_OPER_NOTEQUAL:
       print_binary(op, "!=", indent);
       break;
 
-   case slang_oper_less:
+   case SLANG_OPER_LESS:
       print_binary(op, "<", indent);
       break;
 
-   case slang_oper_greater:
+   case SLANG_OPER_GREATER:
       print_binary(op, ">", indent);
       break;
 
-   case slang_oper_lessequal:
+   case SLANG_OPER_LESSequal:
       print_binary(op, "<=", indent);
       break;
 
-   case slang_oper_greaterequal:
+   case SLANG_OPER_GREATERequal:
       print_binary(op, ">=", indent);
       break;
 
-   /*slang_oper_lshift*/
-   /*slang_oper_rshift*/
-   case slang_oper_add:
+   /*SLANG_OPER_LSHIFT*/
+   /*SLANG_OPER_RSHIFT*/
+   case SLANG_OPER_ADD:
       print_binary(op, "+", indent);
       break;
 
-   case slang_oper_subtract:
+   case SLANG_OPER_SUBTRACT:
       print_binary(op, "-", indent);
       break;
 
-   case slang_oper_multiply:
+   case SLANG_OPER_MULTIPLY:
       print_binary(op, "*", indent);
       break;
 
-   case slang_oper_divide:
+   case SLANG_OPER_DIVIDE:
       print_binary(op, "/", indent);
       break;
 
-   /*slang_oper_modulus*/
-   case slang_oper_preincrement:
+   /*SLANG_OPER_MODULUS*/
+   case SLANG_OPER_PREINCREMENT:
       spaces(indent);
       printf("PRE++\n");
       slang_print_tree(&op->children[0], indent+3);
       break;
 
-   case slang_oper_predecrement:
+   case SLANG_OPER_PREDECREMENT:
       spaces(indent);
       printf("PRE--\n");
       slang_print_tree(&op->children[0], indent+3);
       break;
 
-   case slang_oper_plus:
+   case SLANG_OPER_PLUS:
       spaces(indent);
-      printf("slang_oper_plus\n");
+      printf("SLANG_OPER_PLUS\n");
       break;
 
-   case slang_oper_minus:
+   case SLANG_OPER_MINUS:
       spaces(indent);
-      printf("slang_oper_minus\n");
+      printf("SLANG_OPER_MINUS\n");
       break;
 
-   /*slang_oper_complement*/
-   case slang_oper_not:
+   /*SLANG_OPER_COMPLEMENT*/
+   case SLANG_OPER_NOT:
       spaces(indent);
       printf("NOT\n");
       slang_print_tree(&op->children[0], indent+3);
       break;
 
-   case slang_oper_subscript:
+   case SLANG_OPER_SUBSCRIPT:
       spaces(indent);
-      printf("slang_oper_subscript\n");
+      printf("SLANG_OPER_SUBSCRIPT\n");
       print_generic(op, NULL, indent+3);
       break;
 
-   case slang_oper_call:
+   case SLANG_OPER_CALL:
 #if 0
          slang_function *fun
             = _slang_locate_function(A->space.funcs, oper->a_id,
@@ -581,19 +581,19 @@ slang_print_tree(const slang_operation *op, int indent)
       printf(")\n");
       break;
 
-   case slang_oper_field:
+   case SLANG_OPER_FIELD:
       spaces(indent);
       printf("FIELD %s of\n", (char*) op->a_id);
       slang_print_tree(&op->children[0], indent+3);
       break;
 
-   case slang_oper_postincrement:
+   case SLANG_OPER_POSTINCREMENT:
       spaces(indent);
       printf("POST++\n");
       slang_print_tree(&op->children[0], indent+3);
       break;
 
-   case slang_oper_postdecrement:
+   case SLANG_OPER_POSTDECREMENT:
       spaces(indent);
       printf("POST--\n");
       slang_print_tree(&op->children[0], indent+3);
@@ -637,23 +637,23 @@ const char *
 slang_type_qual_string(slang_type_qualifier q)
 {
    switch (q) {
-   case slang_qual_none:
+   case SLANG_QUAL_NONE:
       return "none";
-   case slang_qual_const:
+   case SLANG_QUAL_CONST:
       return "const";
-   case slang_qual_attribute:
+   case SLANG_QUAL_ATTRIBUTE:
       return "attribute";
-   case slang_qual_varying:
+   case SLANG_QUAL_VARYING:
       return "varying";
-   case slang_qual_uniform:
+   case SLANG_QUAL_UNIFORM:
       return "uniform";
-   case slang_qual_out:
+   case SLANG_QUAL_OUT:
       return "out";
-   case slang_qual_inout:
+   case SLANG_QUAL_INOUT:
       return "inout";
-   case slang_qual_fixedoutput:
+   case SLANG_QUAL_FIXEDOUTPUT:
       return "fixedoutput";
-   case slang_qual_fixedinput:
+   case SLANG_QUAL_FIXEDINPUT:
       return "fixedinputk";
    default:
       return "qual?";
@@ -665,53 +665,53 @@ static const char *
 slang_type_string(slang_type_specifier_type t)
 {
    switch (t) {
-   case slang_spec_void:
+   case SLANG_SPEC_VOID:
       return "void";
-   case slang_spec_bool:
+   case SLANG_SPEC_BOOL:
       return "bool";
-   case slang_spec_bvec2:
+   case SLANG_SPEC_BVEC2:
       return "bvec2";
-   case slang_spec_bvec3:
+   case SLANG_SPEC_BVEC3:
       return "bvec3";
-   case slang_spec_bvec4:
+   case SLANG_SPEC_BVEC4:
       return "bvec4";
-   case slang_spec_int:
+   case SLANG_SPEC_INT:
       return "int";
-   case slang_spec_ivec2:
+   case SLANG_SPEC_IVEC2:
       return "ivec2";
-   case slang_spec_ivec3:
+   case SLANG_SPEC_IVEC3:
       return "ivec3";
-   case slang_spec_ivec4:
+   case SLANG_SPEC_IVEC4:
       return "ivec4";
-   case slang_spec_float:
+   case SLANG_SPEC_FLOAT:
       return "float";
-   case slang_spec_vec2:
+   case SLANG_SPEC_VEC2:
       return "vec2";
-   case slang_spec_vec3:
+   case SLANG_SPEC_VEC3:
       return "vec3";
-   case slang_spec_vec4:
+   case SLANG_SPEC_VEC4:
       return "vec4";
-   case slang_spec_mat2:
+   case SLANG_SPEC_MAT2:
       return "mat2";
-   case slang_spec_mat3:
+   case SLANG_SPEC_MAT3:
       return "mat3";
-   case slang_spec_mat4:
+   case SLANG_SPEC_MAT4:
       return "mat4";
-   case slang_spec_sampler1D:
+   case SLANG_SPEC_SAMPLER1D:
       return "sampler1D";
-   case slang_spec_sampler2D:
+   case SLANG_SPEC_SAMPLER2D:
       return "sampler2D";
-   case slang_spec_sampler3D:
+   case SLANG_SPEC_SAMPLER3D:
       return "sampler3D";
-   case slang_spec_samplerCube:
+   case SLANG_SPEC_SAMPLERCUBE:
       return "samplerCube";
-   case slang_spec_sampler1DShadow:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
       return "sampler1DShadow";
-   case slang_spec_sampler2DShadow:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
       return "sampler2DShadow";
-   case slang_spec_struct:
+   case SLANG_SPEC_STRUCT:
       return "struct";
-   case slang_spec_array:
+   case SLANG_SPEC_ARRAY:
       return "array";
    default:
       return "type?";
diff --git a/src/mesa/shader/slang/slang_simplify.c b/src/mesa/shader/slang/slang_simplify.c
index 0e433281e8..07b4ae2760 100644
--- a/src/mesa/shader/slang/slang_simplify.c
+++ b/src/mesa/shader/slang/slang_simplify.c
@@ -97,7 +97,7 @@ _slang_simplify(slang_operation *oper,
    GLboolean isBool[4];
    GLuint i, n;
 
-   if (oper->type == slang_oper_identifier) {
+   if (oper->type == SLANG_OPER_IDENTIFIER) {
       /* see if it's a named constant */
       GLint value = _slang_lookup_constant((char *) oper->a_id);
       if (value >= 0) {
@@ -105,7 +105,7 @@ _slang_simplify(slang_operation *oper,
          oper->literal[1] =
          oper->literal[2] =
          oper->literal[3] = value;
-         oper->type = slang_oper_literal_int;
+         oper->type = SLANG_OPER_LITERAL_INT;
          return;
       }
    }
@@ -118,49 +118,49 @@ _slang_simplify(slang_operation *oper,
    /* examine children */
    n = MIN2(oper->num_children, 4);
    for (i = 0; i < n; i++) {
-      isFloat[i] = (oper->children[i].type == slang_oper_literal_float ||
-                   oper->children[i].type == slang_oper_literal_int);
-      isBool[i] = (oper->children[i].type == slang_oper_literal_bool);
+      isFloat[i] = (oper->children[i].type == SLANG_OPER_LITERAL_FLOAT ||
+                   oper->children[i].type == SLANG_OPER_LITERAL_INT);
+      isBool[i] = (oper->children[i].type == SLANG_OPER_LITERAL_BOOL);
    }
                               
    if (oper->num_children == 2 && isFloat[0] && isFloat[1]) {
       /* probably simple arithmetic */
       switch (oper->type) {
-      case slang_oper_add:
+      case SLANG_OPER_ADD:
          for (i = 0; i < 4; i++) {
             oper->literal[i]
                = oper->children[0].literal[i] + oper->children[1].literal[i];
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
-      case slang_oper_subtract:
+      case SLANG_OPER_SUBTRACT:
          for (i = 0; i < 4; i++) {
             oper->literal[i]
                = oper->children[0].literal[i] - oper->children[1].literal[i];
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
-      case slang_oper_multiply:
+      case SLANG_OPER_MULTIPLY:
          for (i = 0; i < 4; i++) {
             oper->literal[i]
                = oper->children[0].literal[i] * oper->children[1].literal[i];
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
-      case slang_oper_divide:
+      case SLANG_OPER_DIVIDE:
          for (i = 0; i < 4; i++) {
             oper->literal[i]
                = oper->children[0].literal[i] / oper->children[1].literal[i];
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
       default:
          ; /* nothing */
@@ -169,19 +169,19 @@ _slang_simplify(slang_operation *oper,
 
    if (oper->num_children == 1 && isFloat[0]) {
       switch (oper->type) {
-      case slang_oper_minus:
+      case SLANG_OPER_MINUS:
          for (i = 0; i < 4; i++) {
             oper->literal[i] = -oper->children[0].literal[i];
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
-      case slang_oper_plus:
+      case SLANG_OPER_PLUS:
          COPY_4V(oper->literal, oper->children[0].literal);
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_float;
+         oper->type = SLANG_OPER_LITERAL_FLOAT;
          return;
       default:
          ; /* nothing */
@@ -191,7 +191,7 @@ _slang_simplify(slang_operation *oper,
    if (oper->num_children == 2 && isBool[0] && isBool[1]) {
       /* simple boolean expression */
       switch (oper->type) {
-      case slang_oper_logicaland:
+      case SLANG_OPER_LOGICALAND:
          for (i = 0; i < 4; i++) {
             const GLint a = oper->children[0].literal[i] ? 1 : 0;
             const GLint b = oper->children[1].literal[i] ? 1 : 0;
@@ -199,9 +199,9 @@ _slang_simplify(slang_operation *oper,
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_bool;
+         oper->type = SLANG_OPER_LITERAL_BOOL;
          return;
-      case slang_oper_logicalor:
+      case SLANG_OPER_LOGICALOR:
          for (i = 0; i < 4; i++) {
             const GLint a = oper->children[0].literal[i] ? 1 : 0;
             const GLint b = oper->children[1].literal[i] ? 1 : 0;
@@ -209,9 +209,9 @@ _slang_simplify(slang_operation *oper,
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_bool;
+         oper->type = SLANG_OPER_LITERAL_BOOL;
          return;
-      case slang_oper_logicalxor:
+      case SLANG_OPER_LOGICALXOR:
          for (i = 0; i < 4; i++) {
             const GLint a = oper->children[0].literal[i] ? 1 : 0;
             const GLint b = oper->children[1].literal[i] ? 1 : 0;
@@ -219,7 +219,7 @@ _slang_simplify(slang_operation *oper,
          }
          oper->literal_size = oper->children[0].literal_size;
          slang_operation_destruct(oper);
-         oper->type = slang_oper_literal_bool;
+         oper->type = SLANG_OPER_LITERAL_BOOL;
          return;
       default:
          ; /* nothing */
@@ -229,7 +229,7 @@ _slang_simplify(slang_operation *oper,
    if (oper->num_children == 4
        && isFloat[0] && isFloat[1] && isFloat[2] && isFloat[3]) {
       /* vec4(flt, flt, flt, flt) constructor */
-      if (oper->type == slang_oper_call) {
+      if (oper->type == SLANG_OPER_CALL) {
          if (strcmp((char *) oper->a_id, "vec4") == 0) {
             oper->literal[0] = oper->children[0].literal[0];
             oper->literal[1] = oper->children[1].literal[0];
@@ -237,7 +237,7 @@ _slang_simplify(slang_operation *oper,
             oper->literal[3] = oper->children[3].literal[0];
             oper->literal_size = 4;
             slang_operation_destruct(oper);
-            oper->type = slang_oper_literal_float;
+            oper->type = SLANG_OPER_LITERAL_FLOAT;
             return;
          }
       }
@@ -245,7 +245,7 @@ _slang_simplify(slang_operation *oper,
 
    if (oper->num_children == 3 && isFloat[0] && isFloat[1] && isFloat[2]) {
       /* vec3(flt, flt, flt) constructor */
-      if (oper->type == slang_oper_call) {
+      if (oper->type == SLANG_OPER_CALL) {
          if (strcmp((char *) oper->a_id, "vec3") == 0) {
             oper->literal[0] = oper->children[0].literal[0];
             oper->literal[1] = oper->children[1].literal[0];
@@ -253,7 +253,7 @@ _slang_simplify(slang_operation *oper,
             oper->literal[3] = oper->literal[2];
             oper->literal_size = 3;
             slang_operation_destruct(oper);
-            oper->type = slang_oper_literal_float;
+            oper->type = SLANG_OPER_LITERAL_FLOAT;
             return;
          }
       }
@@ -261,7 +261,7 @@ _slang_simplify(slang_operation *oper,
 
    if (oper->num_children == 2 && isFloat[0] && isFloat[1]) {
       /* vec2(flt, flt) constructor */
-      if (oper->type == slang_oper_call) {
+      if (oper->type == SLANG_OPER_CALL) {
          if (strcmp((char *) oper->a_id, "vec2") == 0) {
             printf("SIMPLIFY vec2 constructor scope = %p\n",
                    (void*) oper->locals);
@@ -271,7 +271,7 @@ _slang_simplify(slang_operation *oper,
             oper->literal[3] = oper->literal[1];
             oper->literal_size = 2;
             slang_operation_destruct(oper); /* XXX oper->locals goes NULL! */
-            oper->type = slang_oper_literal_float;
+            oper->type = SLANG_OPER_LITERAL_FLOAT;
             assert(oper->num_children == 0);
             return;
          }
@@ -305,7 +305,7 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
    if (callOper->num_children != numParams) {
       /* number of arguments doesn't match number of parameters */
 
-      if (fun->kind == slang_func_constructor) {
+      if (fun->kind == SLANG_FUNC_CONSTRUCTOR) {
          /* For constructor calls, we can try to unroll vector/matrix args
           * into individual floats/ints and try to match the function params.
           */
@@ -345,13 +345,13 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
 
                /* replace arg[i+j] with subscript/index oper */
                for (j = 0; j < argSz; j++) {
-                  callOper->children[i + j].type = slang_oper_subscript;
+                  callOper->children[i + j].type = SLANG_OPER_SUBSCRIPT;
                   callOper->children[i + j].num_children = 2;
                   callOper->children[i + j].children = slang_operation_new(2);
                   slang_operation_copy(&callOper->children[i + j].children[0],
                                        &origArg);
                   callOper->children[i + j].children[1].type
-                     = slang_oper_literal_int;
+                     = SLANG_OPER_LITERAL_INT;
                   callOper->children[i + j].children[1].literal[0] = j;
                }
 
@@ -408,7 +408,7 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
          slang_operation_copy(child, &callOper->children[i]);
          child->locals->outer_scope = callOper->locals;
 
-         callOper->children[i].type = slang_oper_call;
+         callOper->children[i].type = SLANG_OPER_CALL;
          callOper->children[i].a_id = slang_atom_pool_atom(atoms, constructorName);
          callOper->children[i].num_children = 1;
          callOper->children[i].children = child;
diff --git a/src/mesa/shader/slang/slang_storage.c b/src/mesa/shader/slang/slang_storage.c
index 9f824371c5..74aff01aad 100644
--- a/src/mesa/shader/slang/slang_storage.c
+++ b/src/mesa/shader/slang/slang_storage.c
@@ -36,7 +36,7 @@
 GLboolean
 slang_storage_array_construct(slang_storage_array * arr)
 {
-   arr->type = slang_stor_aggregate;
+   arr->type = SLANG_STORE_AGGREGATE;
    arr->aggregate = NULL;
    arr->length = 0;
    return GL_TRUE;
@@ -110,7 +110,7 @@ aggregate_matrix(slang_storage_aggregate * agg, slang_storage_type basic_type,
    slang_storage_array *arr = slang_storage_aggregate_push_new(agg);
    if (arr == NULL)
       return GL_FALSE;
-   arr->type = slang_stor_aggregate;
+   arr->type = SLANG_STORE_AGGREGATE;
    arr->length = dimension;
    arr->aggregate =
       (slang_storage_aggregate *)
@@ -155,54 +155,54 @@ _slang_aggregate_variable(slang_storage_aggregate * agg,
                           slang_atom_pool * atoms)
 {
    switch (spec->type) {
-   case slang_spec_bool:
-      return aggregate_vector(agg, slang_stor_bool, 1);
-   case slang_spec_bvec2:
-      return aggregate_vector(agg, slang_stor_bool, 2);
-   case slang_spec_bvec3:
-      return aggregate_vector(agg, slang_stor_bool, 3);
-   case slang_spec_bvec4:
-      return aggregate_vector(agg, slang_stor_bool, 4);
-   case slang_spec_int:
-      return aggregate_vector(agg, slang_stor_int, 1);
-   case slang_spec_ivec2:
-      return aggregate_vector(agg, slang_stor_int, 2);
-   case slang_spec_ivec3:
-      return aggregate_vector(agg, slang_stor_int, 3);
-   case slang_spec_ivec4:
-      return aggregate_vector(agg, slang_stor_int, 4);
-   case slang_spec_float:
-      return aggregate_vector(agg, slang_stor_float, 1);
-   case slang_spec_vec2:
-      return aggregate_vector(agg, slang_stor_float, 2);
-   case slang_spec_vec3:
-      return aggregate_vector(agg, slang_stor_float, 3);
-   case slang_spec_vec4:
-      return aggregate_vector(agg, slang_stor_float, 4);
-   case slang_spec_mat2:
-      return aggregate_matrix(agg, slang_stor_float, 2);
-   case slang_spec_mat3:
-      return aggregate_matrix(agg, slang_stor_float, 3);
-   case slang_spec_mat4:
-      return aggregate_matrix(agg, slang_stor_float, 4);
-   case slang_spec_sampler1D:
-   case slang_spec_sampler2D:
-   case slang_spec_sampler3D:
-   case slang_spec_samplerCube:
-   case slang_spec_sampler1DShadow:
-   case slang_spec_sampler2DShadow:
-      return aggregate_vector(agg, slang_stor_int, 1);
-   case slang_spec_struct:
+   case SLANG_SPEC_BOOL:
+      return aggregate_vector(agg, SLANG_STORE_BOOL, 1);
+   case SLANG_SPEC_BVEC2:
+      return aggregate_vector(agg, SLANG_STORE_BOOL, 2);
+   case SLANG_SPEC_BVEC3:
+      return aggregate_vector(agg, SLANG_STORE_BOOL, 3);
+   case SLANG_SPEC_BVEC4:
+      return aggregate_vector(agg, SLANG_STORE_BOOL, 4);
+   case SLANG_SPEC_INT:
+      return aggregate_vector(agg, SLANG_STORE_INT, 1);
+   case SLANG_SPEC_IVEC2:
+      return aggregate_vector(agg, SLANG_STORE_INT, 2);
+   case SLANG_SPEC_IVEC3:
+      return aggregate_vector(agg, SLANG_STORE_INT, 3);
+   case SLANG_SPEC_IVEC4:
+      return aggregate_vector(agg, SLANG_STORE_INT, 4);
+   case SLANG_SPEC_FLOAT:
+      return aggregate_vector(agg, SLANG_STORE_FLOAT, 1);
+   case SLANG_SPEC_VEC2:
+      return aggregate_vector(agg, SLANG_STORE_FLOAT, 2);
+   case SLANG_SPEC_VEC3:
+      return aggregate_vector(agg, SLANG_STORE_FLOAT, 3);
+   case SLANG_SPEC_VEC4:
+      return aggregate_vector(agg, SLANG_STORE_FLOAT, 4);
+   case SLANG_SPEC_MAT2:
+      return aggregate_matrix(agg, SLANG_STORE_FLOAT, 2);
+   case SLANG_SPEC_MAT3:
+      return aggregate_matrix(agg, SLANG_STORE_FLOAT, 3);
+   case SLANG_SPEC_MAT4:
+      return aggregate_matrix(agg, SLANG_STORE_FLOAT, 4);
+   case SLANG_SPEC_SAMPLER1D:
+   case SLANG_SPEC_SAMPLER2D:
+   case SLANG_SPEC_SAMPLER3D:
+   case SLANG_SPEC_SAMPLERCUBE:
+   case SLANG_SPEC_SAMPLER1DSHADOW:
+   case SLANG_SPEC_SAMPLER2DSHADOW:
+      return aggregate_vector(agg, SLANG_STORE_INT, 1);
+   case SLANG_SPEC_STRUCT:
       return aggregate_variables(agg, spec->_struct->fields, funcs, structs,
                                  vars, atoms);
-   case slang_spec_array:
+   case SLANG_SPEC_ARRAY:
       {
          slang_storage_array *arr;
 
          arr = slang_storage_aggregate_push_new(agg);
          if (arr == NULL)
             return GL_FALSE;
-         arr->type = slang_stor_aggregate;
+         arr->type = SLANG_STORE_AGGREGATE;
          arr->aggregate =
             (slang_storage_aggregate *)
             slang_alloc_malloc(sizeof(slang_storage_aggregate));
@@ -229,9 +229,9 @@ _slang_aggregate_variable(slang_storage_aggregate * agg,
 GLuint
 _slang_sizeof_type(slang_storage_type type)
 {
-   if (type == slang_stor_aggregate)
+   if (type == SLANG_STORE_AGGREGATE)
       return 0;
-   if (type == slang_stor_vec4)
+   if (type == SLANG_STORE_VEC4)
       return 4 * sizeof(GLfloat);
    return sizeof(GLfloat);
 }
@@ -246,7 +246,7 @@ _slang_sizeof_aggregate(const slang_storage_aggregate * agg)
       slang_storage_array *arr = &agg->arrays[i];
       GLuint element_size;
 
-      if (arr->type == slang_stor_aggregate)
+      if (arr->type == SLANG_STORE_AGGREGATE)
          element_size = _slang_sizeof_aggregate(arr->aggregate);
       else
          element_size = _slang_sizeof_type(arr->type);
@@ -266,7 +266,7 @@ _slang_flatten_aggregate(slang_storage_aggregate * flat,
       GLuint j;
 
       for (j = 0; j < agg->arrays[i].length; j++) {
-         if (agg->arrays[i].type == slang_stor_aggregate) {
+         if (agg->arrays[i].type == SLANG_STORE_AGGREGATE) {
             if (!_slang_flatten_aggregate(flat, agg->arrays[i].aggregate))
                return GL_FALSE;
          }
@@ -274,9 +274,9 @@ _slang_flatten_aggregate(slang_storage_aggregate * flat,
             GLuint k, count;
             slang_storage_type type;
 
-            if (agg->arrays[i].type == slang_stor_vec4) {
+            if (agg->arrays[i].type == SLANG_STORE_VEC4) {
                count = 4;
-               type = slang_stor_float;
+               type = SLANG_STORE_FLOAT;
             }
             else {
                count = 1;
diff --git a/src/mesa/shader/slang/slang_storage.h b/src/mesa/shader/slang/slang_storage.h
index 5d756b5216..b02931fcc2 100644
--- a/src/mesa/shader/slang/slang_storage.h
+++ b/src/mesa/shader/slang/slang_storage.h
@@ -22,7 +22,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#if !defined SLANG_STORAGE_H
+#ifndef SLANG_STORAGE_H
 #define SLANG_STORAGE_H
 
 #include "slang_compile.h"
@@ -47,12 +47,12 @@
 typedef enum slang_storage_type_
 {
    /* core */
-   slang_stor_aggregate,
-   slang_stor_bool,
-   slang_stor_int,
-   slang_stor_float,
+   SLANG_STORE_AGGREGATE,
+   SLANG_STORE_BOOL,
+   SLANG_STORE_INT,
+   SLANG_STORE_FLOAT,
    /* vec4 */
-   slang_stor_vec4
+   SLANG_STORE_VEC4
 } slang_storage_type;
 
 
@@ -110,7 +110,7 @@ _slang_aggregate_variable(slang_storage_aggregate *agg,
 
 /*
  * Returns the size (in machine units) of the given storage type.
- * It is an error to pass-in slang_stor_aggregate.
+ * It is an error to pass-in SLANG_STORE_AGGREGATE.
  * Returns 0 on error.
  */
 extern GLuint
@@ -135,5 +135,4 @@ _slang_flatten_aggregate (slang_storage_aggregate *,
                           const slang_storage_aggregate *);
 
 
-#endif
-
+#endif /* SLANG_STORAGE_H */
diff --git a/src/mesa/shader/slang/slang_typeinfo.c b/src/mesa/shader/slang/slang_typeinfo.c
index 824bcc713f..bbcc1c740c 100644
--- a/src/mesa/shader/slang/slang_typeinfo.c
+++ b/src/mesa/shader/slang/slang_typeinfo.c
@@ -170,7 +170,7 @@ _slang_multiply_swizzles(slang_swizzle * dst, const slang_swizzle * left,
 GLvoid
 slang_type_specifier_ctr(slang_type_specifier * self)
 {
-   self->type = slang_spec_void;
+   self->type = SLANG_SPEC_VOID;
    self->_struct = NULL;
    self->_array = NULL;
 }
@@ -196,7 +196,7 @@ slang_type_specifier_copy(slang_type_specifier * x,
 
    slang_type_specifier_ctr(&z);
    z.type = y->type;
-   if (z.type == slang_spec_struct) {
+   if (z.type == SLANG_SPEC_STRUCT) {
       z._struct = (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
       if (z._struct == NULL) {
          slang_type_specifier_dtr(&z);
@@ -212,7 +212,7 @@ slang_type_specifier_copy(slang_type_specifier * x,
          return GL_FALSE;
       }
    }
-   else if (z.type == slang_spec_array) {
+   else if (z.type == SLANG_SPEC_ARRAY) {
       z._array =
          (slang_type_specifier *)
          slang_alloc_malloc(sizeof(slang_type_specifier));
@@ -241,9 +241,9 @@ slang_type_specifier_equal(const slang_type_specifier * x,
 {
    if (x->type != y->type)
       return GL_FALSE;
-   if (x->type == slang_spec_struct)
+   if (x->type == SLANG_SPEC_STRUCT)
       return slang_struct_equal(x->_struct, y->_struct);
-   if (x->type == slang_spec_array)
+   if (x->type == SLANG_SPEC_ARRAY)
       return slang_type_specifier_equal(x->_array, y->_array);
    return GL_TRUE;
 }
@@ -257,16 +257,16 @@ slang_type_specifier_compatible(const slang_type_specifier * x,
                                 const slang_type_specifier * y)
 {
    /* special case: float == int */
-   if (x->type == slang_spec_int && y->type == slang_spec_float) {
+   if (x->type == SLANG_SPEC_INT && y->type == SLANG_SPEC_FLOAT) {
       return GL_TRUE;
    }
    /* XXX may need to add bool/int compatibility, etc */
 
    if (x->type != y->type)
       return GL_FALSE;
-   if (x->type == slang_spec_struct)
+   if (x->type == SLANG_SPEC_STRUCT)
       return slang_struct_equal(x->_struct, y->_struct);
-   if (x->type == slang_spec_array)
+   if (x->type == SLANG_SPEC_ARRAY)
       return slang_type_specifier_compatible(x->_array, y->_array);
    return GL_TRUE;
 }
@@ -341,93 +341,93 @@ _slang_typeof_operation_(const slang_operation * op,
    ti->is_swizzled = GL_FALSE;
 
    switch (op->type) {
-   case slang_oper_block_no_new_scope:
-   case slang_oper_block_new_scope:
-   case slang_oper_variable_decl:
-   case slang_oper_asm:
-   case slang_oper_break:
-   case slang_oper_continue:
-   case slang_oper_discard:
-   case slang_oper_return:
-   case slang_oper_if:
-   case slang_oper_while:
-   case slang_oper_do:
-   case slang_oper_for:
-   case slang_oper_void:
-      ti->spec.type = slang_spec_void;
+   case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
+   case SLANG_OPER_BLOCK_NEW_SCOPE:
+   case SLANG_OPER_VARIABLE_DECL:
+   case SLANG_OPER_ASM:
+   case SLANG_OPER_BREAK:
+   case SLANG_OPER_CONTINUE:
+   case SLANG_OPER_DISCARD:
+   case SLANG_OPER_RETURN:
+   case SLANG_OPER_IF:
+   case SLANG_OPER_WHILE:
+   case SLANG_OPER_DO:
+   case SLANG_OPER_FOR:
+   case SLANG_OPER_VOID:
+      ti->spec.type = SLANG_SPEC_VOID;
       break;
-   case slang_oper_expression:
-   case slang_oper_assign:
-   case slang_oper_addassign:
-   case slang_oper_subassign:
-   case slang_oper_mulassign:
-   case slang_oper_divassign:
-   case slang_oper_preincrement:
-   case slang_oper_predecrement:
+   case SLANG_OPER_EXPRESSION:
+   case SLANG_OPER_ASSIGN:
+   case SLANG_OPER_ADDASSIGN:
+   case SLANG_OPER_SUBASSIGN:
+   case SLANG_OPER_MULASSIGN:
+   case SLANG_OPER_DIVASSIGN:
+   case SLANG_OPER_PREINCREMENT:
+   case SLANG_OPER_PREDECREMENT:
       if (!_slang_typeof_operation_(op->children, space, ti, atoms))
          return GL_FALSE;
       break;
-   case slang_oper_literal_bool:
+   case SLANG_OPER_LITERAL_BOOL:
       if (op->literal_size == 1)
-         ti->spec.type = slang_spec_bool;
+         ti->spec.type = SLANG_SPEC_BOOL;
       else if (op->literal_size == 2)
-         ti->spec.type = slang_spec_bvec2;
+         ti->spec.type = SLANG_SPEC_BVEC2;
       else if (op->literal_size == 3)
-         ti->spec.type = slang_spec_bvec3;
+         ti->spec.type = SLANG_SPEC_BVEC3;
       else if (op->literal_size == 4)
-         ti->spec.type = slang_spec_bvec4;
+         ti->spec.type = SLANG_SPEC_BVEC4;
       else {
          _mesa_problem(NULL,
                "Unexpected bool literal_size %d in _slang_typeof_operation()",
                op->literal_size);
-         ti->spec.type = slang_spec_bool;
+         ti->spec.type = SLANG_SPEC_BOOL;
       }
       break;
-   case slang_oper_logicalor:
-   case slang_oper_logicalxor:
-   case slang_oper_logicaland:
-   case slang_oper_equal:
-   case slang_oper_notequal:
-   case slang_oper_less:
-   case slang_oper_greater:
-   case slang_oper_lessequal:
-   case slang_oper_greaterequal:
-   case slang_oper_not:
-      ti->spec.type = slang_spec_bool;
+   case SLANG_OPER_LOGICALOR:
+   case SLANG_OPER_LOGICALXOR:
+   case SLANG_OPER_LOGICALAND:
+   case SLANG_OPER_EQUAL:
+   case SLANG_OPER_NOTEQUAL:
+   case SLANG_OPER_LESS:
+   case SLANG_OPER_GREATER:
+   case SLANG_OPER_LESSequal:
+   case SLANG_OPER_GREATERequal:
+   case SLANG_OPER_NOT:
+      ti->spec.type = SLANG_SPEC_BOOL;
       break;
-   case slang_oper_literal_int:
+   case SLANG_OPER_LITERAL_INT:
       if (op->literal_size == 1)
-         ti->spec.type = slang_spec_int;
+         ti->spec.type = SLANG_SPEC_INT;
       else if (op->literal_size == 2)
-         ti->spec.type = slang_spec_ivec2;
+         ti->spec.type = SLANG_SPEC_IVEC2;
       else if (op->literal_size == 3)
-         ti->spec.type = slang_spec_ivec3;
+         ti->spec.type = SLANG_SPEC_IVEC3;
       else if (op->literal_size == 4)
-         ti->spec.type = slang_spec_ivec4;
+         ti->spec.type = SLANG_SPEC_IVEC4;
       else {
          _mesa_problem(NULL,
                "Unexpected int literal_size %d in _slang_typeof_operation()",
                op->literal_size);
-         ti->spec.type = slang_spec_int;
+         ti->spec.type = SLANG_SPEC_INT;
       }
       break;
-   case slang_oper_literal_float:
+   case SLANG_OPER_LITERAL_FLOAT:
       if (op->literal_size == 1)
-         ti->spec.type = slang_spec_float;
+         ti->spec.type = SLANG_SPEC_FLOAT;
       else if (op->literal_size == 2)
-         ti->spec.type = slang_spec_vec2;
+         ti->spec.type = SLANG_SPEC_VEC2;
       else if (op->literal_size == 3)
-         ti->spec.type = slang_spec_vec3;
+         ti->spec.type = SLANG_SPEC_VEC3;
       else if (op->literal_size == 4)
-         ti->spec.type = slang_spec_vec4;
+         ti->spec.type = SLANG_SPEC_VEC4;
       else {
          _mesa_problem(NULL,
                "Unexpected float literal_size %d in _slang_typeof_operation()",
                op->literal_size);
-         ti->spec.type = slang_spec_float;
+         ti->spec.type = SLANG_SPEC_FLOAT;
       }
       break;
-   case slang_oper_identifier:
+   case SLANG_OPER_IDENTIFIER:
       {
          slang_variable *var;
          var = _slang_locate_variable(op->locals, op->a_id, GL_TRUE);
@@ -439,65 +439,65 @@ _slang_typeof_operation_(const slang_operation * op,
          ti->array_len = var->array_len;
       }
       break;
-   case slang_oper_sequence:
+   case SLANG_OPER_SEQUENCE:
       /* TODO: check [0] and [1] if they match */
       if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms))
          RETURN_NIL();
       ti->can_be_referenced = GL_FALSE;
       ti->is_swizzled = GL_FALSE;
       break;
-      /*case slang_oper_modassign: */
-      /*case slang_oper_lshassign: */
-      /*case slang_oper_rshassign: */
-      /*case slang_oper_orassign: */
-      /*case slang_oper_xorassign: */
-      /*case slang_oper_andassign: */
-   case slang_oper_select:
+      /*case SLANG_OPER_MODASSIGN: */
+      /*case SLANG_OPER_LSHASSIGN: */
+      /*case SLANG_OPER_RSHASSIGN: */
+      /*case SLANG_OPER_ORASSIGN: */
+      /*case SLANG_OPER_XORASSIGN: */
+      /*case SLANG_OPER_ANDASSIGN: */
+   case SLANG_OPER_SELECT:
       /* TODO: check [1] and [2] if they match */
       if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms))
          RETURN_NIL();
       ti->can_be_referenced = GL_FALSE;
       ti->is_swizzled = GL_FALSE;
       break;
-      /*case slang_oper_bitor: */
-      /*case slang_oper_bitxor: */
-      /*case slang_oper_bitand: */
-      /*case slang_oper_lshift: */
-      /*case slang_oper_rshift: */
-   case slang_oper_add:
+      /*case SLANG_OPER_BITOR: */
+      /*case SLANG_OPER_BITXOR: */
+      /*case SLANG_OPER_BITAND: */
+      /*case SLANG_OPER_LSHIFT: */
+      /*case SLANG_OPER_RSHIFT: */
+   case SLANG_OPER_ADD:
       if (!typeof_existing_function("+", op->children, 2, space,
                                     &ti->spec, atoms))
          RETURN_NIL();
       break;
-   case slang_oper_subtract:
+   case SLANG_OPER_SUBTRACT:
       if (!typeof_existing_function("-", op->children, 2, space,
                                     &ti->spec, atoms))
          RETURN_NIL();
       break;
-   case slang_oper_multiply:
+   case SLANG_OPER_MULTIPLY:
       if (!typeof_existing_function("*", op->children, 2, space,
                                     &ti->spec, atoms))
          RETURN_NIL();
       break;
-   case slang_oper_divide:
+   case SLANG_OPER_DIVIDE:
       if (!typeof_existing_function("/", op->children, 2, space,
                                     &ti->spec, atoms))
          RETURN_NIL();
       break;
-      /*case slang_oper_modulus: */
-   case slang_oper_plus:
+      /*case SLANG_OPER_MODULUS: */
+   case SLANG_OPER_PLUS:
       if (!_slang_typeof_operation_(op->children, space, ti, atoms))
          RETURN_NIL();
       ti->can_be_referenced = GL_FALSE;
       ti->is_swizzled = GL_FALSE;
       break;
-   case slang_oper_minus:
+   case SLANG_OPER_MINUS:
       if (!typeof_existing_function("-", op->children, 1, space,
                                     &ti->spec, atoms))
          RETURN_NIL();
       break;
-      /*case slang_oper_complement: */
-   case slang_oper_subscript:
+      /*case SLANG_OPER_COMPLEMENT: */
+   case SLANG_OPER_SUBSCRIPT:
       {
          slang_typeinfo _ti;
 
@@ -508,7 +508,7 @@ _slang_typeof_operation_(const slang_operation * op,
             RETURN_NIL();
          }
          ti->can_be_referenced = _ti.can_be_referenced;
-         if (_ti.spec.type == slang_spec_array) {
+         if (_ti.spec.type == SLANG_SPEC_ARRAY) {
             if (!slang_type_specifier_copy(&ti->spec, _ti.spec._array)) {
                slang_typeinfo_destruct(&_ti);
                RETURN_NIL();
@@ -525,7 +525,7 @@ _slang_typeof_operation_(const slang_operation * op,
          slang_typeinfo_destruct(&_ti);
       }
       break;
-   case slang_oper_call:
+   case SLANG_OPER_CALL:
       {
          GLboolean exists;
 
@@ -536,7 +536,7 @@ _slang_typeof_operation_(const slang_operation * op,
             slang_struct *s =
                slang_struct_scope_find(space->structs, op->a_id, GL_TRUE);
             if (s != NULL) {
-               ti->spec.type = slang_spec_struct;
+               ti->spec.type = SLANG_SPEC_STRUCT;
                ti->spec._struct =
                   (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
                if (ti->spec._struct == NULL)
@@ -555,14 +555,14 @@ _slang_typeof_operation_(const slang_operation * op,
 
                name = slang_atom_pool_id(atoms, op->a_id);
                type = slang_type_specifier_type_from_string(name);
-               if (type == slang_spec_void)
+               if (type == SLANG_SPEC_VOID)
                   RETURN_ERROR2("function not found", name, 0);
                ti->spec.type = type;
             }
          }
       }
       break;
-   case slang_oper_field:
+   case SLANG_OPER_FIELD:
       {
          slang_typeinfo _ti;
 
@@ -572,7 +572,7 @@ _slang_typeof_operation_(const slang_operation * op,
             slang_typeinfo_destruct(&_ti);
             RETURN_NIL();
          }
-         if (_ti.spec.type == slang_spec_struct) {
+         if (_ti.spec.type == SLANG_SPEC_STRUCT) {
             slang_variable *field;
 
             field = _slang_locate_variable(_ti.spec._struct->fields, op->a_id,
@@ -622,14 +622,14 @@ _slang_typeof_operation_(const slang_operation * op,
                break;
             case 2:
                switch (base) {
-               case slang_spec_float:
-                  ti->spec.type = slang_spec_vec2;
+               case SLANG_SPEC_FLOAT:
+                  ti->spec.type = SLANG_SPEC_VEC2;
                   break;
-               case slang_spec_int:
-                  ti->spec.type = slang_spec_ivec2;
+               case SLANG_SPEC_INT:
+                  ti->spec.type = SLANG_SPEC_IVEC2;
                   break;
-               case slang_spec_bool:
-                  ti->spec.type = slang_spec_bvec2;
+               case SLANG_SPEC_BOOL:
+                  ti->spec.type = SLANG_SPEC_BVEC2;
                   break;
                default:
                   break;
@@ -637,14 +637,14 @@ _slang_typeof_operation_(const slang_operation * op,
                break;
             case 3:
                switch (base) {
-               case slang_spec_float:
-                  ti->spec.type = slang_spec_vec3;
+               case SLANG_SPEC_FLOAT:
+                  ti->spec.type = SLANG_SPEC_VEC3;
                   break;
-               case slang_spec_int:
-                  ti->spec.type = slang_spec_ivec3;
+               case SLANG_SPEC_INT:
+                  ti->spec.type = SLANG_SPEC_IVEC3;
                   break;
-               case slang_spec_bool:
-                  ti->spec.type = slang_spec_bvec3;
+               case SLANG_SPEC_BOOL:
+                  ti->spec.type = SLANG_SPEC_BVEC3;
                   break;
                default:
                   break;
@@ -652,14 +652,14 @@ _slang_typeof_operation_(const slang_operation * op,
                break;
             case 4:
                switch (base) {
-               case slang_spec_float:
-                  ti->spec.type = slang_spec_vec4;
+               case SLANG_SPEC_FLOAT:
+                  ti->spec.type = SLANG_SPEC_VEC4;
                   break;
-               case slang_spec_int:
-                  ti->spec.type = slang_spec_ivec4;
+               case SLANG_SPEC_INT:
+                  ti->spec.type = SLANG_SPEC_IVEC4;
                   break;
-               case slang_spec_bool:
-                  ti->spec.type = slang_spec_bvec4;
+               case SLANG_SPEC_BOOL:
+                  ti->spec.type = SLANG_SPEC_BVEC4;
                   break;
                default:
                   break;
@@ -672,8 +672,8 @@ _slang_typeof_operation_(const slang_operation * op,
          slang_typeinfo_destruct(&_ti);
       }
       break;
-   case slang_oper_postincrement:
-   case slang_oper_postdecrement:
+   case SLANG_OPER_POSTINCREMENT:
+   case SLANG_OPER_POSTDECREMENT:
       if (!_slang_typeof_operation_(op->children, space, ti, atoms))
          RETURN_NIL();
       ti->can_be_referenced = GL_FALSE;
@@ -728,8 +728,8 @@ _slang_locate_function(const slang_function_scope * funcs, slang_atom a_name,
           * parameter to be l-value.
           */
          if (!ti.can_be_referenced &&
-             (f->parameters->variables[j]->type.qualifier == slang_qual_out ||
-              f->parameters->variables[j]->type.qualifier == slang_qual_inout))
+             (f->parameters->variables[j]->type.qualifier == SLANG_QUAL_OUT ||
+              f->parameters->variables[j]->type.qualifier == SLANG_QUAL_INOUT))
             break;
       }
       if (j == num_args)
@@ -777,9 +777,9 @@ GLboolean
 _slang_type_is_matrix(slang_type_specifier_type ty)
 {
    switch (ty) {
-   case slang_spec_mat2:
-   case slang_spec_mat3:
-   case slang_spec_mat4:
+   case SLANG_SPEC_MAT2:
+   case SLANG_SPEC_MAT3:
+   case SLANG_SPEC_MAT4:
       return GL_TRUE;
    default:
       return GL_FALSE;
@@ -795,15 +795,15 @@ GLboolean
 _slang_type_is_vector(slang_type_specifier_type ty)
 {
    switch (ty) {
-   case slang_spec_vec2:
-   case slang_spec_vec3:
-   case slang_spec_vec4:
-   case slang_spec_ivec2:
-   case slang_spec_ivec3:
-   case slang_spec_ivec4:
-   case slang_spec_bvec2:
-   case slang_spec_bvec3:
-   case slang_spec_bvec4:
+   case SLANG_SPEC_VEC2:
+   case SLANG_SPEC_VEC3:
+   case SLANG_SPEC_VEC4:
+   case SLANG_SPEC_IVEC2:
+   case SLANG_SPEC_IVEC3:
+   case SLANG_SPEC_IVEC4:
+   case SLANG_SPEC_BVEC2:
+   case SLANG_SPEC_BVEC3:
+   case SLANG_SPEC_BVEC4:
       return GL_TRUE;
    default:
       return GL_FALSE;
@@ -818,29 +818,29 @@ slang_type_specifier_type
 _slang_type_base(slang_type_specifier_type ty)
 {
    switch (ty) {
-   case slang_spec_float:
-   case slang_spec_vec2:
-   case slang_spec_vec3:
-   case slang_spec_vec4:
-      return slang_spec_float;
-   case slang_spec_int:
-   case slang_spec_ivec2:
-   case slang_spec_ivec3:
-   case slang_spec_ivec4:
-      return slang_spec_int;
-   case slang_spec_bool:
-   case slang_spec_bvec2:
-   case slang_spec_bvec3:
-   case slang_spec_bvec4:
-      return slang_spec_bool;
-   case slang_spec_mat2:
-      return slang_spec_vec2;
-   case slang_spec_mat3:
-      return slang_spec_vec3;
-   case slang_spec_mat4:
-      return slang_spec_vec4;
+   case SLANG_SPEC_FLOAT:
+   case SLANG_SPEC_VEC2:
+   case SLANG_SPEC_VEC3:
+   case SLANG_SPEC_VEC4:
+      return SLANG_SPEC_FLOAT;
+   case SLANG_SPEC_INT:
+   case SLANG_SPEC_IVEC2:
+   case SLANG_SPEC_IVEC3:
+   case SLANG_SPEC_IVEC4:
+      return SLANG_SPEC_INT;
+   case SLANG_SPEC_BOOL:
+   case SLANG_SPEC_BVEC2:
+   case SLANG_SPEC_BVEC3:
+   case SLANG_SPEC_BVEC4:
+      return SLANG_SPEC_BOOL;
+   case SLANG_SPEC_MAT2:
+      return SLANG_SPEC_VEC2;
+   case SLANG_SPEC_MAT3:
+      return SLANG_SPEC_VEC3;
+   case SLANG_SPEC_MAT4:
+      return SLANG_SPEC_VEC4;
    default:
-      return slang_spec_void;
+      return SLANG_SPEC_VOID;
    }
 }
 
@@ -852,24 +852,24 @@ GLuint
 _slang_type_dim(slang_type_specifier_type ty)
 {
    switch (ty) {
-   case slang_spec_float:
-   case slang_spec_int:
-   case slang_spec_bool:
+   case SLANG_SPEC_FLOAT:
+   case SLANG_SPEC_INT:
+   case SLANG_SPEC_BOOL:
       return 1;
-   case slang_spec_vec2:
-   case slang_spec_ivec2:
-   case slang_spec_bvec2:
-   case slang_spec_mat2:
+   case SLANG_SPEC_VEC2:
+   case SLANG_SPEC_IVEC2:
+   case SLANG_SPEC_BVEC2:
+   case SLANG_SPEC_MAT2:
       return 2;
-   case slang_spec_vec3:
-   case slang_spec_ivec3:
-   case slang_spec_bvec3:
-   case slang_spec_mat3:
+   case SLANG_SPEC_VEC3:
+   case SLANG_SPEC_IVEC3:
+   case SLANG_SPEC_BVEC3:
+   case SLANG_SPEC_MAT3:
       return 3;
-   case slang_spec_vec4:
-   case slang_spec_ivec4:
-   case slang_spec_bvec4:
-   case slang_spec_mat4:
+   case SLANG_SPEC_VEC4:
+   case SLANG_SPEC_IVEC4:
+   case SLANG_SPEC_BVEC4:
+   case SLANG_SPEC_MAT4:
       return 4;
    default:
       return 0;
diff --git a/src/mesa/shader/slang/slang_typeinfo.h b/src/mesa/shader/slang/slang_typeinfo.h
index 0f72fad090..3115b71e08 100644
--- a/src/mesa/shader/slang/slang_typeinfo.h
+++ b/src/mesa/shader/slang/slang_typeinfo.h
@@ -89,30 +89,30 @@ _slang_multiply_swizzles(slang_swizzle *, const slang_swizzle *,
  */
 typedef enum slang_type_specifier_type_
 {
-   slang_spec_void,
-   slang_spec_bool,
-   slang_spec_bvec2,
-   slang_spec_bvec3,
-   slang_spec_bvec4,
-   slang_spec_int,
-   slang_spec_ivec2,
-   slang_spec_ivec3,
-   slang_spec_ivec4,
-   slang_spec_float,
-   slang_spec_vec2,
-   slang_spec_vec3,
-   slang_spec_vec4,
-   slang_spec_mat2,
-   slang_spec_mat3,
-   slang_spec_mat4,
-   slang_spec_sampler1D,
-   slang_spec_sampler2D,
-   slang_spec_sampler3D,
-   slang_spec_samplerCube,
-   slang_spec_sampler1DShadow,
-   slang_spec_sampler2DShadow,
-   slang_spec_struct,
-   slang_spec_array
+   SLANG_SPEC_VOID,
+   SLANG_SPEC_BOOL,
+   SLANG_SPEC_BVEC2,
+   SLANG_SPEC_BVEC3,
+   SLANG_SPEC_BVEC4,
+   SLANG_SPEC_INT,
+   SLANG_SPEC_IVEC2,
+   SLANG_SPEC_IVEC3,
+   SLANG_SPEC_IVEC4,
+   SLANG_SPEC_FLOAT,
+   SLANG_SPEC_VEC2,
+   SLANG_SPEC_VEC3,
+   SLANG_SPEC_VEC4,
+   SLANG_SPEC_MAT2,
+   SLANG_SPEC_MAT3,
+   SLANG_SPEC_MAT4,
+   SLANG_SPEC_SAMPLER1D,
+   SLANG_SPEC_SAMPLER2D,
+   SLANG_SPEC_SAMPLER3D,
+   SLANG_SPEC_SAMPLERCUBE,
+   SLANG_SPEC_SAMPLER1DSHADOW,
+   SLANG_SPEC_SAMPLER2DSHADOW,
+   SLANG_SPEC_STRUCT,
+   SLANG_SPEC_ARRAY
 } slang_type_specifier_type;