+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));
+
+ TraversingVisitor::visit(iface);
+}
+
+
+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)