Begin tracking the nesting of loops and switch-statements

Use switch based on mode in ast_jump_statement::hir

Add some newlines when printing ir_loop instructions

Process ast_iteration_statement into ir_loop

This causes the following tests to pass:
     glslparsertest/shaders/dowhile.frag
     glslparsertest/shaders/while.frag
     glslparsertest/shaders/while1.frag
     glslparsertest/shaders/while2.frag

Add ir_loop_jump to represent 'break' and 'continue' in loops

Add ir_loop to represent loops

This touches a lot of files because everything derived from ir_visitor
has to be updated.  This is the primary disadvantage of the visitor pattern.

Add some linebreaks in the ir_print_visitor of if statement bodies.

Make constant folding descend into if statements.

Descend down the tree in more locations in constant folding.

Perform constant folding on array indices.

Replaces a constant var deref with a constant value in CorrectParse1.frag.

Add float/int conversion to ir_constant_expression.cpp.

Gives CorrectParse2.frag one more constant folding.

Handle constant expressions using derefs of const values.

Fixes CorrectParse1.frag and makes for a ton of folding in
CorrectParse2.frag.

Fold constant expressions in if conditionals.

Fixes up 3 more expressions in CorrectParse2.frag.

Add support for =, != to ir_constant_expresion.cpp

This results in constant folding of one more expression in CorrectParse2.frag.

Add ir_constant_expression.cpp support for <, >, <=, >=.

This results in folding one more constant expression in CorrectParse2.frag.

Add a constant folding optimization pass.

Add definition of gl_ClipDistance[]

Set lower bound on size implied by whole-array assignment

When an unsized array is accessed with a constant extension index this
sets a lower bound on the allowable sizes.  When the unsized array
gets a size set due to a whole-array assignment, this size must be at
least as large as the implied lower bound.

This causes the following tests to pass:

    glslparsertest/glsl2/array-16.vert

Allow dereference of vectors and matrices with []

This causes the following tests to pass:
     glslparsertest/glsl2/matrix-11.vert
     glslparsertest/glsl2/matrix-12.vert
     glslparsertest/shaders/CorrectParse2.vert
     glslparsertest/shaders/CorrectSwizzle2.frag

Set correct type for ir_dereference of a matrix or a vector

Propagate sizes when assigning a whole array to an unsized array

Track whether whole-arrays are assignable

In GLSL 1.10 this was not allowed, but in GLSL 1.20 and later it is.

This causes the following tests to pass:

    glslparsertest/glsl2/array-09.vert
    glslparsertest/glsl2/array-13.vert

Whole structures are assignable

Whole arrays are assignable in GLSL 1.20 and later, but it's not clear
how to handle that within the IR because the IR is supposed to be
shading language version agnostic.

Use glsl_type::element_type to get the type of array elements

Ensure that 'in' and 'inout' formal parameters are valid lvalues

This causes the following tests to pass:

    glslparsertest/shaders/function10.frag

Additional void parameter checks

If there is a void parameter it must not have a name, and it must be
the only parameter.

Require that function formal parameters have names

Make built-in gl_TexCoord available in vertex and fragment shaders

Fix matching of integer function parameters

This causes the following tests to pass:

    glslparsertest/shaders/function10.frag

Add bool/int conversion as IR operations.

Fixes constructor-09.glsl and CorrectParse2.frag.

Add conversion of bool to float as an IR operation to match int to float.

Add PASS / FAIL annotations to tests missing them.

This tricked my import of the tests into piglit.

Test that invalid quailfiers aren't used on variables in GLSL 1.10.

Allow array dereferences to be considered as lvalues.

Fixes glsl-vs-arrays.vert and glsl-vs-mov-after-deref.vert.
Regresses parser3.frag which was failing for the wrong reason.

Test for the type being different in parameter_lists_match.

Fixes CorrectFuncOverload.frag.

Add some more operations to ir_constant_expression.cpp.

Make ir_constant_expression.cpp support multi-component types.

Simplify ir_constant_expression.cpp by factoring operand computation out.

Reject non-float varyings.

Fixes varying2.frag.

Remove fake ir_binop_logic_not.  I think you meant ir_unop_logic_not.

Handle logic not in constant expression evaluation.

Fix error handling of logic operators.

They were always throwing a type error because type wasn't being set.

Emit errors for unfinished ast_to_hir expression operations.

Fix ast_logic_not handling to be unary, not binary.

Add errors for type results of other expressions.

Emit errors from failure in arithmetic_result_type.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>

Start trying to fill in a few bits of ir_constant_expression.cpp

This makes a little progress on CorrectParse2.frag.

Compute the constant value of a constant initializer.

Fixes constFunc.frag.

Allow initializers of constant values to succeed.

This regresses constFunc.frag, but that's just unexpectedly passing
because of the FINISHME just above.

Don't create a parameter declaration for a (void) parameter.

Fixes segfaults in a shader consisting of just:

    void main(void) { }

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>

Remove ast_node::type

It isn't a type (is was enum specifying the kind of node), it was
unused, and it was easily confused with actual type fields.  Kill with fire.

Track max accessed array element, reject additional out-of-bounds accesses

For unsized arrays, we can't flag out-of-bounds accesses until the
array is redeclared with a size.  Track the maximum accessed element
and generate an error if the declaration specifies a size that would
cause that access to be out-of-bounds.

This causes the following tests to pass:

    glslparsertest/shaders/array10.frag

Begin processing ast_array_index nodes

This causes the following tests to pass:

    glslparsertest/shaders/parser3.frag
    glslparsertest/shaders/varying3.frag (also generates spurious error)

Fix type handling in ir_dereference array dereference constructor

Allow unsized arrays to be redeclared with a size

Test glslparsertest/shaders/array11.frag now passes for the right reason.

Add glsl_type::element_type and glsl_type::array_size queries

The former gets the type of elements in an array, and the later gets
the declared size, if any, of the array.

Set source locations on AST nodes so error messages print locations.

I haven't verified that these are all correct, but it's still a lot
better than not having anything.

Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>

Add ast_function::hir

ast_function::hir consists of bits pulled out of
ast_function_definition::hir.  In fact, the later uses the former to
do a lot of its processing.  Several class private data fields were
added to ast_function to facilitate communicate between the two.

This causes the following tests to pass:

    glslparsertest/shaders/CorrectModule.frag

This causes the following tests to fail.  These shaders were
previously failing to compile, but they were all failing for the wrong
reasons.

    glslparsertest/shaders/function9.frag
    glslparsertest/shaders/function10.frag

Fix exec_list::move_nodes_to when the source list is empty

Use ir_variable::clone to copy parameters to the function body

Several other code movements were also done.  This partitions this
function into two halves.  The first half processes the prototype
part, and the second have processes the actual function definition.
The coming patch series will parition ast_function_definition::hir
into (at least) two separate functions.

Add ir_variable::clone

Minor cleanups in ast_function_definition::hir

Generate array constructor calls

Add ir_function_signature::function_name

Make ir_function::signatures private

Add ir_function::iterator to iterate over function signatures

Use ir_function::add_signature to create link between function and signature

ir_function_signature now has a pointer back to the ir_function that owns it.

Add glsl_type::generate_constructor_prototype

Generates a symbol table entry and the IR approximation of a prototype for a
type's constructor.  Currently only arrays are supported.

Refactor parts of match_function_by_name into process_parameters and process_call

These will be used in the functions that implement calls to array constructors.

Reject array constructor calls in GLSL 1.10

Use ast_type_specifier::glsl_type to get the type of a constructor

This is the first baby step towards getting array constructors working.

Move type_specifier_to_glsl_type to ast_type_specifier::glsl_type

This make is easily accessible from other modules.

More array declaration tests

Fix big dumbness in glsl_type::get_array_instance

hash_table_insert needs to keep the key so that it compare keys on a
following hash_table_find call.  Since key was allocated on the stack,
it disappeared out from under the hash table.

glsl_type array constructor generate a real name for the type

Test that const declarations include initializers.

Fixes dataType6.frag, and also array2.frag for an unexpected but valid
reason.

Reject declarations with 'in' or 'out' qualifiers

'in' and 'out' can only be used in function parameter lists or at
global scope (1.30 and later).  This change enforces this.

Add 'in' to some parameters of the function

This goes along with the qualifier-?? tests.

Add some variable declaration qualifier tests

Fix comment bug and printf bug in previous commit

Require that 'uniform' and 'varying' variables be declared at global scope

This causes the following tests to pass:

    glslparsertest/shaders/uniform.frag
    glslparsertest/shaders/varying.frag

Slightly refector checks for declarations that must be at global scope

Implement logical operators.

Fixes parser9.frag.

Test that variable names don't use the reserved gl_ prefix.

Fixes identifier2.frag.

Test that discard only appears in the fragment shader.

Fixes fragmentOnly4.vert.

Test that main doesn't take any parameters.

Fixes main2.vert.

Test that a non-void function returns a value.

Test that a void function doesn't return a value.

Fixes function1.frag.

Fix unused variable warning.

Forbid array comparisons in GLSL 1.10

This causes the following tests to pass:

    glslparsertest/shaders/array3.frag

Begin handling array declarations

This causes the following tests to pass:

    glslparsertest/shaders/array4.frag
    glslparsertest/shaders/array5.frag

This causes the following tests to fail.  These shaders were
previously failing to compile, but they were all failing for the wrong
reasons.

    glslparsertest/shaders/array3.frag

Implement array type handling

Since all glsl_type objects are flyweights, support is added to track all
known array types.  This accounts for most of the changes.

Add proper wrappers so that C++ code can use hash_table type

Initial bits of constant expression evaluator

Currently only works for constants.  The rest will be added later.

Add some array declaration tests

Arrays are not allowed as vertex shader inputs in GLSL 1.30 either

Add several tests for vertex shader attributes

Add some checking for vertex shader inputs / attributes

This causes the following tests to pass:

     glslparsertest/shaders/attribute.vert
     glslparsertest/shaders/attribute1.vert
     glslparsertest/shaders/attribute2.vert

Add parser support for texture rectangle types

Use call-by-reference for apply_implicit_conversion

I'm not sure if this is a win or not.  It makes the code in
apply_implicit_conversion more clear, but it obscures the fact that it
may change the pointers.