ir_reader: Set function signatures as defined.

FS gl_FragCoord and and gl_FrontFacing are FS ins, not outs.

Fix function call parameter printer to omit extraneous leading comma

The output of all test cases was verified to be the same using diff.

Replace many uses of foreach_list with foreach_list_typed

exec_list: Add foreach_list_typed and foreach_list_typed_const

These variations are parameterized by the type of the nodes in the
list.  This enables skipping the explicit usage of exec_node_data in
the loop body.

Convert ast_node use of simple_node to exec_list and exec_node

exec_list: Add simpler exec_list for-each macros

exec_list: Add macros to get ptr to structure containing a node

This has some ugly hackery to work-around C++ fail.  I have
emperically determined that it works in all the cases that matter.

Loop bodies, then-statements, and else-statements are not lists

The statement making up a loop body, a then-statement, or an
else-statement are single nodes.  If the statement is a block, the
single node will be an ast_compound_statement.  There is no need to
loop at the top level when processing these statements.

Remove unnecessary include of simple_list.h

Store AST function call parameters in expressions

Previously the list of function call parameters was stored as a
circular list in ast_expression::subexpressions[1].  They are now
stored as a regular list in ast_expression::expressions.

Move optimization pass prototypes to a single header.

ir_dead_code_local: Remove redundant assignments within basic blocks.

This cleans up a bunch of junk code in some of the GLSL parser tests,
and could potentially help real-world too (particularly after copy
propagation has happened).

ir_visit_tree: Make sure we visit dereference targets, too.

Found this with the local dead code pass, which never saw variable
dereferences occurring.

ir_copy_propagation: Fix up the doxygen about the file.

ir_copy_propagation: Return true if we optimized out any assignments.

This may trigger other optimization phases to make more progress themselves.

ir_copy_propagation: Handle swizzles and array derefs on LHS of assign.

This improves the ACP to not get cleared when more complicated assignments
occur, cleaning up more redundant copies in programs.

ir_copy_propagation: New pass to rewrite dereferences to avoid copies.

This is pretty basic.  Right now it only handles pure assignments --
same type on each side, no swizzling, and only within basic blocks.

ir_to_mesa.cpp: Fix missing types on some ir_swizzles.

Debugging this took forever as I only looked at constructors in ir.cpp
to find who wasn't setting up ->type.  I dislike hiding code (as
opposed to prototypes and definitions) in C++ header files, but in
this case I have only myself to blame.

Remove the pedantic C junk.

Mesa doesn't use pedantic ANSI C89, so I have no idea why we would.

Store warnings and errors in a parser state infolog.

Cleans up compile warning about unused state in _mesa_glsl_warning.  We
would want infolog handling roughly like this anyway.

Quiet warnings about ir_shader not being handled in places it's not needed.

Use the AM_SILENT_RULES when available.

glsl_lexer: Quiet warning about unused unput().

Merge branch 'fixes'

Use %p rather than %08x when printing pointers to fix compile.

Fix ir_return cloning to actually use the cloned subexpression.

This caused a nasty bug where the function inliner would create new
variables for each of the formal parameters, but the body would still
reference the old copies.

This was highly visible since the dead code eliminator (rightly) removed
the new declarations, leading to printed IR that referenced non-existent
variable names.

Fix incorrect comments in function inliner.

ir_dead_code: Fix segfault on handling a return statement with no value.

Track and print user defined structure types

IR print visitor: Move logic for printing the whole program to _mesa_print_ir

IR print visitor: Just print the name of structures

Treat structure types like other non-array types.  We'll have to print
the structure defintion elsewhere.

ir_function_inlining: Handle inlining of structure dereferences.

Correctly handle remapping of array dereferences if ->var is a variable.

Begin handling some varieties of invalid declarations

Reject conflicting struct declarations, generate struct constructor

glsl_type::generate_constructor_prototype now generates the function too

Also, change the name of the method to generate_constructor.

Always return a value from ast_type_specifier::hir

Support structures in glsl_type::generate_constructor_prototype

Implement structures and arrays in ir_dereference::is_lvalue

Ensure that structure fields have non-NULL types

Ensure that anonymous structures have non-NULL names

Convert structure field dereferences to HIR

Add ir_dereference constructor for structure field dereferences

Add glsl_type::field_type

Query the type of a structure field

Begin converting structure definitions to IR

Use IDENTIFIER instead of TYPE_NAME for structure names

Since there is no track of which names are structure names during parsing,
TYPE_NAME cannot be produced by the lexer.  Use IDENTIFIER and let the AST
processor sort it out.

ir_reader: Slightly better error message when failing to read swizzles.

ir_reader: Don't print out the S-Expression.

It's no longer useful for debugging.

ir_reader: Read function calls.

ir_reader: Replace function prototypes with the definition.

Previously, we just created a new one, which was wrong.

ir_reader: Fix incorrect error message for expressions.

Make ir_read_error print out the given S-Expression, for context.

ir_reader: Fix for swizzles.

ir_reader: Preliminary work toward reading functions.

ir_reader: Perform a preliminary pass to scan for function prototypes.

ir_reader: Don't initialize globals, builtins, or constructors.

All of these are currently emitted as part of the IR, so by initializing
them, we actually end up with two copies.  For constructors, we may
eventually wish to avoid emitting them as part of the IR output.

Make ir_read_error set state->error.

ir_reader: Add support for "break" and "continue" in loops.

Includes threading the ir_loop * context through various functions.

ir_reader: Add initial loop support; doesn't yet support break/continue.

ir_reader: Add support for reading (var_ref ...) and (array_ref ...)

ir_reader: rvalues are instructions too!

ir_reader: Add support for reading conditionals: (if ...)

ir_reader: Add support for reading array types.

Also, constify glsl_type pointers; this was necessary to use
glsl_type::get_array_instance.

ir_reader: Add support for reading (return ...)

ir_reader: Add support for reading variable declarations.

It also now reads a list of instructions, as it should, rather than a
single rvalue.

Partial IR reader.

Currently reads assignments, constants, expressions, and swizzles.

Set language_version to 130 (the max currently supported) when reading IR.

This is necessary so _mesa_glsl_initialize_types can create appropriate
glsl_types and add them to the symbol table.

In the future, we'll want to set it to the max GLSL version supported by
the current driver.

Add stub ir_reader and new 'i' mode for reading IR rather than GLSL.

Add a simple S-Expression reader and printer.

Use "neg" when printing/reading unary negation rather than "-".

"-" is now only used for binary subtraction.

Move array of operator strings out of ir_print_visitor.cpp.

Also implement a reverse-lookup function for use in the IR reader.

Factor out parameter list replacement for later reuse.

Factor out parameter list matching from ast_function::hir for later reuse.

Unfortunately, we still have two kinds of matching - one, with implicit
conversions (for use in calls) and another without them (for finding a
prototype to overwrite when processing a function body).  This commit
does not attempt to coalesce the two.

Factor out qualifier checking code for later reuse.

ir_print_visitor: Re-parenthesize ir_call output.

ir_print_visitor: Print return type of ir_function_signatures.

ir_print_visitor: Print (constant bool (1)) instead of "true"

It might be better to simply handle "true" in the reader, but since
booleans normally aren't printed as "true" or "false", we may as well go
for consistency.

ir_print_visitor: Remove unnecessary parens around expression operands.

ir_print_visitor: Remove unnecessary parens around array size in types.

ir_print_visitor: Fix unclosed parenthesis in (call...

ir_print_visitor: Fix unclosed parenthesis in (assign ...

Also remove useless parens around subexpressions.

Add parens around printed IR so it's an official list of instructions.

ir_print_visitor: Remove unnecessary parenthesis around variable names.

Refactor ir_expression::get_num_operands.

A new static version takes an ir_expression_operation enum, and the
original non-static version now uses it.  This will make it easier to
read operations (where the ir_expression doesn't yet exist).

ir_print_visitor: print the type of expressions.

This can be useful for debugging - it allows us to see that the inferred
type is what we think it should be.  Furthermore, it will allow the IR
reader to avoid complex, operator-specific type inference.

ir_print_visitor: Remove unnecessary parenthesis around type names.

Parenthesis should only be present for compound types (i.e. arrays
or structures).  For atomic types, simply print the symbol.

Print full type for ir_constant instead of base and component count.

vec4 and mat2x2 have the same base type and number of components;
printing the full type allows us to distinguish the two.

Implement gl_TextureMatrix built-in uniform

Make private glsl_type singletons public

Initial implementation of #line

Does not handle comments in #line or line continuation characters, but
it should be good enough for now.

builtin_functions: Clean up compiler warning about unused name, instructions.

De-obfuscate some of builtin_types.h.

ir_function_inlining: Implement inlining in many more cases.

We still don't inline for control flow in the inlined function, and we
don't have any limits on what we will inline.

Put static pointers to vec[234]_types along with the static float_type.

Otherwise you have to type a lot of get_instance.

Replace builtin_types.h generation with the generated output.

The script to generate it was longer and more obfuscated than the output.

Fix the swizzling of vector constructors from scalars.

A refactor turned 'i' into '1', meaning everything writemasked into
the y component.

ir_function_inlining: Avoid NULL dereference on assignment conditions.

Zero-out the entire parser state structure at initialization

Among other things, this ensures that all of the extension flags are
initially disabled.

This causes the following tests to pass:

    glslparsertest/glsl2/draw_buffers-02.frag

Add missing 'else's to fix extension processing

The missing else-statements caused all of the extensions execpt
GL_ARB_texture_rectangle to be unsupported.

This causes the following tests to pass:

     glslparsertest/glsl2/draw_buffers-04.frag