X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=c670bc1a814ee1002eac71285c9002fe568c1968;hp=c9803acc3b2afd5698b29f66c8d69a110ddfc18c;hb=91e2fb59219089ac0f16bc49152c20be42a14cc5;hpb=de87bb70ae10de39a39b2415407a234ab28099cf

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index c9803acc..c670bc1a 100644
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -1,6 +1,8 @@
+#include <algorithm>
 #include <msp/core/hash.h>
 #include <msp/core/raii.h>
 #include <msp/strings/lexicalcast.h>
+#include <msp/strings/utils.h>
 #include "builtin.h"
 #include "generate.h"
 
@@ -10,57 +12,6 @@ namespace Msp {
 namespace GL {
 namespace SL {
 
-void DeclarationCombiner::apply(Stage &stage)
-{
-	stage.content.visit(*this);
-	NodeRemover().apply(stage, nodes_to_remove);
-}
-
-void DeclarationCombiner::visit(Block &block)
-{
-	if(current_block)
-		return;
-
-	TraversingVisitor::visit(block);
-}
-
-void DeclarationCombiner::visit(VariableDeclaration &var)
-{
-	VariableDeclaration *&ptr = variables[var.name];
-	if(ptr)
-	{
-		ptr->type = var.type;
-		if(var.init_expression)
-			ptr->init_expression = var.init_expression;
-		if(var.layout)
-		{
-			if(ptr->layout)
-			{
-				for(vector<Layout::Qualifier>::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i)
-				{
-					bool found = false;
-					for(vector<Layout::Qualifier>::iterator j=ptr->layout->qualifiers.begin(); (!found && j!=ptr->layout->qualifiers.end()); ++j)
-						if(j->name==i->name)
-						{
-							j->has_value = i->value;
-							j->value = i->value;
-							found = true;
-						}
-
-					if(!found)
-						ptr->layout->qualifiers.push_back(*i);
-				}
-			}
-			else
-				ptr->layout = var.layout;
-		}
-		nodes_to_remove.insert(&var);
-	}
-	else
-		ptr = &var;
-}
-
-
 ConstantSpecializer::ConstantSpecializer():
 	values(0)
 { }
@@ -116,31 +67,58 @@ void ConstantSpecializer::visit(VariableDeclaration &var)
 
 void BlockHierarchyResolver::enter(Block &block)
 {
+	r_any_resolved |= (current_block!=block.parent);
 	block.parent = current_block;
 }
 
 
 TypeResolver::TypeResolver():
-	stage(0)
+	stage(0),
+	iface_block(0),
+	r_any_resolved(false)
 { }
 
-void TypeResolver::apply(Stage &s)
+bool TypeResolver::apply(Stage &s)
 {
 	stage = &s;
 	s.types.clear();
+	r_any_resolved = false;
 	s.content.visit(*this);
+	return r_any_resolved;
 }
 
-TypeDeclaration *TypeResolver::resolve_type(const string &name)
+TypeDeclaration *TypeResolver::get_or_create_array_type(TypeDeclaration &type)
 {
+	map<TypeDeclaration *, TypeDeclaration *>::iterator i = array_types.find(&type);
+	if(i!=array_types.end())
+		return i->second;
+
+	BasicTypeDeclaration *array = new BasicTypeDeclaration;
+	array->source = BUILTIN_SOURCE;
+	array->name = type.name+"[]";
+	array->kind = BasicTypeDeclaration::ARRAY;
+	array->base = type.name;
+	array->base_type = &type;
+	stage->content.body.insert(type_insert_point, array);
+	array_types[&type] = array;
+	return array;
+}
+
+void TypeResolver::resolve_type(TypeDeclaration *&type, const string &name, bool array)
+{
+	TypeDeclaration *resolved = 0;
 	map<string, TypeDeclaration *>::iterator i = stage->types.find(name);
 	if(i!=stage->types.end())
 	{
 		map<TypeDeclaration *, TypeDeclaration *>::iterator j = alias_map.find(i->second);
-		return (j!=alias_map.end() ? j->second : i->second);
+		resolved = (j!=alias_map.end() ? j->second : i->second);
 	}
-	else
-		return 0;
+
+	if(resolved && array)
+		resolved = get_or_create_array_type(*resolved);
+
+	r_any_resolved |= (resolved!=type);
+	type=resolved;
 }
 
 void TypeResolver::visit(Block &block)
@@ -155,13 +133,16 @@ void TypeResolver::visit(Block &block)
 
 void TypeResolver::visit(BasicTypeDeclaration &type)
 {
-	type.base_type = resolve_type(type.base);
+	resolve_type(type.base_type, type.base, false);
 
 	if(type.kind==BasicTypeDeclaration::VECTOR && type.base_type)
 		if(BasicTypeDeclaration *basic_base = dynamic_cast<BasicTypeDeclaration *>(type.base_type))
 			if(basic_base->kind==BasicTypeDeclaration::VECTOR)
 			{
 				type.kind = BasicTypeDeclaration::MATRIX;
+				/* A matrix's base type is its column vector type.  This will put
+				the column vector's size, i.e. the matrix's row count, in the high
+				half of the size. */
 				type.size |= basic_base->size<<16;
 			}
 
@@ -175,7 +156,7 @@ void TypeResolver::visit(BasicTypeDeclaration &type)
 
 void TypeResolver::visit(ImageTypeDeclaration &type)
 {
-	type.base_type = resolve_type(type.base);
+	resolve_type(type.base_type, type.base, false);
 	stage->types.insert(make_pair(type.name, &type));
 }
 
@@ -187,48 +168,61 @@ void TypeResolver::visit(StructDeclaration &strct)
 
 void TypeResolver::visit(VariableDeclaration &var)
 {
-	TypeDeclaration *type = resolve_type(var.type);
-	if(var.array && type)
+	resolve_type(var.type_declaration, var.type, var.array);
+	if(iface_block && var.interface==iface_block->interface)
+		var.interface.clear();
+}
+
+void TypeResolver::visit(InterfaceBlock &iface)
+{
+	if(iface.members)
 	{
-		map<TypeDeclaration *, TypeDeclaration *>::iterator i = array_types.find(type);
-		if(i==array_types.end())
-		{
-			BasicTypeDeclaration *array = new BasicTypeDeclaration;
-			array->source = BUILTIN_SOURCE;
-			array->name = type->name+"[]";
-			array->kind = BasicTypeDeclaration::ARRAY;
-			array->base = type->name;
-			array->base_type = type;
-			stage->content.body.insert(type_insert_point, array);
-			array->visit(*this);
-			type = array;
-		}
-		else
-			type = i->second;
+		SetForScope<InterfaceBlock *> set_iface(iface_block, &iface);
+		iface.members->visit(*this);
+
+		StructDeclaration *strct = new StructDeclaration;
+		strct->source = INTERNAL_SOURCE;
+		strct->name = format("_%s_%s", iface.interface, iface.name);
+		strct->members.body.splice(strct->members.body.begin(), iface.members->body);
+		stage->content.body.insert(type_insert_point, strct);
+		stage->types.insert(make_pair(strct->name, strct));
+
+		iface.members = 0;
+		strct->interface_block = &iface;
+		iface.struct_declaration = strct;
 	}
-	var.type_declaration = type;
+
+	TypeDeclaration *type = iface.struct_declaration;
+	if(type && iface.array)
+		type = get_or_create_array_type(*type);
+	r_any_resolved = (type!=iface.type_declaration);
+	iface.type_declaration = type;
 }
 
 void TypeResolver::visit(FunctionDeclaration &func)
 {
-	func.return_type_declaration = resolve_type(func.return_type);
+	resolve_type(func.return_type_declaration, func.return_type, false);
 	TraversingVisitor::visit(func);
 }
 
 
 VariableResolver::VariableResolver():
 	stage(0),
-	r_members(0),
+	r_any_resolved(false),
 	record_target(false),
-	r_self_referencing(false),
-	r_assignment_target(0)
+	r_self_referencing(false)
 { }
 
-void VariableResolver::apply(Stage &s)
+bool VariableResolver::apply(Stage &s)
 {
 	stage = &s;
 	s.interface_blocks.clear();
+	r_any_resolved = false;
 	s.content.visit(*this);
+	for(vector<VariableDeclaration *>::const_iterator i=redeclared_builtins.begin(); i!=redeclared_builtins.end(); ++i)
+		(*i)->source = GENERATED_SOURCE;
+	NodeRemover().apply(s, nodes_to_remove);
+	return r_any_resolved;
 }
 
 void VariableResolver::enter(Block &block)
@@ -236,21 +230,55 @@ void VariableResolver::enter(Block &block)
 	block.variables.clear();
 }
 
+void VariableResolver::visit(RefPtr<Expression> &expr)
+{
+	r_replacement_expr = 0;
+	expr->visit(*this);
+	if(r_replacement_expr)
+	{
+		expr = r_replacement_expr;
+		/* Don't record assignment target when doing a replacement, because chain
+		information won't be correct. */
+		r_assignment_target.declaration = 0;
+		r_any_resolved = true;
+	}
+	r_replacement_expr = 0;
+}
+
+void VariableResolver::check_assignment_target(Statement *declaration)
+{
+	if(record_target)
+	{
+		if(r_assignment_target.declaration)
+		{
+			/* More than one reference found in assignment target.  Unable to
+			determine what the primary target is. */
+			record_target = false;
+			r_assignment_target.declaration = 0;
+		}
+		else
+			r_assignment_target.declaration = declaration;
+	}
+	// TODO This check is overly broad and may prevent some optimizations.
+	else if(declaration && declaration==r_assignment_target.declaration)
+		r_self_referencing = true;
+}
+
 void VariableResolver::visit(VariableReference &var)
 {
-	var.declaration = 0;
-	r_members = 0;
+	VariableDeclaration *declaration = 0;
+
 	/* Look for variable declarations in the block hierarchy first.  Interface
 	blocks are always defined in the top level so we can't accidentally skip
 	one. */
-	for(Block *block=current_block; (!var.declaration && block); block=block->parent)
+	for(Block *block=current_block; (!declaration && block); block=block->parent)
 	{
 		map<string, VariableDeclaration *>::iterator i = block->variables.find(var.name);
 		if(i!=block->variables.end())
-			var.declaration = i->second;
+			declaration = i->second;
 	}
 
-	if(!var.declaration)
+	if(!declaration)
 	{
 		const map<string, InterfaceBlock *> &blocks = stage->interface_blocks;
 		map<string, InterfaceBlock *>::const_iterator i = blocks.find("_"+var.name);
@@ -258,91 +286,115 @@ void VariableResolver::visit(VariableReference &var)
 		{
 			/* The name refers to an interface block with an instance name rather
 			than a variable.  Prepare a new syntax tree node accordingly. */
-			r_iface_ref = new InterfaceBlockReference;
-			r_iface_ref->source = var.source;
-			r_iface_ref->line = var.line;
-			r_iface_ref->name = var.name;
-			r_iface_ref->declaration = i->second;
-			r_members = &i->second->members.variables;
+			InterfaceBlockReference *iface_ref = new InterfaceBlockReference;
+			iface_ref->source = var.source;
+			iface_ref->line = var.line;
+			iface_ref->name = var.name;
+			iface_ref->declaration = i->second;
+			r_replacement_expr = iface_ref;
 		}
 		else
 		{
 			// Look for the variable in anonymous interface blocks.
-			for(i=blocks.begin(); (!var.declaration && i!=blocks.end()); ++i)
-				if(i->second->instance_name.empty())
+			for(i=blocks.begin(); (!declaration && i!=blocks.end()); ++i)
+				if(i->second->instance_name.empty() && i->second->struct_declaration)
 				{
-					map<string, VariableDeclaration *>::iterator j = i->second->members.variables.find(var.name);
-					if(j!=i->second->members.variables.end())
-						var.declaration = j->second;
+					const map<string, VariableDeclaration *> &iface_vars = i->second->struct_declaration->members.variables;
+					map<string, VariableDeclaration *>::const_iterator j = iface_vars.find(var.name);
+					if(j!=iface_vars.end())
+						declaration = j->second;
 				}
 		}
 	}
 
-	if(var.declaration)
-		if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(var.declaration->type_declaration))
-			r_members = &strct->members.variables;
+	r_any_resolved |= (declaration!=var.declaration);
+	var.declaration = declaration;
 
-	if(record_target)
-	{
-		if(r_assignment_target)
-		{
-			/* More than one variable reference found in assignment target.
-			Unable to determine what the primary target is. */
-			record_target = false;
-			r_assignment_target = 0;
-		}
-		else
-			r_assignment_target = var.declaration;
-	}
-	else if(var.declaration && var.declaration==r_assignment_target)
-		r_self_referencing = true;
+	check_assignment_target(var.declaration);
 }
 
 void VariableResolver::visit(InterfaceBlockReference &iface)
 {
-	iface.declaration = 0;
-	for(Block *block=current_block; block; block=block->parent)
-	{
-		map<string, InterfaceBlock *>::iterator i = stage->interface_blocks.find("_"+iface.name);
-		if(i!=stage->interface_blocks.end())
-		{
-			iface.declaration = i->second;
-			r_members = &i->second->members.variables;
-			break;
-		}
-	}
+	map<string, InterfaceBlock *>::iterator i = stage->interface_blocks.find("_"+iface.name);
+	InterfaceBlock *declaration = (i!=stage->interface_blocks.end() ? i->second : 0);
+	r_any_resolved |= (declaration!=iface.declaration);
+	iface.declaration = declaration;
+
+	check_assignment_target(iface.declaration);
+}
+
+void VariableResolver::add_to_chain(Assignment::Target::ChainType type, unsigned index)
+{
+	if(r_assignment_target.chain_len<7)
+		r_assignment_target.chain[r_assignment_target.chain_len] = type | min<unsigned>(index, 0x3F);
+	++r_assignment_target.chain_len;
 }
 
 void VariableResolver::visit(MemberAccess &memacc)
 {
-	r_members = 0;
-	r_iface_ref = 0;
-	memacc.left->visit(*this);
+	TraversingVisitor::visit(memacc);
 
-	if(r_iface_ref)
-		memacc.left = r_iface_ref;
-	r_iface_ref = 0;
+	VariableDeclaration *declaration = 0;
+	if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(memacc.left->type))
+	{
+		map<string, VariableDeclaration *>::iterator i = strct->members.variables.find(memacc.member);
+		if(i!=strct->members.variables.end())
+		{
+			declaration = i->second;
+
+			if(record_target)
+			{
+				unsigned index = 0;
+				for(NodeList<Statement>::const_iterator j=strct->members.body.begin(); (j!=strct->members.body.end() && j->get()!=i->second); ++j)
+					++index;
 
-	memacc.declaration = 0;
-	if(r_members)
+				add_to_chain(Assignment::Target::MEMBER, index);
+			}
+		}
+	}
+	else if(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(memacc.left->type))
 	{
-		map<string, VariableDeclaration *>::iterator i = r_members->find(memacc.member);
-		if(i!=r_members->end())
+		bool scalar_swizzle = ((basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT) && memacc.member.size()==1);
+		bool vector_swizzle = (basic->kind==BasicTypeDeclaration::VECTOR && memacc.member.size()<=4);
+		if(scalar_swizzle || vector_swizzle)
 		{
-			memacc.declaration = i->second;
-			if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(i->second->type_declaration))
-				r_members = &strct->members.variables;
+			static const char component_names[] = { 'x', 'r', 's', 'y', 'g', 't', 'z', 'b', 'p', 'w', 'a', 'q' };
+
+			bool ok = true;
+			UInt8 components[4] = { };
+			for(unsigned i=0; (ok && i<memacc.member.size()); ++i)
+				ok = ((components[i] = (find(component_names, component_names+12, memacc.member[i])-component_names)/3) < 4);
+
+			if(ok)
+			{
+				Swizzle *swizzle = new Swizzle;
+				swizzle->source = memacc.source;
+				swizzle->line = memacc.line;
+				swizzle->oper = memacc.oper;
+				swizzle->left = memacc.left;
+				swizzle->component_group = memacc.member;
+				swizzle->count = memacc.member.size();
+				copy(components, components+memacc.member.size(), swizzle->components);
+				r_replacement_expr = swizzle;
+			}
 		}
-		else
-			r_members = 0;
 	}
+
+	r_any_resolved |= (declaration!=memacc.declaration);
+	memacc.declaration = declaration;
 }
 
-void VariableResolver::visit(UnaryExpression &unary)
+void VariableResolver::visit(Swizzle &swizzle)
 {
-	TraversingVisitor::visit(unary);
-	r_members = 0;
-	r_iface_ref = 0;
+	TraversingVisitor::visit(swizzle);
+
+	if(record_target)
+	{
+		unsigned mask = 0;
+		for(unsigned i=0; i<swizzle.count; ++i)
+			mask |= 1<<swizzle.components[i];
+		add_to_chain(Assignment::Target::SWIZZLE, mask);
+	}
 }
 
 void VariableResolver::visit(BinaryExpression &binary)
@@ -353,54 +405,83 @@ void VariableResolver::visit(BinaryExpression &binary)
 			/* The subscript expression is not a part of the primary assignment
 			target. */
 			SetFlag set(record_target, false);
-			binary.right->visit(*this);
+			visit(binary.right);
+		}
+		visit(binary.left);
+
+		if(record_target)
+		{
+			unsigned index = 0x3F;
+			if(Literal *literal_subscript = dynamic_cast<Literal *>(binary.right.get()))
+				if(literal_subscript->value.check_type<int>())
+					index = literal_subscript->value.value<int>();
+			add_to_chain(Assignment::Target::ARRAY, index);
 		}
-		r_members = 0;
-		r_iface_ref = 0;
-		binary.left->visit(*this);
-		if(r_iface_ref)
-			binary.left = r_iface_ref;
 	}
 	else
-	{
 		TraversingVisitor::visit(binary);
-		r_members = 0;
-	}
-
-	r_iface_ref = 0;
 }
 
 void VariableResolver::visit(Assignment &assign)
 {
 	{
 		SetFlag set(record_target);
-		r_assignment_target = 0;
-		assign.left->visit(*this);
-		assign.target_declaration = r_assignment_target;
+		r_assignment_target = Assignment::Target();
+		visit(assign.left);
+		r_any_resolved |= (r_assignment_target<assign.target || assign.target<r_assignment_target);
+		assign.target = r_assignment_target;
 	}
 
 	r_self_referencing = false;
-	assign.right->visit(*this);
+	visit(assign.right);
 	assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='=');
-
-	r_members = 0;
-	r_iface_ref = 0;
 }
 
-void VariableResolver::visit(FunctionCall &call)
+void VariableResolver::merge_layouts(Layout &to_layout, const Layout &from_layout)
 {
-	TraversingVisitor::visit(call);
-	r_members = 0;
-	r_iface_ref = 0;
+	for(vector<Layout::Qualifier>::const_iterator i=from_layout.qualifiers.begin(); i!=from_layout.qualifiers.end(); ++i)
+	{
+		bool found = false;
+		for(vector<Layout::Qualifier>::iterator j=to_layout.qualifiers.begin(); (!found && j!=to_layout.qualifiers.end()); ++j)
+			if(j->name==i->name)
+			{
+				j->has_value = i->value;
+				j->value = i->value;
+				found = true;
+			}
+
+		if(!found)
+			to_layout.qualifiers.push_back(*i);
+	}
 }
 
 void VariableResolver::visit(VariableDeclaration &var)
 {
-	if(!block_interface.empty() && var.interface.empty())
-		var.interface = block_interface;
-
 	TraversingVisitor::visit(var);
-	current_block->variables.insert(make_pair(var.name, &var));
+	VariableDeclaration *&ptr = current_block->variables[var.name];
+	if(!ptr)
+		ptr = &var;
+	else if(!current_block->parent && ptr->interface==var.interface && ptr->type==var.type)
+	{
+		if(ptr->source==BUILTIN_SOURCE)
+			redeclared_builtins.push_back(&var);
+		else
+			stage->diagnostics.push_back(Diagnostic(Diagnostic::WARN, var.source, var.line,
+				format("Redeclaring non-builtin variable '%s' is deprecated", var.name)));
+
+		if(var.init_expression)
+			ptr->init_expression = var.init_expression;
+		if(var.layout)
+		{
+			if(ptr->layout)
+				merge_layouts(*ptr->layout, *var.layout);
+			else
+				ptr->layout = var.layout;
+		}
+		nodes_to_remove.insert(&var);
+
+		r_any_resolved = true;
+	}
 }
 
 void VariableResolver::visit(InterfaceBlock &iface)
@@ -411,31 +492,498 @@ void VariableResolver::visit(InterfaceBlock &iface)
 	if(!iface.instance_name.empty())
 		stage->interface_blocks.insert(make_pair("_"+iface.instance_name, &iface));
 
-	SetForScope<string> set_iface(block_interface, iface.interface);
 	TraversingVisitor::visit(iface);
 }
 
 
-void FunctionResolver::apply(Stage &s)
+ExpressionResolver::ExpressionResolver():
+	stage(0),
+	r_any_resolved(false)
+{ }
+
+bool ExpressionResolver::apply(Stage &s)
+{
+	stage = &s;
+	r_any_resolved = false;
+	s.content.visit(*this);
+	return r_any_resolved;
+}
+
+bool ExpressionResolver::is_scalar(BasicTypeDeclaration &type)
+{
+	return (type.kind==BasicTypeDeclaration::INT || type.kind==BasicTypeDeclaration::FLOAT);
+}
+
+bool ExpressionResolver::is_vector_or_matrix(BasicTypeDeclaration &type)
+{
+	return (type.kind==BasicTypeDeclaration::VECTOR || type.kind==BasicTypeDeclaration::MATRIX);
+}
+
+BasicTypeDeclaration *ExpressionResolver::get_element_type(BasicTypeDeclaration &type)
+{
+	if(is_vector_or_matrix(type) || type.kind==BasicTypeDeclaration::ARRAY)
+	{
+		BasicTypeDeclaration *basic_base = dynamic_cast<BasicTypeDeclaration *>(type.base_type);
+		return (basic_base ? get_element_type(*basic_base) : 0);
+	}
+	else
+		return &type;
+}
+
+bool ExpressionResolver::can_convert(BasicTypeDeclaration &from, BasicTypeDeclaration &to)
+{
+	if(from.kind==BasicTypeDeclaration::INT && to.kind==BasicTypeDeclaration::FLOAT)
+		return from.size<=to.size;
+	else if(from.kind!=to.kind)
+		return false;
+	else if((from.kind==BasicTypeDeclaration::VECTOR || from.kind==BasicTypeDeclaration::MATRIX) && from.size==to.size)
+	{
+		BasicTypeDeclaration *from_base = dynamic_cast<BasicTypeDeclaration *>(from.base_type);
+		BasicTypeDeclaration *to_base = dynamic_cast<BasicTypeDeclaration *>(to.base_type);
+		return (from_base && to_base && can_convert(*from_base, *to_base));
+	}
+	else
+		return false;
+}
+
+ExpressionResolver::Compatibility ExpressionResolver::get_compatibility(BasicTypeDeclaration &left, BasicTypeDeclaration &right)
+{
+	if(&left==&right)
+		return SAME_TYPE;
+	else if(can_convert(left, right))
+		return LEFT_CONVERTIBLE;
+	else if(can_convert(right, left))
+		return RIGHT_CONVERTIBLE;
+	else
+		return NOT_COMPATIBLE;
+}
+
+BasicTypeDeclaration *ExpressionResolver::find_type(BasicTypeDeclaration::Kind kind, unsigned size)
+{
+	for(vector<BasicTypeDeclaration *>::const_iterator i=basic_types.begin(); i!=basic_types.end(); ++i)
+		if((*i)->kind==kind && (*i)->size==size)
+			return *i;
+	return 0;
+}
+
+BasicTypeDeclaration *ExpressionResolver::find_type(BasicTypeDeclaration &elem_type, BasicTypeDeclaration::Kind kind, unsigned size)
+{
+	for(vector<BasicTypeDeclaration *>::const_iterator i=basic_types.begin(); i!=basic_types.end(); ++i)
+		if(get_element_type(**i)==&elem_type && (*i)->kind==kind && (*i)->size==size)
+			return *i;
+	return 0;
+}
+
+void ExpressionResolver::convert_to(RefPtr<Expression> &expr, BasicTypeDeclaration &type)
+{
+	RefPtr<FunctionCall> call = new FunctionCall;
+	call->name = type.name;
+	call->constructor = true;
+	call->arguments.push_back(0);
+	call->arguments.back() = expr;
+	call->type = &type;
+	expr = call;
+}
+
+bool ExpressionResolver::convert_to_element(RefPtr<Expression> &expr, BasicTypeDeclaration &elem_type)
+{
+	if(BasicTypeDeclaration *expr_basic = dynamic_cast<BasicTypeDeclaration *>(expr->type))
+	{
+		BasicTypeDeclaration *to_type = &elem_type;
+		if(is_vector_or_matrix(*expr_basic))
+			to_type = find_type(elem_type, expr_basic->kind, expr_basic->size);
+		if(to_type)
+		{
+			convert_to(expr, *to_type);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void ExpressionResolver::resolve(Expression &expr, TypeDeclaration *type, bool lvalue)
+{
+	r_any_resolved |= (type!=expr.type || lvalue!=expr.lvalue);
+	expr.type = type;
+	expr.lvalue = lvalue;
+}
+
+void ExpressionResolver::visit(Literal &literal)
+{
+	if(literal.value.check_type<bool>())
+		resolve(literal, find_type(BasicTypeDeclaration::BOOL, 1), false);
+	else if(literal.value.check_type<int>())
+		resolve(literal, find_type(BasicTypeDeclaration::INT, 32), false);
+	else if(literal.value.check_type<float>())
+		resolve(literal, find_type(BasicTypeDeclaration::FLOAT, 32), false);
+}
+
+void ExpressionResolver::visit(ParenthesizedExpression &parexpr)
+{
+	TraversingVisitor::visit(parexpr);
+	resolve(parexpr, parexpr.expression->type, parexpr.expression->lvalue);
+}
+
+void ExpressionResolver::visit(VariableReference &var)
+{
+	if(var.declaration)
+		resolve(var, var.declaration->type_declaration, true);
+}
+
+void ExpressionResolver::visit(InterfaceBlockReference &iface)
+{
+	if(iface.declaration)
+		resolve(iface, iface.declaration->type_declaration, true);
+}
+
+void ExpressionResolver::visit(MemberAccess &memacc)
+{
+	TraversingVisitor::visit(memacc);
+
+	if(memacc.declaration)
+		resolve(memacc, memacc.declaration->type_declaration, memacc.left->lvalue);
+}
+
+void ExpressionResolver::visit(Swizzle &swizzle)
+{
+	TraversingVisitor::visit(swizzle);
+
+	if(BasicTypeDeclaration *left_basic = dynamic_cast<BasicTypeDeclaration *>(swizzle.left->type))
+	{
+		BasicTypeDeclaration *left_elem = get_element_type(*left_basic);
+		if(swizzle.count==1)
+			resolve(swizzle, left_elem, swizzle.left->lvalue);
+		else if(left_basic->kind==BasicTypeDeclaration::VECTOR && left_elem)
+			resolve(swizzle, find_type(*left_elem, left_basic->kind, swizzle.count), swizzle.left->lvalue);
+	}
+}
+
+void ExpressionResolver::visit(UnaryExpression &unary)
+{
+	TraversingVisitor::visit(unary);
+
+	BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(unary.expression->type);
+	if(!basic)
+		return;
+
+	char oper = unary.oper->token[0];
+	if(oper=='!')
+	{
+		if(basic->kind!=BasicTypeDeclaration::BOOL)
+			return;
+	}
+	else if(oper=='~')
+	{
+		if(basic->kind!=BasicTypeDeclaration::INT)
+			return;
+	}
+	else if(oper=='+' || oper=='-')
+	{
+		BasicTypeDeclaration *elem = get_element_type(*basic);
+		if(!elem || !is_scalar(*elem))
+			return;
+	}
+	resolve(unary, basic, unary.expression->lvalue);
+}
+
+void ExpressionResolver::visit(BinaryExpression &binary, bool assign)
+{
+	/* Binary operators are only defined for basic types (not for image or
+	structure types). */
+	BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(binary.left->type);
+	BasicTypeDeclaration *basic_right = dynamic_cast<BasicTypeDeclaration *>(binary.right->type);
+	if(!basic_left || !basic_right)
+		return;
+
+	char oper = binary.oper->token[0];
+	if(oper=='[')
+	{
+		/* Subscripting operates on vectors, matrices and arrays, and the right
+		operand must be an integer. */
+		if((!is_vector_or_matrix(*basic_left) && basic_left->kind!=BasicTypeDeclaration::ARRAY) || basic_right->kind!=BasicTypeDeclaration::INT)
+			return;
+
+		resolve(binary, basic_left->base_type, binary.left->lvalue);
+		return;
+	}
+	else if(basic_left->kind==BasicTypeDeclaration::ARRAY || basic_right->kind==BasicTypeDeclaration::ARRAY)
+		// No other binary operator can be used with arrays.
+		return;
+
+	BasicTypeDeclaration *elem_left = get_element_type(*basic_left);
+	BasicTypeDeclaration *elem_right = get_element_type(*basic_right);
+	if(!elem_left || !elem_right)
+		return;
+
+	Compatibility compat = get_compatibility(*basic_left, *basic_right);
+	Compatibility elem_compat = get_compatibility(*elem_left, *elem_right);
+	if(elem_compat==NOT_COMPATIBLE)
+		return;
+	if(assign && (compat==LEFT_CONVERTIBLE || elem_compat==LEFT_CONVERTIBLE))
+		return;
+
+	TypeDeclaration *type = 0;
+	char oper2 = binary.oper->token[1];
+	if((oper=='<' && oper2!='<') || (oper=='>' && oper2!='>'))
+	{
+		/* Relational operators compare two scalar integer or floating-point
+		values. */
+		if(!is_scalar(*elem_left) || !is_scalar(*elem_right) || compat==NOT_COMPATIBLE)
+			return;
+
+		type = find_type(BasicTypeDeclaration::BOOL, 1);
+	}
+	else if((oper=='=' || oper=='!') && oper2=='=')
+	{
+		// Equality comparison can be done on any compatible types.
+		if(compat==NOT_COMPATIBLE)
+			return;
+
+		type = find_type(BasicTypeDeclaration::BOOL, 1);
+	}
+	else if(oper2=='&' || oper2=='|' || oper2=='^')
+	{
+		// Logical operators can only be applied to booleans.
+		if(basic_left->kind!=BasicTypeDeclaration::BOOL || basic_right->kind!=BasicTypeDeclaration::BOOL)
+			return;
+
+		type = basic_left;
+	}
+	else if((oper=='&' || oper=='|' || oper=='^' || oper=='%') && !oper2)
+	{
+		// Bitwise operators and modulo can only be applied to integers.
+		if(basic_left->kind!=BasicTypeDeclaration::INT || basic_right->kind!=BasicTypeDeclaration::INT)
+			return;
+
+		type = (compat==LEFT_CONVERTIBLE ? basic_right : basic_left);
+	}
+	else if((oper=='<' || oper=='>') && oper2==oper)
+	{
+		// Shifts apply to integer scalars and vectors, with some restrictions.
+		if(elem_left->kind!=BasicTypeDeclaration::INT || elem_right->kind!=BasicTypeDeclaration::INT)
+			return;
+		unsigned left_size = (basic_left->kind==BasicTypeDeclaration::INT ? 1 : basic_left->kind==BasicTypeDeclaration::VECTOR ? basic_left->size : 0);
+		unsigned right_size = (basic_right->kind==BasicTypeDeclaration::INT ? 1 : basic_right->kind==BasicTypeDeclaration::VECTOR ? basic_right->size : 0);
+		if(!left_size || (left_size==1 && right_size!=1) || (left_size>1 && right_size!=1 && right_size!=left_size))
+			return;
+
+		type = basic_left;
+		// Don't perform conversion even if the operands are of different sizes.
+		compat = SAME_TYPE;
+	}
+	else if(oper=='+' || oper=='-' || oper=='*' || oper=='/')
+	{
+		// Arithmetic operators require scalar elements.
+		if(!is_scalar(*elem_left) || !is_scalar(*elem_right))
+			return;
+
+		if(oper=='*' && is_vector_or_matrix(*basic_left) && is_vector_or_matrix(*basic_right) &&
+			(basic_left->kind==BasicTypeDeclaration::MATRIX || basic_right->kind==BasicTypeDeclaration::MATRIX))
+		{
+			/* Multiplication has special rules when at least one operand is a
+			matrix and the other is a vector or a matrix. */
+			unsigned left_columns = basic_left->size&0xFFFF;
+			unsigned right_rows = basic_right->size;
+			if(basic_right->kind==BasicTypeDeclaration::MATRIX)
+				right_rows >>= 16;
+			if(left_columns!=right_rows)
+				return;
+
+			BasicTypeDeclaration *elem_result = (elem_compat==LEFT_CONVERTIBLE ? elem_right : elem_left);
+
+			if(basic_left->kind==BasicTypeDeclaration::VECTOR)
+				type = find_type(*elem_result, BasicTypeDeclaration::VECTOR, basic_right->size&0xFFFF);
+			else if(basic_right->kind==BasicTypeDeclaration::VECTOR)
+				type = find_type(*elem_result, BasicTypeDeclaration::VECTOR, basic_left->size>>16);
+			else
+				type = find_type(*elem_result, BasicTypeDeclaration::MATRIX, (basic_left->size&0xFFFF0000)|(basic_right->size&0xFFFF));
+		}
+		else if(compat==NOT_COMPATIBLE)
+		{
+			// Arithmetic between scalars and matrices or vectors is supported.
+			if(is_scalar(*basic_left) && is_vector_or_matrix(*basic_right))
+				type = (elem_compat==RIGHT_CONVERTIBLE ? find_type(*elem_left, basic_right->kind, basic_right->size) : basic_right);
+			else if(is_vector_or_matrix(*basic_left) && is_scalar(*basic_right))
+				type = (elem_compat==LEFT_CONVERTIBLE ? find_type(*elem_right, basic_left->kind, basic_left->size) : basic_left);
+			else
+				return;
+		}
+		else if(compat==LEFT_CONVERTIBLE)
+			type = basic_right;
+		else
+			type = basic_left;
+	}
+	else
+		return;
+
+	if(assign && type!=basic_left)
+		return;
+
+	bool converted = true;
+	if(compat==LEFT_CONVERTIBLE)
+		convert_to(binary.left, *basic_right);
+	else if(compat==RIGHT_CONVERTIBLE)
+		convert_to(binary.right, *basic_left);
+	else if(elem_compat==LEFT_CONVERTIBLE)
+		converted = convert_to_element(binary.left, *elem_right);
+	else if(elem_compat==RIGHT_CONVERTIBLE)
+		converted = convert_to_element(binary.right, *elem_left);
+
+	if(!converted)
+		type = 0;
+
+	resolve(binary, type, assign);
+}
+
+void ExpressionResolver::visit(BinaryExpression &binary)
+{
+	TraversingVisitor::visit(binary);
+	visit(binary, false);
+}
+
+void ExpressionResolver::visit(Assignment &assign)
+{
+	TraversingVisitor::visit(assign);
+
+	if(assign.oper->token[0]!='=')
+		return visit(assign, true);
+	else if(assign.left->type!=assign.right->type)
+	{
+		BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(assign.left->type);
+		BasicTypeDeclaration *basic_right = dynamic_cast<BasicTypeDeclaration *>(assign.right->type);
+		if(!basic_left || !basic_right)
+			return;
+
+		Compatibility compat = get_compatibility(*basic_left, *basic_right);
+		if(compat==RIGHT_CONVERTIBLE)
+			convert_to(assign.right, *basic_left);
+		else if(compat!=SAME_TYPE)
+			return;
+	}
+
+	resolve(assign, assign.left->type, true);
+}
+
+void ExpressionResolver::visit(TernaryExpression &ternary)
+{
+	TraversingVisitor::visit(ternary);
+
+	BasicTypeDeclaration *basic_cond = dynamic_cast<BasicTypeDeclaration *>(ternary.condition->type);
+	if(!basic_cond || basic_cond->kind!=BasicTypeDeclaration::BOOL)
+		return;
+
+	TypeDeclaration *type = 0;
+	if(ternary.true_expr->type==ternary.false_expr->type)
+		type = ternary.true_expr->type;
+	else
+	{
+		BasicTypeDeclaration *basic_true = dynamic_cast<BasicTypeDeclaration *>(ternary.true_expr->type);
+		BasicTypeDeclaration *basic_false = dynamic_cast<BasicTypeDeclaration *>(ternary.false_expr->type);
+		Compatibility compat = get_compatibility(*basic_true, *basic_false);
+		if(compat==NOT_COMPATIBLE)
+			return;
+
+		type = (compat==LEFT_CONVERTIBLE ? basic_true : basic_false);
+
+		if(compat==LEFT_CONVERTIBLE)
+			convert_to(ternary.true_expr, *basic_false);
+		else if(compat==RIGHT_CONVERTIBLE)
+			convert_to(ternary.false_expr, *basic_true);
+	}
+
+	resolve(ternary, type, false);
+}
+
+void ExpressionResolver::visit(FunctionCall &call)
+{
+	TraversingVisitor::visit(call);
+
+	TypeDeclaration *type = 0;
+	if(call.declaration)
+		type = call.declaration->return_type_declaration;
+	else if(call.constructor)
+	{
+		map<string, TypeDeclaration *>::const_iterator i=stage->types.find(call.name);
+		type = (i!=stage->types.end() ? i->second : 0);
+	}
+	resolve(call, type, false);
+}
+
+void ExpressionResolver::visit(BasicTypeDeclaration &type)
+{
+	basic_types.push_back(&type);
+}
+
+void ExpressionResolver::visit(VariableDeclaration &var)
+{
+	TraversingVisitor::visit(var);
+	if(!var.init_expression)
+		return;
+
+	BasicTypeDeclaration *var_basic = dynamic_cast<BasicTypeDeclaration *>(var.type_declaration);
+	BasicTypeDeclaration *init_basic = dynamic_cast<BasicTypeDeclaration *>(var.init_expression->type);
+	if(!var_basic || !init_basic)
+		return;
+
+	Compatibility compat = get_compatibility(*var_basic, *init_basic);
+	if(compat==RIGHT_CONVERTIBLE)
+		convert_to(var.init_expression, *var_basic);
+}
+
+
+bool FunctionResolver::apply(Stage &s)
 {
 	stage = &s;
 	s.functions.clear();
+	r_any_resolved = false;
 	s.content.visit(*this);
+	return r_any_resolved;
 }
 
 void FunctionResolver::visit(FunctionCall &call)
 {
-	map<string, FunctionDeclaration *>::iterator i = stage->functions.find(call.name);
-	if(i!=stage->functions.end())
-		call.declaration = i->second;
+	string arg_types;
+	bool has_signature = true;
+	for(NodeArray<Expression>::const_iterator i=call.arguments.begin(); (has_signature && i!=call.arguments.end()); ++i)
+	{
+		if((*i)->type)
+			append(arg_types, ",", (*i)->type->name);
+		else
+			has_signature = false;
+	}
+
+	FunctionDeclaration *declaration = 0;
+	if(has_signature)
+	{
+		map<string, FunctionDeclaration *>::iterator i = stage->functions.find(format("%s(%s)", call.name, arg_types));
+		declaration = (i!=stage->functions.end() ? i->second : 0);
+	}
+	r_any_resolved |= (declaration!=call.declaration);
+	call.declaration = declaration;
 
 	TraversingVisitor::visit(call);
 }
 
 void FunctionResolver::visit(FunctionDeclaration &func)
 {
-	FunctionDeclaration *&stage_decl = stage->functions[func.name];
-	vector<FunctionDeclaration *> &decls = declarations[func.name];
+	if(func.signature.empty())
+	{
+		string param_types;
+		for(NodeArray<VariableDeclaration>::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+		{
+			if((*i)->type_declaration)
+				append(param_types, ",", (*i)->type_declaration->name);
+			else
+				return;
+		}
+		func.signature = format("(%s)", param_types);
+		r_any_resolved = true;
+	}
+
+	string key = func.name+func.signature;
+	FunctionDeclaration *&stage_decl = stage->functions[key];
+	vector<FunctionDeclaration *> &decls = declarations[key];
 	if(func.definition==&func)
 	{
 		stage_decl = &func;
@@ -443,17 +991,19 @@ void FunctionResolver::visit(FunctionDeclaration &func)
 		// Set all previous declarations to use this definition.
 		for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 		{
+			r_any_resolved |= (func.definition!=(*i)->definition);
 			(*i)->definition = func.definition;
 			(*i)->body.body.clear();
 		}
 	}
 	else
 	{
-		func.definition = 0;
+		FunctionDeclaration *definition = (stage_decl ? stage_decl->definition : 0);
+		r_any_resolved |= (definition!=func.definition);
+		func.definition = definition;
+
 		if(!stage_decl)
 			stage_decl = &func;
-		else
-			func.definition = stage_decl->definition;
 	}
 	decls.push_back(&func);
 
@@ -464,7 +1014,6 @@ void FunctionResolver::visit(FunctionDeclaration &func)
 InterfaceGenerator::InterfaceGenerator():
 	stage(0),
 	function_scope(false),
-	iface_block(0),
 	copy_block(false),
 	iface_target_block(0)
 { }
@@ -514,6 +1063,9 @@ VariableDeclaration *InterfaceGenerator::generate_interface(VariableDeclaration
 	if(stage->content.variables.count(name))
 		return 0;
 
+	if(stage->type==Stage::GEOMETRY && !copy_block && var.interface=="out" && var.array)
+		return 0;
+
 	VariableDeclaration* iface_var = new VariableDeclaration;
 	iface_var->sampling = var.sampling;
 	iface_var->interface = iface;
@@ -536,6 +1088,8 @@ VariableDeclaration *InterfaceGenerator::generate_interface(VariableDeclaration
 
 	iface_target_block->body.insert(iface_insert_point, iface_var);
 	iface_target_block->variables.insert(make_pair(name, iface_var));
+	if(iface_target_block==&stage->content && iface=="in")
+		declared_inputs.push_back(iface_var);
 
 	return iface_var;
 }
@@ -548,6 +1102,7 @@ InterfaceBlock *InterfaceGenerator::generate_interface(InterfaceBlock &out_block
 	InterfaceBlock *in_block = new InterfaceBlock;
 	in_block->interface = "in";
 	in_block->name = out_block.name;
+	in_block->members = new Block;
 	in_block->instance_name = out_block.instance_name;
 	if(stage->type==Stage::GEOMETRY)
 		in_block->array = true;
@@ -558,9 +1113,12 @@ InterfaceBlock *InterfaceGenerator::generate_interface(InterfaceBlock &out_block
 
 	{
 		SetFlag set_copy(copy_block, true);
-		SetForScope<Block *> set_target(iface_target_block, &in_block->members);
-		SetForScope<NodeList<Statement>::iterator> set_ins_pt(iface_insert_point, in_block->members.body.end());
-		out_block.members.visit(*this);
+		SetForScope<Block *> set_target(iface_target_block, in_block->members.get());
+		SetForScope<NodeList<Statement>::iterator> set_ins_pt(iface_insert_point, in_block->members->body.end());
+		if(out_block.struct_declaration)
+			out_block.struct_declaration->members.visit(*this);
+		else if(out_block.members)
+			out_block.members->visit(*this);
 	}
 
 	iface_target_block->body.insert(iface_insert_point, in_block);
@@ -607,8 +1165,14 @@ void InterfaceGenerator::visit(VariableReference &var)
 		i = prev_vars.find(in_prefix+var.name);
 	if(i!=prev_vars.end() && i->second->interface=="out")
 	{
-		generate_interface(*i->second, "in", i->second->name);
-		var.name = i->second->name;
+		if(stage->type==Stage::GEOMETRY && i->second->array)
+			stage->diagnostics.push_back(Diagnostic(Diagnostic::WARN, var.source, var.line,
+				format("Can't access '%s' through automatic interface because it's an array", var.name)));
+		else
+		{
+			generate_interface(*i->second, "in", i->second->name);
+			var.name = i->second->name;
+		}
 		return;
 	}
 
@@ -623,10 +1187,11 @@ void InterfaceGenerator::visit(VariableReference &var)
 	}
 
 	for(j=prev_blocks.begin(); j!=prev_blocks.end(); ++j)
-		if(j->second->instance_name.empty())
+		if(j->second->instance_name.empty() && j->second->struct_declaration)
 		{
-			i = j->second->members.variables.find(var.name);
-			if(i!=j->second->members.variables.end())
+			const map<string, VariableDeclaration *> &iface_vars = j->second->struct_declaration->members.variables;
+			i = iface_vars.find(var.name);
+			if(i!=iface_vars.end())
 			{
 				generate_interface(*j->second);
 				return;
@@ -637,28 +1202,8 @@ void InterfaceGenerator::visit(VariableReference &var)
 void InterfaceGenerator::visit(VariableDeclaration &var)
 {
 	if(copy_block)
-	{
 		generate_interface(var, "in", var.name);
-		return;
-	}
-
-	if(iface_block)
-	{
-		if(iface_block->linked_block)
-		{
-			// Link all variables to their counterparts in the linked block.
-			const map<string, VariableDeclaration *> &linked_vars = iface_block->linked_block->members.variables;
-			map<string, VariableDeclaration *>::const_iterator i = linked_vars.find(var.name);
-			if(i!=linked_vars.end())
-			{
-				var.linked_declaration = i->second;
-				var.linked_declaration->linked_declaration = &var;
-			}
-		}
-		return;
-	}
-
-	if(var.interface=="out")
+	else if(var.interface=="out")
 	{
 		/* For output variables in function scope, generate a global interface
 		and replace the local declaration with an assignment. */
@@ -677,11 +1222,14 @@ void InterfaceGenerator::visit(VariableDeclaration &var)
 			}
 		}
 	}
-	else if(var.interface=="in")
+	else if(var.interface=="in" && current_block==&stage->content)
 	{
+		if(var.name.compare(0, 3, "gl_"))
+			declared_inputs.push_back(&var);
+
 		/* Try to link input variables in global scope with output variables from
 		previous stage. */
-		if(current_block==&stage->content && !var.linked_declaration && stage->previous)
+		if(!var.linked_declaration && stage->previous)
 		{
 			const map<string, VariableDeclaration *> &prev_vars = stage->previous->content.variables;
 			map<string, VariableDeclaration *>::const_iterator i = prev_vars.find(var.name);
@@ -714,7 +1262,6 @@ void InterfaceGenerator::visit(InterfaceBlock &iface)
 		}
 	}
 
-	SetForScope<InterfaceBlock *> set_iface(iface_block, &iface);
 	TraversingVisitor::visit(iface);
 }
 
@@ -727,12 +1274,8 @@ void InterfaceGenerator::visit(FunctionDeclaration &func)
 
 void InterfaceGenerator::visit(Passthrough &pass)
 {
-	vector<VariableDeclaration *> pass_vars;
-
-	// Pass through all input variables of this stage.
-	for(map<string, VariableDeclaration *>::const_iterator i=stage->content.variables.begin(); i!=stage->content.variables.end(); ++i)
-		if(i->second->interface=="in")
-			pass_vars.push_back(i->second);
+	// Pass through all input variables declared so far.
+	vector<VariableDeclaration *> pass_vars = declared_inputs;
 
 	if(stage->previous)
 	{