Implement the first builtin function: exp().

Generate more correctly diagnostics from some invalid initializers

Initial bits to process initializers in variable declarations

As a result, the following tests pass:

    glslparsertest/array3.frag
    glslparsertest/CGStandardLibrary.frag
    glslparsertest/ConstantConversions.frag
    glslparsertest/constructor1.frag
    glslparsertest/constructor2.frag
    glslparsertest/constructor3.V110.frag
    glslparsertest/dataType4.frag
    glslparsertest/dataType5.frag
    glslparsertest/dataType13.frag
    glslparsertest/dataType19.frag
    glslparsertest/matrix.V110.frag
    glslparsertest/parser7.frag
    glslparsertest/swizzle3.frag

The following tests also pass, but it is just by dumb luck.  In these
cases the shader fails to compile, but it fails for the wrong reason:

    glslparsertest/array6.frag
    glslparsertest/comma2.frag
    glslparsertest/conditional1.frag
    glslparsertest/conditional2.frag
    glslparsertest/conditional3.frag
    glslparsertest/constFunc.frag
    glslparsertest/ParseTest3.frag
    glslparsertest/ParseTest4.frag
    glslparsertest/varying3.frag
    glslparsertest/parser8.frag (also segfaults)
    glslparsertest/parser9.frag (also segfaults)

The following tests now fail.  As far as I can tell, these are all
cases where the shader was failing to compile, but it was failing for
the wrong reason.

    glslparsertest/CorrectMatComma.frag
    glslparsertest/CorrectModule.frag
    glslparsertest/CorrectSwizzle2.vert
    glslparsertest/shaders/glsl-fs-bug25902.frag

Reject uniform initializers in GLSL 1.10 mode

Now both glslparsertest/dataType3.frag and glslparsertest/dataType2.frag pass.

Set variables with the sampler base type to read only.

Fixes increment3.frag.

Set the var_type for arrays to error_type until it's implemented.

"Fixes" segfaults in array tests.

Add support for ast_to_hir of pre inc/dec.

Add support for ast_to_hir of post inc/dec.

Make read-only variables not be considered lvalues.

This should fix tests trying to assign to builtin "in" variables, and
will also be relied on for post_inc/dec handling.

Add constructors for immediate hir constants.

This will make ast_to_hir for inc/dec easier.

Add support for %= in ast_to_hir.

Factor out assignment setup in ast_to_hir.

IR print visitor: Print out something for the operator.

IR print visitor: Print expressions a little better

Initial implementation of constructor handling code

All of the scalar, vector, and matrix constructors *except* "from
bool" constructors should be handled.  Array and structure
constructors are also not yet handled.

IR print visitor: print function calls

Add hack ir_call::callee_name to get the name of the called function

Be sure to set ir_function_signature::definition for constructors

Add ir_call::iterator to iterate over actual parameters

Add missing parenthesis in foreach_iter

This allows uses like 'foreach_iter(exec_list_iterator, iter, *list_ptr)'.

Add some simple constructor tests

Add unary operator to convert unsigned integer to float

Slightly change the representation of numeric types

For numeric types, vector_elements and matrix_columns must be at least
1.  Previously matrix_columns was 0 for vectors, and both were 0 for
scalars.  This change simplifies things in some places.

Add glsl_type::components to query total number of components in a type

Replace remaining use of is_error_type with glsl_type::is_error

Replace remaining uses of is_numeric_base_type with glsl_type::is_numeric

Replace is_integer_base_type macro with glsl_type::is_integer method

Make glsl_*_type glsl_type class static data

Use glsl_type::is_error instead of comparison with glsl_error_type pointer

Move swizzles out of ir_dereference and into their own class.

Also turn generate_swizzle into a static "create" method of the new
class; we'll want to use it for the IR reader as well.

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

Add new abstract ir_rvalue class; rework accordingly.

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

Replace "mode" type tag with virtual as_foo() downcasting functions.

These should work well even in a non-flat IR hierarchy.

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

Merge branch 'anholt'

IR print visitor: Finish printing constants

IR print visitor: Remove most of the newlines from the printed output

This makes it a lot easier to read... if you have a really wide display.

IR print visitor: print expressions

Not quite complete.  The operator is not yet printed.

IR print visitor: print ir_dereference instructions

Also make a slight change to ir_variable.  The ir_dereference tracks
the number of nested dereferences.  If an ir_variable is visited and
the count is non-zero, just print the name of the variable.

IR print visitor: Less newlines when printing ir_variables

Fix assignment operators: *=, /=, +=, -=.

Basically, replace everything different from operator_assign other
than the creation of the rhs value from the lvalue and rvalue with the
contents of operator_assign.  Fixes a segfault in
CorrectSwizzle1.frag, and fixes parser10.frag.

Before generating HIR for user code, generate constructors for built-in types

Add dereference constructor for array element dereferences

This should have gone in before the previous commit.

Add functions to generate constructors for built-in types.

Currently only vector and matrix types are supported.  Structure types will be
added later.

Fix up the operator printing for the logic or and beyond, check array bounds.

Merge branch 'anholt'

Set up fragment shader builtin variables.

Make the standalone parser return an exit code so we can automate testing.

More matrix compilation tests

Merge branch 'kwg'

Fix matrix dimensioning

Newb GL mistake: matrices in GL are column-major.  This means that
vector_elements is the number of rows.  Making these changes causes
matrix-08.glsl to pass.

Use glsl_type::row_type and glsl_type::column type in arithmetic_result_type

This substantially clarifies the code for matching matrix types.  It
also eliminates some uses of glsl_type member data.

Replace several glsl_type field comparisons with a single pointer comparison

This simplifies the process of matching function parameter types.
More simplifications are probably possible here, but arrays and
structures need to be implemented first.

Add queries to get the glsl_type of a row or column of a matrix

Widen num_components to handle vec4 correctly.

Typo fixes: de/re/ference.

Replace several field comparisons with a single pointer comparison

The only way the specified type fields can match is if the types are the
same.  Previous tests (and assertions) have filtered away all other possible
cases.

Remove unused _mesa_glsl_get_vector_type

This function has been completely replaced by glsl_type::get_instance.

Use glsl_type::get_instance instead of _mesa_glsl_get_vector_type

Use glsl_type::get_instance instead of symbol table look-up

Add some matrix math tests

Add glsl_type::get_instance method

Gets the singleton corresponding to a particular scalar, vector, or
matrix type.

Replace accesses to glsl_type data with query functions

In these particular cases, using the query functions makes it more obvious
what is happening.

Add class-private handles to matrix types in glsl_type

Fix typo in swizzle processing loop

One of the accesses to str in the loop used str[0] instead of str[i].

Reported-by: Kenneth Graunke

Trivial cleanups in generate_swizzle

Add 'const' and 'static const' in a couple of places.

Use ir_dereference::set_swizzle

Add method to set the swizzle of an ir_dereference

Allow duplicate symbols at the same scope that are in different name spaces

Merge branch 'anholt'

Add (negative) test for constructing samplers

ir_function constructor now takes the function name as a parameter

Add glsl_type::get_base_type query

Retreives the glsl_type that corresponds to the base type of a numeric scalar /
vector / matrix type.  So vec4 returns float, etc.

Add glsl_type::is_numeric and glsl_type::is_boolean queries

Begin processing constructors

Right now, reject constructors for samplers because the are illegal.

Add query to determine whether a type is a sampler

Add test for invalid assignment of function return value

Add *some* type checking for assignments

Disallow passing NULL for state to _mesa_glsl_error

The two places that were still passing NULL had a state pointer to
pass.  Not passing it in these places prevented termination of
compilation of erroneous programs.

Fix typographical errors of "FINISHME"

Include other generated sources in BUILT_SOURCES.

Otherwise, having cleaned glsl_parser.h, we'd never regenerate it because
glsl_parser.cpp was already right where it needed to be.

Use bash for the built file generation since builtin_types.sh requires it.

Clean the built sources with make clean.

Generate an error for variables declared with type void

Add is_error and is_void type queries

Set the type of a function call to be the return type of the callee

Set, and require, a return type for function signatures

Add `void' type to table of available types

This will make void-01.glsl test fail, so I may regret this later.
However, this will make supporting functions that return void or
functions that have a void parameter list easier to handle.

Rename test GLSL sources from .txt to .glsl

Add test for declaring variables of type void.

Track the function that is currently being defined

Later this will allow type checking for return statements.

Initial bits for converting AST return nodes to IR return instructions

Implement IR return instructions

Use glsl_symbol_table::name_declared_this_scope

Prevent most illegal name reuse.

Add query to determine whether a name was declared at this scope

This will be used to prevent a variable and a function with the same
name from being declared.  As a side effect, the calls to
add_{type,name,function} should never fail.

Use separate namespaces for types, variables, and functions

This will allow types and their constructors to be easily stored in
the same symbol table.  This does add a potential problem that a
shader could declare a variable and a function with the same name.
This appears to be forbidden by the GLSL spec.

Add function to determine the scope where a variable is declared

Use glsl_symbol_table instead of using _mesa_symbol_table directly

Add a GLSL-specific facade to _mesa_symbol_table

This adds some type saftey and will enable elimination of a bunch of
type casts and other ugly crap in the code.

Don't track new type names during pass-1 parsing

This implementation was wrong anyway because it did not respect
scoping rules.  This will need to be revisited soon.  The most likely
result is that the grammar is going to need some significant re-work
to be able to use a IDENTIFIER in all the places where a TYPE_NAME is
currently used.

Add multiple include protection to ir.h

Trivial clean-ups to ast_type_specifier(int) constructor