glsl: Replace _mesa_glsl_parser_targets enum with gl_shader_type.

These enums were redundant.

Reviewed-by: Brian Paul <brianp@vmware.com>

diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
index b2bbccac5b8045f109eec43e144feea30dc1c95a..3bc181e8785acb1a73cf154a7ae100309ed1453a 100644 (file)
--- a/src/glsl/ast_to_hir.cpp
+++ b/src/glsl/ast_to_hir.cpp
@@ -1860,7 +1860,7 @@ ast_fully_specified_type::glsl_type(const char **name,
 
    if (type->base_type == GLSL_TYPE_FLOAT
        && state->es_shader
-       && state->target == fragment_shader
+       && state->target == MESA_SHADER_FRAGMENT
        && this->qualifier.precision == ast_precision_none
        && state->symbols->get_variable("#default precision") == NULL) {
       YYLTYPE loc = this->get_location();
@@ -1882,12 +1882,12 @@ ast_fully_specified_type::glsl_type(const char **name,
  * this function will produce undefined results.
  */
 static bool
-is_varying_var(ir_variable *var, _mesa_glsl_parser_targets target)
+is_varying_var(ir_variable *var, gl_shader_type target)
 {
    switch (target) {
-   case vertex_shader:
+   case MESA_SHADER_VERTEX:
       return var->data.mode == ir_var_shader_out;
-   case fragment_shader:
+   case MESA_SHADER_FRAGMENT:
       return var->data.mode == ir_var_shader_in;
    default:
       return var->data.mode == ir_var_shader_out || var->data.mode == ir_var_shader_in;
@@ -1985,13 +1985,13 @@ validate_binding_qualifier(struct _mesa_glsl_parse_state *state,
        */
       unsigned limit = 0;
       switch (state->target) {
-      case vertex_shader:
+      case MESA_SHADER_VERTEX:
          limit = ctx->Const.VertexProgram.MaxTextureImageUnits;
          break;
-      case geometry_shader:
+      case MESA_SHADER_GEOMETRY:
          limit = ctx->Const.GeometryProgram.MaxTextureImageUnits;
          break;
-      case fragment_shader:
+      case MESA_SHADER_FRAGMENT:
          limit = ctx->Const.FragmentProgram.MaxTextureImageUnits;
          break;
       }
@@ -2049,8 +2049,8 @@ interpret_interpolation_qualifier(const struct ast_type_qualifier *qual,
 
       }
 
-      if ((state->target == vertex_shader && mode == ir_var_shader_in) ||
-          (state->target == fragment_shader && mode == ir_var_shader_out)) {
+      if ((state->target == MESA_SHADER_VERTEX && mode == ir_var_shader_in) ||
+          (state->target == MESA_SHADER_FRAGMENT && mode == ir_var_shader_out)) {
          _mesa_glsl_error(loc, state,
                           "interpolation qualifier `%s' cannot be applied to "
                           "vertex shader inputs or fragment shader outputs",
@@ -2077,7 +2077,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
     * locations.
     */
    switch (state->target) {
-   case vertex_shader:
+   case MESA_SHADER_VERTEX:
       if (var->data.mode == ir_var_shader_in) {
          if (!state->check_explicit_attrib_location_allowed(loc, var))
             return;
@@ -2088,13 +2088,13 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
       fail = true;
       break;
 
-   case geometry_shader:
+   case MESA_SHADER_GEOMETRY:
       _mesa_glsl_error(loc, state,
                        "geometry shader variables cannot be given "
                        "explicit locations");
       return;
 
-   case fragment_shader:
+   case MESA_SHADER_FRAGMENT:
       if (var->data.mode == ir_var_shader_out) {
          if (!state->check_explicit_attrib_location_allowed(loc, var))
             return;
@@ -2122,7 +2122,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
        * ensures that negative values stay negative.
        */
       if (qual->location >= 0) {
-         var->data.location = (state->target == vertex_shader)
+         var->data.location = (state->target == MESA_SHADER_VERTEX)
             ? (qual->location + VERT_ATTRIB_GENERIC0)
             : (qual->location + FRAG_RESULT_DATA0);
       } else {
@@ -2174,7 +2174,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
 
    if (qual->flags.q.constant || qual->flags.q.attribute
        || qual->flags.q.uniform
-       || (qual->flags.q.varying && (state->target == fragment_shader)))
+       || (qual->flags.q.varying && (state->target == MESA_SHADER_FRAGMENT)))
       var->data.read_only = 1;
 
    if (qual->flags.q.centroid)
@@ -2183,7 +2183,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if (qual->flags.q.sample)
       var->data.sample = 1;
 
-   if (qual->flags.q.attribute && state->target != vertex_shader) {
+   if (qual->flags.q.attribute && state->target != MESA_SHADER_VERTEX) {
       var->type = glsl_type::error_type;
       _mesa_glsl_error(loc, state,
                       "`attribute' variables may not be declared in the "
@@ -2214,11 +2214,11 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    else if (qual->flags.q.in)
       var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in;
    else if (qual->flags.q.attribute
-           || (qual->flags.q.varying && (state->target == fragment_shader)))
+           || (qual->flags.q.varying && (state->target == MESA_SHADER_FRAGMENT)))
       var->data.mode = ir_var_shader_in;
    else if (qual->flags.q.out)
       var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out;
-   else if (qual->flags.q.varying && (state->target == vertex_shader))
+   else if (qual->flags.q.varying && (state->target == MESA_SHADER_VERTEX))
       var->data.mode = ir_var_shader_out;
    else if (qual->flags.q.uniform)
       var->data.mode = ir_var_uniform;
@@ -2273,16 +2273,16 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
 
    if (state->all_invariant && (state->current_function == NULL)) {
       switch (state->target) {
-      case vertex_shader:
+      case MESA_SHADER_VERTEX:
         if (var->data.mode == ir_var_shader_out)
            var->data.invariant = true;
         break;
-      case geometry_shader:
+      case MESA_SHADER_GEOMETRY:
         if ((var->data.mode == ir_var_shader_in)
              || (var->data.mode == ir_var_shader_out))
            var->data.invariant = true;
         break;
-      case fragment_shader:
+      case MESA_SHADER_FRAGMENT:
         if (var->data.mode == ir_var_shader_in)
            var->data.invariant = true;
         break;
@@ -2600,7 +2600,7 @@ process_initializer(ir_variable *var, ast_declaration *decl,
       _mesa_glsl_error(& initializer_loc, state,
                       "cannot initialize %s shader input / %s",
                       _mesa_glsl_shader_target_name(state->target),
-                      (state->target == vertex_shader)
+                      (state->target == MESA_SHADER_VERTEX)
                       ? "attribute" : "varying");
    }
 
@@ -2844,12 +2844,12 @@ ast_declarator_list::hir(exec_list *instructions,
            _mesa_glsl_error(& loc, state,
                             "undeclared variable `%s' cannot be marked "
                             "invariant", decl->identifier);
-        } else if ((state->target == vertex_shader)
+        } else if ((state->target == MESA_SHADER_VERTEX)
               && (earlier->data.mode != ir_var_shader_out)) {
            _mesa_glsl_error(& loc, state,
                             "`%s' cannot be marked invariant, vertex shader "
                             "outputs only", decl->identifier);
-        } else if ((state->target == fragment_shader)
+        } else if ((state->target == MESA_SHADER_FRAGMENT)
               && (earlier->data.mode != ir_var_shader_in)) {
            _mesa_glsl_error(& loc, state,
                             "`%s' cannot be marked invariant, fragment shader "
@@ -3034,12 +3034,12 @@ ast_declarator_list::hir(exec_list *instructions,
                                       & loc, false);
 
       if (this->type->qualifier.flags.q.invariant) {
-        if ((state->target == vertex_shader) &&
+        if ((state->target == MESA_SHADER_VERTEX) &&
              var->data.mode != ir_var_shader_out) {
            _mesa_glsl_error(& loc, state,
                             "`%s' cannot be marked invariant, vertex shader "
                             "outputs only", var->name);
-        } else if ((state->target == fragment_shader) &&
+        } else if ((state->target == MESA_SHADER_FRAGMENT) &&
                    var->data.mode != ir_var_shader_in) {
            /* FINISHME: Note that this doesn't work for invariant on
             * a function signature inval
@@ -3080,7 +3080,7 @@ ast_declarator_list::hir(exec_list *instructions,
       } else if (var->data.mode == ir_var_shader_in) {
          var->data.read_only = true;
 
-        if (state->target == vertex_shader) {
+        if (state->target == MESA_SHADER_VERTEX) {
            bool error_emitted = false;
 
            /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
@@ -3135,7 +3135,7 @@ ast_declarator_list::hir(exec_list *instructions,
                                       "cannot have array type")) {
               error_emitted = true;
            }
-        } else if (state->target == geometry_shader) {
+        } else if (state->target == MESA_SHADER_GEOMETRY) {
             /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
              *
              *     Geometry shader input variables get the per-vertex values
@@ -3185,10 +3185,10 @@ ast_declarator_list::hir(exec_list *instructions,
       if (state->is_version(130, 300) &&
           var->type->contains_integer() &&
           var->data.interpolation != INTERP_QUALIFIER_FLAT &&
-          ((state->target == fragment_shader && var->data.mode == ir_var_shader_in)
-           || (state->target == vertex_shader && var->data.mode == ir_var_shader_out
+          ((state->target == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_in)
+           || (state->target == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_out
                && state->es_shader))) {
-         const char *var_type = (state->target == vertex_shader) ?
+         const char *var_type = (state->target == MESA_SHADER_VERTEX) ?
             "vertex output" : "fragment input";
          _mesa_glsl_error(&loc, state, "if a %s is (or contains) "
                           "an integer, then it must be qualified with 'flat'",
@@ -3245,14 +3245,14 @@ ast_declarator_list::hir(exec_list *instructions,
          assert(i != NULL);
 
          switch (state->target) {
-         case vertex_shader:
+         case MESA_SHADER_VERTEX:
             if (this->type->qualifier.flags.q.in) {
                _mesa_glsl_error(&loc, state,
                                 "qualifier '%s' cannot be applied to vertex "
                                 "shader inputs", i);
             }
             break;
-         case fragment_shader:
+         case MESA_SHADER_FRAGMENT:
             if (this->type->qualifier.flags.q.out) {
                _mesa_glsl_error(&loc, state,
                                 "qualifier '%s' cannot be applied to fragment "
@@ -3275,13 +3275,13 @@ ast_declarator_list::hir(exec_list *instructions,
       if (state->is_version(130, 300)
           && this->type->qualifier.flags.q.centroid
           && this->type->qualifier.flags.q.in
-          && state->target == vertex_shader) {
+          && state->target == MESA_SHADER_VERTEX) {
 
          _mesa_glsl_error(&loc, state,
                           "'centroid in' cannot be used in a vertex shader");
       }
 
-      if (state->target == vertex_shader
+      if (state->target == MESA_SHADER_VERTEX
           && this->type->qualifier.flags.q.sample
           && this->type->qualifier.flags.q.in) {
 
@@ -3296,7 +3296,7 @@ ast_declarator_list::hir(exec_list *instructions,
        * "It is an error to use auxiliary storage qualifiers or interpolation
        *  qualifiers on an output in a fragment shader."
        */
-      if (state->target == fragment_shader &&
+      if (state->target == MESA_SHADER_FRAGMENT &&
           this->type->qualifier.flags.q.out &&
           this->type->qualifier.has_auxiliary_storage()) {
          _mesa_glsl_error(&loc, state,
@@ -3954,7 +3954,7 @@ ast_jump_statement::hir(exec_list *instructions,
    }
 
    case ast_discard:
-      if (state->target != fragment_shader) {
+      if (state->target != MESA_SHADER_FRAGMENT) {
         YYLTYPE loc = this->get_location();
 
         _mesa_glsl_error(& loc, state,
@@ -4492,7 +4492,7 @@ ast_type_specifier::hir(exec_list *instructions,
 
       if (type->base_type == GLSL_TYPE_FLOAT
           && state->es_shader
-          && state->target == fragment_shader) {
+          && state->target == MESA_SHADER_FRAGMENT) {
          /* Section 4.5.3 (Default Precision Qualifiers) of the GLSL ES 1.00
           * spec says:
           *
@@ -4995,7 +4995,7 @@ ast_interface_block::hir(exec_list *instructions,
     *     variable (or input block, see interface blocks below) needs to be
     *     declared as an array.
     */
-   if (state->target == geometry_shader && !this->is_array &&
+   if (state->target == MESA_SHADER_GEOMETRY && !this->is_array &&
        var_mode == ir_var_shader_in) {
       _mesa_glsl_error(&loc, state, "geometry shader inputs must be arrays");
    }
@@ -5050,7 +5050,7 @@ ast_interface_block::hir(exec_list *instructions,
           * geometry shader input.
           */
          if (this->array_size == NULL &&
-             (state->target != geometry_shader || !this->layout.flags.q.in)) {
+             (state->target != MESA_SHADER_GEOMETRY || !this->layout.flags.q.in)) {
             _mesa_glsl_error(&loc, state,
                              "only geometry shader inputs may be unsized "
                              "instance block arrays");
@@ -5069,7 +5069,7 @@ ast_interface_block::hir(exec_list *instructions,
                                       var_mode);
       }
 
-      if (state->target == geometry_shader && var_mode == ir_var_shader_in)
+      if (state->target == MESA_SHADER_GEOMETRY && var_mode == ir_var_shader_in)
          handle_geometry_shader_input_decl(state, loc, var);
 
       if (ir_variable *earlier =
@@ -5265,7 +5265,7 @@ detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
       else if (strcmp(var->name, "gl_FragData") == 0)
         gl_FragData_assigned = true;
       else if (strncmp(var->name, "gl_", 3) != 0) {
-        if (state->target == fragment_shader &&
+        if (state->target == MESA_SHADER_FRAGMENT &&
             var->data.mode == ir_var_shader_out) {
            user_defined_fs_output_assigned = true;
            user_defined_fs_output = var;

diff --git a/src/glsl/builtin_functions.cpp b/src/glsl/builtin_functions.cpp
index 6af587add53b7d0789cc814b9f1806657b50c859..840a6c9a27c31d8bf33f51c6aa21c5ffa5c344a7 100644 (file)
--- a/src/glsl/builtin_functions.cpp
+++ b/src/glsl/builtin_functions.cpp
@@ -77,7 +77,7 @@ always_available(const _mesa_glsl_parse_state *state)
 static bool
 compatibility_vs_only(const _mesa_glsl_parse_state *state)
 {
-   return state->target == vertex_shader &&
+   return state->target == MESA_SHADER_VERTEX &&
           state->language_version <= 130 &&
           !state->es_shader;
 }
@@ -85,13 +85,13 @@ compatibility_vs_only(const _mesa_glsl_parse_state *state)
 static bool
 fs_only(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader;
+   return state->target == MESA_SHADER_FRAGMENT;
 }
 
 static bool
 gs_only(const _mesa_glsl_parse_state *state)
 {
-   return state->target == geometry_shader;
+   return state->target == MESA_SHADER_GEOMETRY;
 }
 
 static bool
@@ -103,7 +103,7 @@ v110(const _mesa_glsl_parse_state *state)
 static bool
 v110_fs_only(const _mesa_glsl_parse_state *state)
 {
-   return !state->es_shader && state->target == fragment_shader;
+   return !state->es_shader && state->target == MESA_SHADER_FRAGMENT;
 }
 
 static bool
@@ -122,7 +122,7 @@ static bool
 v130_fs_only(const _mesa_glsl_parse_state *state)
 {
    return state->is_version(130, 300) &&
-          state->target == fragment_shader;
+          state->target == MESA_SHADER_FRAGMENT;
 }
 
 static bool
@@ -155,7 +155,7 @@ lod_exists_in_stage(const _mesa_glsl_parse_state *state)
     * Since ARB_shader_texture_lod can only be enabled on desktop GLSL, we
     * don't need to explicitly check state->es_shader.
     */
-   return state->target == vertex_shader ||
+   return state->target == MESA_SHADER_VERTEX ||
           state->is_version(130, 300) ||
           state->ARB_shader_texture_lod_enable;
 }
@@ -223,7 +223,7 @@ texture_array_lod(const _mesa_glsl_parse_state *state)
 static bool
 fs_texture_array(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader &&
+   return state->target == MESA_SHADER_FRAGMENT &&
           state->EXT_texture_array_enable;
 }
 
@@ -243,7 +243,7 @@ texture_multisample(const _mesa_glsl_parse_state *state)
 static bool
 fs_texture_cube_map_array(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader &&
+   return state->target == MESA_SHADER_FRAGMENT &&
           (state->is_version(400, 0) ||
            state->ARB_texture_cube_map_array_enable);
 }
@@ -265,7 +265,7 @@ texture_query_levels(const _mesa_glsl_parse_state *state)
 static bool
 texture_query_lod(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader &&
+   return state->target == MESA_SHADER_FRAGMENT &&
           state->ARB_texture_query_lod_enable;
 }
 
@@ -292,7 +292,7 @@ texture_gather_only(const _mesa_glsl_parse_state *state)
 static bool
 fs_oes_derivatives(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader &&
+   return state->target == MESA_SHADER_FRAGMENT &&
           (state->is_version(110, 300) ||
            state->OES_standard_derivatives_enable);
 }
@@ -318,7 +318,7 @@ tex3d(const _mesa_glsl_parse_state *state)
 static bool
 fs_tex3d(const _mesa_glsl_parse_state *state)
 {
-   return state->target == fragment_shader &&
+   return state->target == MESA_SHADER_FRAGMENT &&
           (!state->es_shader || state->OES_texture_3D_enable);
 }
 

diff --git a/src/glsl/builtin_variables.cpp b/src/glsl/builtin_variables.cpp
index 0a3f129f8d565982879a8a1f04f314b22c8da9ef..ff9acb8d0d0341fed02fead35a507a585f3606f1 100644 (file)
--- a/src/glsl/builtin_variables.cpp
+++ b/src/glsl/builtin_variables.cpp
@@ -877,13 +877,13 @@ builtin_variable_generator::add_varying(int slot, const glsl_type *type,
                                         const char *name_as_gs_input)
 {
    switch (state->target) {
-   case geometry_shader:
+   case MESA_SHADER_GEOMETRY:
       this->per_vertex_in.add_field(slot, type, name);
       /* FALLTHROUGH */
-   case vertex_shader:
+   case MESA_SHADER_VERTEX:
       this->per_vertex_out.add_field(slot, type, name);
       break;
-   case fragment_shader:
+   case MESA_SHADER_FRAGMENT:
       add_input(slot, type, name);
       break;
    }
@@ -901,7 +901,7 @@ builtin_variable_generator::generate_varyings()
    add_varying(loc, type, name, name "In")
 
    /* gl_Position and gl_PointSize are not visible from fragment shaders. */
-   if (state->target != fragment_shader) {
+   if (state->target != MESA_SHADER_FRAGMENT) {
       ADD_VARYING(VARYING_SLOT_POS, vec4_t, "gl_Position");
       ADD_VARYING(VARYING_SLOT_PSIZ, float_t, "gl_PointSize");
    }
@@ -914,7 +914,7 @@ builtin_variable_generator::generate_varyings()
    if (compatibility) {
       ADD_VARYING(VARYING_SLOT_TEX0, array(vec4_t, 0), "gl_TexCoord");
       ADD_VARYING(VARYING_SLOT_FOGC, float_t, "gl_FogFragCoord");
-      if (state->target == fragment_shader) {
+      if (state->target == MESA_SHADER_FRAGMENT) {
          ADD_VARYING(VARYING_SLOT_COL0, vec4_t, "gl_Color");
          ADD_VARYING(VARYING_SLOT_COL1, vec4_t, "gl_SecondaryColor");
       } else {
@@ -926,13 +926,13 @@ builtin_variable_generator::generate_varyings()
       }
    }
 
-   if (state->target == geometry_shader) {
+   if (state->target == MESA_SHADER_GEOMETRY) {
       const glsl_type *per_vertex_in_type =
          this->per_vertex_in.construct_interface_instance();
       add_variable("gl_in", array(per_vertex_in_type, 0),
                    ir_var_shader_in, -1);
    }
-   if (state->target == vertex_shader || state->target == geometry_shader) {
+   if (state->target == MESA_SHADER_VERTEX || state->target == MESA_SHADER_GEOMETRY) {
       const glsl_type *per_vertex_out_type =
          this->per_vertex_out.construct_interface_instance();
       const glsl_struct_field *fields = per_vertex_out_type->fields.structure;
@@ -964,13 +964,13 @@ _mesa_glsl_initialize_variables(exec_list *instructions,
    gen.generate_varyings();
 
    switch (state->target) {
-   case vertex_shader:
+   case MESA_SHADER_VERTEX:
       gen.generate_vs_special_vars();
       break;
-   case geometry_shader:
+   case MESA_SHADER_GEOMETRY:
       gen.generate_gs_special_vars();
       break;
-   case fragment_shader:
+   case MESA_SHADER_FRAGMENT:
       gen.generate_fs_special_vars();
       break;
    }

diff --git a/src/glsl/glsl_parser.yy b/src/glsl/glsl_parser.yy
index 10165547924ba143b586e89e2c05b657cc2a339a..39767609d2095abbd0404975fc9bfe9615bf9491 100644 (file)
--- a/src/glsl/glsl_parser.yy
+++ b/src/glsl/glsl_parser.yy
@@ -2219,11 +2219,11 @@ basic_interface_block:
        * "It is illegal to have an input block in a vertex shader
        *  or an output block in a fragment shader"
        */
-      if ((state->target == vertex_shader) && $1.flags.q.in) {
+      if ((state->target == MESA_SHADER_VERTEX) && $1.flags.q.in) {
          _mesa_glsl_error(& @1, state,
                           "`in' interface block is not allowed for "
                           "a vertex shader");
-      } else if ((state->target == fragment_shader) && $1.flags.q.out) {
+      } else if ((state->target == MESA_SHADER_FRAGMENT) && $1.flags.q.out) {
          _mesa_glsl_error(& @1, state,
                           "`out' interface block is not allowed for "
                           "a fragment shader");
@@ -2377,7 +2377,7 @@ layout_defaults:
    {
       void *ctx = state;
       $$ = NULL;
-      if (state->target != geometry_shader) {
+      if (state->target != MESA_SHADER_GEOMETRY) {
          _mesa_glsl_error(& @1, state,
                           "input layout qualifiers only valid in "
                           "geometry shaders");
@@ -2405,7 +2405,7 @@ layout_defaults:
 
    | layout_qualifier OUT_TOK ';'
    {
-      if (state->target != geometry_shader) {
+      if (state->target != MESA_SHADER_GEOMETRY) {
          _mesa_glsl_error(& @1, state,
                           "out layout qualifiers only valid in "
                           "geometry shaders");

diff --git a/src/glsl/glsl_parser_extras.cpp b/src/glsl/glsl_parser_extras.cpp
index 2645c08af901131283f81928814c5330551d340a..5f19368d8562c75fb6555687089ef5d5e52c9c07 100644 (file)
--- a/src/glsl/glsl_parser_extras.cpp
+++ b/src/glsl/glsl_parser_extras.cpp
@@ -58,9 +58,9 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx,
    : ctx(_ctx), switch_state()
 {
    switch (target) {
-   case GL_VERTEX_SHADER:   this->target = vertex_shader; break;
-   case GL_FRAGMENT_SHADER: this->target = fragment_shader; break;
-   case GL_GEOMETRY_SHADER: this->target = geometry_shader; break;
+   case GL_VERTEX_SHADER:   this->target = MESA_SHADER_VERTEX; break;
+   case GL_FRAGMENT_SHADER: this->target = MESA_SHADER_FRAGMENT; break;
+   case GL_GEOMETRY_SHADER: this->target = MESA_SHADER_GEOMETRY; break;
    }
 
    this->scanner = NULL;
@@ -367,12 +367,12 @@ _mesa_glsl_shader_target_name(GLenum type)
  * our internal enum into short stage names.
  */
 const char *
-_mesa_glsl_shader_target_name(enum _mesa_glsl_parser_targets target)
+_mesa_glsl_shader_target_name(gl_shader_type target)
 {
    switch (target) {
-   case vertex_shader:   return "vertex";
-   case fragment_shader: return "fragment";
-   case geometry_shader: return "geometry";
+   case MESA_SHADER_VERTEX:   return "vertex";
+   case MESA_SHADER_FRAGMENT: return "fragment";
+   case MESA_SHADER_GEOMETRY: return "geometry";
    }
 
    assert(!"Should not get here.");

diff --git a/src/glsl/glsl_parser_extras.h b/src/glsl/glsl_parser_extras.h
index c1f5ff58979f7eb776c74be65c5a7651ec1cfe0a..622ddbac7268a4d921db6420bbac6df7417ffe2a 100644 (file)
--- a/src/glsl/glsl_parser_extras.h
+++ b/src/glsl/glsl_parser_extras.h
@@ -34,12 +34,6 @@
 #include <stdlib.h>
 #include "glsl_symbol_table.h"
 
-enum _mesa_glsl_parser_targets {
-   vertex_shader,
-   geometry_shader,
-   fragment_shader
-};
-
 struct gl_context;
 
 struct glsl_switch_state {
@@ -171,7 +165,7 @@ struct _mesa_glsl_parse_state {
 
    bool es_shader;
    unsigned language_version;
-   enum _mesa_glsl_parser_targets target;
+   gl_shader_type target;
 
    /**
     * Number of nested struct_specifier levels
@@ -431,7 +425,7 @@ extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
  * Get the textual name of the specified shader target
  */
 extern const char *
-_mesa_glsl_shader_target_name(enum _mesa_glsl_parser_targets target);
+_mesa_glsl_shader_target_name(gl_shader_type target);
 
 
 #endif /* __cplusplus */