Resolve constructors in FunctionResolver

[libs/gl.git] / source / glsl / generate.cpp

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index ce1283721d6f7b0796e40808b3425acd49d49b64..11116b11ecb164cb704fdcf277de380ac882ba82 100644 (file)
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -619,12 +619,6 @@ void ExpressionResolver::visit(Literal &literal)
                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)
@@ -943,22 +937,28 @@ bool FunctionResolver::apply(Stage &s)
 
 void FunctionResolver::visit(FunctionCall &call)
 {
-       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)
+       if(stage->types.count(call.name))
+               call.constructor = true;
+       else
        {
-               map<string, FunctionDeclaration *>::iterator i = stage->functions.find(format("%s(%s)", call.name, arg_types));
-               declaration = (i!=stage->functions.end() ? i->second : 0);
+               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;
+               }
+
+               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;
 
@@ -986,6 +986,15 @@ void FunctionResolver::visit(FunctionDeclaration &func)
        vector<FunctionDeclaration *> &decls = declarations[key];
        if(func.definition==&func)
        {
+               if(stage_decl && stage_decl->definition)
+               {
+                       if(!func.overrd)
+                               stage->diagnostics.push_back(Diagnostic(Diagnostic::WARN, func.source, func.line,
+                                       format("Overriding function '%s' without the override keyword is deprecated", key)));
+                       if(!stage_decl->definition->virtua)
+                               stage->diagnostics.push_back(Diagnostic(Diagnostic::WARN, func.source, func.line,
+                                       format("Overriding function '%s' not declared as virtual is deprecated", key)));
+               }
                stage_decl = &func;
 
                // Set all previous declarations to use this definition.
@@ -1224,7 +1233,8 @@ void InterfaceGenerator::visit(VariableDeclaration &var)
        }
        else if(var.interface=="in" && current_block==&stage->content)
        {
-               declared_inputs.push_back(&var);
+               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. */