#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"
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;
}
stage(0),
r_any_resolved(false),
record_target(false),
- r_self_referencing(false),
- r_assignment_target(0)
+ r_self_referencing(false)
{ }
bool VariableResolver::apply(Stage &s)
block.variables.clear();
}
-void VariableResolver::visit_and_replace(RefPtr<Expression> &expr)
+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)
{
VariableDeclaration *declaration = 0;
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)
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)
{
- visit_and_replace(memacc.left);
+ TraversingVisitor::visit(memacc);
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;
+
+ add_to_chain(Assignment::Target::MEMBER, index);
+ }
+ }
}
else if(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(memacc.left->type))
{
void VariableResolver::visit(Swizzle &swizzle)
{
- visit_and_replace(swizzle.left);
-}
+ TraversingVisitor::visit(swizzle);
-void VariableResolver::visit(UnaryExpression &unary)
-{
- visit_and_replace(unary.expression);
+ 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)
/* The subscript expression is not a part of the primary assignment
target. */
SetFlag set(record_target, false);
- visit_and_replace(binary.right);
+ 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);
}
- visit_and_replace(binary.left);
}
else
- {
- visit_and_replace(binary.left);
- visit_and_replace(binary.right);
- }
+ TraversingVisitor::visit(binary);
}
void VariableResolver::visit(Assignment &assign)
{
{
SetFlag set(record_target);
- r_assignment_target = 0;
- visit_and_replace(assign.left);
- r_any_resolved |= (r_assignment_target!=assign.target_declaration);
- 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;
- visit_and_replace(assign.right);
+ visit(assign.right);
assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='=');
}
-void VariableResolver::visit(FunctionCall &call)
-{
- for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
- visit_and_replace(*i);
-}
-
void VariableResolver::visit(VariableDeclaration &var)
{
- if(var.layout)
- var.layout->visit(*this);
- if(var.array_size)
- visit_and_replace(var.array_size);
- if(var.init_expression)
- visit_and_replace(var.init_expression);
+ TraversingVisitor::visit(var);
current_block->variables.insert(make_pair(var.name, &var));
}
bool ExpressionResolver::convert_to_element(RefPtr<Expression> &expr, BasicTypeDeclaration &elem_type)
{
- if(BasicTypeDeclaration *expr_type = dynamic_cast<BasicTypeDeclaration *>(expr->type))
+ if(BasicTypeDeclaration *expr_basic = dynamic_cast<BasicTypeDeclaration *>(expr->type))
{
BasicTypeDeclaration *to_type = &elem_type;
- if(is_vector_or_matrix(*expr_type))
- to_type = find_type(elem_type, expr_type->kind, expr_type->size);
+ 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);
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;
// 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);
projects / libs / gl.git / blobdiff