#include <algorithm>
#include <msp/core/raii.h>
#include <msp/strings/utils.h>
+#include "reflect.h"
#include "resolve.h"
using namespace std;
if(i!=strct->members.variables.end())
{
declaration = i->second;
+ index = 0;
for(NodeList<Statement>::const_iterator j=strct->members.body.begin(); (j!=strct->members.body.end() && j->get()!=i->second); ++j)
++index;
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)
if(!left_size || (left_size==1 && right_size!=1) || (left_size>1 && right_size!=1 && right_size!=left_size))
return;
+ /* If the left operand is a vector and right is scalar, convert the right
+ operand to a vector too. */
+ if(left_size>1 && right_size==1)
+ {
+ BasicTypeDeclaration *vec_right = find_type(*elem_right, basic_left->kind, basic_left->size);
+ if(!vec_right)
+ return;
+
+ convert_to(binary.right, *vec_right);
+ }
+
type = basic_left;
// Don't perform conversion even if the operands are of different sizes.
compat = SAME_TYPE;
map<string, TypeDeclaration *>::const_iterator i = stage->types.find(call.name);
if(i==stage->types.end())
return;
+ else if(call.arguments.size()==1 && i->second==call.arguments[0]->type)
+ ;
else if(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(i->second))
{
BasicTypeDeclaration *elem = get_element_type(*basic);
return r_any_resolved;
}
+bool FunctionResolver::can_convert_arguments(const FunctionCall &call, const FunctionDeclaration &decl)
+{
+ if(decl.parameters.size()!=call.arguments.size())
+ return false;
+
+ for(unsigned j=0; j<call.arguments.size(); ++j)
+ {
+ const TypeDeclaration *arg_type = call.arguments[j]->type;
+ const TypeDeclaration *param_type = decl.parameters[j]->type_declaration;
+ if(arg_type==param_type)
+ continue;
+
+ const BasicTypeDeclaration *arg_basic = dynamic_cast<const BasicTypeDeclaration *>(arg_type);
+ const BasicTypeDeclaration *param_basic = dynamic_cast<const BasicTypeDeclaration *>(param_type);
+ if(arg_basic && param_basic && can_convert(*arg_basic, *param_basic))
+ continue;
+
+ return false;
+ }
+
+ return true;
+}
+
void FunctionResolver::visit(FunctionCall &call)
{
FunctionDeclaration *declaration = 0;
{
map<string, FunctionDeclaration *>::iterator i = stage->functions.find(format("%s(%s)", call.name, arg_types));
declaration = (i!=stage->functions.end() ? i->second : 0);
+
+ if(!declaration)
+ {
+ for(i=stage->functions.lower_bound(call.name+"("); (i!=stage->functions.end() && i->second->name==call.name); ++i)
+ if(can_convert_arguments(call, *i->second))
+ {
+ if(declaration)
+ {
+ declaration = 0;
+ break;
+ }
+ else
+ declaration = i->second;
+ }
+ }
}
}