X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.cpp;h=ea2e956d023f1e02d66b44b7771186542076dd28;hb=d18df036b247f7f0978b547bb8ea1d624af2c4b2;hp=676dd9e808792867458d8c59d03a62d47ceb8e88;hpb=50ab5ca2babc8d9592903da6072a13b381ed6656;p=libs%2Fgl.git diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp index 676dd9e8..ea2e956d 100644 --- a/source/glsl/validate.cpp +++ b/source/glsl/validate.cpp @@ -1,3 +1,5 @@ +#include +#include #include #include #include "validate.h" @@ -9,17 +11,29 @@ namespace GL { namespace SL { Validator::Validator(): - stage(0) + stage(0), + last_provoker(0) { } -void Validator::diagnose(Node &node, Diagnostic::Severity severity, const string &message) +void Validator::diagnose(Node &node, Node &provoking_node, Diagnostic::Severity severity, const string &message) { Diagnostic diag; diag.severity = severity; diag.source = node.source; diag.line = node.line; + diag.provoking_source = provoking_node.source; + diag.provoking_line = provoking_node.line; diag.message = message; stage->diagnostics.push_back(diag); + + last_provoker = &provoking_node; +} + +void Validator::add_info(Node &node, const string &message) +{ + if(!last_provoker) + throw logic_error("Tried to add info without a previous provoker"); + diagnose(node, *last_provoker, Diagnostic::INFO, message); } @@ -81,7 +95,7 @@ DeclarationValidator::DeclarationValidator(): void DeclarationValidator::multiple_definition(const string &name, Statement &statement, Statement &previous) { error(statement, format("Multiple definition of %s", name)); - diagnose(previous, Diagnostic::INFO, "Previous definition is here"); + add_info(previous, "Previous definition is here"); } Statement *DeclarationValidator::find_definition(const string &name) @@ -148,18 +162,28 @@ void DeclarationValidator::visit(InterfaceBlock &iface) if(!iface.instance_name.empty()) check_definition(iface.instance_name, iface); - SetFlag set_anon(anonymous_block, iface.instance_name.empty()); - TraversingVisitor::visit(iface); + if(iface.instance_name.empty() && iface.struct_declaration) + { + // Inject anonymous interface block members into the global scope + const map &iface_vars = iface.struct_declaration->members.variables; + for(map::const_iterator j=iface_vars.begin(); j!=iface_vars.end(); ++j) + check_definition(j->first, *j->second); + } } void DeclarationValidator::visit(FunctionDeclaration &func) { if(Statement *previous = find_definition(func.name)) - if(!dynamic_cast(previous)) + { + FunctionDeclaration *prev_func = dynamic_cast(previous); + if(prev_func && prev_func->definition==&func) + declarations[current_block][func.name] = &func; + else multiple_definition(format("'%s'", func.name), func, *previous); + } + else + record_definition(func.name, func); - if(func.definition==&func) - check_definition(func.name, func); TraversingVisitor::visit(func); } @@ -184,6 +208,13 @@ void ReferenceValidator::visit(VariableReference &var) error(var, format("Use of unlinked input variable '%s'", var.name)); } +void ReferenceValidator::visit(MemberAccess &memacc) +{ + if(memacc.left->type && !memacc.declaration) + error(memacc, format("Use of undeclared member '%s'", memacc.member)); + TraversingVisitor::visit(memacc); +} + void ReferenceValidator::visit(InterfaceBlockReference &iface) { /* An interface block reference without a declaration should be impossible @@ -201,6 +232,13 @@ void ReferenceValidator::visit(VariableDeclaration &var) TraversingVisitor::visit(var); } +void ReferenceValidator::visit(InterfaceBlock &iface) +{ + if(!iface.struct_declaration) + error(iface, format("Interface block '%s %s' lacks a struct declaration", iface.interface, iface.name)); + TraversingVisitor::visit(iface); +} + void ReferenceValidator::visit(FunctionDeclaration &func) { if(!func.return_type_declaration) @@ -209,6 +247,44 @@ void ReferenceValidator::visit(FunctionDeclaration &func) } +void ExpressionValidator::visit(Swizzle &swizzle) +{ + unsigned size = 0; + if(BasicTypeDeclaration *basic = dynamic_cast(swizzle.left->type)) + { + if(basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT) + size = 1; + else if(basic->kind==BasicTypeDeclaration::VECTOR) + size = basic->size; + } + + if(size) + { + static const char component_names[] = { 'x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q' }; + int flavour = -1; + for(unsigned i=0; i=0 && component_flavour!=static_cast(flavour)) + { + error(swizzle, format("Flavour of swizzle component '%c' is inconsistent with '%c'", + swizzle.component_group[i], swizzle.component_group[0])); + flavour = -2; + } + + if(swizzle.components[i]>=size) + error(swizzle, format("Access to component '%c' which is not present in '%s'", + swizzle.component_group[i], swizzle.left->type->name)); + } + } + else if(swizzle.left->type) + error(swizzle, format("Swizzle applied to '%s' which is neither a scalar nor a vector", swizzle.left->type->name)); + + TraversingVisitor::visit(swizzle); +} + void ExpressionValidator::visit(UnaryExpression &unary) { if(unary.expression->type) @@ -231,18 +307,30 @@ void ExpressionValidator::visit(BinaryExpression &binary) void ExpressionValidator::visit(Assignment &assign) { - if(assign.left->type && !assign.left->lvalue) - error(assign, "Target of assignment is not an lvalue"); - if(assign.left->type && assign.right->type && assign.left->type!=assign.right->type) - error(assign, format("Assignment to variable of type '%s' from expression of type '%s'", - assign.left->type->name, assign.right->type->name)); + if(assign.left->type) + { + if(!assign.left->lvalue) + error(assign, "Target of assignment is not an lvalue"); + if(assign.right->type) + { + if(assign.oper->token[0]!='=') + { + if(!assign.type) + error(assign, format("No matching operator '%s' found for '%s' and '%s'", + string(assign.oper->token, strlen(assign.oper->token)-1), assign.left->type->name, assign.right->type->name)); + } + else if(assign.left->type!=assign.right->type) + error(assign, format("Assignment to variable of type '%s' from expression of incompatible type '%s'", + assign.left->type->name, assign.right->type->name)); + } + } TraversingVisitor::visit(assign); } void ExpressionValidator::visit(VariableDeclaration &var) { if(var.init_expression && var.init_expression->type && var.type_declaration && var.init_expression->type!=var.type_declaration) - error(var, format("Initializing a variable of type '%s' with an expression of type '%s'", + error(var, format("Initializing a variable of type '%s' with an expression of incompatible type '%s'", var.type_declaration->name, var.init_expression->type->name)); TraversingVisitor::visit(var); }