Typo fixes: de/re/ference.

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

Add new constructors for ast_type_specifier

Add a constructor that uses an ast_struct_specifier and one that uses
a type name.  This saves a (trivial) bit of code, but it also ensures
some of the class invariants (i.e., type_name != NULL) are met.

Ensure that ast_type always has type_name set

For built-in types, type_name would be NULL.  This ensures that
type_name is set even for the built-in types.  This simplifies code in
a few places and centralizes the name setting code.

Factor ast_type_specifier code out to ast_type.cpp

Factor guts of function matching code out to match_function_by_name

This function will be used for matching some types of constructors as well.

Move ast_function_expression::hir to ast_function.cpp

Remove DOA hir_function.c file

Change type of function_identifier to silence bison warning

When the implementation of function_call_header and
function_identifier were changed a few commits ago, the types of the
production changed.  This just updates the types specified for the
productions to match reality.

Add parameters to function declarations in the correct order

Initial pass at resolving function calls

The code is still really rough and *REALLY* incomplete.  This at least
passes the first few trivially simple test cases.

Default function parameters to 'in' instead of auto

Add a handful of simple tests for function calls in constructors

Add ir_call call to represent function calls.

Fix broken constructor of ir_instruction base class

Make the constructor inline-able, and don't try to initialize it as a
simple_node.  It hasn't been derived from simple_node in a long time.

Track generation of errors and halt compilation appropriately

Differentiate in ast_function_expression between constructors and func. calls

Tell emacs that C++ .h files are C++

Make ast_function_expression subclass of ast_expression

Simplified constructor for identifier expressions

IR variable: Initial work to support GLSL built-in variables

Include cstdlib to be sure size_t is available

Move top-level AST to HIR conversion to _mesa_ast_to_hir

Require the shader target be specified to the driver program

Use ir_print_visitor to dump IR tree

Fix typeo in gl_FogParameters.scale (was scalre)

AST to IR: Mark 'varying' in a vertex shader as 'out'

ir_variable: Initialize all attribute bits to reasonable defaults

This prevents variables from randomly having their 'invariant' or
'read_only' bits set, for example.

IR print visitor: Add some support for printing types and constants

IR print visitor: Print assignments

Add assignment side-effect to the instruction stream

The actual assignment is a side-effect of the assignment expression.
Add it to the instruction stream and return the LHS of the assignment
as its rvalue.

IR visitor: Add initial version of ir_visitor classes

The ir_visitor class is the abstract base class for all visitors.
ir_print_visitor contains the beginnings of a concrete visitor class
that will print out an IR sequence in a Lisp / Scheme-like syntax.

Convert is_glsl_type_matrix to glsl_type::is_matrix

Convert is_glsl_type_vector to glsl_type::is_vector

Convert is_glsl_type_scalar to glsl_type::is_scalar

Make glsl_type a class

Among other benefits, this cleans up a the hackery invovled in
initializing the union field in builtin_types.h.

Remove unused function

Conver IR structures to use exec_list instead of simple_node

Add yet-another linked list type

The use of macros to access existing linked list type makes it
unsuitable for its current use as a base class.  Since this type and
the accompanying macros are used all over the place in Mesa, we can't
really change them.

Remove prototypes for *_to_hir functions that no longer exist

Set C++ indent too.

Make AST->HIR conversion a method of ast_node, re-enable

autoconf for the ...

Replace tacky wrapper macros with tacky in-line type-casts

Convert to new interfaces so that it will compile

Convert TRUE and FALSE to true and false.  Convert
_mesa_ast_get_location to ast_node::get_location.

Add ast_expression_bin subclass of ast_expression

The ast_expression_bin subclass is used for all binary expressions
such as addition, subtraction, and comparisons.  Several other
subclasses are soon to follow.

Ignore all build products

Rename .cc files to .cpp

Initialize the node structure embedded in the ast_node

Initial commit.  lol