-
- if(qualifiers.empty())
- var.layout = 0;
- }
-
- if(specializable && values)
- {
- map<string, int>::const_iterator i = values->find(var.name);
- if(i!=values->end())
- {
- RefPtr<Literal> literal = new Literal;
- if(var.type=="bool")
- {
- literal->token = (i->second ? "true" : "false");
- literal->value = static_cast<bool>(i->second);
- }
- else if(var.type=="int")
- {
- literal->token = lexical_cast<string>(i->second);
- literal->value = i->second;
- }
- var.init_expression = literal;
- }
- }
-}
-
-
-void BlockHierarchyResolver::enter(Block &block)
-{
- block.parent = current_block;
-}
-
-
-TypeResolver::TypeResolver():
- stage(0)
-{ }
-
-void TypeResolver::apply(Stage &s)
-{
- stage = &s;
- s.types.clear();
- s.content.visit(*this);
-}
-
-TypeDeclaration *TypeResolver::resolve_type(const string &name)
-{
- 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);
- }
- else
- return 0;
-}
-
-void TypeResolver::visit(Block &block)
-{
- for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
- {
- if(!block.parent)
- type_insert_point = i;
- (*i)->visit(*this);
- }
-}
-
-void TypeResolver::visit(BasicTypeDeclaration &type)
-{
- type.base_type = resolve_type(type.base);
-
- 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;
- type.size |= basic_base->size<<16;
- }
-
- if(type.kind==BasicTypeDeclaration::ALIAS && type.base_type)
- alias_map[&type] = type.base_type;
- else if(type.kind==BasicTypeDeclaration::ARRAY && type.base_type)
- array_types[type.base_type] = &type;
-
- stage->types.insert(make_pair(type.name, &type));
-}
-
-void TypeResolver::visit(ImageTypeDeclaration &type)
-{
- type.base_type = resolve_type(type.base);
- stage->types.insert(make_pair(type.name, &type));
-}
-
-void TypeResolver::visit(StructDeclaration &strct)
-{
- stage->types.insert(make_pair(strct.name, &strct));
- TraversingVisitor::visit(strct);
-}
-
-void TypeResolver::visit(VariableDeclaration &var)
-{
- TypeDeclaration *type = resolve_type(var.type);
- if(var.array && type)
- {
- 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;
- }
- var.type_declaration = type;
-}
-
-void TypeResolver::visit(FunctionDeclaration &func)
-{
- func.return_type_declaration = resolve_type(func.return_type);
- TraversingVisitor::visit(func);
-}
-
-
-VariableResolver::VariableResolver():
- stage(0),
- r_members(0),
- record_target(false),
- r_self_referencing(false),
- r_assignment_target(0)
-{ }
-
-void VariableResolver::apply(Stage &s)
-{
- stage = &s;
- s.interface_blocks.clear();
- s.content.visit(*this);
-}
-
-void VariableResolver::enter(Block &block)
-{
- block.variables.clear();
-}
-
-void VariableResolver::visit(VariableReference &var)
-{
- var.declaration = 0;
- r_members = 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)
- {
- map<string, VariableDeclaration *>::iterator i = block->variables.find(var.name);
- if(i!=block->variables.end())
- var.declaration = i->second;
- }
-
- if(!var.declaration)
- {
- const map<string, InterfaceBlock *> &blocks = stage->interface_blocks;
- map<string, InterfaceBlock *>::const_iterator i = blocks.find("_"+var.name);
- if(i!=blocks.end())
- {
- /* 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;
- }
- 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())
- {
- map<string, VariableDeclaration *>::iterator j = i->second->members.variables.find(var.name);
- if(j!=i->second->members.variables.end())
- var.declaration = j->second;
- }
- }
- }
-
- if(var.declaration)
- if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(var.declaration->type_declaration))
- r_members = &strct->members.variables;
-
- 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;
-}
-
-void VariableResolver::visit(InterfaceBlockReference &iface)
-{
- iface.declaration = 0;
- 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;
- }
-}
-
-void VariableResolver::visit(MemberAccess &memacc)
-{
- r_members = 0;
- r_iface_ref = 0;
- memacc.left->visit(*this);
-
- if(r_iface_ref)
- memacc.left = r_iface_ref;
- r_iface_ref = 0;
-
- memacc.declaration = 0;
- if(r_members)
- {
- map<string, VariableDeclaration *>::iterator i = r_members->find(memacc.member);
- if(i!=r_members->end())
- {
- memacc.declaration = i->second;
- if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(i->second->type_declaration))
- r_members = &strct->members.variables;
- }
- else
- r_members = 0;
- }
-}
-
-void VariableResolver::visit(UnaryExpression &unary)
-{
- TraversingVisitor::visit(unary);
- r_members = 0;
- r_iface_ref = 0;
-}
-
-void VariableResolver::visit(BinaryExpression &binary)
-{
- if(binary.oper->token[0]=='[')
- {
- {
- /* The subscript expression is not a part of the primary assignment
- target. */
- SetFlag set(record_target, false);
- binary.right->visit(*this);
- }
- 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_self_referencing = false;
- assign.right->visit(*this);
- assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='=');
-
- r_members = 0;
- r_iface_ref = 0;
-}
-
-void VariableResolver::visit(FunctionCall &call)
-{
- TraversingVisitor::visit(call);
- r_members = 0;
- r_iface_ref = 0;
-}
-
-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));
-}
-
-void VariableResolver::visit(InterfaceBlock &iface)
-{
- /* Block names can be reused in different interfaces. Prefix the name with
- the first character of the interface to avoid conflicts. */
- stage->interface_blocks.insert(make_pair(iface.interface+iface.name, &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);
-}
-
-
-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_type = 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(to_type)
- {
- convert_to(expr, *to_type);
- return true;
- }
- }
-
- return false;
-}
-
-void ExpressionResolver::visit(Literal &literal)
-{
- if(literal.value.check_type<bool>())
- literal.type = find_type(BasicTypeDeclaration::BOOL, 1);
- else if(literal.value.check_type<int>())
- literal.type = find_type(BasicTypeDeclaration::INT, 32);
- else if(literal.value.check_type<float>())
- literal.type = find_type(BasicTypeDeclaration::FLOAT, 32);
-}
-
-void ExpressionResolver::visit(ParenthesizedExpression &parexpr)
-{
- TraversingVisitor::visit(parexpr);
-
- parexpr.type = parexpr.expression->type;
- parexpr.lvalue = parexpr.expression->lvalue;
-}
-
-void ExpressionResolver::visit(VariableReference &var)
-{
- if(var.declaration)
- var.type = var.declaration->type_declaration;
- var.lvalue = true;
-}
-
-void ExpressionResolver::visit(InterfaceBlockReference &iface)
-{
- iface.lvalue = true;
-}
-
-void ExpressionResolver::visit(MemberAccess &memacc)
-{
- TraversingVisitor::visit(memacc);
-
- if(memacc.declaration)
- memacc.type = memacc.declaration->type_declaration;
- memacc.lvalue = memacc.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)
- unary.type = basic;
- }
- else if(oper=='~')
- {
- if(basic->kind==BasicTypeDeclaration::INT)
- unary.type = basic;
- }
- else if(oper=='+' || oper=='-')
- {
- BasicTypeDeclaration *elem = get_element_type(*basic);
- if(elem && is_scalar(*elem))
- unary.type = basic;