xserver libxcb mesa git update 5 Mar 2011

5 files changed, 4124 insertions, 4082 deletions

diff --git a/mesalib/src/glsl/SConscript b/mesalib/src/glsl/SConscript
index bb02a87c7..d7c3459f2 100644
--- a/mesalib/src/glsl/SConscript
+++ b/mesalib/src/glsl/SConscript
@@ -1,170 +1,176 @@
-import common
-
-Import('*')
-
-from sys import executable as python_cmd
-
-env = env.Clone()
-
-env.Prepend(CPPPATH = [
-    '#include',
-    '#src/mapi',
-    '#src/mesa',
-    '#src/glsl',
-    '#src/glsl/glcpp',
-])
-
-# Make glcpp/glcpp-parse.h and glsl_parser.h reacheable from the include path
-env.Append(CPPPATH = [Dir('.').abspath])
-
-env.Append(YACCFLAGS = '-d')
-
-parser_env = env.Clone()
-parser_env.Append(YACCFLAGS = [
-    '--defines=%s' % File('glsl_parser.h').abspath,
-    '-p', '_mesa_glsl_',
-])
-
-glcpp_lexer = env.CFile('glcpp/glcpp-lex.c', 'glcpp/glcpp-lex.l')
-glcpp_parser = env.CFile('glcpp/glcpp-parse.c', 'glcpp/glcpp-parse.y')
-glsl_lexer = parser_env.CXXFile('glsl_lexer.cpp', 'glsl_lexer.ll')
-glsl_parser = parser_env.CXXFile('glsl_parser.cpp', 'glsl_parser.yy')
-
-sources = [
-    glcpp_lexer,
-    glcpp_parser[0],
-    'glcpp/pp.c',
-    'ast_expr.cpp',
-    'ast_function.cpp',
-    'ast_to_hir.cpp',
-    'ast_type.cpp',
-    glsl_lexer,
-    glsl_parser[0],
-    'glsl_parser_extras.cpp',
-    'glsl_types.cpp',
-    'glsl_symbol_table.cpp',
-    'hir_field_selection.cpp',
-    'ir_basic_block.cpp',
-    'ir_clone.cpp',
-    'ir_constant_expression.cpp',
-    'ir.cpp',
-    'ir_expression_flattening.cpp',
-    'ir_function_can_inline.cpp',
-    'ir_function.cpp',
-    'ir_hierarchical_visitor.cpp',
-    'ir_hv_accept.cpp',
-    'ir_import_prototypes.cpp',
-    'ir_print_visitor.cpp',
-    'ir_reader.cpp',
-    'ir_rvalue_visitor.cpp',
-    'ir_set_program_inouts.cpp',
-    'ir_validate.cpp',
-    'ir_variable.cpp',
-    'ir_variable_refcount.cpp',
-    'linker.cpp',
-    'link_functions.cpp',
-    'loop_analysis.cpp',
-    'loop_controls.cpp',
-    'loop_unroll.cpp',
-    'lower_discard.cpp',
-    'lower_if_to_cond_assign.cpp',
-    'lower_instructions.cpp',
-    'lower_jumps.cpp',
-    'lower_mat_op_to_vec.cpp',
-    'lower_noise.cpp',
-    'lower_variable_index_to_cond_assign.cpp',
-    'lower_vec_index_to_cond_assign.cpp',
-    'lower_vec_index_to_swizzle.cpp',
-    'lower_vector.cpp',
-    'opt_algebraic.cpp',
-    'opt_constant_folding.cpp',
-    'opt_constant_propagation.cpp',
-    'opt_constant_variable.cpp',
-    'opt_copy_propagation.cpp',
-    'opt_copy_propagation_elements.cpp',
-    'opt_dead_code.cpp',
-    'opt_dead_code_local.cpp',
-    'opt_dead_functions.cpp',
-    'opt_discard_simplification.cpp',
-    'opt_function_inlining.cpp',
-    'opt_if_simplification.cpp',
-    'opt_noop_swizzle.cpp',
-    'opt_redundant_jumps.cpp',
-    'opt_structure_splitting.cpp',
-    'opt_swizzle_swizzle.cpp',
-    'opt_tree_grafting.cpp',
-    'ralloc.c',
-    's_expression.cpp',
-    'strtod.c',
-] 
-
-
-if env['crosscompile'] and env['platform'] != 'embedded':
-    Import('builtin_glsl_function')
-else:
-    if env['msvc']:
-        env.Prepend(CPPPATH = ['#/src/getopt'])
-        env.PrependUnique(LIBS = [getopt])
-
-    builtin_compiler = env.Program(
-        target = 'builtin_compiler',
-        source = sources + ['main.cpp', 'builtin_stubs.cpp',
-                            '#src/mesa/program/hash_table.c',
-                            '#src/mesa/program/symbol_table.c'],
-    )
-
-    # SCons builtin dependency scanner doesn't detect that glsl_lexer.ll
-    # depends on glsl_parser.h
-    env.Depends(builtin_compiler, glsl_parser)
-
-    builtin_glsl_function = env.CodeGenerate(
-        target = 'builtin_function.cpp',
-        script = 'builtins/tools/generate_builtins.py',
-        source = builtin_compiler,
-        command = python_cmd + ' $SCRIPT $SOURCE > $TARGET'
-    )
-
-    env.Depends(builtin_glsl_function, ['builtins/tools/generate_builtins.py', 'builtins/tools/texture_builtins.py'] + Glob('builtins/ir/*'))
-
-    Export('builtin_glsl_function')
-
-    if env['hostonly']:
-        Return()
-
-
-sources += builtin_glsl_function
-
-glsl = env.ConvenienceLibrary(
-    target = 'glsl',
-    source = sources,
-)
-
-# SCons builtin dependency scanner doesn't detect that glsl_lexer.ll depends on
-# glsl_parser.h
-env.Depends(glsl, glsl_parser)
-
-Export('glsl')
-
-# FIXME: We can't build the programs because there's a cyclic dependency between tis directory and src/mesa
-Return()
-
-env = env.Clone()
-
-if env['platform'] == 'windows':
-    env.PrependUnique(LIBS = [
-        'user32',
-    ])
-
-env.Prepend(LIBS = [glsl])
-
-env.Program(
-    target = 'glsl2',
-    source = [
-        'main.cpp',
-    ]
-)
-
-env.Program(
-    target = 'glcpp',
-    source = ['glcpp/glcpp.c'],
-)
+import common

+

+Import('*')

+

+from sys import executable as python_cmd

+

+env = env.Clone()

+

+env.Prepend(CPPPATH = [

+    '#include',

+    '#src/mapi',

+    '#src/mesa',

+    '#src/glsl',

+    '#src/glsl/glcpp',

+])

+

+# Make glcpp/glcpp-parse.h and glsl_parser.h reacheable from the include path

+env.Append(CPPPATH = [Dir('.').abspath])

+

+env.Append(YACCFLAGS = '-d')

+

+parser_env = env.Clone()

+parser_env.Append(YACCFLAGS = [

+    '--defines=%s' % File('glsl_parser.h').abspath,

+    '-p', '_mesa_glsl_',

+])

+

+glcpp_lexer = env.CFile('glcpp/glcpp-lex.c', 'glcpp/glcpp-lex.l')

+glcpp_parser = env.CFile('glcpp/glcpp-parse.c', 'glcpp/glcpp-parse.y')

+glsl_lexer = parser_env.CXXFile('glsl_lexer.cpp', 'glsl_lexer.ll')

+glsl_parser = parser_env.CXXFile('glsl_parser.cpp', 'glsl_parser.yy')

+

+glsl_sources = [

+    glcpp_lexer,

+    glcpp_parser[0],

+    'glcpp/pp.c',

+    'ast_expr.cpp',

+    'ast_function.cpp',

+    'ast_to_hir.cpp',

+    'ast_type.cpp',

+    glsl_lexer,

+    glsl_parser[0],

+    'glsl_parser_extras.cpp',

+    'glsl_types.cpp',

+    'glsl_symbol_table.cpp',

+    'hir_field_selection.cpp',

+    'ir_basic_block.cpp',

+    'ir_clone.cpp',

+    'ir_constant_expression.cpp',

+    'ir.cpp',

+    'ir_expression_flattening.cpp',

+    'ir_function_can_inline.cpp',

+    'ir_function.cpp',

+    'ir_hierarchical_visitor.cpp',

+    'ir_hv_accept.cpp',

+    'ir_import_prototypes.cpp',

+    'ir_print_visitor.cpp',

+    'ir_reader.cpp',

+    'ir_rvalue_visitor.cpp',

+    'ir_set_program_inouts.cpp',

+    'ir_validate.cpp',

+    'ir_variable.cpp',

+    'ir_variable_refcount.cpp',

+    'linker.cpp',

+    'link_functions.cpp',

+    'loop_analysis.cpp',

+    'loop_controls.cpp',

+    'loop_unroll.cpp',

+    'lower_discard.cpp',

+    'lower_if_to_cond_assign.cpp',

+    'lower_instructions.cpp',

+    'lower_jumps.cpp',

+    'lower_mat_op_to_vec.cpp',

+    'lower_noise.cpp',

+    'lower_variable_index_to_cond_assign.cpp',

+    'lower_vec_index_to_cond_assign.cpp',

+    'lower_vec_index_to_swizzle.cpp',

+    'lower_vector.cpp',

+    'opt_algebraic.cpp',

+    'opt_constant_folding.cpp',

+    'opt_constant_propagation.cpp',

+    'opt_constant_variable.cpp',

+    'opt_copy_propagation.cpp',

+    'opt_copy_propagation_elements.cpp',

+    'opt_dead_code.cpp',

+    'opt_dead_code_local.cpp',

+    'opt_dead_functions.cpp',

+    'opt_discard_simplification.cpp',

+    'opt_function_inlining.cpp',

+    'opt_if_simplification.cpp',

+    'opt_noop_swizzle.cpp',

+    'opt_redundant_jumps.cpp',

+    'opt_structure_splitting.cpp',

+    'opt_swizzle_swizzle.cpp',

+    'opt_tree_grafting.cpp',

+    'ralloc.c',

+    's_expression.cpp',

+    'strtod.c',

+] 

+

+if env['msvc']:

+    env.Prepend(CPPPATH = ['#/src/getopt'])

+    env.PrependUnique(LIBS = [getopt])

+

+if env['crosscompile'] and env['platform'] != 'embedded':

+    Import('builtin_glsl_function')

+else:

+    main_obj = env.StaticObject('main.cpp')

+

+    mesa_objs = env.StaticObject([

+        '#src/mesa/program/hash_table.c',

+        '#src/mesa/program/symbol_table.c',

+    ])

+

+    builtin_compiler = env.Program(

+        target = 'builtin_compiler',

+        source = main_obj + glsl_sources + ['builtin_stubs.cpp'] + mesa_objs,

+    )

+

+    # SCons builtin dependency scanner doesn't detect that glsl_lexer.ll

+    # depends on glsl_parser.h

+    env.Depends(builtin_compiler, glsl_parser)

+

+    builtin_glsl_function = env.CodeGenerate(

+        target = 'builtin_function.cpp',

+        script = 'builtins/tools/generate_builtins.py',

+        source = builtin_compiler,

+        command = python_cmd + ' $SCRIPT $SOURCE > $TARGET'

+    )

+

+    env.Depends(builtin_glsl_function, ['builtins/tools/generate_builtins.py', 'builtins/tools/texture_builtins.py'] + Glob('builtins/ir/*'))

+

+    Export('builtin_glsl_function')

+

+    if env['hostonly']:

+        Return()

+

+

+glsl_sources += builtin_glsl_function

+

+glsl = env.ConvenienceLibrary(

+    target = 'glsl',

+    source = glsl_sources,

+)

+

+# SCons builtin dependency scanner doesn't detect that glsl_lexer.ll depends on

+# glsl_parser.h

+env.Depends(glsl, glsl_parser)

+

+Export('glsl')

+

+# Skip building these programs as they will cause SCons error "Two environments

+# with different actions were specified for the same target"

+if env['crosscompile'] or env['platform'] == 'embedded':

+    Return()

+

+env = env.Clone()

+

+if env['platform'] == 'windows':

+    env.PrependUnique(LIBS = [

+        'user32',

+    ])

+

+env.Prepend(LIBS = [glsl])

+

+glsl2 = env.Program(

+    target = 'glsl2',

+    source = main_obj + mesa_objs,

+)

+env.Alias('glsl2', glsl2)

+

+glcpp = env.Program(

+    target = 'glcpp/glcpp',

+    source = ['glcpp/glcpp.c'] + mesa_objs,

+)

+env.Alias('glcpp', glcpp)

diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index fd1f0b49f..b8a812d94 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -1,3461 +1,3499 @@
-/*
- * Copyright © 2010 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file ast_to_hir.c
- * Convert abstract syntax to to high-level intermediate reprensentation (HIR).
- *
- * During the conversion to HIR, the majority of the symantic checking is
- * preformed on the program.  This includes:
- *
- *    * Symbol table management
- *    * Type checking
- *    * Function binding
- *
- * The majority of this work could be done during parsing, and the parser could
- * probably generate HIR directly.  However, this results in frequent changes
- * to the parser code.  Since we do not assume that every system this complier
- * is built on will have Flex and Bison installed, we have to store the code
- * generated by these tools in our version control system.  In other parts of
- * the system we've seen problems where a parser was changed but the generated
- * code was not committed, merge conflicts where created because two developers
- * had slightly different versions of Bison installed, etc.
- *
- * I have also noticed that running Bison generated parsers in GDB is very
- * irritating.  When you get a segfault on '$$ = $1->foo', you can't very
- * well 'print $1' in GDB.
- *
- * As a result, my preference is to put as little C code as possible in the
- * parser (and lexer) sources.
- */
-
-#include "main/core.h" /* for struct gl_extensions */
-#include "glsl_symbol_table.h"
-#include "glsl_parser_extras.h"
-#include "ast.h"
-#include "glsl_types.h"
-#include "ir.h"
-
-void
-_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
-{
-   _mesa_glsl_initialize_variables(instructions, state);
-   _mesa_glsl_initialize_functions(state);
-
-   state->symbols->language_version = state->language_version;
-
-   state->current_function = NULL;
-
-   /* Section 4.2 of the GLSL 1.20 specification states:
-    * "The built-in functions are scoped in a scope outside the global scope
-    *  users declare global variables in.  That is, a shader's global scope,
-    *  available for user-defined functions and global variables, is nested
-    *  inside the scope containing the built-in functions."
-    *
-    * Since built-in functions like ftransform() access built-in variables,
-    * it follows that those must be in the outer scope as well.
-    *
-    * We push scope here to create this nesting effect...but don't pop.
-    * This way, a shader's globals are still in the symbol table for use
-    * by the linker.
-    */
-   state->symbols->push_scope();
-
-   foreach_list_typed (ast_node, ast, link, & state->translation_unit)
-      ast->hir(instructions, state);
-}
-
-
-/**
- * If a conversion is available, convert one operand to a different type
- *
- * The \c from \c ir_rvalue is converted "in place".
- *
- * \param to     Type that the operand it to be converted to
- * \param from   Operand that is being converted
- * \param state  GLSL compiler state
- *
- * \return
- * If a conversion is possible (or unnecessary), \c true is returned.
- * Otherwise \c false is returned.
- */
-bool
-apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
-			  struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   if (to->base_type == from->type->base_type)
-      return true;
-
-   /* This conversion was added in GLSL 1.20.  If the compilation mode is
-    * GLSL 1.10, the conversion is skipped.
-    */
-   if (state->language_version < 120)
-      return false;
-
-   /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
-    *
-    *    "There are no implicit array or structure conversions. For
-    *    example, an array of int cannot be implicitly converted to an
-    *    array of float. There are no implicit conversions between
-    *    signed and unsigned integers."
-    */
-   /* FINISHME: The above comment is partially a lie.  There is int/uint
-    * FINISHME: conversion for immediate constants.
-    */
-   if (!to->is_float() || !from->type->is_numeric())
-      return false;
-
-   /* Convert to a floating point type with the same number of components
-    * as the original type - i.e. int to float, not int to vec4.
-    */
-   to = glsl_type::get_instance(GLSL_TYPE_FLOAT, from->type->vector_elements,
-			        from->type->matrix_columns);
-
-   switch (from->type->base_type) {
-   case GLSL_TYPE_INT:
-      from = new(ctx) ir_expression(ir_unop_i2f, to, from, NULL);
-      break;
-   case GLSL_TYPE_UINT:
-      from = new(ctx) ir_expression(ir_unop_u2f, to, from, NULL);
-      break;
-   case GLSL_TYPE_BOOL:
-      from = new(ctx) ir_expression(ir_unop_b2f, to, from, NULL);
-      break;
-   default:
-      assert(0);
-   }
-
-   return true;
-}
-
-
-static const struct glsl_type *
-arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
-		       bool multiply,
-		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
-{
-   const glsl_type *type_a = value_a->type;
-   const glsl_type *type_b = value_b->type;
-
-   /* From GLSL 1.50 spec, page 56:
-    *
-    *    "The arithmetic binary operators add (+), subtract (-),
-    *    multiply (*), and divide (/) operate on integer and
-    *    floating-point scalars, vectors, and matrices."
-    */
-   if (!type_a->is_numeric() || !type_b->is_numeric()) {
-      _mesa_glsl_error(loc, state,
-		       "Operands to arithmetic operators must be numeric");
-      return glsl_type::error_type;
-   }
-
-
-   /*    "If one operand is floating-point based and the other is
-    *    not, then the conversions from Section 4.1.10 "Implicit
-    *    Conversions" are applied to the non-floating-point-based operand."
-    */
-   if (!apply_implicit_conversion(type_a, value_b, state)
-       && !apply_implicit_conversion(type_b, value_a, state)) {
-      _mesa_glsl_error(loc, state,
-		       "Could not implicitly convert operands to "
-		       "arithmetic operator");
-      return glsl_type::error_type;
-   }
-   type_a = value_a->type;
-   type_b = value_b->type;
-
-   /*    "If the operands are integer types, they must both be signed or
-    *    both be unsigned."
-    *
-    * From this rule and the preceeding conversion it can be inferred that
-    * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
-    * The is_numeric check above already filtered out the case where either
-    * type is not one of these, so now the base types need only be tested for
-    * equality.
-    */
-   if (type_a->base_type != type_b->base_type) {
-      _mesa_glsl_error(loc, state,
-		       "base type mismatch for arithmetic operator");
-      return glsl_type::error_type;
-   }
-
-   /*    "All arithmetic binary operators result in the same fundamental type
-    *    (signed integer, unsigned integer, or floating-point) as the
-    *    operands they operate on, after operand type conversion. After
-    *    conversion, the following cases are valid
-    *
-    *    * The two operands are scalars. In this case the operation is
-    *      applied, resulting in a scalar."
-    */
-   if (type_a->is_scalar() && type_b->is_scalar())
-      return type_a;
-
-   /*   "* One operand is a scalar, and the other is a vector or matrix.
-    *      In this case, the scalar operation is applied independently to each
-    *      component of the vector or matrix, resulting in the same size
-    *      vector or matrix."
-    */
-   if (type_a->is_scalar()) {
-      if (!type_b->is_scalar())
-	 return type_b;
-   } else if (type_b->is_scalar()) {
-      return type_a;
-   }
-
-   /* All of the combinations of <scalar, scalar>, <vector, scalar>,
-    * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
-    * handled.
-    */
-   assert(!type_a->is_scalar());
-   assert(!type_b->is_scalar());
-
-   /*   "* The two operands are vectors of the same size. In this case, the
-    *      operation is done component-wise resulting in the same size
-    *      vector."
-    */
-   if (type_a->is_vector() && type_b->is_vector()) {
-      if (type_a == type_b) {
-	 return type_a;
-      } else {
-	 _mesa_glsl_error(loc, state,
-			  "vector size mismatch for arithmetic operator");
-	 return glsl_type::error_type;
-      }
-   }
-
-   /* All of the combinations of <scalar, scalar>, <vector, scalar>,
-    * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
-    * <vector, vector> have been handled.  At least one of the operands must
-    * be matrix.  Further, since there are no integer matrix types, the base
-    * type of both operands must be float.
-    */
-   assert(type_a->is_matrix() || type_b->is_matrix());
-   assert(type_a->base_type == GLSL_TYPE_FLOAT);
-   assert(type_b->base_type == GLSL_TYPE_FLOAT);
-
-   /*   "* The operator is add (+), subtract (-), or divide (/), and the
-    *      operands are matrices with the same number of rows and the same
-    *      number of columns. In this case, the operation is done component-
-    *      wise resulting in the same size matrix."
-    *    * The operator is multiply (*), where both operands are matrices or
-    *      one operand is a vector and the other a matrix. A right vector
-    *      operand is treated as a column vector and a left vector operand as a
-    *      row vector. In all these cases, it is required that the number of
-    *      columns of the left operand is equal to the number of rows of the
-    *      right operand. Then, the multiply (*) operation does a linear
-    *      algebraic multiply, yielding an object that has the same number of
-    *      rows as the left operand and the same number of columns as the right
-    *      operand. Section 5.10 "Vector and Matrix Operations" explains in
-    *      more detail how vectors and matrices are operated on."
-    */
-   if (! multiply) {
-      if (type_a == type_b)
-	 return type_a;
-   } else {
-      if (type_a->is_matrix() && type_b->is_matrix()) {
-	 /* Matrix multiply.  The columns of A must match the rows of B.  Given
-	  * the other previously tested constraints, this means the vector type
-	  * of a row from A must be the same as the vector type of a column from
-	  * B.
-	  */
-	 if (type_a->row_type() == type_b->column_type()) {
-	    /* The resulting matrix has the number of columns of matrix B and
-	     * the number of rows of matrix A.  We get the row count of A by
-	     * looking at the size of a vector that makes up a column.  The
-	     * transpose (size of a row) is done for B.
-	     */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_a->column_type()->vector_elements,
-				       type_b->row_type()->vector_elements);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
-      } else if (type_a->is_matrix()) {
-	 /* A is a matrix and B is a column vector.  Columns of A must match
-	  * rows of B.  Given the other previously tested constraints, this
-	  * means the vector type of a row from A must be the same as the
-	  * vector the type of B.
-	  */
-	 if (type_a->row_type() == type_b) {
-	    /* The resulting vector has a number of elements equal to
-	     * the number of rows of matrix A. */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_a->column_type()->vector_elements,
-				       1);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
-      } else {
-	 assert(type_b->is_matrix());
-
-	 /* A is a row vector and B is a matrix.  Columns of A must match rows
-	  * of B.  Given the other previously tested constraints, this means
-	  * the type of A must be the same as the vector type of a column from
-	  * B.
-	  */
-	 if (type_a == type_b->column_type()) {
-	    /* The resulting vector has a number of elements equal to
-	     * the number of columns of matrix B. */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_b->row_type()->vector_elements,
-				       1);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
-      }
-
-      _mesa_glsl_error(loc, state, "size mismatch for matrix multiplication");
-      return glsl_type::error_type;
-   }
-
-
-   /*    "All other cases are illegal."
-    */
-   _mesa_glsl_error(loc, state, "type mismatch");
-   return glsl_type::error_type;
-}
-
-
-static const struct glsl_type *
-unary_arithmetic_result_type(const struct glsl_type *type,
-			     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
-{
-   /* From GLSL 1.50 spec, page 57:
-    *
-    *    "The arithmetic unary operators negate (-), post- and pre-increment
-    *     and decrement (-- and ++) operate on integer or floating-point
-    *     values (including vectors and matrices). All unary operators work
-    *     component-wise on their operands. These result with the same type
-    *     they operated on."
-    */
-   if (!type->is_numeric()) {
-      _mesa_glsl_error(loc, state,
-		       "Operands to arithmetic operators must be numeric");
-      return glsl_type::error_type;
-   }
-
-   return type;
-}
-
-/**
- * \brief Return the result type of a bit-logic operation.
- *
- * If the given types to the bit-logic operator are invalid, return
- * glsl_type::error_type.
- *
- * \param type_a Type of LHS of bit-logic op
- * \param type_b Type of RHS of bit-logic op
- */
-static const struct glsl_type *
-bit_logic_result_type(const struct glsl_type *type_a,
-                      const struct glsl_type *type_b,
-                      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");
-       return glsl_type::error_type;
-    }
-
-    /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:
-     *
-     *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or
-     *     (|). The operands must be of type signed or unsigned integers or
-     *     integer vectors."
-     */
-    if (!type_a->is_integer()) {
-       _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",
-                         ast_expression::operator_string(op));
-       return glsl_type::error_type;
-    }
-    if (!type_b->is_integer()) {
-       _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",
-                        ast_expression::operator_string(op));
-       return glsl_type::error_type;
-    }
-
-    /*     "The fundamental types of the operands (signed or unsigned) must
-     *     match,"
-     */
-    if (type_a->base_type != type_b->base_type) {
-       _mesa_glsl_error(loc, state, "operands of `%s' must have the same "
-                        "base type", ast_expression::operator_string(op));
-       return glsl_type::error_type;
-    }
-
-    /*     "The operands cannot be vectors of differing size." */
-    if (type_a->is_vector() &&
-        type_b->is_vector() &&
-        type_a->vector_elements != type_b->vector_elements) {
-       _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "
-                        "different sizes", ast_expression::operator_string(op));
-       return glsl_type::error_type;
-    }
-
-    /*     "If one operand is a scalar and the other a vector, the scalar is
-     *     applied component-wise to the vector, resulting in the same type as
-     *     the vector. The fundamental types of the operands [...] will be the
-     *     resulting fundamental type."
-     */
-    if (type_a->is_scalar())
-        return type_b;
-    else
-        return type_a;
-}
-
-static const struct glsl_type *
-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->version_string);
-      return glsl_type::error_type;
-   }
-
-   /* From GLSL 1.50 spec, page 56:
-    *    "The operator modulus (%) operates on signed or unsigned integers or
-    *    integer vectors. The operand types must both be signed or both be
-    *    unsigned."
-    */
-   if (!type_a->is_integer() || !type_b->is_integer()
-       || (type_a->base_type != type_b->base_type)) {
-      _mesa_glsl_error(loc, state, "type mismatch");
-      return glsl_type::error_type;
-   }
-
-   /*    "The operands cannot be vectors of differing size. If one operand is
-    *    a scalar and the other vector, then the scalar is applied component-
-    *    wise to the vector, resulting in the same type as the vector. If both
-    *    are vectors of the same size, the result is computed component-wise."
-    */
-   if (type_a->is_vector()) {
-      if (!type_b->is_vector()
-	  || (type_a->vector_elements == type_b->vector_elements))
-	 return type_a;
-   } else
-      return type_b;
-
-   /*    "The operator modulus (%) is not defined for any other data types
-    *    (non-integer types)."
-    */
-   _mesa_glsl_error(loc, state, "type mismatch");
-   return glsl_type::error_type;
-}
-
-
-static const struct glsl_type *
-relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
-		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
-{
-   const glsl_type *type_a = value_a->type;
-   const glsl_type *type_b = value_b->type;
-
-   /* From GLSL 1.50 spec, page 56:
-    *    "The relational operators greater than (>), less than (<), greater
-    *    than or equal (>=), and less than or equal (<=) operate only on
-    *    scalar integer and scalar floating-point expressions."
-    */
-   if (!type_a->is_numeric()
-       || !type_b->is_numeric()
-       || !type_a->is_scalar()
-       || !type_b->is_scalar()) {
-      _mesa_glsl_error(loc, state,
-		       "Operands to relational operators must be scalar and "
-		       "numeric");
-      return glsl_type::error_type;
-   }
-
-   /*    "Either the operands' types must match, or the conversions from
-    *    Section 4.1.10 "Implicit Conversions" will be applied to the integer
-    *    operand, after which the types must match."
-    */
-   if (!apply_implicit_conversion(type_a, value_b, state)
-       && !apply_implicit_conversion(type_b, value_a, state)) {
-      _mesa_glsl_error(loc, state,
-		       "Could not implicitly convert operands to "
-		       "relational operator");
-      return glsl_type::error_type;
-   }
-   type_a = value_a->type;
-   type_b = value_b->type;
-
-   if (type_a->base_type != type_b->base_type) {
-      _mesa_glsl_error(loc, state, "base type mismatch");
-      return glsl_type::error_type;
-   }
-
-   /*    "The result is scalar Boolean."
-    */
-   return glsl_type::bool_type;
-}
-
-/**
- * \brief Return the result type of a bit-shift operation.
- *
- * If the given types to the bit-shift operator are invalid, return
- * glsl_type::error_type.
- *
- * \param type_a Type of LHS of bit-shift op
- * \param type_b Type of RHS of bit-shift op
- */
-static const struct glsl_type *
-shift_result_type(const struct glsl_type *type_a,
-                  const struct glsl_type *type_b,
-                  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");
-      return glsl_type::error_type;
-   }
-
-   /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:
-    *
-    *     "The shift operators (<<) and (>>). For both operators, the operands
-    *     must be signed or unsigned integers or integer vectors. One operand
-    *     can be signed while the other is unsigned."
-    */
-   if (!type_a->is_integer()) {
-      _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
-              "integer vector", ast_expression::operator_string(op));
-     return glsl_type::error_type;
-
-   }
-   if (!type_b->is_integer()) {
-      _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
-              "integer vector", ast_expression::operator_string(op));
-     return glsl_type::error_type;
-   }
-
-   /*     "If the first operand is a scalar, the second operand has to be
-    *     a scalar as well."
-    */
-   if (type_a->is_scalar() && !type_b->is_scalar()) {
-      _mesa_glsl_error(loc, state, "If the first operand of %s is scalar, the "
-              "second must be scalar as well",
-              ast_expression::operator_string(op));
-     return glsl_type::error_type;
-   }
-
-   /* If both operands are vectors, check that they have same number of
-    * elements.
-    */
-   if (type_a->is_vector() &&
-      type_b->is_vector() &&
-      type_a->vector_elements != type_b->vector_elements) {
-      _mesa_glsl_error(loc, state, "Vector operands to operator %s must "
-              "have same number of elements",
-              ast_expression::operator_string(op));
-     return glsl_type::error_type;
-   }
-
-   /*     "In all cases, the resulting type will be the same type as the left
-    *     operand."
-    */
-   return type_a;
-}
-
-/**
- * Validates that a value can be assigned to a location with a specified type
- *
- * Validates that \c rhs can be assigned to some location.  If the types are
- * not an exact match but an automatic conversion is possible, \c rhs will be
- * converted.
- *
- * \return
- * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
- * Otherwise the actual RHS to be assigned will be returned.  This may be
- * \c rhs, or it may be \c rhs after some type conversion.
- *
- * \note
- * In addition to being used for assignments, this function is used to
- * type-check return values.
- */
-ir_rvalue *
-validate_assignment(struct _mesa_glsl_parse_state *state,
-		    const glsl_type *lhs_type, ir_rvalue *rhs)
-{
-   /* If there is already some error in the RHS, just return it.  Anything
-    * else will lead to an avalanche of error message back to the user.
-    */
-   if (rhs->type->is_error())
-      return rhs;
-
-   /* If the types are identical, the assignment can trivially proceed.
-    */
-   if (rhs->type == lhs_type)
-      return rhs;
-
-   /* If the array element types are the same and the size of the LHS is zero,
-    * the assignment is okay.
-    *
-    * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
-    * is handled by ir_dereference::is_lvalue.
-    */
-   if (lhs_type->is_array() && rhs->type->is_array()
-       && (lhs_type->element_type() == rhs->type->element_type())
-       && (lhs_type->array_size() == 0)) {
-      return rhs;
-   }
-
-   /* Check for implicit conversion in GLSL 1.20 */
-   if (apply_implicit_conversion(lhs_type, rhs, state)) {
-      if (rhs->type == lhs_type)
-	 return rhs;
-   }
-
-   return NULL;
-}
-
-ir_rvalue *
-do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
-	      ir_rvalue *lhs, ir_rvalue *rhs,
-	      YYLTYPE lhs_loc)
-{
-   void *ctx = state;
-   bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());
-
-   if (!error_emitted) {
-      if (lhs->variable_referenced() != NULL
-          && lhs->variable_referenced()->read_only) {
-         _mesa_glsl_error(&lhs_loc, state,
-                          "assignment to read-only variable '%s'",
-                          lhs->variable_referenced()->name);
-         error_emitted = true;
-
-      } else if (!lhs->is_lvalue()) {
-	 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
-	 error_emitted = true;
-      }
-
-      if (state->es_shader && lhs->type->is_array()) {
-	 _mesa_glsl_error(&lhs_loc, state, "whole array assignment is not "
-			  "allowed in GLSL ES 1.00.");
-	 error_emitted = true;
-      }
-   }
-
-   ir_rvalue *new_rhs = validate_assignment(state, lhs->type, rhs);
-   if (new_rhs == NULL) {
-      _mesa_glsl_error(& lhs_loc, state, "type mismatch");
-   } else {
-      rhs = new_rhs;
-
-      /* If the LHS array was not declared with a size, it takes it size from
-       * the RHS.  If the LHS is an l-value and a whole array, it must be a
-       * dereference of a variable.  Any other case would require that the LHS
-       * is either not an l-value or not a whole array.
-       */
-      if (lhs->type->array_size() == 0) {
-	 ir_dereference *const d = lhs->as_dereference();
-
-	 assert(d != NULL);
-
-	 ir_variable *const var = d->variable_referenced();
-
-	 assert(var != NULL);
-
-	 if (var->max_array_access >= unsigned(rhs->type->array_size())) {
-	    /* FINISHME: This should actually log the location of the RHS. */
-	    _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
-			     "previous access",
-			     var->max_array_access);
-	 }
-
-	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),
-						   rhs->type->array_size());
-	 d->type = var->type;
-      }
-   }
-
-   /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,
-    * but not post_inc) need the converted assigned value as an rvalue
-    * to handle things like:
-    *
-    * i = j += 1;
-    *
-    * So we always just store the computed value being assigned to a
-    * temporary and return a deref of that temporary.  If the rvalue
-    * ends up not being used, the temp will get copy-propagated out.
-    */
-   ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
-					   ir_var_temporary);
-   ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var);
-   instructions->push_tail(var);
-   instructions->push_tail(new(ctx) ir_assignment(deref_var,
-						  rhs,
-						  NULL));
-   deref_var = new(ctx) ir_dereference_variable(var);
-
-   if (!error_emitted)
-      instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var, NULL));
-
-   return new(ctx) ir_dereference_variable(var);
-}
-
-static ir_rvalue *
-get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
-{
-   void *ctx = ralloc_parent(lvalue);
-   ir_variable *var;
-
-   var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
-			      ir_var_temporary);
-   instructions->push_tail(var);
-   var->mode = ir_var_auto;
-
-   instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
-						  lvalue, NULL));
-
-   /* Once we've created this temporary, mark it read only so it's no
-    * longer considered an lvalue.
-    */
-   var->read_only = true;
-
-   return new(ctx) ir_dereference_variable(var);
-}
-
-
-ir_rvalue *
-ast_node::hir(exec_list *instructions,
-	      struct _mesa_glsl_parse_state *state)
-{
-   (void) instructions;
-   (void) state;
-
-   return NULL;
-}
-
-static void
-mark_whole_array_access(ir_rvalue *access)
-{
-   ir_dereference_variable *deref = access->as_dereference_variable();
-
-   if (deref) {
-      deref->var->max_array_access = deref->type->length - 1;
-   }
-}
-
-static ir_rvalue *
-do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
-{
-   int join_op;
-   ir_rvalue *cmp = NULL;
-
-   if (operation == ir_binop_all_equal)
-      join_op = ir_binop_logic_and;
-   else
-      join_op = ir_binop_logic_or;
-
-   switch (op0->type->base_type) {
-   case GLSL_TYPE_FLOAT:
-   case GLSL_TYPE_UINT:
-   case GLSL_TYPE_INT:
-   case GLSL_TYPE_BOOL:
-      return new(mem_ctx) ir_expression(operation, op0, op1);
-
-   case GLSL_TYPE_ARRAY: {
-      for (unsigned int i = 0; i < op0->type->length; i++) {
-	 ir_rvalue *e0, *e1, *result;
-
-	 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
-						new(mem_ctx) ir_constant(i));
-	 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
-						new(mem_ctx) ir_constant(i));
-	 result = do_comparison(mem_ctx, operation, e0, e1);
-
-	 if (cmp) {
-	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
-	 } else {
-	    cmp = result;
-	 }
-      }
-
-      mark_whole_array_access(op0);
-      mark_whole_array_access(op1);
-      break;
-   }
-
-   case GLSL_TYPE_STRUCT: {
-      for (unsigned int i = 0; i < op0->type->length; i++) {
-	 ir_rvalue *e0, *e1, *result;
-	 const char *field_name = op0->type->fields.structure[i].name;
-
-	 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
-						 field_name);
-	 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
-						 field_name);
-	 result = do_comparison(mem_ctx, operation, e0, e1);
-
-	 if (cmp) {
-	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
-	 } else {
-	    cmp = result;
-	 }
-      }
-      break;
-   }
-
-   case GLSL_TYPE_ERROR:
-   case GLSL_TYPE_VOID:
-   case GLSL_TYPE_SAMPLER:
-      /* I assume a comparison of a struct containing a sampler just
-       * ignores the sampler present in the type.
-       */
-      break;
-
-   default:
-      assert(!"Should not get here.");
-      break;
-   }
-
-   if (cmp == NULL)
-      cmp = new(mem_ctx) ir_constant(true);
-
-   return cmp;
-}
-
-ir_rvalue *
-ast_expression::hir(exec_list *instructions,
-		    struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   static const int operations[AST_NUM_OPERATORS] = {
-      -1,               /* ast_assign doesn't convert to ir_expression. */
-      -1,               /* ast_plus doesn't convert to ir_expression. */
-      ir_unop_neg,
-      ir_binop_add,
-      ir_binop_sub,
-      ir_binop_mul,
-      ir_binop_div,
-      ir_binop_mod,
-      ir_binop_lshift,
-      ir_binop_rshift,
-      ir_binop_less,
-      ir_binop_greater,
-      ir_binop_lequal,
-      ir_binop_gequal,
-      ir_binop_all_equal,
-      ir_binop_any_nequal,
-      ir_binop_bit_and,
-      ir_binop_bit_xor,
-      ir_binop_bit_or,
-      ir_unop_bit_not,
-      ir_binop_logic_and,
-      ir_binop_logic_xor,
-      ir_binop_logic_or,
-      ir_unop_logic_not,
-
-      /* Note: The following block of expression types actually convert
-       * to multiple IR instructions.
-       */
-      ir_binop_mul,     /* ast_mul_assign */
-      ir_binop_div,     /* ast_div_assign */
-      ir_binop_mod,     /* ast_mod_assign */
-      ir_binop_add,     /* ast_add_assign */
-      ir_binop_sub,     /* ast_sub_assign */
-      ir_binop_lshift,  /* ast_ls_assign */
-      ir_binop_rshift,  /* ast_rs_assign */
-      ir_binop_bit_and, /* ast_and_assign */
-      ir_binop_bit_xor, /* ast_xor_assign */
-      ir_binop_bit_or,  /* ast_or_assign */
-
-      -1,               /* ast_conditional doesn't convert to ir_expression. */
-      ir_binop_add,     /* ast_pre_inc. */
-      ir_binop_sub,     /* ast_pre_dec. */
-      ir_binop_add,     /* ast_post_inc. */
-      ir_binop_sub,     /* ast_post_dec. */
-      -1,               /* ast_field_selection doesn't conv to ir_expression. */
-      -1,               /* ast_array_index doesn't convert to ir_expression. */
-      -1,               /* ast_function_call doesn't conv to ir_expression. */
-      -1,               /* ast_identifier doesn't convert to ir_expression. */
-      -1,               /* ast_int_constant doesn't convert to ir_expression. */
-      -1,               /* ast_uint_constant doesn't conv to ir_expression. */
-      -1,               /* ast_float_constant doesn't conv to ir_expression. */
-      -1,               /* ast_bool_constant doesn't conv to ir_expression. */
-      -1,               /* ast_sequence doesn't convert to ir_expression. */
-   };
-   ir_rvalue *result = NULL;
-   ir_rvalue *op[3];
-   const struct glsl_type *type = glsl_type::error_type;
-   bool error_emitted = false;
-   YYLTYPE loc;
-
-   loc = this->get_location();
-
-   switch (this->oper) {
-   case ast_assign: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      result = do_assignment(instructions, state, op[0], op[1],
-			     this->subexpressions[0]->get_location());
-      error_emitted = result->type->is_error();
-      type = result->type;
-      break;
-   }
-
-   case ast_plus:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      type = unary_arithmetic_result_type(op[0]->type, state, & loc);
-
-      error_emitted = type->is_error();
-
-      result = op[0];
-      break;
-
-   case ast_neg:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      type = unary_arithmetic_result_type(op[0]->type, state, & loc);
-
-      error_emitted = type->is_error();
-
-      result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], NULL);
-      break;
-
-   case ast_add:
-   case ast_sub:
-   case ast_mul:
-   case ast_div:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      type = arithmetic_result_type(op[0], op[1],
-				    (this->oper == ast_mul),
-				    state, & loc);
-      error_emitted = type->is_error();
-
-      result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], op[1]);
-      break;
-
-   case ast_mod:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
-
-      assert(operations[this->oper] == ir_binop_mod);
-
-      result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], op[1]);
-      error_emitted = type->is_error();
-      break;
-
-   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));
-          error_emitted = true;
-       }
-
-       op[0] = this->subexpressions[0]->hir(instructions, state);
-       op[1] = this->subexpressions[1]->hir(instructions, state);
-       type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
-                                &loc);
-       result = new(ctx) ir_expression(operations[this->oper], type,
-                                       op[0], op[1]);
-       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-       break;
-
-   case ast_less:
-   case ast_greater:
-   case ast_lequal:
-   case ast_gequal:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      type = relational_result_type(op[0], op[1], state, & loc);
-
-      /* The relational operators must either generate an error or result
-       * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.
-       */
-      assert(type->is_error()
-	     || ((type->base_type == GLSL_TYPE_BOOL)
-		 && type->is_scalar()));
-
-      result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], op[1]);
-      error_emitted = type->is_error();
-      break;
-
-   case ast_nequal:
-   case ast_equal:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
-       *
-       *    "The equality operators equal (==), and not equal (!=)
-       *    operate on all types. They result in a scalar Boolean. If
-       *    the operand types do not match, then there must be a
-       *    conversion from Section 4.1.10 "Implicit Conversions"
-       *    applied to one operand that can make them match, in which
-       *    case this conversion is done."
-       */
-      if ((!apply_implicit_conversion(op[0]->type, op[1], state)
-	   && !apply_implicit_conversion(op[1]->type, op[0], state))
-	  || (op[0]->type != op[1]->type)) {
-	 _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");
-	 error_emitted = true;
-      }
-
-      result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
-      type = glsl_type::bool_type;
-
-      assert(error_emitted || (result->type == glsl_type::bool_type));
-      break;
-
-   case ast_bit_and:
-   case ast_bit_xor:
-   case ast_bit_or:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-      type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
-                                   state, &loc);
-      result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], op[1]);
-      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-      break;
-
-   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");
-	 error_emitted = true;
-      }
-
-      if (!op[0]->type->is_integer()) {
-	 _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
-	 error_emitted = true;
-      }
-
-      type = op[0]->type;
-      result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);
-      break;
-
-   case ast_logic_and: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
-	 YYLTYPE loc = this->subexpressions[0]->get_location();
-
-	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
-			  operator_string(this->oper));
-	 error_emitted = true;
-      }
-
-      ir_constant *op0_const = op[0]->constant_expression_value();
-      if (op0_const) {
-	 if (op0_const->value.b[0]) {
-	    op[1] = this->subexpressions[1]->hir(instructions, state);
-
-	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
-	       YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	       _mesa_glsl_error(& loc, state,
-				"RHS of `%s' must be scalar boolean",
-				operator_string(this->oper));
-	       error_emitted = true;
-	    }
-	    result = op[1];
-	 } else {
-	    result = op0_const;
-	 }
-	 type = glsl_type::bool_type;
-      } else {
-	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
-						       "and_tmp",
-						       ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state);
-
-	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
-	    YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	    _mesa_glsl_error(& loc, state,
-			     "RHS of `%s' must be scalar boolean",
-			     operator_string(this->oper));
-	    error_emitted = true;
-	 }
-
-	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, op[1], NULL);
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false), NULL);
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
-	 type = tmp->type;
-      }
-      break;
-   }
-
-   case ast_logic_or: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
-	 YYLTYPE loc = this->subexpressions[0]->get_location();
-
-	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
-			  operator_string(this->oper));
-	 error_emitted = true;
-      }
-
-      ir_constant *op0_const = op[0]->constant_expression_value();
-      if (op0_const) {
-	 if (op0_const->value.b[0]) {
-	    result = op0_const;
-	 } else {
-	    op[1] = this->subexpressions[1]->hir(instructions, state);
-
-	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
-	       YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	       _mesa_glsl_error(& loc, state,
-				"RHS of `%s' must be scalar boolean",
-				operator_string(this->oper));
-	       error_emitted = true;
-	    }
-	    result = op[1];
-	 }
-	 type = glsl_type::bool_type;
-      } else {
-	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
-						       "or_tmp",
-						       ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 op[1] = this->subexpressions[1]->hir(&stmt->else_instructions, state);
-
-	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
-	    YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	    _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean",
-			     operator_string(this->oper));
-	    error_emitted = true;
-	 }
-
-	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true), NULL);
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, op[1], NULL);
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
-	 type = tmp->type;
-      }
-      break;
-   }
-
-   case ast_logic_xor:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-
-      result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
-				      op[0], op[1]);
-      type = glsl_type::bool_type;
-      break;
-
-   case ast_logic_not:
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
-	 YYLTYPE loc = this->subexpressions[0]->get_location();
-
-	 _mesa_glsl_error(& loc, state,
-			  "operand of `!' must be scalar boolean");
-	 error_emitted = true;
-      }
-
-      result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
-				      op[0], NULL);
-      type = glsl_type::bool_type;
-      break;
-
-   case ast_mul_assign:
-   case ast_div_assign:
-   case ast_add_assign:
-   case ast_sub_assign: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      type = arithmetic_result_type(op[0], op[1],
-				    (this->oper == ast_mul_assign),
-				    state, & loc);
-
-      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-						   op[0], op[1]);
-
-      result = do_assignment(instructions, state,
-			     op[0]->clone(ctx, NULL), temp_rhs,
-			     this->subexpressions[0]->get_location());
-      type = result->type;
-      error_emitted = (op[0]->type->is_error());
-
-      /* GLSL 1.10 does not allow array assignment.  However, we don't have to
-       * explicitly test for this because none of the binary expression
-       * operators allow array operands either.
-       */
-
-      break;
-   }
-
-   case ast_mod_assign: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-
-      type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
-
-      assert(operations[this->oper] == ir_binop_mod);
-
-      ir_rvalue *temp_rhs;
-      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-					op[0], op[1]);
-
-      result = do_assignment(instructions, state,
-			     op[0]->clone(ctx, NULL), temp_rhs,
-			     this->subexpressions[0]->get_location());
-      type = result->type;
-      error_emitted = type->is_error();
-      break;
-   }
-
-   case ast_ls_assign:
-   case ast_rs_assign: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-      type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
-                               &loc);
-      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
-                                                   type, op[0], op[1]);
-      result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),
-                             temp_rhs,
-                             this->subexpressions[0]->get_location());
-      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-      break;
-   }
-
-   case ast_and_assign:
-   case ast_xor_assign:
-   case ast_or_assign: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      op[1] = this->subexpressions[1]->hir(instructions, state);
-      type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
-                                   state, &loc);
-      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
-                                                   type, op[0], op[1]);
-      result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),
-                             temp_rhs,
-                             this->subexpressions[0]->get_location());
-      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-      break;
-   }
-
-   case ast_conditional: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-
-      /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
-       *
-       *    "The ternary selection operator (?:). It operates on three
-       *    expressions (exp1 ? exp2 : exp3). This operator evaluates the
-       *    first expression, which must result in a scalar Boolean."
-       */
-      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
-	 YYLTYPE loc = this->subexpressions[0]->get_location();
-
-	 _mesa_glsl_error(& loc, state, "?: condition must be scalar boolean");
-	 error_emitted = true;
-      }
-
-      /* The :? operator is implemented by generating an anonymous temporary
-       * followed by an if-statement.  The last instruction in each branch of
-       * the if-statement assigns a value to the anonymous temporary.  This
-       * temporary is the r-value of the expression.
-       */
-      exec_list then_instructions;
-      exec_list else_instructions;
-
-      op[1] = this->subexpressions[1]->hir(&then_instructions, state);
-      op[2] = this->subexpressions[2]->hir(&else_instructions, state);
-
-      /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
-       *
-       *     "The second and third expressions can be any type, as
-       *     long their types match, or there is a conversion in
-       *     Section 4.1.10 "Implicit Conversions" that can be applied
-       *     to one of the expressions to make their types match. This
-       *     resulting matching type is the type of the entire
-       *     expression."
-       */
-      if ((!apply_implicit_conversion(op[1]->type, op[2], state)
-	   && !apply_implicit_conversion(op[2]->type, op[1], state))
-	  || (op[1]->type != op[2]->type)) {
-	 YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	 _mesa_glsl_error(& loc, state, "Second and third operands of ?: "
-			  "operator must have matching types.");
-	 error_emitted = true;
-	 type = glsl_type::error_type;
-      } else {
-	 type = op[1]->type;
-      }
-
-      /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
-       *
-       *    "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.");
-	 error_emitted = true;
-      }
-
-      ir_constant *cond_val = op[0]->constant_expression_value();
-      ir_constant *then_val = op[1]->constant_expression_value();
-      ir_constant *else_val = op[2]->constant_expression_value();
-
-      if (then_instructions.is_empty()
-	  && else_instructions.is_empty()
-	  && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
-	 result = (cond_val->value.b[0]) ? then_val : else_val;
-      } else {
-	 ir_variable *const tmp =
-	    new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 then_instructions.move_nodes_to(& stmt->then_instructions);
-	 ir_dereference *const then_deref =
-	    new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, op[1], NULL);
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 else_instructions.move_nodes_to(& stmt->else_instructions);
-	 ir_dereference *const else_deref =
-	    new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, op[2], NULL);
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
-      }
-      break;
-   }
-
-   case ast_pre_inc:
-   case ast_pre_dec: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      if (op[0]->type->base_type == GLSL_TYPE_FLOAT)
-	 op[1] = new(ctx) ir_constant(1.0f);
-      else
-	 op[1] = new(ctx) ir_constant(1);
-
-      type = arithmetic_result_type(op[0], op[1], false, state, & loc);
-
-      ir_rvalue *temp_rhs;
-      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-					op[0], op[1]);
-
-      result = do_assignment(instructions, state,
-			     op[0]->clone(ctx, NULL), temp_rhs,
-			     this->subexpressions[0]->get_location());
-      type = result->type;
-      error_emitted = op[0]->type->is_error();
-      break;
-   }
-
-   case ast_post_inc:
-   case ast_post_dec: {
-      op[0] = this->subexpressions[0]->hir(instructions, state);
-      if (op[0]->type->base_type == GLSL_TYPE_FLOAT)
-	 op[1] = new(ctx) ir_constant(1.0f);
-      else
-	 op[1] = new(ctx) ir_constant(1);
-
-      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-
-      type = arithmetic_result_type(op[0], op[1], false, state, & loc);
-
-      ir_rvalue *temp_rhs;
-      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-					op[0], op[1]);
-
-      /* Get a temporary of a copy of the lvalue before it's modified.
-       * This may get thrown away later.
-       */
-      result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
-
-      (void)do_assignment(instructions, state,
-			  op[0]->clone(ctx, NULL), temp_rhs,
-			  this->subexpressions[0]->get_location());
-
-      type = result->type;
-      error_emitted = op[0]->type->is_error();
-      break;
-   }
-
-   case ast_field_selection:
-      result = _mesa_ast_field_selection_to_hir(this, instructions, state);
-      type = result->type;
-      break;
-
-   case ast_array_index: {
-      YYLTYPE index_loc = subexpressions[1]->get_location();
-
-      op[0] = subexpressions[0]->hir(instructions, state);
-      op[1] = subexpressions[1]->hir(instructions, state);
-
-      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
-
-      ir_rvalue *const array = op[0];
-
-      result = new(ctx) ir_dereference_array(op[0], op[1]);
-
-      /* Do not use op[0] after this point.  Use array.
-       */
-      op[0] = NULL;
-
-
-      if (error_emitted)
-	 break;
-
-      if (!array->type->is_array()
-	  && !array->type->is_matrix()
-	  && !array->type->is_vector()) {
-	 _mesa_glsl_error(& index_loc, state,
-			  "cannot dereference non-array / non-matrix / "
-			  "non-vector");
-	 error_emitted = true;
-      }
-
-      if (!op[1]->type->is_integer()) {
-	 _mesa_glsl_error(& index_loc, state,
-			  "array index must be integer type");
-	 error_emitted = true;
-      } else if (!op[1]->type->is_scalar()) {
-	 _mesa_glsl_error(& index_loc, state,
-			  "array index must be scalar");
-	 error_emitted = true;
-      }
-
-      /* If the array index is a constant expression and the array has a
-       * declared size, ensure that the access is in-bounds.  If the array
-       * index is not a constant expression, ensure that the array has a
-       * declared size.
-       */
-      ir_constant *const const_index = op[1]->constant_expression_value();
-      if (const_index != NULL) {
-	 const int idx = const_index->value.i[0];
-	 const char *type_name;
-	 unsigned bound = 0;
-
-	 if (array->type->is_matrix()) {
-	    type_name = "matrix";
-	 } else if (array->type->is_vector()) {
-	    type_name = "vector";
-	 } else {
-	    type_name = "array";
-	 }
-
-	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec:
-	  *
-	  *    "It is illegal to declare an array with a size, and then
-	  *    later (in the same shader) index the same array with an
-	  *    integral constant expression greater than or equal to the
-	  *    declared size. It is also illegal to index an array with a
-	  *    negative constant expression."
-	  */
-	 if (array->type->is_matrix()) {
-	    if (array->type->row_type()->vector_elements <= idx) {
-	       bound = array->type->row_type()->vector_elements;
-	    }
-	 } else if (array->type->is_vector()) {
-	    if (array->type->vector_elements <= idx) {
-	       bound = array->type->vector_elements;
-	    }
-	 } else {
-	    if ((array->type->array_size() > 0)
-		&& (array->type->array_size() <= idx)) {
-	       bound = array->type->array_size();
-	    }
-	 }
-
-	 if (bound > 0) {
-	    _mesa_glsl_error(& loc, state, "%s index must be < %u",
-			     type_name, bound);
-	    error_emitted = true;
-	 } else if (idx < 0) {
-	    _mesa_glsl_error(& loc, state, "%s index must be >= 0",
-			     type_name);
-	    error_emitted = true;
-	 }
-
-	 if (array->type->is_array()) {
-	    /* If the array is a variable dereference, it dereferences the
-	     * whole array, by definition.  Use this to get the variable.
-	     *
-	     * FINISHME: Should some methods for getting / setting / testing
-	     * FINISHME: array access limits be added to ir_dereference?
-	     */
-	    ir_variable *const v = array->whole_variable_referenced();
-	    if ((v != NULL) && (unsigned(idx) > v->max_array_access))
-	       v->max_array_access = idx;
-	 }
-      } else if (array->type->array_size() == 0) {
-	 _mesa_glsl_error(&loc, state, "unsized array index must be constant");
-      } else {
-	 if (array->type->is_array()) {
-	    /* whole_variable_referenced can return NULL if the array is a
-	     * member of a structure.  In this case it is safe to not update
-	     * the max_array_access field because it is never used for fields
-	     * of structures.
-	     */
-	    ir_variable *v = array->whole_variable_referenced();
-	    if (v != NULL)
-	       v->max_array_access = array->type->array_size();
-	 }
-      }
-
-      /* From page 23 (29 of the PDF) of the GLSL 1.30 spec:
-       *
-       *    "Samplers aggregated into arrays within a shader (using square
-       *    brackets [ ]) can only be indexed with integral constant
-       *    expressions [...]."
-       *
-       * This restriction was added in GLSL 1.30.  Shaders using earlier version
-       * of the language should not be rejected by the compiler front-end for
-       * using this construct.  This allows useful things such as using a loop
-       * counter as the index to an array of samplers.  If the loop in unrolled,
-       * the code should compile correctly.  Instead, emit a warning.
-       */
-      if (array->type->is_array() &&
-          array->type->element_type()->is_sampler() &&
-          const_index == NULL) {
-
-	 if (state->language_version == 100) {
-	    _mesa_glsl_warning(&loc, state,
-			       "sampler arrays indexed with non-constant "
-			       "expressions is optional in GLSL ES 1.00");
-	 } else if (state->language_version < 130) {
-	    _mesa_glsl_warning(&loc, state,
-			       "sampler arrays indexed with non-constant "
-			       "expressions is forbidden in GLSL 1.30 and "
-			       "later");
-	 } else {
-	    _mesa_glsl_error(&loc, state,
-			     "sampler arrays indexed with non-constant "
-			     "expressions is forbidden in GLSL 1.30 and "
-			     "later");
-	    error_emitted = true;
-	 }
-      }
-
-      if (error_emitted)
-	 result->type = glsl_type::error_type;
-
-      type = result->type;
-      break;
-   }
-
-   case ast_function_call:
-      /* Should *NEVER* get here.  ast_function_call should always be handled
-       * by ast_function_expression::hir.
-       */
-      assert(0);
-      break;
-
-   case ast_identifier: {
-      /* ast_identifier can appear several places in a full abstract syntax
-       * tree.  This particular use must be at location specified in the grammar
-       * as 'variable_identifier'.
-       */
-      ir_variable *var = 
-	 state->symbols->get_variable(this->primary_expression.identifier);
-
-      result = new(ctx) ir_dereference_variable(var);
-
-      if (var != NULL) {
-	 var->used = true;
-	 type = result->type;
-      } else {
-	 _mesa_glsl_error(& loc, state, "`%s' undeclared",
-			  this->primary_expression.identifier);
-
-	 error_emitted = true;
-      }
-      break;
-   }
-
-   case ast_int_constant:
-      type = glsl_type::int_type;
-      result = new(ctx) ir_constant(this->primary_expression.int_constant);
-      break;
-
-   case ast_uint_constant:
-      type = glsl_type::uint_type;
-      result = new(ctx) ir_constant(this->primary_expression.uint_constant);
-      break;
-
-   case ast_float_constant:
-      type = glsl_type::float_type;
-      result = new(ctx) ir_constant(this->primary_expression.float_constant);
-      break;
-
-   case ast_bool_constant:
-      type = glsl_type::bool_type;
-      result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
-      break;
-
-   case ast_sequence: {
-      /* It should not be possible to generate a sequence in the AST without
-       * any expressions in it.
-       */
-      assert(!this->expressions.is_empty());
-
-      /* The r-value of a sequence is the last expression in the sequence.  If
-       * the other expressions in the sequence do not have side-effects (and
-       * therefore add instructions to the instruction list), they get dropped
-       * on the floor.
-       */
-      foreach_list_typed (ast_node, ast, link, &this->expressions)
-	 result = ast->hir(instructions, state);
-
-      type = result->type;
-
-      /* Any errors should have already been emitted in the loop above.
-       */
-      error_emitted = true;
-      break;
-   }
-   }
-
-   if (type->is_error() && !error_emitted)
-      _mesa_glsl_error(& loc, state, "type mismatch");
-
-   return result;
-}
-
-
-ir_rvalue *
-ast_expression_statement::hir(exec_list *instructions,
-			      struct _mesa_glsl_parse_state *state)
-{
-   /* It is possible to have expression statements that don't have an
-    * expression.  This is the solitary semicolon:
-    *
-    * for (i = 0; i < 5; i++)
-    *     ;
-    *
-    * In this case the expression will be NULL.  Test for NULL and don't do
-    * anything in that case.
-    */
-   if (expression != NULL)
-      expression->hir(instructions, state);
-
-   /* Statements do not have r-values.
-    */
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_compound_statement::hir(exec_list *instructions,
-			    struct _mesa_glsl_parse_state *state)
-{
-   if (new_scope)
-      state->symbols->push_scope();
-
-   foreach_list_typed (ast_node, ast, link, &this->statements)
-      ast->hir(instructions, state);
-
-   if (new_scope)
-      state->symbols->pop_scope();
-
-   /* Compound statements do not have r-values.
-    */
-   return NULL;
-}
-
-
-static const glsl_type *
-process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size,
-		   struct _mesa_glsl_parse_state *state)
-{
-   unsigned length = 0;
-
-   /* FINISHME: Reject delcarations of multidimensional arrays. */
-
-   if (array_size != NULL) {
-      exec_list dummy_instructions;
-      ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
-      YYLTYPE loc = array_size->get_location();
-
-      /* FINISHME: Verify that the grammar forbids side-effects in array
-       * FINISHME: sizes.   i.e., 'vec4 [x = 12] data'
-       */
-      assert(dummy_instructions.is_empty());
-
-      if (ir != NULL) {
-	 if (!ir->type->is_integer()) {
-	    _mesa_glsl_error(& loc, state, "array size must be integer type");
-	 } else if (!ir->type->is_scalar()) {
-	    _mesa_glsl_error(& loc, state, "array size must be scalar type");
-	 } else {
-	    ir_constant *const size = ir->constant_expression_value();
-
-	    if (size == NULL) {
-	       _mesa_glsl_error(& loc, state, "array size must be a "
-				"constant valued expression");
-	    } else if (size->value.i[0] <= 0) {
-	       _mesa_glsl_error(& loc, state, "array size must be > 0");
-	    } else {
-	       assert(size->type == ir->type);
-	       length = size->value.u[0];
-	    }
-	 }
-      }
-   } else if (state->es_shader) {
-      /* Section 10.17 of the GLSL ES 1.00 specification states that unsized
-       * array declarations have been removed from the language.
-       */
-      _mesa_glsl_error(loc, state, "unsized array declarations are not "
-		       "allowed in GLSL ES 1.00.");
-   }
-
-   return glsl_type::get_array_instance(base, length);
-}
-
-
-const glsl_type *
-ast_type_specifier::glsl_type(const char **name,
-			      struct _mesa_glsl_parse_state *state) const
-{
-   const struct glsl_type *type;
-
-   type = state->symbols->get_type(this->type_name);
-   *name = this->type_name;
-
-   if (this->is_array) {
-      YYLTYPE loc = this->get_location();
-      type = process_array_type(&loc, type, this->array_size, state);
-   }
-
-   return type;
-}
-
-
-static void
-apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
-				 ir_variable *var,
-				 struct _mesa_glsl_parse_state *state,
-				 YYLTYPE *loc)
-{
-   if (qual->flags.q.invariant) {
-      if (var->used) {
-	 _mesa_glsl_error(loc, state,
-			  "variable `%s' may not be redeclared "
-			  "`invariant' after being used",
-			  var->name);
-      } else {
-	 var->invariant = 1;
-      }
-   }
-
-   if (qual->flags.q.constant || qual->flags.q.attribute
-       || qual->flags.q.uniform
-       || (qual->flags.q.varying && (state->target == fragment_shader)))
-      var->read_only = 1;
-
-   if (qual->flags.q.centroid)
-      var->centroid = 1;
-
-   if (qual->flags.q.attribute && state->target != vertex_shader) {
-      var->type = glsl_type::error_type;
-      _mesa_glsl_error(loc, state,
-		       "`attribute' variables may not be declared in the "
-		       "%s shader",
-		       _mesa_glsl_shader_target_name(state->target));
-   }
-
-   /* From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:
-    *
-    *     "The varying qualifier can be used only with the data types
-    *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of
-    *     these."
-    */
-   if (qual->flags.q.varying) {
-      const glsl_type *non_array_type;
-
-      if (var->type && var->type->is_array())
-	 non_array_type = var->type->fields.array;
-      else
-	 non_array_type = var->type;
-
-      if (non_array_type && non_array_type->base_type != GLSL_TYPE_FLOAT) {
-	 var->type = glsl_type::error_type;
-	 _mesa_glsl_error(loc, state,
-			  "varying variables must be of base type float");
-      }
-   }
-
-   /* If there is no qualifier that changes the mode of the variable, leave
-    * the setting alone.
-    */
-   if (qual->flags.q.in && qual->flags.q.out)
-      var->mode = ir_var_inout;
-   else if (qual->flags.q.attribute || qual->flags.q.in
-	    || (qual->flags.q.varying && (state->target == fragment_shader)))
-      var->mode = ir_var_in;
-   else if (qual->flags.q.out
-	    || (qual->flags.q.varying && (state->target == vertex_shader)))
-      var->mode = ir_var_out;
-   else if (qual->flags.q.uniform)
-      var->mode = ir_var_uniform;
-
-   if (state->all_invariant && (state->current_function == NULL)) {
-      switch (state->target) {
-      case vertex_shader:
-	 if (var->mode == ir_var_out)
-	    var->invariant = true;
-	 break;
-      case geometry_shader:
-	 if ((var->mode == ir_var_in) || (var->mode == ir_var_out))
-	    var->invariant = true;
-	 break;
-      case fragment_shader:
-	 if (var->mode == ir_var_in)
-	    var->invariant = true;
-	 break;
-      }
-   }
-
-   if (qual->flags.q.flat)
-      var->interpolation = ir_var_flat;
-   else if (qual->flags.q.noperspective)
-      var->interpolation = ir_var_noperspective;
-   else
-      var->interpolation = ir_var_smooth;
-
-   var->pixel_center_integer = qual->flags.q.pixel_center_integer;
-   var->origin_upper_left = qual->flags.q.origin_upper_left;
-   if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
-       && (strcmp(var->name, "gl_FragCoord") != 0)) {
-      const char *const qual_string = (qual->flags.q.origin_upper_left)
-	 ? "origin_upper_left" : "pixel_center_integer";
-
-      _mesa_glsl_error(loc, state,
-		       "layout qualifier `%s' can only be applied to "
-		       "fragment shader input `gl_FragCoord'",
-		       qual_string);
-   }
-
-   if (qual->flags.q.explicit_location) {
-      const bool global_scope = (state->current_function == NULL);
-      bool fail = false;
-      const char *string = "";
-
-      /* In the vertex shader only shader inputs can be given explicit
-       * locations.
-       *
-       * In the fragment shader only shader outputs can be given explicit
-       * locations.
-       */
-      switch (state->target) {
-      case vertex_shader:
-	 if (!global_scope || (var->mode != ir_var_in)) {
-	    fail = true;
-	    string = "input";
-	 }
-	 break;
-
-      case geometry_shader:
-	 _mesa_glsl_error(loc, state,
-			  "geometry shader variables cannot be given "
-			  "explicit locations\n");
-	 break;
-
-      case fragment_shader:
-	 if (!global_scope || (var->mode != ir_var_in)) {
-	    fail = true;
-	    string = "output";
-	 }
-	 break;
-      };
-
-      if (fail) {
-	 _mesa_glsl_error(loc, state,
-			  "only %s shader %s variables can be given an "
-			  "explicit location\n",
-			  _mesa_glsl_shader_target_name(state->target),
-			  string);
-      } else {
-	 var->explicit_location = true;
-
-	 /* This bit of silliness is needed because invalid explicit locations
-	  * are supposed to be flagged during linking.  Small negative values
-	  * biased by VERT_ATTRIB_GENERIC0 or FRAG_RESULT_DATA0 could alias
-	  * built-in values (e.g., -16+VERT_ATTRIB_GENERIC0 = VERT_ATTRIB_POS).
-	  * The linker needs to be able to differentiate these cases.  This
-	  * ensures that negative values stay negative.
-	  */
-	 if (qual->location >= 0) {
-	    var->location = (state->target == vertex_shader)
-	       ? (qual->location + VERT_ATTRIB_GENERIC0)
-	       : (qual->location + FRAG_RESULT_DATA0);
-	 } else {
-	    var->location = qual->location;
-	 }
-      }
-   }
-
-   /* Does the declaration use the 'layout' keyword?
-    */
-   const bool uses_layout = qual->flags.q.pixel_center_integer
-      || qual->flags.q.origin_upper_left
-      || qual->flags.q.explicit_location;
-
-   /* Does the declaration use the deprecated 'attribute' or 'varying'
-    * keywords?
-    */
-   const bool uses_deprecated_qualifier = qual->flags.q.attribute
-      || qual->flags.q.varying;
-
-   /* Is the 'layout' keyword used with parameters that allow relaxed checking.
-    * Many implementations of GL_ARB_fragment_coord_conventions_enable and some
-    * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable
-    * allowed the layout qualifier to be used with 'varying' and 'attribute'.
-    * These extensions and all following extensions that add the 'layout'
-    * keyword have been modified to require the use of 'in' or 'out'.
-    *
-    * The following extension do not allow the deprecated keywords:
-    *
-    *    GL_AMD_conservative_depth
-    *    GL_ARB_gpu_shader5
-    *    GL_ARB_separate_shader_objects
-    *    GL_ARB_tesselation_shader
-    *    GL_ARB_transform_feedback3
-    *    GL_ARB_uniform_buffer_object
-    *
-    * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5
-    * allow layout with the deprecated keywords.
-    */
-   const bool relaxed_layout_qualifier_checking =
-      state->ARB_fragment_coord_conventions_enable;
-
-   if (uses_layout && uses_deprecated_qualifier) {
-      if (relaxed_layout_qualifier_checking) {
-	 _mesa_glsl_warning(loc, state,
-			    "`layout' qualifier may not be used with "
-			    "`attribute' or `varying'");
-      } else {
-	 _mesa_glsl_error(loc, state,
-			  "`layout' qualifier may not be used with "
-			  "`attribute' or `varying'");
-      }
-   }
-
-   /* Layout qualifiers for gl_FragDepth, which are enabled by extension
-    * AMD_conservative_depth.
-    */
-   int depth_layout_count = qual->flags.q.depth_any
-      + qual->flags.q.depth_greater
-      + qual->flags.q.depth_less
-      + qual->flags.q.depth_unchanged;
-   if (depth_layout_count > 0
-       && !state->AMD_conservative_depth_enable) {
-       _mesa_glsl_error(loc, state,
-                        "extension GL_AMD_conservative_depth must be enabled "
-			"to use depth layout qualifiers");
-   } else if (depth_layout_count > 0
-              && strcmp(var->name, "gl_FragDepth") != 0) {
-       _mesa_glsl_error(loc, state,
-                        "depth layout qualifiers can be applied only to "
-                        "gl_FragDepth");
-   } else if (depth_layout_count > 1
-              && strcmp(var->name, "gl_FragDepth") == 0) {
-      _mesa_glsl_error(loc, state,
-                       "at most one depth layout qualifier can be applied to "
-                       "gl_FragDepth");
-   }
-   if (qual->flags.q.depth_any)
-      var->depth_layout = ir_depth_layout_any;
-   else if (qual->flags.q.depth_greater)
-      var->depth_layout = ir_depth_layout_greater;
-   else if (qual->flags.q.depth_less)
-      var->depth_layout = ir_depth_layout_less;
-   else if (qual->flags.q.depth_unchanged)
-       var->depth_layout = ir_depth_layout_unchanged;
-   else
-       var->depth_layout = ir_depth_layout_none;
-
-   if (var->type->is_array() && state->language_version != 110) {
-      var->array_lvalue = true;
-   }
-}
-
-
-ir_rvalue *
-ast_declarator_list::hir(exec_list *instructions,
-			 struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   const struct glsl_type *decl_type;
-   const char *type_name = NULL;
-   ir_rvalue *result = NULL;
-   YYLTYPE loc = this->get_location();
-
-   /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec:
-    *
-    *     "To ensure that a particular output variable is invariant, it is
-    *     necessary to use the invariant qualifier. It can either be used to
-    *     qualify a previously declared variable as being invariant
-    *
-    *         invariant gl_Position; // make existing gl_Position be invariant"
-    *
-    * In these cases the parser will set the 'invariant' flag in the declarator
-    * list, and the type will be NULL.
-    */
-   if (this->invariant) {
-      assert(this->type == NULL);
-
-      if (state->current_function != NULL) {
-	 _mesa_glsl_error(& loc, state,
-			  "All uses of `invariant' keyword must be at global "
-			  "scope\n");
-      }
-
-      foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
-	 assert(!decl->is_array);
-	 assert(decl->array_size == NULL);
-	 assert(decl->initializer == NULL);
-
-	 ir_variable *const earlier =
-	    state->symbols->get_variable(decl->identifier);
-	 if (earlier == NULL) {
-	    _mesa_glsl_error(& loc, state,
-			     "Undeclared variable `%s' cannot be marked "
-			     "invariant\n", decl->identifier);
-	 } else if ((state->target == vertex_shader)
-	       && (earlier->mode != ir_var_out)) {
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, vertex shader "
-			     "outputs only\n", decl->identifier);
-	 } else if ((state->target == fragment_shader)
-	       && (earlier->mode != ir_var_in)) {
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, fragment shader "
-			     "inputs only\n", decl->identifier);
-	 } else if (earlier->used) {
-	    _mesa_glsl_error(& loc, state,
-			     "variable `%s' may not be redeclared "
-			     "`invariant' after being used",
-			     earlier->name);
-	 } else {
-	    earlier->invariant = true;
-	 }
-      }
-
-      /* Invariant redeclarations do not have r-values.
-       */
-      return NULL;
-   }
-
-   assert(this->type != NULL);
-   assert(!this->invariant);
-
-   /* The type specifier may contain a structure definition.  Process that
-    * before any of the variable declarations.
-    */
-   (void) this->type->specifier->hir(instructions, state);
-
-   decl_type = this->type->specifier->glsl_type(& type_name, state);
-   if (this->declarations.is_empty()) {
-      /* The only valid case where the declaration list can be empty is when
-       * the declaration is setting the default precision of a built-in type
-       * (e.g., 'precision highp vec4;').
-       */
-
-      if (decl_type != NULL) {
-      } else {
-	    _mesa_glsl_error(& loc, state, "incomplete declaration");
-      }
-   }
-
-   foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
-      const struct glsl_type *var_type;
-      ir_variable *var;
-
-      /* FINISHME: Emit a warning if a variable declaration shadows a
-       * FINISHME: declaration at a higher scope.
-       */
-
-      if ((decl_type == NULL) || decl_type->is_void()) {
-	 if (type_name != NULL) {
-	    _mesa_glsl_error(& loc, state,
-			     "invalid type `%s' in declaration of `%s'",
-			     type_name, decl->identifier);
-	 } else {
-	    _mesa_glsl_error(& loc, state,
-			     "invalid type in declaration of `%s'",
-			     decl->identifier);
-	 }
-	 continue;
-      }
-
-      if (decl->is_array) {
-	 var_type = process_array_type(&loc, decl_type, decl->array_size,
-				       state);
-      } else {
-	 var_type = decl_type;
-      }
-
-      var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto);
-
-      /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
-       *
-       *     "Global variables can only use the qualifiers const,
-       *     attribute, uni form, or varying. Only one may be
-       *     specified.
-       *
-       *     Local variables can only use the qualifier const."
-       *
-       * This is relaxed in GLSL 1.30.  It is also relaxed by any extension
-       * that adds the 'layout' keyword.
-       */
-      if ((state->language_version < 130)
-	  && !state->ARB_explicit_attrib_location_enable
-	  && !state->ARB_fragment_coord_conventions_enable) {
-	 if (this->type->qualifier.flags.q.out) {
-	    _mesa_glsl_error(& loc, state,
-			     "`out' qualifier in declaration of `%s' "
-			     "only valid for function parameters in %s.",
-			     decl->identifier, state->version_string);
-	 }
-	 if (this->type->qualifier.flags.q.in) {
-	    _mesa_glsl_error(& loc, state,
-			     "`in' qualifier in declaration of `%s' "
-			     "only valid for function parameters in %s.",
-			     decl->identifier, state->version_string);
-	 }
-	 /* FINISHME: Test for other invalid qualifiers. */
-      }
-
-      apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
-				       & loc);
-
-      if (this->type->qualifier.flags.q.invariant) {
-	 if ((state->target == vertex_shader) && !(var->mode == ir_var_out ||
-						   var->mode == ir_var_inout)) {
-	    /* FINISHME: Note that this doesn't work for invariant on
-	     * a function signature outval
-	     */
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, vertex shader "
-			     "outputs only\n", var->name);
-	 } else if ((state->target == fragment_shader) &&
-		    !(var->mode == ir_var_in || var->mode == ir_var_inout)) {
-	    /* FINISHME: Note that this doesn't work for invariant on
-	     * a function signature inval
-	     */
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, fragment shader "
-			     "inputs only\n", var->name);
-	 }
-      }
-
-      if (state->current_function != NULL) {
-	 const char *mode = NULL;
-	 const char *extra = "";
-
-	 /* There is no need to check for 'inout' here because the parser will
-	  * only allow that in function parameter lists.
-	  */
-	 if (this->type->qualifier.flags.q.attribute) {
-	    mode = "attribute";
-	 } else if (this->type->qualifier.flags.q.uniform) {
-	    mode = "uniform";
-	 } else if (this->type->qualifier.flags.q.varying) {
-	    mode = "varying";
-	 } else if (this->type->qualifier.flags.q.in) {
-	    mode = "in";
-	    extra = " or in function parameter list";
-	 } else if (this->type->qualifier.flags.q.out) {
-	    mode = "out";
-	    extra = " or in function parameter list";
-	 }
-
-	 if (mode) {
-	    _mesa_glsl_error(& loc, state,
-			     "%s variable `%s' must be declared at "
-			     "global scope%s",
-			     mode, var->name, extra);
-	 }
-      } else if (var->mode == ir_var_in) {
-         var->read_only = true;
-
-	 if (state->target == vertex_shader) {
-	    bool error_emitted = false;
-
-	    /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
-	     *
-	     *    "Vertex shader inputs can only be float, floating-point
-	     *    vectors, matrices, signed and unsigned integers and integer
-	     *    vectors. Vertex shader inputs can also form arrays of these
-	     *    types, but not structures."
-	     *
-	     * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
-	     *
-	     *    "Vertex shader inputs can only be float, floating-point
-	     *    vectors, matrices, signed and unsigned integers and integer
-	     *    vectors. They cannot be arrays or structures."
-	     *
-	     * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
-	     *
-	     *    "The attribute qualifier can be used only with float,
-	     *    floating-point vectors, and matrices. Attribute variables
-	     *    cannot be declared as arrays or structures."
-	     */
-	    const glsl_type *check_type = var->type->is_array()
-	       ? var->type->fields.array : var->type;
-
-	    switch (check_type->base_type) {
-	    case GLSL_TYPE_FLOAT:
-	       break;
-	    case GLSL_TYPE_UINT:
-	    case GLSL_TYPE_INT:
-	       if (state->language_version > 120)
-		  break;
-	       /* FALLTHROUGH */
-	    default:
-	       _mesa_glsl_error(& loc, state,
-				"vertex shader input / attribute cannot have "
-				"type %s`%s'",
-				var->type->is_array() ? "array of " : "",
-				check_type->name);
-	       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");
-	       error_emitted = true;
-	    }
-	 }
-      }
-
-      /* Integer vertex outputs must be qualified with 'flat'.
-       *
-       * From section 4.3.6 of the GLSL 1.30 spec:
-       *    "If a vertex output is a signed or unsigned integer or integer
-       *    vector, then it must be qualified with the interpolation qualifier
-       *    flat."
-       */
-      if (state->language_version >= 130
-          && state->target == vertex_shader
-          && state->current_function == NULL
-          && var->type->is_integer()
-          && var->mode == ir_var_out
-          && var->interpolation != ir_var_flat) {
-
-         _mesa_glsl_error(&loc, state, "If a vertex output is an integer, "
-                          "then it must be qualified with 'flat'");
-      }
-
-
-      /* Interpolation qualifiers cannot be applied to 'centroid' and
-       * 'centroid varying'.
-       *
-       * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:
-       *    "interpolation qualifiers may only precede the qualifiers in,
-       *    centroid in, out, or centroid out in a declaration. They do not apply
-       *    to the deprecated storage qualifiers varying or centroid varying."
-       */
-      if (state->language_version >= 130
-          && this->type->qualifier.has_interpolation()
-          && this->type->qualifier.flags.q.varying) {
-
-         const char *i = this->type->qualifier.interpolation_string();
-         assert(i != NULL);
-         const char *s;
-         if (this->type->qualifier.flags.q.centroid)
-            s = "centroid varying";
-         else
-            s = "varying";
-
-         _mesa_glsl_error(&loc, state,
-                          "qualifier '%s' cannot be applied to the "
-                          "deprecated storage qualifier '%s'", i, s);
-      }
-
-
-      /* Interpolation qualifiers can only apply to vertex shader outputs and
-       * fragment shader inputs.
-       *
-       * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:
-       *    "Outputs from a vertex shader (out) and inputs to a fragment
-       *    shader (in) can be further qualified with one or more of these
-       *    interpolation qualifiers"
-       */
-      if (state->language_version >= 130
-          && this->type->qualifier.has_interpolation()) {
-
-         const char *i = this->type->qualifier.interpolation_string();
-         assert(i != NULL);
-
-         switch (state->target) {
-         case vertex_shader:
-            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:
-            if (this->type->qualifier.flags.q.out) {
-               _mesa_glsl_error(&loc, state,
-                                "qualifier '%s' cannot be applied to fragment "
-                                "shader outputs", i);
-            }
-            break;
-         default:
-            assert(0);
-         }
-      }
-
-
-      /* From section 4.3.4 of the GLSL 1.30 spec:
-       *    "It is an error to use centroid in in a vertex shader."
-       */
-      if (state->language_version >= 130
-          && this->type->qualifier.flags.q.centroid
-          && this->type->qualifier.flags.q.in
-          && state->target == vertex_shader) {
-
-         _mesa_glsl_error(&loc, state,
-                          "'centroid in' cannot be used in a vertex shader");
-      }
-
-
-      /* 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");
-      }
-
-
-      /* Precision qualifiers only apply to floating point and integer types.
-       *
-       * From section 4.5.2 of the GLSL 1.30 spec:
-       *    "Any floating point or any integer declaration can have the type
-       *    preceded by one of these precision qualifiers [...] Literal
-       *    constants do not have precision qualifiers. Neither do Boolean
-       *    variables.
-       */
-      if (this->type->specifier->precision != ast_precision_none
-          && !var->type->is_float()
-          && !var->type->is_integer()
-          && !(var->type->is_array()
-               && (var->type->fields.array->is_float()
-                   || var->type->fields.array->is_integer()))) {
-
-         _mesa_glsl_error(&loc, state,
-                          "precision qualifiers apply only to floating point "
-                          "and integer types");
-      }
-
-      /* Process the initializer and add its instructions to a temporary
-       * list.  This list will be added to the instruction stream (below) after
-       * the declaration is added.  This is done because in some cases (such as
-       * redeclarations) the declaration may not actually be added to the
-       * instruction stream.
-       */
-      exec_list initializer_instructions;
-      if (decl->initializer != NULL) {
-	 YYLTYPE initializer_loc = decl->initializer->get_location();
-
-	 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:
-	  *
-	  *    "All uniform variables are read-only and are initialized either
-	  *    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->type->is_sampler()) {
-	    _mesa_glsl_error(& initializer_loc, state,
-			     "cannot initialize samplers");
-	 }
-
-	 if ((var->mode == ir_var_in) && (state->current_function == NULL)) {
-	    _mesa_glsl_error(& initializer_loc, state,
-			     "cannot initialize %s shader input / %s",
-			     _mesa_glsl_shader_target_name(state->target),
-			     (state->target == vertex_shader)
-			     ? "attribute" : "varying");
-	 }
-
-	 ir_dereference *const lhs = new(ctx) ir_dereference_variable(var);
-	 ir_rvalue *rhs = decl->initializer->hir(&initializer_instructions,
-						 state);
-
-	 /* Calculate the constant value if this is a const or uniform
-	  * declaration.
-	  */
-	 if (this->type->qualifier.flags.q.constant
-	     || this->type->qualifier.flags.q.uniform) {
-	    ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs);
-	    if (new_rhs != NULL) {
-	       rhs = new_rhs;
-
-	       ir_constant *constant_value = rhs->constant_expression_value();
-	       if (!constant_value) {
-		  _mesa_glsl_error(& initializer_loc, state,
-				   "initializer of %s variable `%s' must be a "
-				   "constant expression",
-				   (this->type->qualifier.flags.q.constant)
-				   ? "const" : "uniform",
-				   decl->identifier);
-		  if (var->type->is_numeric()) {
-		     /* Reduce cascading errors. */
-		     var->constant_value = ir_constant::zero(ctx, var->type);
-		  }
-	       } else {
-		  rhs = constant_value;
-		  var->constant_value = constant_value;
-	       }
-	    } else {
-	       _mesa_glsl_error(&initializer_loc, state,
-			        "initializer of type %s cannot be assigned to "
-				"variable of type %s",
-				rhs->type->name, var->type->name);
-	       if (var->type->is_numeric()) {
-		  /* Reduce cascading errors. */
-		  var->constant_value = ir_constant::zero(ctx, var->type);
-	       }
-	    }
-	 }
-
-	 if (rhs && !rhs->type->is_error()) {
-	    bool temp = var->read_only;
-	    if (this->type->qualifier.flags.q.constant)
-	       var->read_only = false;
-
-	    /* Never emit code to initialize a uniform.
-	     */
-	    const glsl_type *initializer_type;
-	    if (!this->type->qualifier.flags.q.uniform) {
-	       result = do_assignment(&initializer_instructions, state,
-				      lhs, rhs,
-				      this->get_location());
-	       initializer_type = result->type;
-	    } else
-	       initializer_type = rhs->type;
-
-	    /* If the declared variable is an unsized array, it must inherrit
-	     * its full type from the initializer.  A declaration such as
-	     *
-	     *     uniform float a[] = float[](1.0, 2.0, 3.0, 3.0);
-	     *
-	     * becomes
-	     *
-	     *     uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0);
-	     *
-	     * The assignment generated in the if-statement (below) will also
-	     * automatically handle this case for non-uniforms.
-	     *
-	     * If the declared variable is not an array, the types must
-	     * already match exactly.  As a result, the type assignment
-	     * here can be done unconditionally.  For non-uniforms the call
-	     * to do_assignment can change the type of the initializer (via
-	     * the implicit conversion rules).  For uniforms the initializer
-	     * must be a constant expression, and the type of that expression
-	     * was validated above.
-	     */
-	    var->type = initializer_type;
-
-	    var->read_only = temp;
-	 }
-      }
-
-      /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:
-       *
-       *     "It is an error to write to a const variable outside of
-       *      its declaration, so they must be initialized when
-       *      declared."
-       */
-      if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {
-	 _mesa_glsl_error(& loc, state,
-			  "const declaration of `%s' must be initialized",
-			  decl->identifier);
-      }
-
-      /* Check if this declaration is actually a re-declaration, either to
-       * resize an array or add qualifiers to an existing variable.
-       *
-       * This is allowed for variables in the current scope, or when at
-       * global scope (for built-ins in the implicit outer scope).
-       */
-      ir_variable *earlier = state->symbols->get_variable(decl->identifier);
-      if (earlier != NULL && (state->current_function == NULL ||
-	  state->symbols->name_declared_this_scope(decl->identifier))) {
-
-	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec,
-	  *
-	  * "It is legal to declare an array without a size and then
-	  *  later re-declare the same name as an array of the same
-	  *  type and specify a size."
-	  */
-	 if ((earlier->type->array_size() == 0)
-	     && var->type->is_array()
-	     && (var->type->element_type() == earlier->type->element_type())) {
-	    /* FINISHME: This doesn't match the qualifiers on the two
-	     * FINISHME: declarations.  It's not 100% clear whether this is
-	     * FINISHME: required or not.
-	     */
-
-	    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
-	     *
-	     *     "The size [of gl_TexCoord] can be at most
-	     *     gl_MaxTextureCoords."
-	     */
-	    const unsigned size = unsigned(var->type->array_size());
-	    if ((strcmp("gl_TexCoord", var->name) == 0)
-		&& (size > state->Const.MaxTextureCoords)) {
-	       YYLTYPE loc = this->get_location();
-
-	       _mesa_glsl_error(& loc, state, "`gl_TexCoord' array size cannot "
-				"be larger than gl_MaxTextureCoords (%u)\n",
-				state->Const.MaxTextureCoords);
-	    } else if ((size > 0) && (size <= earlier->max_array_access)) {
-	       YYLTYPE loc = this->get_location();
-
-	       _mesa_glsl_error(& loc, state, "array size must be > %u due to "
-				"previous access",
-				earlier->max_array_access);
-	    }
-
-	    earlier->type = var->type;
-	    delete var;
-	    var = NULL;
-	 } else if (state->ARB_fragment_coord_conventions_enable
-		    && strcmp(var->name, "gl_FragCoord") == 0
-		    && earlier->type == var->type
-		    && earlier->mode == var->mode) {
-	    /* Allow redeclaration of gl_FragCoord for ARB_fcc layout
-	     * qualifiers.
-	     */
-	    earlier->origin_upper_left = var->origin_upper_left;
-	    earlier->pixel_center_integer = var->pixel_center_integer;
-
-	 /* According to section 4.3.7 of the GLSL 1.30 spec,
-	  * the following built-in varaibles can be redeclared with an
-	  * interpolation qualifier:
-	  *    * gl_FrontColor
-	  *    * gl_BackColor
-	  *    * gl_FrontSecondaryColor
-	  *    * gl_BackSecondaryColor
-	  *    * gl_Color
-	  *    * gl_SecondaryColor
-	  */
-	 } else if (state->language_version >= 130
-	            && (strcmp(var->name, "gl_FrontColor") == 0
-                        || strcmp(var->name, "gl_BackColor") == 0
-                        || strcmp(var->name, "gl_FrontSecondaryColor") == 0
-                        || strcmp(var->name, "gl_BackSecondaryColor") == 0
-                        || strcmp(var->name, "gl_Color") == 0
-                        || strcmp(var->name, "gl_SecondaryColor") == 0)
-	            && earlier->type == var->type
-	            && earlier->mode == var->mode) {
-	    earlier->interpolation = var->interpolation;
-
-         /* Layout qualifiers for gl_FragDepth. */
-         } else if (state->AMD_conservative_depth_enable
-                    && strcmp(var->name, "gl_FragDepth") == 0
-                    && earlier->type == var->type
-                    && earlier->mode == var->mode) {
-
-            /** From the AMD_conservative_depth spec:
-             *     Within any shader, the first redeclarations of gl_FragDepth
-             *     must appear before any use of gl_FragDepth.
-             */
-            if (earlier->used) {
-               _mesa_glsl_error(&loc, state,
-                                "the first redeclaration of gl_FragDepth "
-                                "must appear before any use of gl_FragDepth");
-            }
-
-            /* Prevent inconsistent redeclaration of depth layout qualifier. */
-            if (earlier->depth_layout != ir_depth_layout_none
-                && earlier->depth_layout != var->depth_layout) {
-               _mesa_glsl_error(&loc, state,
-                                "gl_FragDepth: depth layout is declared here "
-                                "as '%s, but it was previously declared as "
-                                "'%s'",
-                                depth_layout_string(var->depth_layout),
-                                depth_layout_string(earlier->depth_layout));
-            }
-
-            earlier->depth_layout = var->depth_layout;
-
-	 } else {
-	    YYLTYPE loc = this->get_location();
-	    _mesa_glsl_error(&loc, state, "`%s' redeclared", decl->identifier);
-	 }
-
-	 continue;
-      }
-
-      /* By now, we know it's a new variable declaration (we didn't hit the
-       * above "continue").
-       *
-       * From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
-       *
-       *   "Identifiers starting with "gl_" are reserved for use by
-       *   OpenGL, and may not be declared in a shader as either a
-       *   variable or a function."
-       */
-      if (strncmp(decl->identifier, "gl_", 3) == 0)
-	 _mesa_glsl_error(& loc, state,
-			  "identifier `%s' uses reserved `gl_' prefix",
-			  decl->identifier);
-
-      /* Add the variable to the symbol table.  Note that the initializer's
-       * IR was already processed earlier (though it hasn't been emitted yet),
-       * without the variable in scope.
-       *
-       * This differs from most C-like languages, but it follows the GLSL
-       * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50
-       * spec:
-       *
-       *     "Within a declaration, the scope of a name starts immediately
-       *     after the initializer if present or immediately after the name
-       *     being declared if not."
-       */
-      if (!state->symbols->add_variable(var)) {
-	 YYLTYPE loc = this->get_location();
-	 _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
-			  "current scope", decl->identifier);
-	 continue;
-      }
-
-      /* Push the variable declaration to the top.  It means that all
-       * the variable declarations will appear in a funny
-       * last-to-first order, but otherwise we run into trouble if a
-       * function is prototyped, a global var is decled, then the
-       * function is defined with usage of the global var.  See
-       * glslparsertest's CorrectModule.frag.
-       */
-      instructions->push_head(var);
-      instructions->append_list(&initializer_instructions);
-   }
-
-
-   /* Generally, variable declarations do not have r-values.  However,
-    * one is used for the declaration in
-    *
-    * while (bool b = some_condition()) {
-    *   ...
-    * }
-    *
-    * so we return the rvalue from the last seen declaration here.
-    */
-   return result;
-}
-
-
-ir_rvalue *
-ast_parameter_declarator::hir(exec_list *instructions,
-			      struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   const struct glsl_type *type;
-   const char *name = NULL;
-   YYLTYPE loc = this->get_location();
-
-   type = this->type->specifier->glsl_type(& name, state);
-
-   if (type == NULL) {
-      if (name != NULL) {
-	 _mesa_glsl_error(& loc, state,
-			  "invalid type `%s' in declaration of `%s'",
-			  name, this->identifier);
-      } else {
-	 _mesa_glsl_error(& loc, state,
-			  "invalid type in declaration of `%s'",
-			  this->identifier);
-      }
-
-      type = glsl_type::error_type;
-   }
-
-   /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec:
-    *
-    *    "Functions that accept no input arguments need not use void in the
-    *    argument list because prototypes (or definitions) are required and
-    *    therefore there is no ambiguity when an empty argument list "( )" is
-    *    declared. The idiom "(void)" as a parameter list is provided for
-    *    convenience."
-    *
-    * Placing this check here prevents a void parameter being set up
-    * for a function, which avoids tripping up checks for main taking
-    * parameters and lookups of an unnamed symbol.
-    */
-   if (type->is_void()) {
-      if (this->identifier != NULL)
-	 _mesa_glsl_error(& loc, state,
-			  "named parameter cannot have type `void'");
-
-      is_void = true;
-      return NULL;
-   }
-
-   if (formal_parameter && (this->identifier == NULL)) {
-      _mesa_glsl_error(& loc, state, "formal parameter lacks a name");
-      return NULL;
-   }
-
-   /* This only handles "vec4 foo[..]".  The earlier specifier->glsl_type(...)
-    * call already handled the "vec4[..] foo" case.
-    */
-   if (this->is_array) {
-      type = process_array_type(&loc, type, this->array_size, state);
-   }
-
-   if (type->array_size() == 0) {
-      _mesa_glsl_error(&loc, state, "arrays passed as parameters must have "
-		       "a declared size.");
-      type = glsl_type::error_type;
-   }
-
-   is_void = false;
-   ir_variable *var = new(ctx) ir_variable(type, this->identifier, ir_var_in);
-
-   /* Apply any specified qualifiers to the parameter declaration.  Note that
-    * for function parameters the default mode is 'in'.
-    */
-   apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc);
-
-   instructions->push_tail(var);
-
-   /* Parameter declarations do not have r-values.
-    */
-   return NULL;
-}
-
-
-void
-ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
-					    bool formal,
-					    exec_list *ir_parameters,
-					    _mesa_glsl_parse_state *state)
-{
-   ast_parameter_declarator *void_param = NULL;
-   unsigned count = 0;
-
-   foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters) {
-      param->formal_parameter = formal;
-      param->hir(ir_parameters, state);
-
-      if (param->is_void)
-	 void_param = param;
-
-      count++;
-   }
-
-   if ((void_param != NULL) && (count > 1)) {
-      YYLTYPE loc = void_param->get_location();
-
-      _mesa_glsl_error(& loc, state,
-		       "`void' parameter must be only parameter");
-   }
-}
-
-
-void
-emit_function(_mesa_glsl_parse_state *state, exec_list *instructions,
-	      ir_function *f)
-{
-   /* Emit the new function header */
-   if (state->current_function == NULL) {
-      instructions->push_tail(f);
-   } else {
-      /* IR invariants disallow function declarations or definitions nested
-       * within other function definitions.  Insert the new ir_function
-       * block in the instruction sequence before the ir_function block
-       * containing the current ir_function_signature.
-       */
-      ir_function *const curr =
-	 const_cast<ir_function *>(state->current_function->function());
-
-      curr->insert_before(f);
-   }
-}
-
-
-ir_rvalue *
-ast_function::hir(exec_list *instructions,
-		  struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   ir_function *f = NULL;
-   ir_function_signature *sig = NULL;
-   exec_list hir_parameters;
-
-   const char *const name = identifier;
-
-   /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec,
-    *
-    *   "Function declarations (prototypes) cannot occur inside of functions;
-    *   they must be at global scope, or for the built-in functions, outside
-    *   the global scope."
-    *
-    * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec,
-    *
-    *   "User defined functions may only be defined within the global scope."
-    *
-    * Note that this language does not appear in GLSL 1.10.
-    */
-   if ((state->current_function != NULL) && (state->language_version != 110)) {
-      YYLTYPE loc = this->get_location();
-      _mesa_glsl_error(&loc, state,
-		       "declaration of function `%s' not allowed within "
-		       "function body", name);
-   }
-
-   /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
-    *
-    *   "Identifiers starting with "gl_" are reserved for use by
-    *   OpenGL, and may not be declared in a shader as either a
-    *   variable or a function."
-    */
-   if (strncmp(name, "gl_", 3) == 0) {
-      YYLTYPE loc = this->get_location();
-      _mesa_glsl_error(&loc, state,
-		       "identifier `%s' uses reserved `gl_' prefix", name);
-   }
-
-   /* Convert the list of function parameters to HIR now so that they can be
-    * used below to compare this function's signature with previously seen
-    * signatures for functions with the same name.
-    */
-   ast_parameter_declarator::parameters_to_hir(& this->parameters,
-					       is_definition,
-					       & hir_parameters, state);
-
-   const char *return_type_name;
-   const glsl_type *return_type =
-      this->return_type->specifier->glsl_type(& return_type_name, state);
-
-   if (!return_type) {
-      YYLTYPE loc = this->get_location();
-      _mesa_glsl_error(&loc, state,
-		       "function `%s' has undeclared return type `%s'",
-		       name, return_type_name);
-      return_type = glsl_type::error_type;
-   }
-
-   /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec:
-    * "No qualifier is allowed on the return type of a function."
-    */
-   if (this->return_type->has_qualifiers()) {
-      YYLTYPE loc = this->get_location();
-      _mesa_glsl_error(& loc, state,
-		       "function `%s' return type has qualifiers", name);
-   }
-
-   /* Verify that this function's signature either doesn't match a previously
-    * seen signature for a function with the same name, or, if a match is found,
-    * that the previously seen signature does not have an associated definition.
-    */
-   f = state->symbols->get_function(name);
-   if (f != NULL && (state->es_shader || f->has_user_signature())) {
-      sig = f->exact_matching_signature(&hir_parameters);
-      if (sig != NULL) {
-	 const char *badvar = sig->qualifiers_match(&hir_parameters);
-	 if (badvar != NULL) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
-			     "qualifiers don't match prototype", name, badvar);
-	 }
-
-	 if (sig->return_type != return_type) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
-			     "match prototype", name);
-	 }
-
-	 if (is_definition && sig->is_defined) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(& loc, state, "function `%s' redefined", name);
-	 }
-      }
-   } else {
-      f = new(ctx) ir_function(name);
-      if (!state->symbols->add_function(f)) {
-	 /* This function name shadows a non-function use of the same name. */
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
-			  "non-function", name);
-	 return NULL;
-      }
-
-      emit_function(state, instructions, f);
-   }
-
-   /* Verify the return type of main() */
-   if (strcmp(name, "main") == 0) {
-      if (! return_type->is_void()) {
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(& loc, state, "main() must return void");
-      }
-
-      if (!hir_parameters.is_empty()) {
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(& loc, state, "main() must not take any parameters");
-      }
-   }
-
-   /* Finish storing the information about this new function in its signature.
-    */
-   if (sig == NULL) {
-      sig = new(ctx) ir_function_signature(return_type);
-      f->add_signature(sig);
-   }
-
-   sig->replace_parameters(&hir_parameters);
-   signature = sig;
-
-   /* Function declarations (prototypes) do not have r-values.
-    */
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_function_definition::hir(exec_list *instructions,
-			     struct _mesa_glsl_parse_state *state)
-{
-   prototype->is_definition = true;
-   prototype->hir(instructions, state);
-
-   ir_function_signature *signature = prototype->signature;
-   if (signature == NULL)
-      return NULL;
-
-   assert(state->current_function == NULL);
-   state->current_function = signature;
-   state->found_return = false;
-
-   /* Duplicate parameters declared in the prototype as concrete variables.
-    * Add these to the symbol table.
-    */
-   state->symbols->push_scope();
-   foreach_iter(exec_list_iterator, iter, signature->parameters) {
-      ir_variable *const var = ((ir_instruction *) iter.get())->as_variable();
-
-      assert(var != NULL);
-
-      /* The only way a parameter would "exist" is if two parameters have
-       * the same name.
-       */
-      if (state->symbols->name_declared_this_scope(var->name)) {
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
-      } else {
-	 state->symbols->add_variable(var);
-      }
-   }
-
-   /* Convert the body of the function to HIR. */
-   this->body->hir(&signature->body, state);
-   signature->is_defined = true;
-
-   state->symbols->pop_scope();
-
-   assert(state->current_function == signature);
-   state->current_function = NULL;
-
-   if (!signature->return_type->is_void() && !state->found_return) {
-      YYLTYPE loc = this->get_location();
-      _mesa_glsl_error(& loc, state, "function `%s' has non-void return type "
-		       "%s, but no return statement",
-		       signature->function_name(),
-		       signature->return_type->name);
-   }
-
-   /* Function definitions do not have r-values.
-    */
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_jump_statement::hir(exec_list *instructions,
-			struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-
-   switch (mode) {
-   case ast_return: {
-      ir_return *inst;
-      assert(state->current_function);
-
-      if (opt_return_value) {
-	 ir_rvalue *const ret = opt_return_value->hir(instructions, state);
-
-	 /* The value of the return type can be NULL if the shader says
-	  * 'return foo();' and foo() is a function that returns void.
-	  *
-	  * NOTE: The GLSL spec doesn't say that this is an error.  The type
-	  * of the return value is void.  If the return type of the function is
-	  * also void, then this should compile without error.  Seriously.
-	  */
-	 const glsl_type *const ret_type =
-	    (ret == NULL) ? glsl_type::void_type : ret->type;
-
-	 /* Implicit conversions are not allowed for return values. */
-	 if (state->current_function->return_type != ret_type) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(& loc, state,
-			     "`return' with wrong type %s, in function `%s' "
-			     "returning %s",
-			     ret_type->name,
-			     state->current_function->function_name(),
-			     state->current_function->return_type->name);
-	 }
-
-	 inst = new(ctx) ir_return(ret);
-      } else {
-	 if (state->current_function->return_type->base_type !=
-	     GLSL_TYPE_VOID) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(& loc, state,
-			     "`return' with no value, in function %s returning "
-			     "non-void",
-			     state->current_function->function_name());
-	 }
-	 inst = new(ctx) ir_return;
-      }
-
-      state->found_return = true;
-      instructions->push_tail(inst);
-      break;
-   }
-
-   case ast_discard:
-      if (state->target != fragment_shader) {
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(& loc, state,
-			  "`discard' may only appear in a fragment shader");
-      }
-      instructions->push_tail(new(ctx) ir_discard);
-      break;
-
-   case ast_break:
-   case ast_continue:
-      /* FINISHME: Handle switch-statements.  They cannot contain 'continue',
-       * FINISHME: and they use a different IR instruction for 'break'.
-       */
-      /* FINISHME: Correctly handle the nesting.  If a switch-statement is
-       * FINISHME: inside a loop, a 'continue' is valid and will bind to the
-       * FINISHME: loop.
-       */
-      if (state->loop_or_switch_nesting == NULL) {
-	 YYLTYPE loc = this->get_location();
-
-	 _mesa_glsl_error(& loc, state,
-			  "`%s' may only appear in a loop",
-			  (mode == ast_break) ? "break" : "continue");
-      } else {
-	 ir_loop *const loop = state->loop_or_switch_nesting->as_loop();
-
-	 /* Inline the for loop expression again, since we don't know
-	  * where near the end of the loop body the normal copy of it
-	  * is going to be placed.
-	  */
-	 if (mode == ast_continue &&
-	     state->loop_or_switch_nesting_ast->rest_expression) {
-	    state->loop_or_switch_nesting_ast->rest_expression->hir(instructions,
-								    state);
-	 }
-
-	 if (loop != NULL) {
-	    ir_loop_jump *const jump =
-	       new(ctx) ir_loop_jump((mode == ast_break)
-				     ? ir_loop_jump::jump_break
-				     : ir_loop_jump::jump_continue);
-	    instructions->push_tail(jump);
-	 }
-      }
-
-      break;
-   }
-
-   /* Jump instructions do not have r-values.
-    */
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_selection_statement::hir(exec_list *instructions,
-			     struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-
-   ir_rvalue *const condition = this->condition->hir(instructions, state);
-
-   /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec:
-    *
-    *    "Any expression whose type evaluates to a Boolean can be used as the
-    *    conditional expression bool-expression. Vector types are not accepted
-    *    as the expression to if."
-    *
-    * The checks are separated so that higher quality diagnostics can be
-    * generated for cases where both rules are violated.
-    */
-   if (!condition->type->is_boolean() || !condition->type->is_scalar()) {
-      YYLTYPE loc = this->condition->get_location();
-
-      _mesa_glsl_error(& loc, state, "if-statement condition must be scalar "
-		       "boolean");
-   }
-
-   ir_if *const stmt = new(ctx) ir_if(condition);
-
-   if (then_statement != NULL) {
-      state->symbols->push_scope();
-      then_statement->hir(& stmt->then_instructions, state);
-      state->symbols->pop_scope();
-   }
-
-   if (else_statement != NULL) {
-      state->symbols->push_scope();
-      else_statement->hir(& stmt->else_instructions, state);
-      state->symbols->pop_scope();
-   }
-
-   instructions->push_tail(stmt);
-
-   /* if-statements do not have r-values.
-    */
-   return NULL;
-}
-
-
-void
-ast_iteration_statement::condition_to_hir(ir_loop *stmt,
-					  struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-
-   if (condition != NULL) {
-      ir_rvalue *const cond =
-	 condition->hir(& stmt->body_instructions, state);
-
-      if ((cond == NULL)
-	  || !cond->type->is_boolean() || !cond->type->is_scalar()) {
-	 YYLTYPE loc = condition->get_location();
-
-	 _mesa_glsl_error(& loc, state,
-			  "loop condition must be scalar boolean");
-      } else {
-	 /* As the first code in the loop body, generate a block that looks
-	  * like 'if (!condition) break;' as the loop termination condition.
-	  */
-	 ir_rvalue *const not_cond =
-	    new(ctx) ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond,
-				   NULL);
-
-	 ir_if *const if_stmt = new(ctx) ir_if(not_cond);
-
-	 ir_jump *const break_stmt =
-	    new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
-
-	 if_stmt->then_instructions.push_tail(break_stmt);
-	 stmt->body_instructions.push_tail(if_stmt);
-      }
-   }
-}
-
-
-ir_rvalue *
-ast_iteration_statement::hir(exec_list *instructions,
-			     struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-
-   /* For-loops and while-loops start a new scope, but do-while loops do not.
-    */
-   if (mode != ast_do_while)
-      state->symbols->push_scope();
-
-   if (init_statement != NULL)
-      init_statement->hir(instructions, state);
-
-   ir_loop *const stmt = new(ctx) ir_loop();
-   instructions->push_tail(stmt);
-
-   /* Track the current loop and / or switch-statement nesting.
-    */
-   ir_instruction *const nesting = state->loop_or_switch_nesting;
-   ast_iteration_statement *nesting_ast = state->loop_or_switch_nesting_ast;
-
-   state->loop_or_switch_nesting = stmt;
-   state->loop_or_switch_nesting_ast = this;
-
-   if (mode != ast_do_while)
-      condition_to_hir(stmt, state);
-
-   if (body != NULL)
-      body->hir(& stmt->body_instructions, state);
-
-   if (rest_expression != NULL)
-      rest_expression->hir(& stmt->body_instructions, state);
-
-   if (mode == ast_do_while)
-      condition_to_hir(stmt, state);
-
-   if (mode != ast_do_while)
-      state->symbols->pop_scope();
-
-   /* Restore previous nesting before returning.
-    */
-   state->loop_or_switch_nesting = nesting;
-   state->loop_or_switch_nesting_ast = nesting_ast;
-
-   /* Loops do not have r-values.
-    */
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_type_specifier::hir(exec_list *instructions,
-			  struct _mesa_glsl_parse_state *state)
-{
-   if (!this->is_precision_statement && this->structure == NULL)
-      return NULL;
-
-   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");
-      return NULL;
-   }
-   if (this->precision != ast_precision_none
-       && this->structure != NULL) {
-      _mesa_glsl_error(&loc, state,
-                       "precision qualifiers do not apply to structures");
-      return NULL;
-   }
-
-   /* If this is a precision statement, check that the type to which it is
-    * applied is either float or int.
-    *
-    * From section 4.5.3 of the GLSL 1.30 spec:
-    *    "The precision statement
-    *       precision precision-qualifier type;
-    *    can be used to establish a default precision qualifier. The type
-    *    field can be either int or float [...].  Any other types or
-    *    qualifiers will result in an error.
-    */
-   if (this->is_precision_statement) {
-      assert(this->precision != ast_precision_none);
-      assert(this->structure == NULL); /* The check for structures was
-                                        * performed above. */
-      if (this->is_array) {
-         _mesa_glsl_error(&loc, state,
-                          "default precision statements do not apply to "
-                          "arrays");
-         return NULL;
-      }
-      if (this->type_specifier != ast_float
-          && this->type_specifier != ast_int) {
-         _mesa_glsl_error(&loc, state,
-                          "default precision statements apply only to types "
-                          "float and int");
-         return NULL;
-      }
-
-      /* FINISHME: Translate precision statements into IR. */
-      return NULL;
-   }
-
-   if (this->structure != NULL)
-      return this->structure->hir(instructions, state);
-
-   return NULL;
-}
-
-
-ir_rvalue *
-ast_struct_specifier::hir(exec_list *instructions,
-			  struct _mesa_glsl_parse_state *state)
-{
-   unsigned decl_count = 0;
-
-   /* Make an initial pass over the list of structure fields to determine how
-    * many there are.  Each element in this list is an ast_declarator_list.
-    * This means that we actually need to count the number of elements in the
-    * 'declarations' list in each of the elements.
-    */
-   foreach_list_typed (ast_declarator_list, decl_list, link,
-		       &this->declarations) {
-      foreach_list_const (decl_ptr, & decl_list->declarations) {
-	 decl_count++;
-      }
-   }
-
-   /* Allocate storage for the structure fields and process the field
-    * declarations.  As the declarations are processed, try to also convert
-    * the types to HIR.  This ensures that structure definitions embedded in
-    * other structure definitions are processed.
-    */
-   glsl_struct_field *const fields = ralloc_array(state, glsl_struct_field,
-						  decl_count);
-
-   unsigned i = 0;
-   foreach_list_typed (ast_declarator_list, decl_list, link,
-		       &this->declarations) {
-      const char *type_name;
-
-      decl_list->type->specifier->hir(instructions, state);
-
-      /* Section 10.9 of the GLSL ES 1.00 specification states that
-       * embedded structure definitions have been removed from the language.
-       */
-      if (state->es_shader && decl_list->type->specifier->structure != NULL) {
-	 YYLTYPE loc = this->get_location();
-	 _mesa_glsl_error(&loc, state, "Embedded structure definitions are "
-			  "not allowed in GLSL ES 1.00.");
-      }
-
-      const glsl_type *decl_type =
-	 decl_list->type->specifier->glsl_type(& type_name, state);
-
-      foreach_list_typed (ast_declaration, decl, link,
-			  &decl_list->declarations) {
-	 const struct glsl_type *field_type = decl_type;
-	 if (decl->is_array) {
-	    YYLTYPE loc = decl->get_location();
-	    field_type = process_array_type(&loc, decl_type, decl->array_size,
-					    state);
-	 }
-	 fields[i].type = (field_type != NULL)
-	    ? field_type : glsl_type::error_type;
-	 fields[i].name = decl->identifier;
-	 i++;
-      }
-   }
-
-   assert(i == decl_count);
-
-   const glsl_type *t =
-      glsl_type::get_record_instance(fields, decl_count, this->name);
-
-   YYLTYPE loc = this->get_location();
-   if (!state->symbols->add_type(name, t)) {
-      _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name);
-   } else {
-      const glsl_type **s = reralloc(state, state->user_structures,
-				     const glsl_type *,
-				     state->num_user_structures + 1);
-      if (s != NULL) {
-	 s[state->num_user_structures] = t;
-	 state->user_structures = s;
-	 state->num_user_structures++;
-      }
-   }
-
-   /* Structure type definitions do not have r-values.
-    */
-   return NULL;
-}
+/*

+ * Copyright © 2010 Intel Corporation

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ */

+

+/**

+ * \file ast_to_hir.c

+ * Convert abstract syntax to to high-level intermediate reprensentation (HIR).

+ *

+ * During the conversion to HIR, the majority of the symantic checking is

+ * preformed on the program.  This includes:

+ *

+ *    * Symbol table management

+ *    * Type checking

+ *    * Function binding

+ *

+ * The majority of this work could be done during parsing, and the parser could

+ * probably generate HIR directly.  However, this results in frequent changes

+ * to the parser code.  Since we do not assume that every system this complier

+ * is built on will have Flex and Bison installed, we have to store the code

+ * generated by these tools in our version control system.  In other parts of

+ * the system we've seen problems where a parser was changed but the generated

+ * code was not committed, merge conflicts where created because two developers

+ * had slightly different versions of Bison installed, etc.

+ *

+ * I have also noticed that running Bison generated parsers in GDB is very

+ * irritating.  When you get a segfault on '$$ = $1->foo', you can't very

+ * well 'print $1' in GDB.

+ *

+ * As a result, my preference is to put as little C code as possible in the

+ * parser (and lexer) sources.

+ */

+

+#include "main/core.h" /* for struct gl_extensions */

+#include "glsl_symbol_table.h"

+#include "glsl_parser_extras.h"

+#include "ast.h"

+#include "glsl_types.h"

+#include "ir.h"

+

+void

+_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)

+{

+   _mesa_glsl_initialize_variables(instructions, state);

+   _mesa_glsl_initialize_functions(state);

+

+   state->symbols->language_version = state->language_version;

+

+   state->current_function = NULL;

+

+   /* Section 4.2 of the GLSL 1.20 specification states:

+    * "The built-in functions are scoped in a scope outside the global scope

+    *  users declare global variables in.  That is, a shader's global scope,

+    *  available for user-defined functions and global variables, is nested

+    *  inside the scope containing the built-in functions."

+    *

+    * Since built-in functions like ftransform() access built-in variables,

+    * it follows that those must be in the outer scope as well.

+    *

+    * We push scope here to create this nesting effect...but don't pop.

+    * This way, a shader's globals are still in the symbol table for use

+    * by the linker.

+    */

+   state->symbols->push_scope();

+

+   foreach_list_typed (ast_node, ast, link, & state->translation_unit)

+      ast->hir(instructions, state);

+}

+

+

+/**

+ * If a conversion is available, convert one operand to a different type

+ *

+ * The \c from \c ir_rvalue is converted "in place".

+ *

+ * \param to     Type that the operand it to be converted to

+ * \param from   Operand that is being converted

+ * \param state  GLSL compiler state

+ *

+ * \return

+ * If a conversion is possible (or unnecessary), \c true is returned.

+ * Otherwise \c false is returned.

+ */

+bool

+apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,

+			  struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+   if (to->base_type == from->type->base_type)

+      return true;

+

+   /* This conversion was added in GLSL 1.20.  If the compilation mode is

+    * GLSL 1.10, the conversion is skipped.

+    */

+   if (state->language_version < 120)

+      return false;

+

+   /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:

+    *

+    *    "There are no implicit array or structure conversions. For

+    *    example, an array of int cannot be implicitly converted to an

+    *    array of float. There are no implicit conversions between

+    *    signed and unsigned integers."

+    */

+   /* FINISHME: The above comment is partially a lie.  There is int/uint

+    * FINISHME: conversion for immediate constants.

+    */

+   if (!to->is_float() || !from->type->is_numeric())

+      return false;

+

+   /* Convert to a floating point type with the same number of components

+    * as the original type - i.e. int to float, not int to vec4.

+    */

+   to = glsl_type::get_instance(GLSL_TYPE_FLOAT, from->type->vector_elements,

+			        from->type->matrix_columns);

+

+   switch (from->type->base_type) {

+   case GLSL_TYPE_INT:

+      from = new(ctx) ir_expression(ir_unop_i2f, to, from, NULL);

+      break;

+   case GLSL_TYPE_UINT:

+      from = new(ctx) ir_expression(ir_unop_u2f, to, from, NULL);

+      break;

+   case GLSL_TYPE_BOOL:

+      from = new(ctx) ir_expression(ir_unop_b2f, to, from, NULL);

+      break;

+   default:

+      assert(0);

+   }

+

+   return true;

+}

+

+

+static const struct glsl_type *

+arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,

+		       bool multiply,

+		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)

+{

+   const glsl_type *type_a = value_a->type;

+   const glsl_type *type_b = value_b->type;

+

+   /* From GLSL 1.50 spec, page 56:

+    *

+    *    "The arithmetic binary operators add (+), subtract (-),

+    *    multiply (*), and divide (/) operate on integer and

+    *    floating-point scalars, vectors, and matrices."

+    */

+   if (!type_a->is_numeric() || !type_b->is_numeric()) {

+      _mesa_glsl_error(loc, state,

+		       "Operands to arithmetic operators must be numeric");

+      return glsl_type::error_type;

+   }

+

+

+   /*    "If one operand is floating-point based and the other is

+    *    not, then the conversions from Section 4.1.10 "Implicit

+    *    Conversions" are applied to the non-floating-point-based operand."

+    */

+   if (!apply_implicit_conversion(type_a, value_b, state)

+       && !apply_implicit_conversion(type_b, value_a, state)) {

+      _mesa_glsl_error(loc, state,

+		       "Could not implicitly convert operands to "

+		       "arithmetic operator");

+      return glsl_type::error_type;

+   }

+   type_a = value_a->type;

+   type_b = value_b->type;

+

+   /*    "If the operands are integer types, they must both be signed or

+    *    both be unsigned."

+    *

+    * From this rule and the preceeding conversion it can be inferred that

+    * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.

+    * The is_numeric check above already filtered out the case where either

+    * type is not one of these, so now the base types need only be tested for

+    * equality.

+    */

+   if (type_a->base_type != type_b->base_type) {

+      _mesa_glsl_error(loc, state,

+		       "base type mismatch for arithmetic operator");

+      return glsl_type::error_type;

+   }

+

+   /*    "All arithmetic binary operators result in the same fundamental type

+    *    (signed integer, unsigned integer, or floating-point) as the

+    *    operands they operate on, after operand type conversion. After

+    *    conversion, the following cases are valid

+    *

+    *    * The two operands are scalars. In this case the operation is

+    *      applied, resulting in a scalar."

+    */

+   if (type_a->is_scalar() && type_b->is_scalar())

+      return type_a;

+

+   /*   "* One operand is a scalar, and the other is a vector or matrix.

+    *      In this case, the scalar operation is applied independently to each

+    *      component of the vector or matrix, resulting in the same size

+    *      vector or matrix."

+    */

+   if (type_a->is_scalar()) {

+      if (!type_b->is_scalar())

+	 return type_b;

+   } else if (type_b->is_scalar()) {

+      return type_a;

+   }

+

+   /* All of the combinations of <scalar, scalar>, <vector, scalar>,

+    * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been

+    * handled.

+    */

+   assert(!type_a->is_scalar());

+   assert(!type_b->is_scalar());

+

+   /*   "* The two operands are vectors of the same size. In this case, the

+    *      operation is done component-wise resulting in the same size

+    *      vector."

+    */

+   if (type_a->is_vector() && type_b->is_vector()) {

+      if (type_a == type_b) {

+	 return type_a;

+      } else {

+	 _mesa_glsl_error(loc, state,

+			  "vector size mismatch for arithmetic operator");

+	 return glsl_type::error_type;

+      }

+   }

+

+   /* All of the combinations of <scalar, scalar>, <vector, scalar>,

+    * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and

+    * <vector, vector> have been handled.  At least one of the operands must

+    * be matrix.  Further, since there are no integer matrix types, the base

+    * type of both operands must be float.

+    */

+   assert(type_a->is_matrix() || type_b->is_matrix());

+   assert(type_a->base_type == GLSL_TYPE_FLOAT);

+   assert(type_b->base_type == GLSL_TYPE_FLOAT);

+

+   /*   "* The operator is add (+), subtract (-), or divide (/), and the

+    *      operands are matrices with the same number of rows and the same

+    *      number of columns. In this case, the operation is done component-

+    *      wise resulting in the same size matrix."

+    *    * The operator is multiply (*), where both operands are matrices or

+    *      one operand is a vector and the other a matrix. A right vector

+    *      operand is treated as a column vector and a left vector operand as a

+    *      row vector. In all these cases, it is required that the number of

+    *      columns of the left operand is equal to the number of rows of the

+    *      right operand. Then, the multiply (*) operation does a linear

+    *      algebraic multiply, yielding an object that has the same number of

+    *      rows as the left operand and the same number of columns as the right

+    *      operand. Section 5.10 "Vector and Matrix Operations" explains in

+    *      more detail how vectors and matrices are operated on."

+    */

+   if (! multiply) {

+      if (type_a == type_b)

+	 return type_a;

+   } else {

+      if (type_a->is_matrix() && type_b->is_matrix()) {

+	 /* Matrix multiply.  The columns of A must match the rows of B.  Given

+	  * the other previously tested constraints, this means the vector type

+	  * of a row from A must be the same as the vector type of a column from

+	  * B.

+	  */

+	 if (type_a->row_type() == type_b->column_type()) {

+	    /* The resulting matrix has the number of columns of matrix B and

+	     * the number of rows of matrix A.  We get the row count of A by

+	     * looking at the size of a vector that makes up a column.  The

+	     * transpose (size of a row) is done for B.

+	     */

+	    const glsl_type *const type =

+	       glsl_type::get_instance(type_a->base_type,

+				       type_a->column_type()->vector_elements,

+				       type_b->row_type()->vector_elements);

+	    assert(type != glsl_type::error_type);

+

+	    return type;

+	 }

+      } else if (type_a->is_matrix()) {

+	 /* A is a matrix and B is a column vector.  Columns of A must match

+	  * rows of B.  Given the other previously tested constraints, this

+	  * means the vector type of a row from A must be the same as the

+	  * vector the type of B.

+	  */

+	 if (type_a->row_type() == type_b) {

+	    /* The resulting vector has a number of elements equal to

+	     * the number of rows of matrix A. */

+	    const glsl_type *const type =

+	       glsl_type::get_instance(type_a->base_type,

+				       type_a->column_type()->vector_elements,

+				       1);

+	    assert(type != glsl_type::error_type);

+

+	    return type;

+	 }

+      } else {

+	 assert(type_b->is_matrix());

+

+	 /* A is a row vector and B is a matrix.  Columns of A must match rows

+	  * of B.  Given the other previously tested constraints, this means

+	  * the type of A must be the same as the vector type of a column from

+	  * B.

+	  */

+	 if (type_a == type_b->column_type()) {

+	    /* The resulting vector has a number of elements equal to

+	     * the number of columns of matrix B. */

+	    const glsl_type *const type =

+	       glsl_type::get_instance(type_a->base_type,

+				       type_b->row_type()->vector_elements,

+				       1);

+	    assert(type != glsl_type::error_type);

+

+	    return type;

+	 }

+      }

+

+      _mesa_glsl_error(loc, state, "size mismatch for matrix multiplication");

+      return glsl_type::error_type;

+   }

+

+

+   /*    "All other cases are illegal."

+    */

+   _mesa_glsl_error(loc, state, "type mismatch");

+   return glsl_type::error_type;

+}

+

+

+static const struct glsl_type *

+unary_arithmetic_result_type(const struct glsl_type *type,

+			     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)

+{

+   /* From GLSL 1.50 spec, page 57:

+    *

+    *    "The arithmetic unary operators negate (-), post- and pre-increment

+    *     and decrement (-- and ++) operate on integer or floating-point

+    *     values (including vectors and matrices). All unary operators work

+    *     component-wise on their operands. These result with the same type

+    *     they operated on."

+    */

+   if (!type->is_numeric()) {

+      _mesa_glsl_error(loc, state,

+		       "Operands to arithmetic operators must be numeric");

+      return glsl_type::error_type;

+   }

+

+   return type;

+}

+

+/**

+ * \brief Return the result type of a bit-logic operation.

+ *

+ * If the given types to the bit-logic operator are invalid, return

+ * glsl_type::error_type.

+ *

+ * \param type_a Type of LHS of bit-logic op

+ * \param type_b Type of RHS of bit-logic op

+ */

+static const struct glsl_type *

+bit_logic_result_type(const struct glsl_type *type_a,

+                      const struct glsl_type *type_b,

+                      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");

+       return glsl_type::error_type;

+    }

+

+    /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:

+     *

+     *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or

+     *     (|). The operands must be of type signed or unsigned integers or

+     *     integer vectors."

+     */

+    if (!type_a->is_integer()) {

+       _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",

+                         ast_expression::operator_string(op));

+       return glsl_type::error_type;

+    }

+    if (!type_b->is_integer()) {

+       _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",

+                        ast_expression::operator_string(op));

+       return glsl_type::error_type;

+    }

+

+    /*     "The fundamental types of the operands (signed or unsigned) must

+     *     match,"

+     */

+    if (type_a->base_type != type_b->base_type) {

+       _mesa_glsl_error(loc, state, "operands of `%s' must have the same "

+                        "base type", ast_expression::operator_string(op));

+       return glsl_type::error_type;

+    }

+

+    /*     "The operands cannot be vectors of differing size." */

+    if (type_a->is_vector() &&

+        type_b->is_vector() &&

+        type_a->vector_elements != type_b->vector_elements) {

+       _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "

+                        "different sizes", ast_expression::operator_string(op));

+       return glsl_type::error_type;

+    }

+

+    /*     "If one operand is a scalar and the other a vector, the scalar is

+     *     applied component-wise to the vector, resulting in the same type as

+     *     the vector. The fundamental types of the operands [...] will be the

+     *     resulting fundamental type."

+     */

+    if (type_a->is_scalar())

+        return type_b;

+    else

+        return type_a;

+}

+

+static const struct glsl_type *

+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->version_string);

+      return glsl_type::error_type;

+   }

+

+   /* From GLSL 1.50 spec, page 56:

+    *    "The operator modulus (%) operates on signed or unsigned integers or

+    *    integer vectors. The operand types must both be signed or both be

+    *    unsigned."

+    */

+   if (!type_a->is_integer() || !type_b->is_integer()

+       || (type_a->base_type != type_b->base_type)) {

+      _mesa_glsl_error(loc, state, "type mismatch");

+      return glsl_type::error_type;

+   }

+

+   /*    "The operands cannot be vectors of differing size. If one operand is

+    *    a scalar and the other vector, then the scalar is applied component-

+    *    wise to the vector, resulting in the same type as the vector. If both

+    *    are vectors of the same size, the result is computed component-wise."

+    */

+   if (type_a->is_vector()) {

+      if (!type_b->is_vector()

+	  || (type_a->vector_elements == type_b->vector_elements))

+	 return type_a;

+   } else

+      return type_b;

+

+   /*    "The operator modulus (%) is not defined for any other data types

+    *    (non-integer types)."

+    */

+   _mesa_glsl_error(loc, state, "type mismatch");

+   return glsl_type::error_type;

+}

+

+

+static const struct glsl_type *

+relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,

+		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)

+{

+   const glsl_type *type_a = value_a->type;

+   const glsl_type *type_b = value_b->type;

+

+   /* From GLSL 1.50 spec, page 56:

+    *    "The relational operators greater than (>), less than (<), greater

+    *    than or equal (>=), and less than or equal (<=) operate only on

+    *    scalar integer and scalar floating-point expressions."

+    */

+   if (!type_a->is_numeric()

+       || !type_b->is_numeric()

+       || !type_a->is_scalar()

+       || !type_b->is_scalar()) {

+      _mesa_glsl_error(loc, state,

+		       "Operands to relational operators must be scalar and "

+		       "numeric");

+      return glsl_type::error_type;

+   }

+

+   /*    "Either the operands' types must match, or the conversions from

+    *    Section 4.1.10 "Implicit Conversions" will be applied to the integer

+    *    operand, after which the types must match."

+    */

+   if (!apply_implicit_conversion(type_a, value_b, state)

+       && !apply_implicit_conversion(type_b, value_a, state)) {

+      _mesa_glsl_error(loc, state,

+		       "Could not implicitly convert operands to "

+		       "relational operator");

+      return glsl_type::error_type;

+   }

+   type_a = value_a->type;

+   type_b = value_b->type;

+

+   if (type_a->base_type != type_b->base_type) {

+      _mesa_glsl_error(loc, state, "base type mismatch");

+      return glsl_type::error_type;

+   }

+

+   /*    "The result is scalar Boolean."

+    */

+   return glsl_type::bool_type;

+}

+

+/**

+ * \brief Return the result type of a bit-shift operation.

+ *

+ * If the given types to the bit-shift operator are invalid, return

+ * glsl_type::error_type.

+ *

+ * \param type_a Type of LHS of bit-shift op

+ * \param type_b Type of RHS of bit-shift op

+ */

+static const struct glsl_type *

+shift_result_type(const struct glsl_type *type_a,

+                  const struct glsl_type *type_b,

+                  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");

+      return glsl_type::error_type;

+   }

+

+   /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:

+    *

+    *     "The shift operators (<<) and (>>). For both operators, the operands

+    *     must be signed or unsigned integers or integer vectors. One operand

+    *     can be signed while the other is unsigned."

+    */

+   if (!type_a->is_integer()) {

+      _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "

+              "integer vector", ast_expression::operator_string(op));

+     return glsl_type::error_type;

+

+   }

+   if (!type_b->is_integer()) {

+      _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "

+              "integer vector", ast_expression::operator_string(op));

+     return glsl_type::error_type;

+   }

+

+   /*     "If the first operand is a scalar, the second operand has to be

+    *     a scalar as well."

+    */

+   if (type_a->is_scalar() && !type_b->is_scalar()) {

+      _mesa_glsl_error(loc, state, "If the first operand of %s is scalar, the "

+              "second must be scalar as well",

+              ast_expression::operator_string(op));

+     return glsl_type::error_type;

+   }

+

+   /* If both operands are vectors, check that they have same number of

+    * elements.

+    */

+   if (type_a->is_vector() &&

+      type_b->is_vector() &&

+      type_a->vector_elements != type_b->vector_elements) {

+      _mesa_glsl_error(loc, state, "Vector operands to operator %s must "

+              "have same number of elements",

+              ast_expression::operator_string(op));

+     return glsl_type::error_type;

+   }

+

+   /*     "In all cases, the resulting type will be the same type as the left

+    *     operand."

+    */

+   return type_a;

+}

+

+/**

+ * Validates that a value can be assigned to a location with a specified type

+ *

+ * Validates that \c rhs can be assigned to some location.  If the types are

+ * not an exact match but an automatic conversion is possible, \c rhs will be

+ * converted.

+ *

+ * \return

+ * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.

+ * Otherwise the actual RHS to be assigned will be returned.  This may be

+ * \c rhs, or it may be \c rhs after some type conversion.

+ *

+ * \note

+ * In addition to being used for assignments, this function is used to

+ * type-check return values.

+ */

+ir_rvalue *

+validate_assignment(struct _mesa_glsl_parse_state *state,

+		    const glsl_type *lhs_type, ir_rvalue *rhs)

+{

+   /* If there is already some error in the RHS, just return it.  Anything

+    * else will lead to an avalanche of error message back to the user.

+    */

+   if (rhs->type->is_error())

+      return rhs;

+

+   /* If the types are identical, the assignment can trivially proceed.

+    */

+   if (rhs->type == lhs_type)

+      return rhs;

+

+   /* If the array element types are the same and the size of the LHS is zero,

+    * the assignment is okay.

+    *

+    * Note: Whole-array assignments are not permitted in GLSL 1.10, but this

+    * is handled by ir_dereference::is_lvalue.

+    */

+   if (lhs_type->is_array() && rhs->type->is_array()

+       && (lhs_type->element_type() == rhs->type->element_type())

+       && (lhs_type->array_size() == 0)) {

+      return rhs;

+   }

+

+   /* Check for implicit conversion in GLSL 1.20 */

+   if (apply_implicit_conversion(lhs_type, rhs, state)) {

+      if (rhs->type == lhs_type)

+	 return rhs;

+   }

+

+   return NULL;

+}

+

+ir_rvalue *

+do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,

+	      ir_rvalue *lhs, ir_rvalue *rhs,

+	      YYLTYPE lhs_loc)

+{

+   void *ctx = state;

+   bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());

+

+   if (!error_emitted) {

+      if (lhs->variable_referenced() != NULL

+          && lhs->variable_referenced()->read_only) {

+         _mesa_glsl_error(&lhs_loc, state,

+                          "assignment to read-only variable '%s'",

+                          lhs->variable_referenced()->name);

+         error_emitted = true;

+

+      } else if (!lhs->is_lvalue()) {

+	 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");

+	 error_emitted = true;

+      }

+

+      if (state->es_shader && lhs->type->is_array()) {

+	 _mesa_glsl_error(&lhs_loc, state, "whole array assignment is not "

+			  "allowed in GLSL ES 1.00.");

+	 error_emitted = true;

+      }

+   }

+

+   ir_rvalue *new_rhs = validate_assignment(state, lhs->type, rhs);

+   if (new_rhs == NULL) {

+      _mesa_glsl_error(& lhs_loc, state, "type mismatch");

+   } else {

+      rhs = new_rhs;

+

+      /* If the LHS array was not declared with a size, it takes it size from

+       * the RHS.  If the LHS is an l-value and a whole array, it must be a

+       * dereference of a variable.  Any other case would require that the LHS

+       * is either not an l-value or not a whole array.

+       */

+      if (lhs->type->array_size() == 0) {

+	 ir_dereference *const d = lhs->as_dereference();

+

+	 assert(d != NULL);

+

+	 ir_variable *const var = d->variable_referenced();

+

+	 assert(var != NULL);

+

+	 if (var->max_array_access >= unsigned(rhs->type->array_size())) {

+	    /* FINISHME: This should actually log the location of the RHS. */

+	    _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "

+			     "previous access",

+			     var->max_array_access);

+	 }

+

+	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),

+						   rhs->type->array_size());

+	 d->type = var->type;

+      }

+   }

+

+   /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,

+    * but not post_inc) need the converted assigned value as an rvalue

+    * to handle things like:

+    *

+    * i = j += 1;

+    *

+    * So we always just store the computed value being assigned to a

+    * temporary and return a deref of that temporary.  If the rvalue

+    * ends up not being used, the temp will get copy-propagated out.

+    */

+   ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",

+					   ir_var_temporary);

+   ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var);

+   instructions->push_tail(var);

+   instructions->push_tail(new(ctx) ir_assignment(deref_var,

+						  rhs,

+						  NULL));

+   deref_var = new(ctx) ir_dereference_variable(var);

+

+   if (!error_emitted)

+      instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var, NULL));

+

+   return new(ctx) ir_dereference_variable(var);

+}

+

+static ir_rvalue *

+get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)

+{

+   void *ctx = ralloc_parent(lvalue);

+   ir_variable *var;

+

+   var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",

+			      ir_var_temporary);

+   instructions->push_tail(var);

+   var->mode = ir_var_auto;

+

+   instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),

+						  lvalue, NULL));

+

+   /* Once we've created this temporary, mark it read only so it's no

+    * longer considered an lvalue.

+    */

+   var->read_only = true;

+

+   return new(ctx) ir_dereference_variable(var);

+}

+

+

+ir_rvalue *

+ast_node::hir(exec_list *instructions,

+	      struct _mesa_glsl_parse_state *state)

+{

+   (void) instructions;

+   (void) state;

+

+   return NULL;

+}

+

+static void

+mark_whole_array_access(ir_rvalue *access)

+{

+   ir_dereference_variable *deref = access->as_dereference_variable();

+

+   if (deref) {

+      deref->var->max_array_access = deref->type->length - 1;

+   }

+}

+

+static ir_rvalue *

+do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)

+{

+   int join_op;

+   ir_rvalue *cmp = NULL;

+

+   if (operation == ir_binop_all_equal)

+      join_op = ir_binop_logic_and;

+   else

+      join_op = ir_binop_logic_or;

+

+   switch (op0->type->base_type) {

+   case GLSL_TYPE_FLOAT:

+   case GLSL_TYPE_UINT:

+   case GLSL_TYPE_INT:

+   case GLSL_TYPE_BOOL:

+      return new(mem_ctx) ir_expression(operation, op0, op1);

+

+   case GLSL_TYPE_ARRAY: {

+      for (unsigned int i = 0; i < op0->type->length; i++) {

+	 ir_rvalue *e0, *e1, *result;

+

+	 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),

+						new(mem_ctx) ir_constant(i));

+	 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),

+						new(mem_ctx) ir_constant(i));

+	 result = do_comparison(mem_ctx, operation, e0, e1);

+

+	 if (cmp) {

+	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);

+	 } else {

+	    cmp = result;

+	 }

+      }

+

+      mark_whole_array_access(op0);

+      mark_whole_array_access(op1);

+      break;

+   }

+

+   case GLSL_TYPE_STRUCT: {

+      for (unsigned int i = 0; i < op0->type->length; i++) {

+	 ir_rvalue *e0, *e1, *result;

+	 const char *field_name = op0->type->fields.structure[i].name;

+

+	 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),

+						 field_name);

+	 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),

+						 field_name);

+	 result = do_comparison(mem_ctx, operation, e0, e1);

+

+	 if (cmp) {

+	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);

+	 } else {

+	    cmp = result;

+	 }

+      }

+      break;

+   }

+

+   case GLSL_TYPE_ERROR:

+   case GLSL_TYPE_VOID:

+   case GLSL_TYPE_SAMPLER:

+      /* I assume a comparison of a struct containing a sampler just

+       * ignores the sampler present in the type.

+       */

+      break;

+

+   default:

+      assert(!"Should not get here.");

+      break;

+   }

+

+   if (cmp == NULL)

+      cmp = new(mem_ctx) ir_constant(true);

+

+   return cmp;

+}

+

+ir_rvalue *

+ast_expression::hir(exec_list *instructions,

+		    struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+   static const int operations[AST_NUM_OPERATORS] = {

+      -1,               /* ast_assign doesn't convert to ir_expression. */

+      -1,               /* ast_plus doesn't convert to ir_expression. */

+      ir_unop_neg,

+      ir_binop_add,

+      ir_binop_sub,

+      ir_binop_mul,

+      ir_binop_div,

+      ir_binop_mod,

+      ir_binop_lshift,

+      ir_binop_rshift,

+      ir_binop_less,

+      ir_binop_greater,

+      ir_binop_lequal,

+      ir_binop_gequal,

+      ir_binop_all_equal,

+      ir_binop_any_nequal,

+      ir_binop_bit_and,

+      ir_binop_bit_xor,

+      ir_binop_bit_or,

+      ir_unop_bit_not,

+      ir_binop_logic_and,

+      ir_binop_logic_xor,

+      ir_binop_logic_or,

+      ir_unop_logic_not,

+

+      /* Note: The following block of expression types actually convert

+       * to multiple IR instructions.

+       */

+      ir_binop_mul,     /* ast_mul_assign */

+      ir_binop_div,     /* ast_div_assign */

+      ir_binop_mod,     /* ast_mod_assign */

+      ir_binop_add,     /* ast_add_assign */

+      ir_binop_sub,     /* ast_sub_assign */

+      ir_binop_lshift,  /* ast_ls_assign */

+      ir_binop_rshift,  /* ast_rs_assign */

+      ir_binop_bit_and, /* ast_and_assign */

+      ir_binop_bit_xor, /* ast_xor_assign */

+      ir_binop_bit_or,  /* ast_or_assign */

+

+      -1,               /* ast_conditional doesn't convert to ir_expression. */

+      ir_binop_add,     /* ast_pre_inc. */

+      ir_binop_sub,     /* ast_pre_dec. */

+      ir_binop_add,     /* ast_post_inc. */

+      ir_binop_sub,     /* ast_post_dec. */

+      -1,               /* ast_field_selection doesn't conv to ir_expression. */

+      -1,               /* ast_array_index doesn't convert to ir_expression. */

+      -1,               /* ast_function_call doesn't conv to ir_expression. */

+      -1,               /* ast_identifier doesn't convert to ir_expression. */

+      -1,               /* ast_int_constant doesn't convert to ir_expression. */

+      -1,               /* ast_uint_constant doesn't conv to ir_expression. */

+      -1,               /* ast_float_constant doesn't conv to ir_expression. */

+      -1,               /* ast_bool_constant doesn't conv to ir_expression. */

+      -1,               /* ast_sequence doesn't convert to ir_expression. */

+   };

+   ir_rvalue *result = NULL;

+   ir_rvalue *op[3];

+   const struct glsl_type *type = glsl_type::error_type;

+   bool error_emitted = false;

+   YYLTYPE loc;

+

+   loc = this->get_location();

+

+   switch (this->oper) {

+   case ast_assign: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      result = do_assignment(instructions, state, op[0], op[1],

+			     this->subexpressions[0]->get_location());

+      error_emitted = result->type->is_error();

+      type = result->type;

+      break;

+   }

+

+   case ast_plus:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      type = unary_arithmetic_result_type(op[0]->type, state, & loc);

+

+      error_emitted = type->is_error();

+

+      result = op[0];

+      break;

+

+   case ast_neg:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      type = unary_arithmetic_result_type(op[0]->type, state, & loc);

+

+      error_emitted = type->is_error();

+

+      result = new(ctx) ir_expression(operations[this->oper], type,

+				      op[0], NULL);

+      break;

+

+   case ast_add:

+   case ast_sub:

+   case ast_mul:

+   case ast_div:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      type = arithmetic_result_type(op[0], op[1],

+				    (this->oper == ast_mul),

+				    state, & loc);

+      error_emitted = type->is_error();

+

+      result = new(ctx) ir_expression(operations[this->oper], type,

+				      op[0], op[1]);

+      break;

+

+   case ast_mod:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);

+

+      assert(operations[this->oper] == ir_binop_mod);

+

+      result = new(ctx) ir_expression(operations[this->oper], type,

+				      op[0], op[1]);

+      error_emitted = type->is_error();

+      break;

+

+   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));

+          error_emitted = true;

+       }

+

+       op[0] = this->subexpressions[0]->hir(instructions, state);

+       op[1] = this->subexpressions[1]->hir(instructions, state);

+       type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,

+                                &loc);

+       result = new(ctx) ir_expression(operations[this->oper], type,

+                                       op[0], op[1]);

+       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+       break;

+

+   case ast_less:

+   case ast_greater:

+   case ast_lequal:

+   case ast_gequal:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      type = relational_result_type(op[0], op[1], state, & loc);

+

+      /* The relational operators must either generate an error or result

+       * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.

+       */

+      assert(type->is_error()

+	     || ((type->base_type == GLSL_TYPE_BOOL)

+		 && type->is_scalar()));

+

+      result = new(ctx) ir_expression(operations[this->oper], type,

+				      op[0], op[1]);

+      error_emitted = type->is_error();

+      break;

+

+   case ast_nequal:

+   case ast_equal:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:

+       *

+       *    "The equality operators equal (==), and not equal (!=)

+       *    operate on all types. They result in a scalar Boolean. If

+       *    the operand types do not match, then there must be a

+       *    conversion from Section 4.1.10 "Implicit Conversions"

+       *    applied to one operand that can make them match, in which

+       *    case this conversion is done."

+       */

+      if ((!apply_implicit_conversion(op[0]->type, op[1], state)

+	   && !apply_implicit_conversion(op[1]->type, op[0], state))

+	  || (op[0]->type != op[1]->type)) {

+	 _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");

+	 error_emitted = true;

+      }

+

+      result = do_comparison(ctx, operations[this->oper], op[0], op[1]);

+      type = glsl_type::bool_type;

+

+      assert(error_emitted || (result->type == glsl_type::bool_type));

+      break;

+

+   case ast_bit_and:

+   case ast_bit_xor:

+   case ast_bit_or:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+      type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,

+                                   state, &loc);

+      result = new(ctx) ir_expression(operations[this->oper], type,

+				      op[0], op[1]);

+      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+      break;

+

+   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");

+	 error_emitted = true;

+      }

+

+      if (!op[0]->type->is_integer()) {

+	 _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");

+	 error_emitted = true;

+      }

+

+      type = op[0]->type;

+      result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);

+      break;

+

+   case ast_logic_and: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {

+	 YYLTYPE loc = this->subexpressions[0]->get_location();

+

+	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",

+			  operator_string(this->oper));

+	 error_emitted = true;

+      }

+

+      ir_constant *op0_const = op[0]->constant_expression_value();

+      if (op0_const) {

+	 if (op0_const->value.b[0]) {

+	    op[1] = this->subexpressions[1]->hir(instructions, state);

+

+	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {

+	       YYLTYPE loc = this->subexpressions[1]->get_location();

+

+	       _mesa_glsl_error(& loc, state,

+				"RHS of `%s' must be scalar boolean",

+				operator_string(this->oper));

+	       error_emitted = true;

+	    }

+	    result = op[1];

+	 } else {

+	    result = op0_const;

+	 }

+	 type = glsl_type::bool_type;

+      } else {

+	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,

+						       "and_tmp",

+						       ir_var_temporary);

+	 instructions->push_tail(tmp);

+

+	 ir_if *const stmt = new(ctx) ir_if(op[0]);

+	 instructions->push_tail(stmt);

+

+	 op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state);

+

+	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {

+	    YYLTYPE loc = this->subexpressions[1]->get_location();

+

+	    _mesa_glsl_error(& loc, state,

+			     "RHS of `%s' must be scalar boolean",

+			     operator_string(this->oper));

+	    error_emitted = true;

+	 }

+

+	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const then_assign =

+	    new(ctx) ir_assignment(then_deref, op[1], NULL);

+	 stmt->then_instructions.push_tail(then_assign);

+

+	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const else_assign =

+	    new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false), NULL);

+	 stmt->else_instructions.push_tail(else_assign);

+

+	 result = new(ctx) ir_dereference_variable(tmp);

+	 type = tmp->type;

+      }

+      break;

+   }

+

+   case ast_logic_or: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {

+	 YYLTYPE loc = this->subexpressions[0]->get_location();

+

+	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",

+			  operator_string(this->oper));

+	 error_emitted = true;

+      }

+

+      ir_constant *op0_const = op[0]->constant_expression_value();

+      if (op0_const) {

+	 if (op0_const->value.b[0]) {

+	    result = op0_const;

+	 } else {

+	    op[1] = this->subexpressions[1]->hir(instructions, state);

+

+	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {

+	       YYLTYPE loc = this->subexpressions[1]->get_location();

+

+	       _mesa_glsl_error(& loc, state,

+				"RHS of `%s' must be scalar boolean",

+				operator_string(this->oper));

+	       error_emitted = true;

+	    }

+	    result = op[1];

+	 }

+	 type = glsl_type::bool_type;

+      } else {

+	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,

+						       "or_tmp",

+						       ir_var_temporary);

+	 instructions->push_tail(tmp);

+

+	 ir_if *const stmt = new(ctx) ir_if(op[0]);

+	 instructions->push_tail(stmt);

+

+	 op[1] = this->subexpressions[1]->hir(&stmt->else_instructions, state);

+

+	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {

+	    YYLTYPE loc = this->subexpressions[1]->get_location();

+

+	    _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean",

+			     operator_string(this->oper));

+	    error_emitted = true;

+	 }

+

+	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const then_assign =

+	    new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true), NULL);

+	 stmt->then_instructions.push_tail(then_assign);

+

+	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const else_assign =

+	    new(ctx) ir_assignment(else_deref, op[1], NULL);

+	 stmt->else_instructions.push_tail(else_assign);

+

+	 result = new(ctx) ir_dereference_variable(tmp);

+	 type = tmp->type;

+      }

+      break;

+   }

+

+   case ast_logic_xor:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+

+      result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,

+				      op[0], op[1]);

+      type = glsl_type::bool_type;

+      break;

+

+   case ast_logic_not:

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {

+	 YYLTYPE loc = this->subexpressions[0]->get_location();

+

+	 _mesa_glsl_error(& loc, state,

+			  "operand of `!' must be scalar boolean");

+	 error_emitted = true;

+      }

+

+      result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,

+				      op[0], NULL);

+      type = glsl_type::bool_type;

+      break;

+

+   case ast_mul_assign:

+   case ast_div_assign:

+   case ast_add_assign:

+   case ast_sub_assign: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      type = arithmetic_result_type(op[0], op[1],

+				    (this->oper == ast_mul_assign),

+				    state, & loc);

+

+      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,

+						   op[0], op[1]);

+

+      result = do_assignment(instructions, state,

+			     op[0]->clone(ctx, NULL), temp_rhs,

+			     this->subexpressions[0]->get_location());

+      type = result->type;

+      error_emitted = (op[0]->type->is_error());

+

+      /* GLSL 1.10 does not allow array assignment.  However, we don't have to

+       * explicitly test for this because none of the binary expression

+       * operators allow array operands either.

+       */

+

+      break;

+   }

+

+   case ast_mod_assign: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+

+      type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);

+

+      assert(operations[this->oper] == ir_binop_mod);

+

+      ir_rvalue *temp_rhs;

+      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,

+					op[0], op[1]);

+

+      result = do_assignment(instructions, state,

+			     op[0]->clone(ctx, NULL), temp_rhs,

+			     this->subexpressions[0]->get_location());

+      type = result->type;

+      error_emitted = type->is_error();

+      break;

+   }

+

+   case ast_ls_assign:

+   case ast_rs_assign: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+      type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,

+                               &loc);

+      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],

+                                                   type, op[0], op[1]);

+      result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),

+                             temp_rhs,

+                             this->subexpressions[0]->get_location());

+      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+      break;

+   }

+

+   case ast_and_assign:

+   case ast_xor_assign:

+   case ast_or_assign: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      op[1] = this->subexpressions[1]->hir(instructions, state);

+      type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,

+                                   state, &loc);

+      ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],

+                                                   type, op[0], op[1]);

+      result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),

+                             temp_rhs,

+                             this->subexpressions[0]->get_location());

+      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+      break;

+   }

+

+   case ast_conditional: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+

+      /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:

+       *

+       *    "The ternary selection operator (?:). It operates on three

+       *    expressions (exp1 ? exp2 : exp3). This operator evaluates the

+       *    first expression, which must result in a scalar Boolean."

+       */

+      if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {

+	 YYLTYPE loc = this->subexpressions[0]->get_location();

+

+	 _mesa_glsl_error(& loc, state, "?: condition must be scalar boolean");

+	 error_emitted = true;

+      }

+

+      /* The :? operator is implemented by generating an anonymous temporary

+       * followed by an if-statement.  The last instruction in each branch of

+       * the if-statement assigns a value to the anonymous temporary.  This

+       * temporary is the r-value of the expression.

+       */

+      exec_list then_instructions;

+      exec_list else_instructions;

+

+      op[1] = this->subexpressions[1]->hir(&then_instructions, state);

+      op[2] = this->subexpressions[2]->hir(&else_instructions, state);

+

+      /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:

+       *

+       *     "The second and third expressions can be any type, as

+       *     long their types match, or there is a conversion in

+       *     Section 4.1.10 "Implicit Conversions" that can be applied

+       *     to one of the expressions to make their types match. This

+       *     resulting matching type is the type of the entire

+       *     expression."

+       */

+      if ((!apply_implicit_conversion(op[1]->type, op[2], state)

+	   && !apply_implicit_conversion(op[2]->type, op[1], state))

+	  || (op[1]->type != op[2]->type)) {

+	 YYLTYPE loc = this->subexpressions[1]->get_location();

+

+	 _mesa_glsl_error(& loc, state, "Second and third operands of ?: "

+			  "operator must have matching types.");

+	 error_emitted = true;

+	 type = glsl_type::error_type;

+      } else {

+	 type = op[1]->type;

+      }

+

+      /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:

+       *

+       *    "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.");

+	 error_emitted = true;

+      }

+

+      ir_constant *cond_val = op[0]->constant_expression_value();

+      ir_constant *then_val = op[1]->constant_expression_value();

+      ir_constant *else_val = op[2]->constant_expression_value();

+

+      if (then_instructions.is_empty()

+	  && else_instructions.is_empty()

+	  && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {

+	 result = (cond_val->value.b[0]) ? then_val : else_val;

+      } else {

+	 ir_variable *const tmp =

+	    new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);

+	 instructions->push_tail(tmp);

+

+	 ir_if *const stmt = new(ctx) ir_if(op[0]);

+	 instructions->push_tail(stmt);

+

+	 then_instructions.move_nodes_to(& stmt->then_instructions);

+	 ir_dereference *const then_deref =

+	    new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const then_assign =

+	    new(ctx) ir_assignment(then_deref, op[1], NULL);

+	 stmt->then_instructions.push_tail(then_assign);

+

+	 else_instructions.move_nodes_to(& stmt->else_instructions);

+	 ir_dereference *const else_deref =

+	    new(ctx) ir_dereference_variable(tmp);

+	 ir_assignment *const else_assign =

+	    new(ctx) ir_assignment(else_deref, op[2], NULL);

+	 stmt->else_instructions.push_tail(else_assign);

+

+	 result = new(ctx) ir_dereference_variable(tmp);

+      }

+      break;

+   }

+

+   case ast_pre_inc:

+   case ast_pre_dec: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      if (op[0]->type->base_type == GLSL_TYPE_FLOAT)

+	 op[1] = new(ctx) ir_constant(1.0f);

+      else

+	 op[1] = new(ctx) ir_constant(1);

+

+      type = arithmetic_result_type(op[0], op[1], false, state, & loc);

+

+      ir_rvalue *temp_rhs;

+      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,

+					op[0], op[1]);

+

+      result = do_assignment(instructions, state,

+			     op[0]->clone(ctx, NULL), temp_rhs,

+			     this->subexpressions[0]->get_location());

+      type = result->type;

+      error_emitted = op[0]->type->is_error();

+      break;

+   }

+

+   case ast_post_inc:

+   case ast_post_dec: {

+      op[0] = this->subexpressions[0]->hir(instructions, state);

+      if (op[0]->type->base_type == GLSL_TYPE_FLOAT)

+	 op[1] = new(ctx) ir_constant(1.0f);

+      else

+	 op[1] = new(ctx) ir_constant(1);

+

+      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+

+      type = arithmetic_result_type(op[0], op[1], false, state, & loc);

+

+      ir_rvalue *temp_rhs;

+      temp_rhs = new(ctx) ir_expression(operations[this->oper], type,

+					op[0], op[1]);

+

+      /* Get a temporary of a copy of the lvalue before it's modified.

+       * This may get thrown away later.

+       */

+      result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));

+

+      (void)do_assignment(instructions, state,

+			  op[0]->clone(ctx, NULL), temp_rhs,

+			  this->subexpressions[0]->get_location());

+

+      type = result->type;

+      error_emitted = op[0]->type->is_error();

+      break;

+   }

+

+   case ast_field_selection:

+      result = _mesa_ast_field_selection_to_hir(this, instructions, state);

+      type = result->type;

+      break;

+

+   case ast_array_index: {

+      YYLTYPE index_loc = subexpressions[1]->get_location();

+

+      op[0] = subexpressions[0]->hir(instructions, state);

+      op[1] = subexpressions[1]->hir(instructions, state);

+

+      error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

+

+      ir_rvalue *const array = op[0];

+

+      result = new(ctx) ir_dereference_array(op[0], op[1]);

+

+      /* Do not use op[0] after this point.  Use array.

+       */

+      op[0] = NULL;

+

+

+      if (error_emitted)

+	 break;

+

+      if (!array->type->is_array()

+	  && !array->type->is_matrix()

+	  && !array->type->is_vector()) {

+	 _mesa_glsl_error(& index_loc, state,

+			  "cannot dereference non-array / non-matrix / "

+			  "non-vector");

+	 error_emitted = true;

+      }

+

+      if (!op[1]->type->is_integer()) {

+	 _mesa_glsl_error(& index_loc, state,

+			  "array index must be integer type");

+	 error_emitted = true;

+      } else if (!op[1]->type->is_scalar()) {

+	 _mesa_glsl_error(& index_loc, state,

+			  "array index must be scalar");

+	 error_emitted = true;

+      }

+

+      /* If the array index is a constant expression and the array has a

+       * declared size, ensure that the access is in-bounds.  If the array

+       * index is not a constant expression, ensure that the array has a

+       * declared size.

+       */

+      ir_constant *const const_index = op[1]->constant_expression_value();

+      if (const_index != NULL) {

+	 const int idx = const_index->value.i[0];

+	 const char *type_name;

+	 unsigned bound = 0;

+

+	 if (array->type->is_matrix()) {

+	    type_name = "matrix";

+	 } else if (array->type->is_vector()) {

+	    type_name = "vector";

+	 } else {

+	    type_name = "array";

+	 }

+

+	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec:

+	  *

+	  *    "It is illegal to declare an array with a size, and then

+	  *    later (in the same shader) index the same array with an

+	  *    integral constant expression greater than or equal to the

+	  *    declared size. It is also illegal to index an array with a

+	  *    negative constant expression."

+	  */

+	 if (array->type->is_matrix()) {

+	    if (array->type->row_type()->vector_elements <= idx) {

+	       bound = array->type->row_type()->vector_elements;

+	    }

+	 } else if (array->type->is_vector()) {

+	    if (array->type->vector_elements <= idx) {

+	       bound = array->type->vector_elements;

+	    }

+	 } else {

+	    if ((array->type->array_size() > 0)

+		&& (array->type->array_size() <= idx)) {

+	       bound = array->type->array_size();

+	    }

+	 }

+

+	 if (bound > 0) {

+	    _mesa_glsl_error(& loc, state, "%s index must be < %u",

+			     type_name, bound);

+	    error_emitted = true;

+	 } else if (idx < 0) {

+	    _mesa_glsl_error(& loc, state, "%s index must be >= 0",

+			     type_name);

+	    error_emitted = true;

+	 }

+

+	 if (array->type->is_array()) {

+	    /* If the array is a variable dereference, it dereferences the

+	     * whole array, by definition.  Use this to get the variable.

+	     *

+	     * FINISHME: Should some methods for getting / setting / testing

+	     * FINISHME: array access limits be added to ir_dereference?

+	     */

+	    ir_variable *const v = array->whole_variable_referenced();

+	    if ((v != NULL) && (unsigned(idx) > v->max_array_access))

+	       v->max_array_access = idx;

+	 }

+      } else if (array->type->array_size() == 0) {

+	 _mesa_glsl_error(&loc, state, "unsized array index must be constant");

+      } else {

+	 if (array->type->is_array()) {

+	    /* whole_variable_referenced can return NULL if the array is a

+	     * member of a structure.  In this case it is safe to not update

+	     * the max_array_access field because it is never used for fields

+	     * of structures.

+	     */

+	    ir_variable *v = array->whole_variable_referenced();

+	    if (v != NULL)

+	       v->max_array_access = array->type->array_size();

+	 }

+      }

+

+      /* From page 23 (29 of the PDF) of the GLSL 1.30 spec:

+       *

+       *    "Samplers aggregated into arrays within a shader (using square

+       *    brackets [ ]) can only be indexed with integral constant

+       *    expressions [...]."

+       *

+       * This restriction was added in GLSL 1.30.  Shaders using earlier version

+       * of the language should not be rejected by the compiler front-end for

+       * using this construct.  This allows useful things such as using a loop

+       * counter as the index to an array of samplers.  If the loop in unrolled,

+       * the code should compile correctly.  Instead, emit a warning.

+       */

+      if (array->type->is_array() &&

+          array->type->element_type()->is_sampler() &&

+          const_index == NULL) {

+

+	 if (state->language_version == 100) {

+	    _mesa_glsl_warning(&loc, state,

+			       "sampler arrays indexed with non-constant "

+			       "expressions is optional in GLSL ES 1.00");

+	 } else if (state->language_version < 130) {

+	    _mesa_glsl_warning(&loc, state,

+			       "sampler arrays indexed with non-constant "

+			       "expressions is forbidden in GLSL 1.30 and "

+			       "later");

+	 } else {

+	    _mesa_glsl_error(&loc, state,

+			     "sampler arrays indexed with non-constant "

+			     "expressions is forbidden in GLSL 1.30 and "

+			     "later");

+	    error_emitted = true;

+	 }

+      }

+

+      if (error_emitted)

+	 result->type = glsl_type::error_type;

+

+      type = result->type;

+      break;

+   }

+

+   case ast_function_call:

+      /* Should *NEVER* get here.  ast_function_call should always be handled

+       * by ast_function_expression::hir.

+       */

+      assert(0);

+      break;

+

+   case ast_identifier: {

+      /* ast_identifier can appear several places in a full abstract syntax

+       * tree.  This particular use must be at location specified in the grammar

+       * as 'variable_identifier'.

+       */

+      ir_variable *var = 

+	 state->symbols->get_variable(this->primary_expression.identifier);

+

+      result = new(ctx) ir_dereference_variable(var);

+

+      if (var != NULL) {

+	 var->used = true;

+	 type = result->type;

+      } else {

+	 _mesa_glsl_error(& loc, state, "`%s' undeclared",

+			  this->primary_expression.identifier);

+

+	 error_emitted = true;

+      }

+      break;

+   }

+

+   case ast_int_constant:

+      type = glsl_type::int_type;

+      result = new(ctx) ir_constant(this->primary_expression.int_constant);

+      break;

+

+   case ast_uint_constant:

+      type = glsl_type::uint_type;

+      result = new(ctx) ir_constant(this->primary_expression.uint_constant);

+      break;

+

+   case ast_float_constant:

+      type = glsl_type::float_type;

+      result = new(ctx) ir_constant(this->primary_expression.float_constant);

+      break;

+

+   case ast_bool_constant:

+      type = glsl_type::bool_type;

+      result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));

+      break;

+

+   case ast_sequence: {

+      /* It should not be possible to generate a sequence in the AST without

+       * any expressions in it.

+       */

+      assert(!this->expressions.is_empty());

+

+      /* The r-value of a sequence is the last expression in the sequence.  If

+       * the other expressions in the sequence do not have side-effects (and

+       * therefore add instructions to the instruction list), they get dropped

+       * on the floor.

+       */

+      foreach_list_typed (ast_node, ast, link, &this->expressions)

+	 result = ast->hir(instructions, state);

+

+      type = result->type;

+

+      /* Any errors should have already been emitted in the loop above.

+       */

+      error_emitted = true;

+      break;

+   }

+   }

+

+   if (type->is_error() && !error_emitted)

+      _mesa_glsl_error(& loc, state, "type mismatch");

+

+   return result;

+}

+

+

+ir_rvalue *

+ast_expression_statement::hir(exec_list *instructions,

+			      struct _mesa_glsl_parse_state *state)

+{

+   /* It is possible to have expression statements that don't have an

+    * expression.  This is the solitary semicolon:

+    *

+    * for (i = 0; i < 5; i++)

+    *     ;

+    *

+    * In this case the expression will be NULL.  Test for NULL and don't do

+    * anything in that case.

+    */

+   if (expression != NULL)

+      expression->hir(instructions, state);

+

+   /* Statements do not have r-values.

+    */

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_compound_statement::hir(exec_list *instructions,

+			    struct _mesa_glsl_parse_state *state)

+{

+   if (new_scope)

+      state->symbols->push_scope();

+

+   foreach_list_typed (ast_node, ast, link, &this->statements)

+      ast->hir(instructions, state);

+

+   if (new_scope)

+      state->symbols->pop_scope();

+

+   /* Compound statements do not have r-values.

+    */

+   return NULL;

+}

+

+

+static const glsl_type *

+process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size,

+		   struct _mesa_glsl_parse_state *state)

+{

+   unsigned length = 0;

+

+   /* FINISHME: Reject delcarations of multidimensional arrays. */

+

+   if (array_size != NULL) {

+      exec_list dummy_instructions;

+      ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);

+      YYLTYPE loc = array_size->get_location();

+

+      /* FINISHME: Verify that the grammar forbids side-effects in array

+       * FINISHME: sizes.   i.e., 'vec4 [x = 12] data'

+       */

+      assert(dummy_instructions.is_empty());

+

+      if (ir != NULL) {

+	 if (!ir->type->is_integer()) {

+	    _mesa_glsl_error(& loc, state, "array size must be integer type");

+	 } else if (!ir->type->is_scalar()) {

+	    _mesa_glsl_error(& loc, state, "array size must be scalar type");

+	 } else {

+	    ir_constant *const size = ir->constant_expression_value();

+

+	    if (size == NULL) {

+	       _mesa_glsl_error(& loc, state, "array size must be a "

+				"constant valued expression");

+	    } else if (size->value.i[0] <= 0) {

+	       _mesa_glsl_error(& loc, state, "array size must be > 0");

+	    } else {

+	       assert(size->type == ir->type);

+	       length = size->value.u[0];

+	    }

+	 }

+      }

+   } else if (state->es_shader) {

+      /* Section 10.17 of the GLSL ES 1.00 specification states that unsized

+       * array declarations have been removed from the language.

+       */

+      _mesa_glsl_error(loc, state, "unsized array declarations are not "

+		       "allowed in GLSL ES 1.00.");

+   }

+

+   return glsl_type::get_array_instance(base, length);

+}

+

+

+const glsl_type *

+ast_type_specifier::glsl_type(const char **name,

+			      struct _mesa_glsl_parse_state *state) const

+{

+   const struct glsl_type *type;

+

+   type = state->symbols->get_type(this->type_name);

+   *name = this->type_name;

+

+   if (this->is_array) {

+      YYLTYPE loc = this->get_location();

+      type = process_array_type(&loc, type, this->array_size, state);

+   }

+

+   return type;

+}

+

+

+static void

+apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,

+				 ir_variable *var,

+				 struct _mesa_glsl_parse_state *state,

+				 YYLTYPE *loc)

+{

+   if (qual->flags.q.invariant) {

+      if (var->used) {

+	 _mesa_glsl_error(loc, state,

+			  "variable `%s' may not be redeclared "

+			  "`invariant' after being used",

+			  var->name);

+      } else {

+	 var->invariant = 1;

+      }

+   }

+

+   if (qual->flags.q.constant || qual->flags.q.attribute

+       || qual->flags.q.uniform

+       || (qual->flags.q.varying && (state->target == fragment_shader)))

+      var->read_only = 1;

+

+   if (qual->flags.q.centroid)

+      var->centroid = 1;

+

+   if (qual->flags.q.attribute && state->target != vertex_shader) {

+      var->type = glsl_type::error_type;

+      _mesa_glsl_error(loc, state,

+		       "`attribute' variables may not be declared in the "

+		       "%s shader",

+		       _mesa_glsl_shader_target_name(state->target));

+   }

+

+   /* From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:

+    *

+    *     "The varying qualifier can be used only with the data types

+    *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of

+    *     these."

+    */

+   if (qual->flags.q.varying) {

+      const glsl_type *non_array_type;

+

+      if (var->type && var->type->is_array())

+	 non_array_type = var->type->fields.array;

+      else

+	 non_array_type = var->type;

+

+      if (non_array_type && non_array_type->base_type != GLSL_TYPE_FLOAT) {

+	 var->type = glsl_type::error_type;

+	 _mesa_glsl_error(loc, state,

+			  "varying variables must be of base type float");

+      }

+   }

+

+   /* If there is no qualifier that changes the mode of the variable, leave

+    * the setting alone.

+    */

+   if (qual->flags.q.in && qual->flags.q.out)

+      var->mode = ir_var_inout;

+   else if (qual->flags.q.attribute || qual->flags.q.in

+	    || (qual->flags.q.varying && (state->target == fragment_shader)))

+      var->mode = ir_var_in;

+   else if (qual->flags.q.out

+	    || (qual->flags.q.varying && (state->target == vertex_shader)))

+      var->mode = ir_var_out;

+   else if (qual->flags.q.uniform)

+      var->mode = ir_var_uniform;

+

+   if (state->all_invariant && (state->current_function == NULL)) {

+      switch (state->target) {

+      case vertex_shader:

+	 if (var->mode == ir_var_out)

+	    var->invariant = true;

+	 break;

+      case geometry_shader:

+	 if ((var->mode == ir_var_in) || (var->mode == ir_var_out))

+	    var->invariant = true;

+	 break;

+      case fragment_shader:

+	 if (var->mode == ir_var_in)

+	    var->invariant = true;

+	 break;

+      }

+   }

+

+   if (qual->flags.q.flat)

+      var->interpolation = ir_var_flat;

+   else if (qual->flags.q.noperspective)

+      var->interpolation = ir_var_noperspective;

+   else

+      var->interpolation = ir_var_smooth;

+

+   var->pixel_center_integer = qual->flags.q.pixel_center_integer;

+   var->origin_upper_left = qual->flags.q.origin_upper_left;

+   if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)

+       && (strcmp(var->name, "gl_FragCoord") != 0)) {

+      const char *const qual_string = (qual->flags.q.origin_upper_left)

+	 ? "origin_upper_left" : "pixel_center_integer";

+

+      _mesa_glsl_error(loc, state,

+		       "layout qualifier `%s' can only be applied to "

+		       "fragment shader input `gl_FragCoord'",

+		       qual_string);

+   }

+

+   if (qual->flags.q.explicit_location) {

+      const bool global_scope = (state->current_function == NULL);

+      bool fail = false;

+      const char *string = "";

+

+      /* In the vertex shader only shader inputs can be given explicit

+       * locations.

+       *

+       * In the fragment shader only shader outputs can be given explicit

+       * locations.

+       */

+      switch (state->target) {

+      case vertex_shader:

+	 if (!global_scope || (var->mode != ir_var_in)) {

+	    fail = true;

+	    string = "input";

+	 }

+	 break;

+

+      case geometry_shader:

+	 _mesa_glsl_error(loc, state,

+			  "geometry shader variables cannot be given "

+			  "explicit locations\n");

+	 break;

+

+      case fragment_shader:

+	 if (!global_scope || (var->mode != ir_var_in)) {

+	    fail = true;

+	    string = "output";

+	 }

+	 break;

+      };

+

+      if (fail) {

+	 _mesa_glsl_error(loc, state,

+			  "only %s shader %s variables can be given an "

+			  "explicit location\n",

+			  _mesa_glsl_shader_target_name(state->target),

+			  string);

+      } else {

+	 var->explicit_location = true;

+

+	 /* This bit of silliness is needed because invalid explicit locations

+	  * are supposed to be flagged during linking.  Small negative values

+	  * biased by VERT_ATTRIB_GENERIC0 or FRAG_RESULT_DATA0 could alias

+	  * built-in values (e.g., -16+VERT_ATTRIB_GENERIC0 = VERT_ATTRIB_POS).

+	  * The linker needs to be able to differentiate these cases.  This

+	  * ensures that negative values stay negative.

+	  */

+	 if (qual->location >= 0) {

+	    var->location = (state->target == vertex_shader)

+	       ? (qual->location + VERT_ATTRIB_GENERIC0)

+	       : (qual->location + FRAG_RESULT_DATA0);

+	 } else {

+	    var->location = qual->location;

+	 }

+      }

+   }

+

+   /* Does the declaration use the 'layout' keyword?

+    */

+   const bool uses_layout = qual->flags.q.pixel_center_integer

+      || qual->flags.q.origin_upper_left

+      || qual->flags.q.explicit_location;

+

+   /* Does the declaration use the deprecated 'attribute' or 'varying'

+    * keywords?

+    */

+   const bool uses_deprecated_qualifier = qual->flags.q.attribute

+      || qual->flags.q.varying;

+

+   /* Is the 'layout' keyword used with parameters that allow relaxed checking.

+    * Many implementations of GL_ARB_fragment_coord_conventions_enable and some

+    * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable

+    * allowed the layout qualifier to be used with 'varying' and 'attribute'.

+    * These extensions and all following extensions that add the 'layout'

+    * keyword have been modified to require the use of 'in' or 'out'.

+    *

+    * The following extension do not allow the deprecated keywords:

+    *

+    *    GL_AMD_conservative_depth

+    *    GL_ARB_gpu_shader5

+    *    GL_ARB_separate_shader_objects

+    *    GL_ARB_tesselation_shader

+    *    GL_ARB_transform_feedback3

+    *    GL_ARB_uniform_buffer_object

+    *

+    * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5

+    * allow layout with the deprecated keywords.

+    */

+   const bool relaxed_layout_qualifier_checking =

+      state->ARB_fragment_coord_conventions_enable;

+

+   if (uses_layout && uses_deprecated_qualifier) {

+      if (relaxed_layout_qualifier_checking) {

+	 _mesa_glsl_warning(loc, state,

+			    "`layout' qualifier may not be used with "

+			    "`attribute' or `varying'");

+      } else {

+	 _mesa_glsl_error(loc, state,

+			  "`layout' qualifier may not be used with "

+			  "`attribute' or `varying'");

+      }

+   }

+

+   /* Layout qualifiers for gl_FragDepth, which are enabled by extension

+    * AMD_conservative_depth.

+    */

+   int depth_layout_count = qual->flags.q.depth_any

+      + qual->flags.q.depth_greater

+      + qual->flags.q.depth_less

+      + qual->flags.q.depth_unchanged;

+   if (depth_layout_count > 0

+       && !state->AMD_conservative_depth_enable) {

+       _mesa_glsl_error(loc, state,

+                        "extension GL_AMD_conservative_depth must be enabled "

+			"to use depth layout qualifiers");

+   } else if (depth_layout_count > 0

+              && strcmp(var->name, "gl_FragDepth") != 0) {

+       _mesa_glsl_error(loc, state,

+                        "depth layout qualifiers can be applied only to "

+                        "gl_FragDepth");

+   } else if (depth_layout_count > 1

+              && strcmp(var->name, "gl_FragDepth") == 0) {

+      _mesa_glsl_error(loc, state,

+                       "at most one depth layout qualifier can be applied to "

+                       "gl_FragDepth");

+   }

+   if (qual->flags.q.depth_any)

+      var->depth_layout = ir_depth_layout_any;

+   else if (qual->flags.q.depth_greater)

+      var->depth_layout = ir_depth_layout_greater;

+   else if (qual->flags.q.depth_less)

+      var->depth_layout = ir_depth_layout_less;

+   else if (qual->flags.q.depth_unchanged)

+       var->depth_layout = ir_depth_layout_unchanged;

+   else

+       var->depth_layout = ir_depth_layout_none;

+

+   if (var->type->is_array() && state->language_version != 110) {

+      var->array_lvalue = true;

+   }

+}

+

+/**

+ * Get the variable that is being redeclared by this declaration

+ *

+ * Semantic checks to verify the validity of the redeclaration are also

+ * performed.  If semantic checks fail, compilation error will be emitted via

+ * \c _mesa_glsl_error, but a non-\c NULL pointer will still be returned.

+ *

+ * \returns

+ * A pointer to an existing variable in the current scope if the declaration

+ * is a redeclaration, \c NULL otherwise.

+ */

+ir_variable *

+get_variable_being_redeclared(ir_variable *var, ast_declaration *decl,

+			      struct _mesa_glsl_parse_state *state)

+{

+   /* Check if this declaration is actually a re-declaration, either to

+    * resize an array or add qualifiers to an existing variable.

+    *

+    * This is allowed for variables in the current scope, or when at

+    * global scope (for built-ins in the implicit outer scope).

+    */

+   ir_variable *earlier = state->symbols->get_variable(decl->identifier);

+   if (earlier == NULL ||

+       (state->current_function != NULL &&

+	!state->symbols->name_declared_this_scope(decl->identifier))) {

+      return NULL;

+   }

+

+

+   YYLTYPE loc = decl->get_location();

+

+   /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec,

+    *

+    * "It is legal to declare an array without a size and then

+    *  later re-declare the same name as an array of the same

+    *  type and specify a size."

+    */

+   if ((earlier->type->array_size() == 0)

+       && var->type->is_array()

+       && (var->type->element_type() == earlier->type->element_type())) {

+      /* FINISHME: This doesn't match the qualifiers on the two

+       * FINISHME: declarations.  It's not 100% clear whether this is

+       * FINISHME: required or not.

+       */

+

+      /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:

+       *

+       *     "The size [of gl_TexCoord] can be at most

+       *     gl_MaxTextureCoords."

+       */

+      const unsigned size = unsigned(var->type->array_size());

+      if ((strcmp("gl_TexCoord", var->name) == 0)

+	  && (size > state->Const.MaxTextureCoords)) {

+	 _mesa_glsl_error(& loc, state, "`gl_TexCoord' array size cannot "

+			  "be larger than gl_MaxTextureCoords (%u)\n",

+			  state->Const.MaxTextureCoords);

+      } else if ((size > 0) && (size <= earlier->max_array_access)) {

+	 _mesa_glsl_error(& loc, state, "array size must be > %u due to "

+			  "previous access",

+			  earlier->max_array_access);

+      }

+

+      earlier->type = var->type;

+      delete var;

+      var = NULL;

+   } else if (state->ARB_fragment_coord_conventions_enable

+	      && strcmp(var->name, "gl_FragCoord") == 0

+	      && earlier->type == var->type

+	      && earlier->mode == var->mode) {

+      /* Allow redeclaration of gl_FragCoord for ARB_fcc layout

+       * qualifiers.

+       */

+      earlier->origin_upper_left = var->origin_upper_left;

+      earlier->pixel_center_integer = var->pixel_center_integer;

+

+      /* According to section 4.3.7 of the GLSL 1.30 spec,

+       * the following built-in varaibles can be redeclared with an

+       * interpolation qualifier:

+       *    * gl_FrontColor

+       *    * gl_BackColor

+       *    * gl_FrontSecondaryColor

+       *    * gl_BackSecondaryColor

+       *    * gl_Color

+       *    * gl_SecondaryColor

+       */

+   } else if (state->language_version >= 130

+	      && (strcmp(var->name, "gl_FrontColor") == 0

+		  || strcmp(var->name, "gl_BackColor") == 0

+		  || strcmp(var->name, "gl_FrontSecondaryColor") == 0

+		  || strcmp(var->name, "gl_BackSecondaryColor") == 0

+		  || strcmp(var->name, "gl_Color") == 0

+		  || strcmp(var->name, "gl_SecondaryColor") == 0)

+	      && earlier->type == var->type

+	      && earlier->mode == var->mode) {

+      earlier->interpolation = var->interpolation;

+

+      /* Layout qualifiers for gl_FragDepth. */

+   } else if (state->AMD_conservative_depth_enable

+	      && strcmp(var->name, "gl_FragDepth") == 0

+	      && earlier->type == var->type

+	      && earlier->mode == var->mode) {

+

+      /** From the AMD_conservative_depth spec:

+       *     Within any shader, the first redeclarations of gl_FragDepth

+       *     must appear before any use of gl_FragDepth.

+       */

+      if (earlier->used) {

+	 _mesa_glsl_error(&loc, state,

+			  "the first redeclaration of gl_FragDepth "

+			  "must appear before any use of gl_FragDepth");

+      }

+

+      /* Prevent inconsistent redeclaration of depth layout qualifier. */

+      if (earlier->depth_layout != ir_depth_layout_none

+	  && earlier->depth_layout != var->depth_layout) {

+	 _mesa_glsl_error(&loc, state,

+			  "gl_FragDepth: depth layout is declared here "

+			  "as '%s, but it was previously declared as "

+			  "'%s'",

+			  depth_layout_string(var->depth_layout),

+			  depth_layout_string(earlier->depth_layout));

+      }

+

+      earlier->depth_layout = var->depth_layout;

+

+   } else {

+      _mesa_glsl_error(&loc, state, "`%s' redeclared", decl->identifier);

+   }

+

+   return earlier;

+}

+

+/**

+ * Generate the IR for an initializer in a variable declaration

+ */

+ir_rvalue *

+process_initializer(ir_variable *var, ast_declaration *decl,

+		    ast_fully_specified_type *type,

+		    exec_list *initializer_instructions,

+		    struct _mesa_glsl_parse_state *state)

+{

+   ir_rvalue *result = NULL;

+

+   YYLTYPE initializer_loc = decl->initializer->get_location();

+

+   /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:

+    *

+    *    "All uniform variables are read-only and are initialized either

+    *    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->type->is_sampler()) {

+      _mesa_glsl_error(& initializer_loc, state,

+		       "cannot initialize samplers");

+   }

+

+   if ((var->mode == ir_var_in) && (state->current_function == NULL)) {

+      _mesa_glsl_error(& initializer_loc, state,

+		       "cannot initialize %s shader input / %s",

+		       _mesa_glsl_shader_target_name(state->target),

+		       (state->target == vertex_shader)

+		       ? "attribute" : "varying");

+   }

+

+   ir_dereference *const lhs = new(state) ir_dereference_variable(var);

+   ir_rvalue *rhs = decl->initializer->hir(initializer_instructions,

+					   state);

+

+   /* Calculate the constant value if this is a const or uniform

+    * declaration.

+    */

+   if (type->qualifier.flags.q.constant

+       || type->qualifier.flags.q.uniform) {

+      ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs);

+      if (new_rhs != NULL) {

+	 rhs = new_rhs;

+

+	 ir_constant *constant_value = rhs->constant_expression_value();

+	 if (!constant_value) {

+	    _mesa_glsl_error(& initializer_loc, state,

+			     "initializer of %s variable `%s' must be a "

+			     "constant expression",

+			     (type->qualifier.flags.q.constant)

+			     ? "const" : "uniform",

+			     decl->identifier);

+	    if (var->type->is_numeric()) {

+	       /* Reduce cascading errors. */

+	       var->constant_value = ir_constant::zero(state, var->type);

+	    }

+	 } else {

+	    rhs = constant_value;

+	    var->constant_value = constant_value;

+	 }

+      } else {

+	 _mesa_glsl_error(&initializer_loc, state,

+			  "initializer of type %s cannot be assigned to "

+			  "variable of type %s",

+			  rhs->type->name, var->type->name);

+	 if (var->type->is_numeric()) {

+	    /* Reduce cascading errors. */

+	    var->constant_value = ir_constant::zero(state, var->type);

+	 }

+      }

+   }

+

+   if (rhs && !rhs->type->is_error()) {

+      bool temp = var->read_only;

+      if (type->qualifier.flags.q.constant)

+	 var->read_only = false;

+

+      /* Never emit code to initialize a uniform.

+       */

+      const glsl_type *initializer_type;

+      if (!type->qualifier.flags.q.uniform) {

+	 result = do_assignment(initializer_instructions, state,

+				lhs, rhs,

+				type->get_location());

+	 initializer_type = result->type;

+      } else

+	 initializer_type = rhs->type;

+

+      /* If the declared variable is an unsized array, it must inherrit

+       * its full type from the initializer.  A declaration such as

+       *

+       *     uniform float a[] = float[](1.0, 2.0, 3.0, 3.0);

+       *

+       * becomes

+       *

+       *     uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0);

+       *

+       * The assignment generated in the if-statement (below) will also

+       * automatically handle this case for non-uniforms.

+       *

+       * If the declared variable is not an array, the types must

+       * already match exactly.  As a result, the type assignment

+       * here can be done unconditionally.  For non-uniforms the call

+       * to do_assignment can change the type of the initializer (via

+       * the implicit conversion rules).  For uniforms the initializer

+       * must be a constant expression, and the type of that expression

+       * was validated above.

+       */

+      var->type = initializer_type;

+

+      var->read_only = temp;

+   }

+

+   return result;

+}

+

+ir_rvalue *

+ast_declarator_list::hir(exec_list *instructions,

+			 struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+   const struct glsl_type *decl_type;

+   const char *type_name = NULL;

+   ir_rvalue *result = NULL;

+   YYLTYPE loc = this->get_location();

+

+   /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec:

+    *

+    *     "To ensure that a particular output variable is invariant, it is

+    *     necessary to use the invariant qualifier. It can either be used to

+    *     qualify a previously declared variable as being invariant

+    *

+    *         invariant gl_Position; // make existing gl_Position be invariant"

+    *

+    * In these cases the parser will set the 'invariant' flag in the declarator

+    * list, and the type will be NULL.

+    */

+   if (this->invariant) {

+      assert(this->type == NULL);

+

+      if (state->current_function != NULL) {

+	 _mesa_glsl_error(& loc, state,

+			  "All uses of `invariant' keyword must be at global "

+			  "scope\n");

+      }

+

+      foreach_list_typed (ast_declaration, decl, link, &this->declarations) {

+	 assert(!decl->is_array);

+	 assert(decl->array_size == NULL);

+	 assert(decl->initializer == NULL);

+

+	 ir_variable *const earlier =

+	    state->symbols->get_variable(decl->identifier);

+	 if (earlier == NULL) {

+	    _mesa_glsl_error(& loc, state,

+			     "Undeclared variable `%s' cannot be marked "

+			     "invariant\n", decl->identifier);

+	 } else if ((state->target == vertex_shader)

+	       && (earlier->mode != ir_var_out)) {

+	    _mesa_glsl_error(& loc, state,

+			     "`%s' cannot be marked invariant, vertex shader "

+			     "outputs only\n", decl->identifier);

+	 } else if ((state->target == fragment_shader)

+	       && (earlier->mode != ir_var_in)) {

+	    _mesa_glsl_error(& loc, state,

+			     "`%s' cannot be marked invariant, fragment shader "

+			     "inputs only\n", decl->identifier);

+	 } else if (earlier->used) {

+	    _mesa_glsl_error(& loc, state,

+			     "variable `%s' may not be redeclared "

+			     "`invariant' after being used",

+			     earlier->name);

+	 } else {

+	    earlier->invariant = true;

+	 }

+      }

+

+      /* Invariant redeclarations do not have r-values.

+       */

+      return NULL;

+   }

+

+   assert(this->type != NULL);

+   assert(!this->invariant);

+

+   /* The type specifier may contain a structure definition.  Process that

+    * before any of the variable declarations.

+    */

+   (void) this->type->specifier->hir(instructions, state);

+

+   decl_type = this->type->specifier->glsl_type(& type_name, state);

+   if (this->declarations.is_empty()) {

+      /* The only valid case where the declaration list can be empty is when

+       * the declaration is setting the default precision of a built-in type

+       * (e.g., 'precision highp vec4;').

+       */

+

+      if (decl_type != NULL) {

+      } else {

+	    _mesa_glsl_error(& loc, state, "incomplete declaration");

+      }

+   }

+

+   foreach_list_typed (ast_declaration, decl, link, &this->declarations) {

+      const struct glsl_type *var_type;

+      ir_variable *var;

+

+      /* FINISHME: Emit a warning if a variable declaration shadows a

+       * FINISHME: declaration at a higher scope.

+       */

+

+      if ((decl_type == NULL) || decl_type->is_void()) {

+	 if (type_name != NULL) {

+	    _mesa_glsl_error(& loc, state,

+			     "invalid type `%s' in declaration of `%s'",

+			     type_name, decl->identifier);

+	 } else {

+	    _mesa_glsl_error(& loc, state,

+			     "invalid type in declaration of `%s'",

+			     decl->identifier);

+	 }

+	 continue;

+      }

+

+      if (decl->is_array) {

+	 var_type = process_array_type(&loc, decl_type, decl->array_size,

+				       state);

+      } else {

+	 var_type = decl_type;

+      }

+

+      var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto);

+

+      /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;

+       *

+       *     "Global variables can only use the qualifiers const,

+       *     attribute, uni form, or varying. Only one may be

+       *     specified.

+       *

+       *     Local variables can only use the qualifier const."

+       *

+       * This is relaxed in GLSL 1.30.  It is also relaxed by any extension

+       * that adds the 'layout' keyword.

+       */

+      if ((state->language_version < 130)

+	  && !state->ARB_explicit_attrib_location_enable

+	  && !state->ARB_fragment_coord_conventions_enable) {

+	 if (this->type->qualifier.flags.q.out) {

+	    _mesa_glsl_error(& loc, state,

+			     "`out' qualifier in declaration of `%s' "

+			     "only valid for function parameters in %s.",

+			     decl->identifier, state->version_string);

+	 }

+	 if (this->type->qualifier.flags.q.in) {

+	    _mesa_glsl_error(& loc, state,

+			     "`in' qualifier in declaration of `%s' "

+			     "only valid for function parameters in %s.",

+			     decl->identifier, state->version_string);

+	 }

+	 /* FINISHME: Test for other invalid qualifiers. */

+      }

+

+      apply_type_qualifier_to_variable(& this->type->qualifier, var, state,

+				       & loc);

+

+      if (this->type->qualifier.flags.q.invariant) {

+	 if ((state->target == vertex_shader) && !(var->mode == ir_var_out ||

+						   var->mode == ir_var_inout)) {

+	    /* FINISHME: Note that this doesn't work for invariant on

+	     * a function signature outval

+	     */

+	    _mesa_glsl_error(& loc, state,

+			     "`%s' cannot be marked invariant, vertex shader "

+			     "outputs only\n", var->name);

+	 } else if ((state->target == fragment_shader) &&

+		    !(var->mode == ir_var_in || var->mode == ir_var_inout)) {

+	    /* FINISHME: Note that this doesn't work for invariant on

+	     * a function signature inval

+	     */

+	    _mesa_glsl_error(& loc, state,

+			     "`%s' cannot be marked invariant, fragment shader "

+			     "inputs only\n", var->name);

+	 }

+      }

+

+      if (state->current_function != NULL) {

+	 const char *mode = NULL;

+	 const char *extra = "";

+

+	 /* There is no need to check for 'inout' here because the parser will

+	  * only allow that in function parameter lists.

+	  */

+	 if (this->type->qualifier.flags.q.attribute) {

+	    mode = "attribute";

+	 } else if (this->type->qualifier.flags.q.uniform) {

+	    mode = "uniform";

+	 } else if (this->type->qualifier.flags.q.varying) {

+	    mode = "varying";

+	 } else if (this->type->qualifier.flags.q.in) {

+	    mode = "in";

+	    extra = " or in function parameter list";

+	 } else if (this->type->qualifier.flags.q.out) {

+	    mode = "out";

+	    extra = " or in function parameter list";

+	 }

+

+	 if (mode) {

+	    _mesa_glsl_error(& loc, state,

+			     "%s variable `%s' must be declared at "

+			     "global scope%s",

+			     mode, var->name, extra);

+	 }

+      } else if (var->mode == ir_var_in) {

+         var->read_only = true;

+

+	 if (state->target == vertex_shader) {

+	    bool error_emitted = false;

+

+	    /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:

+	     *

+	     *    "Vertex shader inputs can only be float, floating-point

+	     *    vectors, matrices, signed and unsigned integers and integer

+	     *    vectors. Vertex shader inputs can also form arrays of these

+	     *    types, but not structures."

+	     *

+	     * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:

+	     *

+	     *    "Vertex shader inputs can only be float, floating-point

+	     *    vectors, matrices, signed and unsigned integers and integer

+	     *    vectors. They cannot be arrays or structures."

+	     *

+	     * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:

+	     *

+	     *    "The attribute qualifier can be used only with float,

+	     *    floating-point vectors, and matrices. Attribute variables

+	     *    cannot be declared as arrays or structures."

+	     */

+	    const glsl_type *check_type = var->type->is_array()

+	       ? var->type->fields.array : var->type;

+

+	    switch (check_type->base_type) {

+	    case GLSL_TYPE_FLOAT:

+	       break;

+	    case GLSL_TYPE_UINT:

+	    case GLSL_TYPE_INT:

+	       if (state->language_version > 120)

+		  break;

+	       /* FALLTHROUGH */

+	    default:

+	       _mesa_glsl_error(& loc, state,

+				"vertex shader input / attribute cannot have "

+				"type %s`%s'",

+				var->type->is_array() ? "array of " : "",

+				check_type->name);

+	       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");

+	       error_emitted = true;

+	    }

+	 }

+      }

+

+      /* Integer vertex outputs must be qualified with 'flat'.

+       *

+       * From section 4.3.6 of the GLSL 1.30 spec:

+       *    "If a vertex output is a signed or unsigned integer or integer

+       *    vector, then it must be qualified with the interpolation qualifier

+       *    flat."

+       */

+      if (state->language_version >= 130

+          && state->target == vertex_shader

+          && state->current_function == NULL

+          && var->type->is_integer()

+          && var->mode == ir_var_out

+          && var->interpolation != ir_var_flat) {

+

+         _mesa_glsl_error(&loc, state, "If a vertex output is an integer, "

+                          "then it must be qualified with 'flat'");

+      }

+

+

+      /* Interpolation qualifiers cannot be applied to 'centroid' and

+       * 'centroid varying'.

+       *

+       * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:

+       *    "interpolation qualifiers may only precede the qualifiers in,

+       *    centroid in, out, or centroid out in a declaration. They do not apply

+       *    to the deprecated storage qualifiers varying or centroid varying."

+       */

+      if (state->language_version >= 130

+          && this->type->qualifier.has_interpolation()

+          && this->type->qualifier.flags.q.varying) {

+

+         const char *i = this->type->qualifier.interpolation_string();

+         assert(i != NULL);

+         const char *s;

+         if (this->type->qualifier.flags.q.centroid)

+            s = "centroid varying";

+         else

+            s = "varying";

+

+         _mesa_glsl_error(&loc, state,

+                          "qualifier '%s' cannot be applied to the "

+                          "deprecated storage qualifier '%s'", i, s);

+      }

+

+

+      /* Interpolation qualifiers can only apply to vertex shader outputs and

+       * fragment shader inputs.

+       *

+       * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:

+       *    "Outputs from a vertex shader (out) and inputs to a fragment

+       *    shader (in) can be further qualified with one or more of these

+       *    interpolation qualifiers"

+       */

+      if (state->language_version >= 130

+          && this->type->qualifier.has_interpolation()) {

+

+         const char *i = this->type->qualifier.interpolation_string();

+         assert(i != NULL);

+

+         switch (state->target) {

+         case vertex_shader:

+            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:

+            if (this->type->qualifier.flags.q.out) {

+               _mesa_glsl_error(&loc, state,

+                                "qualifier '%s' cannot be applied to fragment "

+                                "shader outputs", i);

+            }

+            break;

+         default:

+            assert(0);

+         }

+      }

+

+

+      /* From section 4.3.4 of the GLSL 1.30 spec:

+       *    "It is an error to use centroid in in a vertex shader."

+       */

+      if (state->language_version >= 130

+          && this->type->qualifier.flags.q.centroid

+          && this->type->qualifier.flags.q.in

+          && state->target == vertex_shader) {

+

+         _mesa_glsl_error(&loc, state,

+                          "'centroid in' cannot be used in a vertex shader");

+      }

+

+

+      /* 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");

+      }

+

+

+      /* Precision qualifiers only apply to floating point and integer types.

+       *

+       * From section 4.5.2 of the GLSL 1.30 spec:

+       *    "Any floating point or any integer declaration can have the type

+       *    preceded by one of these precision qualifiers [...] Literal

+       *    constants do not have precision qualifiers. Neither do Boolean

+       *    variables.

+       */

+      if (this->type->specifier->precision != ast_precision_none

+          && !var->type->is_float()

+          && !var->type->is_integer()

+          && !(var->type->is_array()

+               && (var->type->fields.array->is_float()

+                   || var->type->fields.array->is_integer()))) {

+

+         _mesa_glsl_error(&loc, state,

+                          "precision qualifiers apply only to floating point "

+                          "and integer types");

+      }

+

+      /* Process the initializer and add its instructions to a temporary

+       * list.  This list will be added to the instruction stream (below) after

+       * the declaration is added.  This is done because in some cases (such as

+       * redeclarations) the declaration may not actually be added to the

+       * instruction stream.

+       */

+      exec_list initializer_instructions;

+      ir_variable *earlier = get_variable_being_redeclared(var, decl, state);

+

+      if (decl->initializer != NULL) {

+	 result = process_initializer((earlier == NULL) ? var : earlier,

+				      decl, this->type,

+				      &initializer_instructions, state);

+      }

+

+      /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:

+       *

+       *     "It is an error to write to a const variable outside of

+       *      its declaration, so they must be initialized when

+       *      declared."

+       */

+      if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {

+	 _mesa_glsl_error(& loc, state,

+			  "const declaration of `%s' must be initialized",

+			  decl->identifier);

+      }

+

+      /* If the declaration is not a redeclaration, there are a few additional

+       * semantic checks that must be applied.  In addition, variable that was

+       * created for the declaration should be added to the IR stream.

+       */

+      if (earlier == NULL) {

+	 /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,

+	  *

+	  *   "Identifiers starting with "gl_" are reserved for use by

+	  *   OpenGL, and may not be declared in a shader as either a

+	  *   variable or a function."

+	  */

+	 if (strncmp(decl->identifier, "gl_", 3) == 0)

+	    _mesa_glsl_error(& loc, state,

+			     "identifier `%s' uses reserved `gl_' prefix",

+			     decl->identifier);

+

+	 /* Add the variable to the symbol table.  Note that the initializer's

+	  * IR was already processed earlier (though it hasn't been emitted

+	  * yet), without the variable in scope.

+	  *

+	  * This differs from most C-like languages, but it follows the GLSL

+	  * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50

+	  * spec:

+	  *

+	  *     "Within a declaration, the scope of a name starts immediately

+	  *     after the initializer if present or immediately after the name

+	  *     being declared if not."

+	  */

+	 if (!state->symbols->add_variable(var)) {

+	    YYLTYPE loc = this->get_location();

+	    _mesa_glsl_error(&loc, state, "name `%s' already taken in the "

+			     "current scope", decl->identifier);

+	    continue;

+	 }

+

+	 /* Push the variable declaration to the top.  It means that all the

+	  * variable declarations will appear in a funny last-to-first order,

+	  * but otherwise we run into trouble if a function is prototyped, a

+	  * global var is decled, then the function is defined with usage of

+	  * the global var.  See glslparsertest's CorrectModule.frag.

+	  */

+	 instructions->push_head(var);

+      }

+

+      instructions->append_list(&initializer_instructions);

+   }

+

+

+   /* Generally, variable declarations do not have r-values.  However,

+    * one is used for the declaration in

+    *

+    * while (bool b = some_condition()) {

+    *   ...

+    * }

+    *

+    * so we return the rvalue from the last seen declaration here.

+    */

+   return result;

+}

+

+

+ir_rvalue *

+ast_parameter_declarator::hir(exec_list *instructions,

+			      struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+   const struct glsl_type *type;

+   const char *name = NULL;

+   YYLTYPE loc = this->get_location();

+

+   type = this->type->specifier->glsl_type(& name, state);

+

+   if (type == NULL) {

+      if (name != NULL) {

+	 _mesa_glsl_error(& loc, state,

+			  "invalid type `%s' in declaration of `%s'",

+			  name, this->identifier);

+      } else {

+	 _mesa_glsl_error(& loc, state,

+			  "invalid type in declaration of `%s'",

+			  this->identifier);

+      }

+

+      type = glsl_type::error_type;

+   }

+

+   /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec:

+    *

+    *    "Functions that accept no input arguments need not use void in the

+    *    argument list because prototypes (or definitions) are required and

+    *    therefore there is no ambiguity when an empty argument list "( )" is

+    *    declared. The idiom "(void)" as a parameter list is provided for

+    *    convenience."

+    *

+    * Placing this check here prevents a void parameter being set up

+    * for a function, which avoids tripping up checks for main taking

+    * parameters and lookups of an unnamed symbol.

+    */

+   if (type->is_void()) {

+      if (this->identifier != NULL)

+	 _mesa_glsl_error(& loc, state,

+			  "named parameter cannot have type `void'");

+

+      is_void = true;

+      return NULL;

+   }

+

+   if (formal_parameter && (this->identifier == NULL)) {

+      _mesa_glsl_error(& loc, state, "formal parameter lacks a name");

+      return NULL;

+   }

+

+   /* This only handles "vec4 foo[..]".  The earlier specifier->glsl_type(...)

+    * call already handled the "vec4[..] foo" case.

+    */

+   if (this->is_array) {

+      type = process_array_type(&loc, type, this->array_size, state);

+   }

+

+   if (type->array_size() == 0) {

+      _mesa_glsl_error(&loc, state, "arrays passed as parameters must have "

+		       "a declared size.");

+      type = glsl_type::error_type;

+   }

+

+   is_void = false;

+   ir_variable *var = new(ctx) ir_variable(type, this->identifier, ir_var_in);

+

+   /* Apply any specified qualifiers to the parameter declaration.  Note that

+    * for function parameters the default mode is 'in'.

+    */

+   apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc);

+

+   instructions->push_tail(var);

+

+   /* Parameter declarations do not have r-values.

+    */

+   return NULL;

+}

+

+

+void

+ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,

+					    bool formal,

+					    exec_list *ir_parameters,

+					    _mesa_glsl_parse_state *state)

+{

+   ast_parameter_declarator *void_param = NULL;

+   unsigned count = 0;

+

+   foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters) {

+      param->formal_parameter = formal;

+      param->hir(ir_parameters, state);

+

+      if (param->is_void)

+	 void_param = param;

+

+      count++;

+   }

+

+   if ((void_param != NULL) && (count > 1)) {

+      YYLTYPE loc = void_param->get_location();

+

+      _mesa_glsl_error(& loc, state,

+		       "`void' parameter must be only parameter");

+   }

+}

+

+

+void

+emit_function(_mesa_glsl_parse_state *state, exec_list *instructions,

+	      ir_function *f)

+{

+   /* Emit the new function header */

+   if (state->current_function == NULL) {

+      instructions->push_tail(f);

+   } else {

+      /* IR invariants disallow function declarations or definitions nested

+       * within other function definitions.  Insert the new ir_function

+       * block in the instruction sequence before the ir_function block

+       * containing the current ir_function_signature.

+       */

+      ir_function *const curr =

+	 const_cast<ir_function *>(state->current_function->function());

+

+      curr->insert_before(f);

+   }

+}

+

+

+ir_rvalue *

+ast_function::hir(exec_list *instructions,

+		  struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+   ir_function *f = NULL;

+   ir_function_signature *sig = NULL;

+   exec_list hir_parameters;

+

+   const char *const name = identifier;

+

+   /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec,

+    *

+    *   "Function declarations (prototypes) cannot occur inside of functions;

+    *   they must be at global scope, or for the built-in functions, outside

+    *   the global scope."

+    *

+    * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec,

+    *

+    *   "User defined functions may only be defined within the global scope."

+    *

+    * Note that this language does not appear in GLSL 1.10.

+    */

+   if ((state->current_function != NULL) && (state->language_version != 110)) {

+      YYLTYPE loc = this->get_location();

+      _mesa_glsl_error(&loc, state,

+		       "declaration of function `%s' not allowed within "

+		       "function body", name);

+   }

+

+   /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,

+    *

+    *   "Identifiers starting with "gl_" are reserved for use by

+    *   OpenGL, and may not be declared in a shader as either a

+    *   variable or a function."

+    */

+   if (strncmp(name, "gl_", 3) == 0) {

+      YYLTYPE loc = this->get_location();

+      _mesa_glsl_error(&loc, state,

+		       "identifier `%s' uses reserved `gl_' prefix", name);

+   }

+

+   /* Convert the list of function parameters to HIR now so that they can be

+    * used below to compare this function's signature with previously seen

+    * signatures for functions with the same name.

+    */

+   ast_parameter_declarator::parameters_to_hir(& this->parameters,

+					       is_definition,

+					       & hir_parameters, state);

+

+   const char *return_type_name;

+   const glsl_type *return_type =

+      this->return_type->specifier->glsl_type(& return_type_name, state);

+

+   if (!return_type) {

+      YYLTYPE loc = this->get_location();

+      _mesa_glsl_error(&loc, state,

+		       "function `%s' has undeclared return type `%s'",

+		       name, return_type_name);

+      return_type = glsl_type::error_type;

+   }

+

+   /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec:

+    * "No qualifier is allowed on the return type of a function."

+    */

+   if (this->return_type->has_qualifiers()) {

+      YYLTYPE loc = this->get_location();

+      _mesa_glsl_error(& loc, state,

+		       "function `%s' return type has qualifiers", name);

+   }

+

+   /* Verify that this function's signature either doesn't match a previously

+    * seen signature for a function with the same name, or, if a match is found,

+    * that the previously seen signature does not have an associated definition.

+    */

+   f = state->symbols->get_function(name);

+   if (f != NULL && (state->es_shader || f->has_user_signature())) {

+      sig = f->exact_matching_signature(&hir_parameters);

+      if (sig != NULL) {

+	 const char *badvar = sig->qualifiers_match(&hir_parameters);

+	 if (badvar != NULL) {

+	    YYLTYPE loc = this->get_location();

+

+	    _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "

+			     "qualifiers don't match prototype", name, badvar);

+	 }

+

+	 if (sig->return_type != return_type) {

+	    YYLTYPE loc = this->get_location();

+

+	    _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "

+			     "match prototype", name);

+	 }

+

+	 if (is_definition && sig->is_defined) {

+	    YYLTYPE loc = this->get_location();

+

+	    _mesa_glsl_error(& loc, state, "function `%s' redefined", name);

+	 }

+      }

+   } else {

+      f = new(ctx) ir_function(name);

+      if (!state->symbols->add_function(f)) {

+	 /* This function name shadows a non-function use of the same name. */

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "

+			  "non-function", name);

+	 return NULL;

+      }

+

+      emit_function(state, instructions, f);

+   }

+

+   /* Verify the return type of main() */

+   if (strcmp(name, "main") == 0) {

+      if (! return_type->is_void()) {

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(& loc, state, "main() must return void");

+      }

+

+      if (!hir_parameters.is_empty()) {

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(& loc, state, "main() must not take any parameters");

+      }

+   }

+

+   /* Finish storing the information about this new function in its signature.

+    */

+   if (sig == NULL) {

+      sig = new(ctx) ir_function_signature(return_type);

+      f->add_signature(sig);

+   }

+

+   sig->replace_parameters(&hir_parameters);

+   signature = sig;

+

+   /* Function declarations (prototypes) do not have r-values.

+    */

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_function_definition::hir(exec_list *instructions,

+			     struct _mesa_glsl_parse_state *state)

+{

+   prototype->is_definition = true;

+   prototype->hir(instructions, state);

+

+   ir_function_signature *signature = prototype->signature;

+   if (signature == NULL)

+      return NULL;

+

+   assert(state->current_function == NULL);

+   state->current_function = signature;

+   state->found_return = false;

+

+   /* Duplicate parameters declared in the prototype as concrete variables.

+    * Add these to the symbol table.

+    */

+   state->symbols->push_scope();

+   foreach_iter(exec_list_iterator, iter, signature->parameters) {

+      ir_variable *const var = ((ir_instruction *) iter.get())->as_variable();

+

+      assert(var != NULL);

+

+      /* The only way a parameter would "exist" is if two parameters have

+       * the same name.

+       */

+      if (state->symbols->name_declared_this_scope(var->name)) {

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);

+      } else {

+	 state->symbols->add_variable(var);

+      }

+   }

+

+   /* Convert the body of the function to HIR. */

+   this->body->hir(&signature->body, state);

+   signature->is_defined = true;

+

+   state->symbols->pop_scope();

+

+   assert(state->current_function == signature);

+   state->current_function = NULL;

+

+   if (!signature->return_type->is_void() && !state->found_return) {

+      YYLTYPE loc = this->get_location();

+      _mesa_glsl_error(& loc, state, "function `%s' has non-void return type "

+		       "%s, but no return statement",

+		       signature->function_name(),

+		       signature->return_type->name);

+   }

+

+   /* Function definitions do not have r-values.

+    */

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_jump_statement::hir(exec_list *instructions,

+			struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+

+   switch (mode) {

+   case ast_return: {

+      ir_return *inst;

+      assert(state->current_function);

+

+      if (opt_return_value) {

+	 ir_rvalue *const ret = opt_return_value->hir(instructions, state);

+

+	 /* The value of the return type can be NULL if the shader says

+	  * 'return foo();' and foo() is a function that returns void.

+	  *

+	  * NOTE: The GLSL spec doesn't say that this is an error.  The type

+	  * of the return value is void.  If the return type of the function is

+	  * also void, then this should compile without error.  Seriously.

+	  */

+	 const glsl_type *const ret_type =

+	    (ret == NULL) ? glsl_type::void_type : ret->type;

+

+	 /* Implicit conversions are not allowed for return values. */

+	 if (state->current_function->return_type != ret_type) {

+	    YYLTYPE loc = this->get_location();

+

+	    _mesa_glsl_error(& loc, state,

+			     "`return' with wrong type %s, in function `%s' "

+			     "returning %s",

+			     ret_type->name,

+			     state->current_function->function_name(),

+			     state->current_function->return_type->name);

+	 }

+

+	 inst = new(ctx) ir_return(ret);

+      } else {

+	 if (state->current_function->return_type->base_type !=

+	     GLSL_TYPE_VOID) {

+	    YYLTYPE loc = this->get_location();

+

+	    _mesa_glsl_error(& loc, state,

+			     "`return' with no value, in function %s returning "

+			     "non-void",

+			     state->current_function->function_name());

+	 }

+	 inst = new(ctx) ir_return;

+      }

+

+      state->found_return = true;

+      instructions->push_tail(inst);

+      break;

+   }

+

+   case ast_discard:

+      if (state->target != fragment_shader) {

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(& loc, state,

+			  "`discard' may only appear in a fragment shader");

+      }

+      instructions->push_tail(new(ctx) ir_discard);

+      break;

+

+   case ast_break:

+   case ast_continue:

+      /* FINISHME: Handle switch-statements.  They cannot contain 'continue',

+       * FINISHME: and they use a different IR instruction for 'break'.

+       */

+      /* FINISHME: Correctly handle the nesting.  If a switch-statement is

+       * FINISHME: inside a loop, a 'continue' is valid and will bind to the

+       * FINISHME: loop.

+       */

+      if (state->loop_or_switch_nesting == NULL) {

+	 YYLTYPE loc = this->get_location();

+

+	 _mesa_glsl_error(& loc, state,

+			  "`%s' may only appear in a loop",

+			  (mode == ast_break) ? "break" : "continue");

+      } else {

+	 ir_loop *const loop = state->loop_or_switch_nesting->as_loop();

+

+	 /* Inline the for loop expression again, since we don't know

+	  * where near the end of the loop body the normal copy of it

+	  * is going to be placed.

+	  */

+	 if (mode == ast_continue &&

+	     state->loop_or_switch_nesting_ast->rest_expression) {

+	    state->loop_or_switch_nesting_ast->rest_expression->hir(instructions,

+								    state);

+	 }

+

+	 if (loop != NULL) {

+	    ir_loop_jump *const jump =

+	       new(ctx) ir_loop_jump((mode == ast_break)

+				     ? ir_loop_jump::jump_break

+				     : ir_loop_jump::jump_continue);

+	    instructions->push_tail(jump);

+	 }

+      }

+

+      break;

+   }

+

+   /* Jump instructions do not have r-values.

+    */

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_selection_statement::hir(exec_list *instructions,

+			     struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+

+   ir_rvalue *const condition = this->condition->hir(instructions, state);

+

+   /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec:

+    *

+    *    "Any expression whose type evaluates to a Boolean can be used as the

+    *    conditional expression bool-expression. Vector types are not accepted

+    *    as the expression to if."

+    *

+    * The checks are separated so that higher quality diagnostics can be

+    * generated for cases where both rules are violated.

+    */

+   if (!condition->type->is_boolean() || !condition->type->is_scalar()) {

+      YYLTYPE loc = this->condition->get_location();

+

+      _mesa_glsl_error(& loc, state, "if-statement condition must be scalar "

+		       "boolean");

+   }

+

+   ir_if *const stmt = new(ctx) ir_if(condition);

+

+   if (then_statement != NULL) {

+      state->symbols->push_scope();

+      then_statement->hir(& stmt->then_instructions, state);

+      state->symbols->pop_scope();

+   }

+

+   if (else_statement != NULL) {

+      state->symbols->push_scope();

+      else_statement->hir(& stmt->else_instructions, state);

+      state->symbols->pop_scope();

+   }

+

+   instructions->push_tail(stmt);

+

+   /* if-statements do not have r-values.

+    */

+   return NULL;

+}

+

+

+void

+ast_iteration_statement::condition_to_hir(ir_loop *stmt,

+					  struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+

+   if (condition != NULL) {

+      ir_rvalue *const cond =

+	 condition->hir(& stmt->body_instructions, state);

+

+      if ((cond == NULL)

+	  || !cond->type->is_boolean() || !cond->type->is_scalar()) {

+	 YYLTYPE loc = condition->get_location();

+

+	 _mesa_glsl_error(& loc, state,

+			  "loop condition must be scalar boolean");

+      } else {

+	 /* As the first code in the loop body, generate a block that looks

+	  * like 'if (!condition) break;' as the loop termination condition.

+	  */

+	 ir_rvalue *const not_cond =

+	    new(ctx) ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond,

+				   NULL);

+

+	 ir_if *const if_stmt = new(ctx) ir_if(not_cond);

+

+	 ir_jump *const break_stmt =

+	    new(ctx) ir_loop_jump(ir_loop_jump::jump_break);

+

+	 if_stmt->then_instructions.push_tail(break_stmt);

+	 stmt->body_instructions.push_tail(if_stmt);

+      }

+   }

+}

+

+

+ir_rvalue *

+ast_iteration_statement::hir(exec_list *instructions,

+			     struct _mesa_glsl_parse_state *state)

+{

+   void *ctx = state;

+

+   /* For-loops and while-loops start a new scope, but do-while loops do not.

+    */

+   if (mode != ast_do_while)

+      state->symbols->push_scope();

+

+   if (init_statement != NULL)

+      init_statement->hir(instructions, state);

+

+   ir_loop *const stmt = new(ctx) ir_loop();

+   instructions->push_tail(stmt);

+

+   /* Track the current loop and / or switch-statement nesting.

+    */

+   ir_instruction *const nesting = state->loop_or_switch_nesting;

+   ast_iteration_statement *nesting_ast = state->loop_or_switch_nesting_ast;

+

+   state->loop_or_switch_nesting = stmt;

+   state->loop_or_switch_nesting_ast = this;

+

+   if (mode != ast_do_while)

+      condition_to_hir(stmt, state);

+

+   if (body != NULL)

+      body->hir(& stmt->body_instructions, state);

+

+   if (rest_expression != NULL)

+      rest_expression->hir(& stmt->body_instructions, state);

+

+   if (mode == ast_do_while)

+      condition_to_hir(stmt, state);

+

+   if (mode != ast_do_while)

+      state->symbols->pop_scope();

+

+   /* Restore previous nesting before returning.

+    */

+   state->loop_or_switch_nesting = nesting;

+   state->loop_or_switch_nesting_ast = nesting_ast;

+

+   /* Loops do not have r-values.

+    */

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_type_specifier::hir(exec_list *instructions,

+			  struct _mesa_glsl_parse_state *state)

+{

+   if (!this->is_precision_statement && this->structure == NULL)

+      return NULL;

+

+   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");

+      return NULL;

+   }

+   if (this->precision != ast_precision_none

+       && this->structure != NULL) {

+      _mesa_glsl_error(&loc, state,

+                       "precision qualifiers do not apply to structures");

+      return NULL;

+   }

+

+   /* If this is a precision statement, check that the type to which it is

+    * applied is either float or int.

+    *

+    * From section 4.5.3 of the GLSL 1.30 spec:

+    *    "The precision statement

+    *       precision precision-qualifier type;

+    *    can be used to establish a default precision qualifier. The type

+    *    field can be either int or float [...].  Any other types or

+    *    qualifiers will result in an error.

+    */

+   if (this->is_precision_statement) {

+      assert(this->precision != ast_precision_none);

+      assert(this->structure == NULL); /* The check for structures was

+                                        * performed above. */

+      if (this->is_array) {

+         _mesa_glsl_error(&loc, state,

+                          "default precision statements do not apply to "

+                          "arrays");

+         return NULL;

+      }

+      if (this->type_specifier != ast_float

+          && this->type_specifier != ast_int) {

+         _mesa_glsl_error(&loc, state,

+                          "default precision statements apply only to types "

+                          "float and int");

+         return NULL;

+      }

+

+      /* FINISHME: Translate precision statements into IR. */

+      return NULL;

+   }

+

+   if (this->structure != NULL)

+      return this->structure->hir(instructions, state);

+

+   return NULL;

+}

+

+

+ir_rvalue *

+ast_struct_specifier::hir(exec_list *instructions,

+			  struct _mesa_glsl_parse_state *state)

+{

+   unsigned decl_count = 0;

+

+   /* Make an initial pass over the list of structure fields to determine how

+    * many there are.  Each element in this list is an ast_declarator_list.

+    * This means that we actually need to count the number of elements in the

+    * 'declarations' list in each of the elements.

+    */

+   foreach_list_typed (ast_declarator_list, decl_list, link,

+		       &this->declarations) {

+      foreach_list_const (decl_ptr, & decl_list->declarations) {

+	 decl_count++;

+      }

+   }

+

+   /* Allocate storage for the structure fields and process the field

+    * declarations.  As the declarations are processed, try to also convert

+    * the types to HIR.  This ensures that structure definitions embedded in

+    * other structure definitions are processed.

+    */

+   glsl_struct_field *const fields = ralloc_array(state, glsl_struct_field,

+						  decl_count);

+

+   unsigned i = 0;

+   foreach_list_typed (ast_declarator_list, decl_list, link,

+		       &this->declarations) {

+      const char *type_name;

+

+      decl_list->type->specifier->hir(instructions, state);

+

+      /* Section 10.9 of the GLSL ES 1.00 specification states that

+       * embedded structure definitions have been removed from the language.

+       */

+      if (state->es_shader && decl_list->type->specifier->structure != NULL) {

+	 YYLTYPE loc = this->get_location();

+	 _mesa_glsl_error(&loc, state, "Embedded structure definitions are "

+			  "not allowed in GLSL ES 1.00.");

+      }

+

+      const glsl_type *decl_type =

+	 decl_list->type->specifier->glsl_type(& type_name, state);

+

+      foreach_list_typed (ast_declaration, decl, link,

+			  &decl_list->declarations) {

+	 const struct glsl_type *field_type = decl_type;

+	 if (decl->is_array) {

+	    YYLTYPE loc = decl->get_location();

+	    field_type = process_array_type(&loc, decl_type, decl->array_size,

+					    state);

+	 }

+	 fields[i].type = (field_type != NULL)

+	    ? field_type : glsl_type::error_type;

+	 fields[i].name = decl->identifier;

+	 i++;

+      }

+   }

+

+   assert(i == decl_count);

+

+   const glsl_type *t =

+      glsl_type::get_record_instance(fields, decl_count, this->name);

+

+   YYLTYPE loc = this->get_location();

+   if (!state->symbols->add_type(name, t)) {

+      _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name);

+   } else {

+      const glsl_type **s = reralloc(state, state->user_structures,

+				     const glsl_type *,

+				     state->num_user_structures + 1);

+      if (s != NULL) {

+	 s[state->num_user_structures] = t;

+	 state->user_structures = s;

+	 state->num_user_structures++;

+      }

+   }

+

+   /* Structure type definitions do not have r-values.

+    */

+   return NULL;

+}

diff --git a/mesalib/src/glsl/glcpp/glcpp-lex.l b/mesalib/src/glsl/glcpp/glcpp-lex.l
index 68e44eb79..596c6db70 100644
--- a/mesalib/src/glsl/glcpp/glcpp-lex.l
+++ b/mesalib/src/glsl/glcpp/glcpp-lex.l
@@ -1,320 +1,324 @@
-%{
-/*
- * Copyright © 2010 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-
-#include "glcpp.h"
-#include "glcpp-parse.h"
-
-/* Flex annoyingly generates some functions without making them
- * static. Let's declare them here. */
-int glcpp_get_column  (yyscan_t yyscanner);
-void glcpp_set_column (int  column_no , yyscan_t yyscanner);
-
-#define YY_NO_INPUT
-
-#define YY_USER_ACTION                                          \
-   do {                                                         \
-      yylloc->first_column = yycolumn + 1;                      \
-      yylloc->first_line = yylineno;                            \
-      yycolumn += yyleng;                                       \
-   } while(0);
-
-#define YY_USER_INIT			\
-	do {				\
-		yylineno = 1;		\
-		yycolumn = 1;		\
-		yylloc->source = 0;	\
-	} while(0)
-%}
-
-%option bison-bridge bison-locations reentrant noyywrap
-%option extra-type="glcpp_parser_t *"
-%option prefix="glcpp_"
-%option stack
-%option never-interactive
-
-%x DONE COMMENT UNREACHABLE SKIP
-
-SPACE		[[:space:]]
-NONSPACE	[^[:space:]]
-NEWLINE		[\n]
-HSPACE		[ \t]
-HASH		^{HSPACE}*#{HSPACE}*
-IDENTIFIER	[_a-zA-Z][_a-zA-Z0-9]*
-PUNCTUATION	[][(){}.&*~!/%<>^|;,=+-]
-OTHER		[^][(){}.&*~!/%<>^|;,=#[:space:]+-]+
-
-DIGITS			[0-9][0-9]*
-DECIMAL_INTEGER		[1-9][0-9]*[uU]?
-OCTAL_INTEGER		0[0-7]*[uU]?
-HEXADECIMAL_INTEGER	0[xX][0-9a-fA-F]+[uU]?
-
-%%
-	/* Implicitly switch between SKIP and INITIAL (non-skipping);
-	 * don't switch if some other state was explicitly set.
-	 */
-	glcpp_parser_t *parser = yyextra;
-	if (YY_START == 0 || YY_START == SKIP) {
-		if (parser->lexing_if || parser->skip_stack == NULL || parser->skip_stack->type == SKIP_NO_SKIP) {
-			BEGIN 0;
-		} else {
-			BEGIN SKIP;
-		}
-	}
-
-	/* Single-line comments */
-"//"[^\n]* {
-}
-
-	/* Multi-line comments */
-"/*"                    { yy_push_state(COMMENT, yyscanner); }
-<COMMENT>[^*\n]*
-<COMMENT>[^*\n]*\n      { yylineno++; yycolumn = 0; return NEWLINE; }
-<COMMENT>"*"+[^*/\n]*
-<COMMENT>"*"+[^*/\n]*\n { yylineno++; yycolumn = 0; return NEWLINE; }
-<COMMENT>"*"+"/"        {
-	yy_pop_state(yyscanner);
-	if (yyextra->space_tokens)
-		return SPACE;
-}
-
-{HASH}version {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	yyextra->space_tokens = 0;
-	return HASH_VERSION;
-}
-
-	/* glcpp doesn't handle #extension, #version, or #pragma directives.
-	 * Simply pass them through to the main compiler's lexer/parser. */
-{HASH}(extension|pragma)[^\n]+ {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	yylineno++;
-	yycolumn = 0;
-	return OTHER;
-}
-
-{HASH}line{HSPACE}+{DIGITS}{HSPACE}+{DIGITS}{HSPACE}*$ {
-	/* Eat characters until the first digit is
-	 * encountered
-	 */
-	char *ptr = yytext;
-	while (!isdigit(*ptr))
-		ptr++;
-
-	/* Subtract one from the line number because
-	 * yylineno is zero-based instead of
-	 * one-based.
-	 */
-	yylineno = strtol(ptr, &ptr, 0) - 1;
-	yylloc->source = strtol(ptr, NULL, 0);
-}
-
-{HASH}line{HSPACE}+{DIGITS}{HSPACE}*$ {
-	/* Eat characters until the first digit is
-	 * encountered
-	 */
-	char *ptr = yytext;
-	while (!isdigit(*ptr))
-		ptr++;
-
-	/* Subtract one from the line number because
-	 * yylineno is zero-based instead of
-	 * one-based.
-	 */
-	yylineno = strtol(ptr, &ptr, 0) - 1;
-}
-
-<SKIP,INITIAL>{
-{HASH}ifdef {
-	yyextra->lexing_if = 1;
-	yyextra->space_tokens = 0;
-	return HASH_IFDEF;
-}
-
-{HASH}ifndef {
-	yyextra->lexing_if = 1;
-	yyextra->space_tokens = 0;
-	return HASH_IFNDEF;
-}
-
-{HASH}if/[^_a-zA-Z0-9] {
-	yyextra->lexing_if = 1;
-	yyextra->space_tokens = 0;
-	return HASH_IF;
-}
-
-{HASH}elif {
-	yyextra->lexing_if = 1;
-	yyextra->space_tokens = 0;
-	return HASH_ELIF;
-}
-
-{HASH}else {
-	yyextra->space_tokens = 0;
-	return HASH_ELSE;
-}
-
-{HASH}endif {
-	yyextra->space_tokens = 0;
-	return HASH_ENDIF;
-}
-}
-
-<SKIP>[^\n] ;
-
-{HASH}error.* {
-	char *p;
-	for (p = yytext; !isalpha(p[0]); p++); /* skip "  #   " */
-	p += 5; /* skip "error" */
-	glcpp_error(yylloc, yyextra, "#error%s", p);
-}
-
-{HASH}define{HSPACE}+/{IDENTIFIER}"(" {
-	yyextra->space_tokens = 0;
-	return HASH_DEFINE_FUNC;
-}
-
-{HASH}define {
-	yyextra->space_tokens = 0;
-	return HASH_DEFINE_OBJ;
-}
-
-{HASH}undef {
-	yyextra->space_tokens = 0;
-	return HASH_UNDEF;
-}
-
-{HASH} {
-	yyextra->space_tokens = 0;
-	return HASH;
-}
-
-{DECIMAL_INTEGER} {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	return INTEGER_STRING;
-}
-
-{OCTAL_INTEGER} {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	return INTEGER_STRING;
-}
-
-{HEXADECIMAL_INTEGER} {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	return INTEGER_STRING;
-}
-
-"<<"  {
-	return LEFT_SHIFT;
-}
-
-">>" {
-	return RIGHT_SHIFT;
-}
-
-"<=" {
-	return LESS_OR_EQUAL;
-}
-
-">=" {
-	return GREATER_OR_EQUAL;
-}
-
-"==" {
-	return EQUAL;
-}
-
-"!=" {
-	return NOT_EQUAL;
-}
-
-"&&" {
-	return AND;
-}
-
-"||" {
-	return OR;
-}
-
-"##" {
-	return PASTE;
-}
-
-"defined" {
-	return DEFINED;
-}
-
-{IDENTIFIER} {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	return IDENTIFIER;
-}
-
-{PUNCTUATION} {
-	return yytext[0];
-}
-
-{OTHER}+ {
-	yylval->str = ralloc_strdup (yyextra, yytext);
-	return OTHER;
-}
-
-{HSPACE}+ {
-	if (yyextra->space_tokens) {
-		return SPACE;
-	}
-}
-
-<SKIP,INITIAL>\n {
-	yyextra->lexing_if = 0;
-	yylineno++;
-	yycolumn = 0;
-	return NEWLINE;
-}
-
-	/* Handle missing newline at EOF. */
-<INITIAL><<EOF>> {
-	BEGIN DONE; /* Don't keep matching this rule forever. */
-	yyextra->lexing_if = 0;
-	return NEWLINE;
-}
-
-	/* We don't actually use the UNREACHABLE start condition. We
-	only have this action here so that we can pretend to call some
-	generated functions, (to avoid "defined but not used"
-	warnings. */
-<UNREACHABLE>. {
-	unput('.');
-	yy_top_state(yyextra);
-}
-
-%%
-
-void
-glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader)
-{
-	yy_scan_string(shader, parser->scanner);
-}
+%{

+/*

+ * Copyright © 2010 Intel Corporation

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ */

+

+#include <stdio.h>

+#include <string.h>

+#include <ctype.h>

+

+#include "glcpp.h"

+#include "glcpp-parse.h"

+

+/* Flex annoyingly generates some functions without making them

+ * static. Let's declare them here. */

+int glcpp_get_column  (yyscan_t yyscanner);

+void glcpp_set_column (int  column_no , yyscan_t yyscanner);

+

+#ifdef _MSC_VER

+#define YY_NO_UNISTD_H

+#endif

+

+#define YY_NO_INPUT

+

+#define YY_USER_ACTION                                          \

+   do {                                                         \

+      yylloc->first_column = yycolumn + 1;                      \

+      yylloc->first_line = yylineno;                            \

+      yycolumn += yyleng;                                       \

+   } while(0);

+

+#define YY_USER_INIT			\

+	do {				\

+		yylineno = 1;		\

+		yycolumn = 1;		\

+		yylloc->source = 0;	\

+	} while(0)

+%}

+

+%option bison-bridge bison-locations reentrant noyywrap

+%option extra-type="glcpp_parser_t *"

+%option prefix="glcpp_"

+%option stack

+%option never-interactive

+

+%x DONE COMMENT UNREACHABLE SKIP

+

+SPACE		[[:space:]]

+NONSPACE	[^[:space:]]

+NEWLINE		[\n]

+HSPACE		[ \t]

+HASH		^{HSPACE}*#{HSPACE}*

+IDENTIFIER	[_a-zA-Z][_a-zA-Z0-9]*

+PUNCTUATION	[][(){}.&*~!/%<>^|;,=+-]

+OTHER		[^][(){}.&*~!/%<>^|;,=#[:space:]+-]+

+

+DIGITS			[0-9][0-9]*

+DECIMAL_INTEGER		[1-9][0-9]*[uU]?

+OCTAL_INTEGER		0[0-7]*[uU]?

+HEXADECIMAL_INTEGER	0[xX][0-9a-fA-F]+[uU]?

+

+%%

+	/* Implicitly switch between SKIP and INITIAL (non-skipping);

+	 * don't switch if some other state was explicitly set.

+	 */

+	glcpp_parser_t *parser = yyextra;

+	if (YY_START == 0 || YY_START == SKIP) {

+		if (parser->lexing_if || parser->skip_stack == NULL || parser->skip_stack->type == SKIP_NO_SKIP) {

+			BEGIN 0;

+		} else {

+			BEGIN SKIP;

+		}

+	}

+

+	/* Single-line comments */

+"//"[^\n]* {

+}

+

+	/* Multi-line comments */

+"/*"                    { yy_push_state(COMMENT, yyscanner); }

+<COMMENT>[^*\n]*

+<COMMENT>[^*\n]*\n      { yylineno++; yycolumn = 0; return NEWLINE; }

+<COMMENT>"*"+[^*/\n]*

+<COMMENT>"*"+[^*/\n]*\n { yylineno++; yycolumn = 0; return NEWLINE; }

+<COMMENT>"*"+"/"        {

+	yy_pop_state(yyscanner);

+	if (yyextra->space_tokens)

+		return SPACE;

+}

+

+{HASH}version {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	yyextra->space_tokens = 0;

+	return HASH_VERSION;

+}

+

+	/* glcpp doesn't handle #extension, #version, or #pragma directives.

+	 * Simply pass them through to the main compiler's lexer/parser. */

+{HASH}(extension|pragma)[^\n]+ {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	yylineno++;

+	yycolumn = 0;

+	return OTHER;

+}

+

+{HASH}line{HSPACE}+{DIGITS}{HSPACE}+{DIGITS}{HSPACE}*$ {

+	/* Eat characters until the first digit is

+	 * encountered

+	 */

+	char *ptr = yytext;

+	while (!isdigit(*ptr))

+		ptr++;

+

+	/* Subtract one from the line number because

+	 * yylineno is zero-based instead of

+	 * one-based.

+	 */

+	yylineno = strtol(ptr, &ptr, 0) - 1;

+	yylloc->source = strtol(ptr, NULL, 0);

+}

+

+{HASH}line{HSPACE}+{DIGITS}{HSPACE}*$ {

+	/* Eat characters until the first digit is

+	 * encountered

+	 */

+	char *ptr = yytext;

+	while (!isdigit(*ptr))

+		ptr++;

+

+	/* Subtract one from the line number because

+	 * yylineno is zero-based instead of

+	 * one-based.

+	 */

+	yylineno = strtol(ptr, &ptr, 0) - 1;

+}

+

+<SKIP,INITIAL>{

+{HASH}ifdef {

+	yyextra->lexing_if = 1;

+	yyextra->space_tokens = 0;

+	return HASH_IFDEF;

+}

+

+{HASH}ifndef {

+	yyextra->lexing_if = 1;

+	yyextra->space_tokens = 0;

+	return HASH_IFNDEF;

+}

+

+{HASH}if/[^_a-zA-Z0-9] {

+	yyextra->lexing_if = 1;

+	yyextra->space_tokens = 0;

+	return HASH_IF;

+}

+

+{HASH}elif {

+	yyextra->lexing_if = 1;

+	yyextra->space_tokens = 0;

+	return HASH_ELIF;

+}

+

+{HASH}else {

+	yyextra->space_tokens = 0;

+	return HASH_ELSE;

+}

+

+{HASH}endif {

+	yyextra->space_tokens = 0;

+	return HASH_ENDIF;

+}

+}

+

+<SKIP>[^\n] ;

+

+{HASH}error.* {

+	char *p;

+	for (p = yytext; !isalpha(p[0]); p++); /* skip "  #   " */

+	p += 5; /* skip "error" */

+	glcpp_error(yylloc, yyextra, "#error%s", p);

+}

+

+{HASH}define{HSPACE}+/{IDENTIFIER}"(" {

+	yyextra->space_tokens = 0;

+	return HASH_DEFINE_FUNC;

+}

+

+{HASH}define {

+	yyextra->space_tokens = 0;

+	return HASH_DEFINE_OBJ;

+}

+

+{HASH}undef {

+	yyextra->space_tokens = 0;

+	return HASH_UNDEF;

+}

+

+{HASH} {

+	yyextra->space_tokens = 0;

+	return HASH;

+}

+

+{DECIMAL_INTEGER} {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	return INTEGER_STRING;

+}

+

+{OCTAL_INTEGER} {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	return INTEGER_STRING;

+}

+

+{HEXADECIMAL_INTEGER} {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	return INTEGER_STRING;

+}

+

+"<<"  {

+	return LEFT_SHIFT;

+}

+

+">>" {

+	return RIGHT_SHIFT;

+}

+

+"<=" {

+	return LESS_OR_EQUAL;

+}

+

+">=" {

+	return GREATER_OR_EQUAL;

+}

+

+"==" {

+	return EQUAL;

+}

+

+"!=" {

+	return NOT_EQUAL;

+}

+

+"&&" {

+	return AND;

+}

+

+"||" {

+	return OR;

+}

+

+"##" {

+	return PASTE;

+}

+

+"defined" {

+	return DEFINED;

+}

+

+{IDENTIFIER} {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	return IDENTIFIER;

+}

+

+{PUNCTUATION} {

+	return yytext[0];

+}

+

+{OTHER}+ {

+	yylval->str = ralloc_strdup (yyextra, yytext);

+	return OTHER;

+}

+

+{HSPACE}+ {

+	if (yyextra->space_tokens) {

+		return SPACE;

+	}

+}

+

+<SKIP,INITIAL>\n {

+	yyextra->lexing_if = 0;

+	yylineno++;

+	yycolumn = 0;

+	return NEWLINE;

+}

+

+	/* Handle missing newline at EOF. */

+<INITIAL><<EOF>> {

+	BEGIN DONE; /* Don't keep matching this rule forever. */

+	yyextra->lexing_if = 0;

+	return NEWLINE;

+}

+

+	/* We don't actually use the UNREACHABLE start condition. We

+	only have this action here so that we can pretend to call some

+	generated functions, (to avoid "defined but not used"

+	warnings. */

+<UNREACHABLE>. {

+	unput('.');

+	yy_top_state(yyextra);

+}

+

+%%

+

+void

+glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader)

+{

+	yy_scan_string(shader, parser->scanner);

+}

diff --git a/mesalib/src/glsl/glcpp/glcpp.c b/mesalib/src/glsl/glcpp/glcpp.c
index 564194caa..63eb061c2 100644
--- a/mesalib/src/glsl/glcpp/glcpp.c
+++ b/mesalib/src/glsl/glcpp/glcpp.c
@@ -1,131 +1,121 @@
-/*
- * Copyright © 2010 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include "glcpp.h"
-#include "main/mtypes.h"
-#include "main/shaderobj.h"
-
-extern int yydebug;
-
-void
-_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
-                       struct gl_shader *sh)
-{
-   *ptr = sh;
-}
-
-/* Read from fd until EOF and return a string of everything read.
- */
-static char *
-load_text_fd (void *ctx, int fd)
-{
-#define CHUNK 4096
-	char *text = NULL;
-	ssize_t text_size = 0;
-	ssize_t total_read = 0;
-	ssize_t bytes;
-
-	while (1) {
-		if (total_read + CHUNK + 1 > text_size) {
-			text_size = text_size ? text_size * 2 : CHUNK + 1;
-			text = reralloc_size (ctx, text, text_size);
-			if (text == NULL) {
-				fprintf (stderr, "Out of memory\n");
-				return NULL;
-			}
-		}
-		bytes = read (fd, text + total_read, CHUNK);
-		if (bytes < 0) {
-			fprintf (stderr, "Error while reading: %s\n",
-				 strerror (errno));
-			ralloc_free (text);
-			return NULL;
-		}
-
-		if (bytes == 0) {
-			break;
-		}
-
-		total_read += bytes;
-	}
-
-	text[total_read] = '\0';
-
-	return text;
-}
-
-static char *
-load_text_file(void *ctx, const char *filename)
-{
-	char *text;
-	int fd;
-
-	if (filename == NULL || strcmp (filename, "-") == 0)
-		return load_text_fd (ctx, STDIN_FILENO);
-
-	fd = open (filename, O_RDONLY);
-	if (fd < 0) {
-		fprintf (stderr, "Failed to open file %s: %s\n",
-			 filename, strerror (errno));
-		return NULL;
-	}
-
-	text = load_text_fd (ctx, fd);
-
-	close(fd);
-
-	return text;
-}
-
-int
-main (int argc, char *argv[])
-{
-	char *filename = NULL;
-	void *ctx = ralloc(NULL, void*);
-	char *info_log = ralloc_strdup(ctx, "");
-	const char *shader;
-	int ret;
-
-	if (argc) {
-		filename = argv[1];
-	}
-
-	shader = load_text_file (ctx, filename);
-	if (shader == NULL)
-	   return 1;
-
-	ret = preprocess(ctx, &shader, &info_log, NULL, API_OPENGL);
-
-	printf("%s", shader);
-	fprintf(stderr, "%s", info_log);
-
-	ralloc_free(ctx);
-
-	return ret;
-}
+/*

+ * Copyright © 2010 Intel Corporation

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ */

+

+#include <stdio.h>

+#include <string.h>

+#include <errno.h>

+#include "glcpp.h"

+#include "main/mtypes.h"

+#include "main/shaderobj.h"

+

+extern int yydebug;

+

+void

+_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,

+                       struct gl_shader *sh)

+{

+   *ptr = sh;

+}

+

+/* Read from fp until EOF and return a string of everything read.

+ */

+static char *

+load_text_fp (void *ctx, FILE *fp)

+{

+#define CHUNK 4096

+	char *text = NULL;

+	size_t text_size = 0;

+	size_t total_read = 0;

+	size_t bytes;

+

+	while (1) {

+		if (total_read + CHUNK + 1 > text_size) {

+			text_size = text_size ? text_size * 2 : CHUNK + 1;

+			text = reralloc_size (ctx, text, text_size);

+			if (text == NULL) {

+				fprintf (stderr, "Out of memory\n");

+				return NULL;

+			}

+		}

+		bytes = fread (text + total_read, 1, CHUNK, fp);

+		total_read += bytes;

+

+		if (bytes < CHUNK) {

+			break;

+		}

+	}

+

+	text[total_read] = '\0';

+

+	return text;

+}

+

+static char *

+load_text_file(void *ctx, const char *filename)

+{

+	char *text;

+	FILE *fp;

+

+	if (filename == NULL || strcmp (filename, "-") == 0)

+		return load_text_fp (ctx, stdin);

+

+	fp = fopen (filename, "r");

+	if (fp == NULL) {

+		fprintf (stderr, "Failed to open file %s: %s\n",

+			 filename, strerror (errno));

+		return NULL;

+	}

+

+	text = load_text_fp (ctx, fp);

+

+	fclose(fp);

+

+	return text;

+}

+

+int

+main (int argc, char *argv[])

+{

+	char *filename = NULL;

+	void *ctx = ralloc(NULL, void*);

+	char *info_log = ralloc_strdup(ctx, "");

+	const char *shader;

+	int ret;

+

+	if (argc) {

+		filename = argv[1];

+	}

+

+	shader = load_text_file (ctx, filename);

+	if (shader == NULL)

+	   return 1;

+

+	ret = preprocess(ctx, &shader, &info_log, NULL, API_OPENGL);

+

+	printf("%s", shader);

+	fprintf(stderr, "%s", info_log);

+

+	ralloc_free(ctx);

+

+	return ret;

+}

diff --git a/mesalib/src/glsl/glsl_lexer.ll b/mesalib/src/glsl/glsl_lexer.ll
index e6f45f413..267ca0f1c 100644
--- a/mesalib/src/glsl/glsl_lexer.ll
+++ b/mesalib/src/glsl/glsl_lexer.ll
@@ -29,6 +29,10 @@
 

 static int classify_identifier(struct _mesa_glsl_parse_state *, const char *);

 

+#ifdef _MSC_VER

+#define YY_NO_UNISTD_H

+#endif

+

 #define YY_USER_ACTION						\

    do {								\

       yylloc->source = 0;					\