glsl: Make use of new _mesa_glsl_parse_state::check_version() function.

Previous to this patch, we were not very consistent about the errors
we generate when a shader tried to use a feature that is prohibited in
the current GLSL version.  Some error messages failed to mention the
GLSL version currently in use (or did so inaccurately), and some error
messages failed to mention the first GLSL version in which the given
feature is allowed.

This patch reworks all of the error checks to use the check_version()
function, which produces error messages in a standard form
(approximately "$FEATURE forbidden in $CURRENT_GLSL_VERSION
($REQUIRED_GLSL_VERSION required).").

Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
Acked-by: Carl Worth <cworth@cworth.org>

diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp
index 5e1c8918b17dc0a2050cbad944a1e8a51489abee..8a5979fb3e2a658859e53214a9cddd8158ffc448 100644 (file)
--- a/src/glsl/ast_function.cpp
+++ b/src/glsl/ast_function.cpp
@@ -1243,9 +1243,8 @@ ast_function_expression::hir(exec_list *instructions,
       }
 
       if (constructor_type->is_array()) {
-        if (state->language_version <= 110) {
-           _mesa_glsl_error(& loc, state,
-                            "array constructors forbidden in GLSL 1.10");
+         if (!state->check_version(120, 0, &loc,
+                                   "array constructors forbidden")) {
            return ir_rvalue::error_value(ctx);
         }
 
@@ -1368,11 +1367,11 @@ ast_function_expression::hir(exec_list *instructions,
        *    "It is an error to construct matrices from other matrices. This
        *    is reserved for future use."
        */
-      if (state->language_version == 110 && matrix_parameters > 0
-         && constructor_type->is_matrix()) {
-        _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
-                         "matrix in GLSL 1.10",
-                         constructor_type->name);
+      if (matrix_parameters > 0
+          && constructor_type->is_matrix()
+          && !state->check_version(120, 100, &loc,
+                                   "cannot construct `%s' from a matrix",
+                                   constructor_type->name)) {
         return ir_rvalue::error_value(ctx);
       }
 

diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
index 79e4be8dcf1713baded1d17903d3e8a5791eb01a..394a7ef4bd3a19203289f88858d41a9de993ce39 100644 (file)
--- a/src/glsl/ast_to_hir.cpp
+++ b/src/glsl/ast_to_hir.cpp
@@ -390,8 +390,7 @@ bit_logic_result_type(const struct glsl_type *type_a,
                       ast_operators op,
                       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
 {
-    if (state->language_version < 130) {
-       _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30");
+    if (!state->check_bitwise_operations_allowed(loc)) {
        return glsl_type::error_type;
     }
 
@@ -446,10 +445,7 @@ modulus_result_type(const struct glsl_type *type_a,
                    const struct glsl_type *type_b,
                    struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
 {
-   if (state->language_version < 130) {
-      _mesa_glsl_error(loc, state,
-                       "operator '%%' is reserved in %s",
-                       state->get_version_string());
+   if (!state->check_version(130, 0, loc, "operator '%%' is reserved")) {
       return glsl_type::error_type;
    }
 
@@ -553,8 +549,7 @@ shift_result_type(const struct glsl_type *type_a,
                   ast_operators op,
                   struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
 {
-   if (state->language_version < 130) {
-      _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30");
+   if (!state->check_bitwise_operations_allowed(loc)) {
       return glsl_type::error_type;
    }
 
@@ -694,15 +689,15 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
                           lhs->variable_referenced()->name);
          error_emitted = true;
 
-      } else if (state->language_version <= 110 && lhs->type->is_array()) {
+      } else if (lhs->type->is_array() &&
+                 !state->check_version(120, 0, &lhs_loc,
+                                       "whole array assignment forbidden")) {
         /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
          *
          *    "Other binary or unary expressions, non-dereferenced
          *     arrays, function names, swizzles with repeated fields,
          *     and constants cannot be l-values."
          */
-        _mesa_glsl_error(&lhs_loc, state, "whole array assignment is not "
-                         "allowed in GLSL 1.10 or GLSL ES 1.00.");
         error_emitted = true;
       } else if (!lhs->is_lvalue()) {
         _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
@@ -1099,9 +1094,7 @@ ast_expression::hir(exec_list *instructions,
 
    case ast_lshift:
    case ast_rshift:
-       if (state->language_version < 130) {
-          _mesa_glsl_error(&loc, state, "operator %s requires GLSL 1.30",
-              operator_string(this->oper));
+       if (!state->check_bitwise_operations_allowed(&loc)) {
           error_emitted = true;
        }
 
@@ -1155,10 +1148,9 @@ ast_expression::hir(exec_list *instructions,
         _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
                          "type", (this->oper == ast_equal) ? "==" : "!=");
         error_emitted = true;
-      } else if ((state->language_version <= 110)
-                && (op[0]->type->is_array() || op[1]->type->is_array())) {
-        _mesa_glsl_error(& loc, state, "array comparisons forbidden in "
-                         "GLSL 1.10");
+      } else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
+                 !state->check_version(120, 0, &loc,
+                                       "array comparisons forbidden")) {
         error_emitted = true;
       }
 
@@ -1185,8 +1177,7 @@ ast_expression::hir(exec_list *instructions,
    case ast_bit_not:
       op[0] = this->subexpressions[0]->hir(instructions, state);
 
-      if (state->language_version < 130) {
-        _mesa_glsl_error(&loc, state, "bit-wise operations require GLSL 1.30");
+      if (!state->check_bitwise_operations_allowed(&loc)) {
         error_emitted = true;
       }
 
@@ -1424,9 +1415,10 @@ ast_expression::hir(exec_list *instructions,
        *    "The second and third expressions must be the same type, but can
        *    be of any type other than an array."
        */
-      if ((state->language_version <= 110) && type->is_array()) {
-        _mesa_glsl_error(& loc, state, "Second and third operands of ?: "
-                         "operator must not be arrays.");
+      if (type->is_array() &&
+          !state->check_version(120, 0, &loc,
+                                "Second and third operands of ?: operator "
+                                "cannot be arrays")) {
         error_emitted = true;
       }
 
@@ -2358,10 +2350,9 @@ process_initializer(ir_variable *var, ast_declaration *decl,
     *    directly by an application via API commands, or indirectly by
     *    OpenGL."
     */
-   if ((state->language_version <= 110)
-       && (var->mode == ir_var_uniform)) {
-      _mesa_glsl_error(& initializer_loc, state,
-                      "cannot initialize uniforms in GLSL 1.10");
+   if (var->mode == ir_var_uniform) {
+      state->check_version(120, 0, &initializer_loc,
+                           "cannot initialize uniforms");
    }
 
    if (var->type->is_sampler()) {
@@ -2727,11 +2718,10 @@ ast_declarator_list::hir(exec_list *instructions,
               error_emitted = true;
            }
 
-           if (!error_emitted && (state->language_version <= 130)
-               && var->type->is_array()) {
-              _mesa_glsl_error(& loc, state,
-                               "vertex shader input / attribute cannot have "
-                               "array type");
+           if (!error_emitted && var->type->is_array() &&
+                !state->check_version(140, 0, &loc,
+                                      "vertex shader input / attribute "
+                                      "cannot have array type")) {
               error_emitted = true;
            }
         }
@@ -2832,13 +2822,8 @@ ast_declarator_list::hir(exec_list *instructions,
 
       /* Precision qualifiers exists only in GLSL versions 1.00 and >= 1.30.
        */
-      if (this->type->specifier->precision != ast_precision_none
-          && state->language_version != 100
-          && state->language_version < 130) {
-
-         _mesa_glsl_error(&loc, state,
-                          "precision qualifiers are supported only in GLSL ES "
-                          "1.00, and GLSL 1.30 and later");
+      if (this->type->specifier->precision != ast_precision_none) {
+         state->check_precision_qualifiers_allowed(&loc);
       }
 
 
@@ -3080,8 +3065,9 @@ ast_parameter_declarator::hir(exec_list *instructions,
     * allowed.  This restriction is removed in GLSL 1.20, and in GLSL ES.
     */
    if ((var->mode == ir_var_inout || var->mode == ir_var_out)
-       && type->is_array() && state->language_version == 110) {
-      _mesa_glsl_error(&loc, state, "Arrays cannot be out or inout parameters in GLSL 1.10");
+       && type->is_array()
+       && !state->check_version(120, 100, &loc,
+                                "Arrays cannot be out or inout parameters")) {
       type = glsl_type::error_type;
    }
 
@@ -3876,11 +3862,7 @@ ast_type_specifier::hir(exec_list *instructions,
    YYLTYPE loc = this->get_location();
 
    if (this->precision != ast_precision_none
-       && state->language_version != 100
-       && state->language_version < 130) {
-      _mesa_glsl_error(&loc, state,
-                       "precision qualifiers exist only in "
-                       "GLSL ES 1.00, and GLSL 1.30 and later");
+       && !state->check_precision_qualifiers_allowed(&loc)) {
       return NULL;
    }
    if (this->precision != ast_precision_none

diff --git a/src/glsl/glsl_parser.yy b/src/glsl/glsl_parser.yy
index 3b4d84b6e6d6f3875afa4a887718b780606ceba7..ef2d24f08d7454e73cb13063a32103d83248cf2a 100644 (file)
--- a/src/glsl/glsl_parser.yy
+++ b/src/glsl/glsl_parser.yy
@@ -1494,32 +1494,17 @@ basic_type_specifier_nonarray:
 
 precision_qualifier:
        HIGHP     {
-                    if (!state->es_shader && state->language_version < 130)
-                       _mesa_glsl_error(& @1, state,
-                                        "precision qualifier forbidden "
-                                        "in %s (1.30 or later "
-                                        "required)\n",
-                                        state->get_version_string());
+                     state->check_precision_qualifiers_allowed(&@1);
 
                     $$ = ast_precision_high;
                  }
        | MEDIUMP {
-                    if (!state->es_shader && state->language_version < 130)
-                       _mesa_glsl_error(& @1, state,
-                                        "precision qualifier forbidden "
-                                        "in %s (1.30 or later "
-                                        "required)\n",
-                                        state->get_version_string());
+                     state->check_precision_qualifiers_allowed(&@1);
 
                     $$ = ast_precision_medium;
                  }
        | LOWP    {
-                    if (!state->es_shader && state->language_version < 130)
-                       _mesa_glsl_error(& @1, state,
-                                        "precision qualifier forbidden "
-                                        "in %s (1.30 or later "
-                                        "required)\n",
-                                        state->get_version_string());
+                     state->check_precision_qualifiers_allowed(&@1);
 
                     $$ = ast_precision_low;
                  }

diff --git a/src/glsl/glsl_parser_extras.h b/src/glsl/glsl_parser_extras.h
index 597b49ef19d8ce803ee89b0a6162162a82a64051..17f63c0b3c4dd2436ab09915fdd5245ee04f0534 100644 (file)
--- a/src/glsl/glsl_parser_extras.h
+++ b/src/glsl/glsl_parser_extras.h
@@ -125,6 +125,17 @@ struct _mesa_glsl_parse_state {
                       unsigned required_glsl_es_version,
                       YYLTYPE *locp, const char *fmt, ...) PRINTFLIKE(5, 6);
 
+   bool check_precision_qualifiers_allowed(YYLTYPE *locp)
+   {
+      return check_version(130, 100, locp,
+                           "precision qualifiers are forbidden");
+   }
+
+   bool check_bitwise_operations_allowed(YYLTYPE *locp)
+   {
+      return check_version(130, 0, locp, "bit-wise operations are forbidden");
+   }
+
    struct gl_context *const ctx;
    void *scanner;
    exec_list translation_unit;

diff --git a/src/glsl/hir_field_selection.cpp b/src/glsl/hir_field_selection.cpp
index 260b415a800af318f5a7e1a8fa04ae657eda376b..a18227f7b015d9dbec91f525b7e4e9b0e1f0e698 100644 (file)
--- a/src/glsl/hir_field_selection.cpp
+++ b/src/glsl/hir_field_selection.cpp
@@ -72,8 +72,7 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr,
       }
    } else if (expr->subexpressions[1] != NULL) {
       /* Handle "method calls" in GLSL 1.20 - namely, array.length() */
-      if (state->language_version < 120)
-        _mesa_glsl_error(&loc, state, "Methods not supported in GLSL 1.10.");
+      state->check_version(120, 0, &loc, "Methods not supported");
 
       ast_expression *call = expr->subexpressions[1];
       assert(call->oper == ast_function_call);