X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.cpp;h=91d1de991515dc74dbb359d0385a0429ef855803;hp=6368c069244629217b32f04bb78987d3784f39b7;hb=7d66c70e15b84cbaf6b1973db07629f5bd3e5cdf;hpb=1f09306906fbf57c05dccb27189264706cc64cfa diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp index 6368c069..91d1de99 100644 --- a/source/glsl/validate.cpp +++ b/source/glsl/validate.cpp @@ -1,3 +1,5 @@ +#include +#include #include #include #include "validate.h" @@ -9,20 +11,80 @@ namespace GL { namespace SL { Validator::Validator(): - stage(0) + stage(0), + last_provoker(0) { } -void Validator::diagnose(Statement *statement, 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; - if(statement) - { - diag.source = statement->source; - diag.line = statement->line; - } + 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); +} + + +TypeValidator::TypeValidator(): + in_struct(false) +{ } + +void TypeValidator::visit(BasicTypeDeclaration &type) +{ + if(type.kind==BasicTypeDeclaration::VECTOR) + { + BasicTypeDeclaration::Kind base_kind = BasicTypeDeclaration::VOID; + if(BasicTypeDeclaration *basic_base = dynamic_cast(type.base_type)) + base_kind = basic_base->kind; + if(base_kind!=BasicTypeDeclaration::BOOL && base_kind!=BasicTypeDeclaration::INT && base_kind!=BasicTypeDeclaration::FLOAT) + error(type, format("Invalid base type '%s' for vector type '%s'", type.base, type.name)); + } + else if(type.kind==BasicTypeDeclaration::ARRAY) + { + if(BasicTypeDeclaration *basic_base = dynamic_cast(type.base_type)) + if(basic_base->kind==BasicTypeDeclaration::VOID) + error(type, format("Invalid base type '%s' for array type '%s'", type.base, type.name)); + } +} + +void TypeValidator::visit(ImageTypeDeclaration &type) +{ + BasicTypeDeclaration::Kind base_kind = BasicTypeDeclaration::VOID; + if(BasicTypeDeclaration *basic_base = dynamic_cast(type.base_type)) + base_kind = basic_base->kind; + if(base_kind!=BasicTypeDeclaration::INT && base_kind!=BasicTypeDeclaration::FLOAT) + error(type, format("Invalid base type '%s' for image type '%s'", type.base, type.name)); +} + +void TypeValidator::visit(StructDeclaration &strct) +{ + SetFlag set_struct(in_struct); + TraversingVisitor::visit(strct); +} + +void TypeValidator::visit(VariableDeclaration &var) +{ + if(in_struct) + { + if(var.layout) + error(var, "Struct members can't have layouts"); + if(var.init_expression) + error(var, "Struct members can't have initializers"); + } + + TraversingVisitor::visit(var); } @@ -30,6 +92,12 @@ DeclarationValidator::DeclarationValidator(): anonymous_block(false) { } +void DeclarationValidator::multiple_definition(const string &name, Statement &statement, Statement &previous) +{ + error(statement, format("Multiple definition of %s", name)); + add_info(previous, "Previous definition is here"); +} + Statement *DeclarationValidator::find_definition(const string &name) { BlockDeclarationMap *decls = &declarations[current_block]; @@ -45,15 +113,27 @@ Statement *DeclarationValidator::find_definition(const string &name) void DeclarationValidator::check_definition(const string &name, Statement &statement) { if(Statement *previous = find_definition(name)) - { - error(&statement, format("Multiple definition of '%s'", name)); - diagnose(previous, Diagnostic::INFO, "Previous definition is here"); - return; - } + multiple_definition(format("'%s'", name), statement, *previous); + else + record_definition(name, statement); +} - declarations[current_block][name] = &statement; +void DeclarationValidator::record_definition(const string &name, Statement &statement) +{ + declarations[current_block].insert(make_pair(name, &statement)); if(anonymous_block) - declarations[current_block->parent][name] = &statement; + declarations[current_block->parent].insert(make_pair(name, &statement)); +} + +void DeclarationValidator::visit(TypeDeclaration &type) +{ + check_definition(type.name, type); +} + +void DeclarationValidator::visit(StructDeclaration &strct) +{ + check_definition(strct.name, strct); + TraversingVisitor::visit(strct); } void DeclarationValidator::visit(VariableDeclaration &var) @@ -64,20 +144,208 @@ void DeclarationValidator::visit(VariableDeclaration &var) void DeclarationValidator::visit(InterfaceBlock &iface) { - check_definition(iface.name, iface); + string key = iface.interface+iface.name; + map::const_iterator i = interface_blocks.find(key); + if(i!=interface_blocks.end()) + multiple_definition(format("interface block '%s %s'", iface.interface, iface.name), iface, *i->second); + else + interface_blocks.insert(make_pair(key, &iface)); + + if(Statement *previous = find_definition(iface.name)) + { + if(!dynamic_cast(previous)) + multiple_definition(format("'%s'", iface.name), iface, *previous); + } + else + record_definition(iface.name, 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) { + string key = func.name+func.signature; + map::const_iterator i = overloaded_functions.find(key); + if(i==overloaded_functions.end()) + overloaded_functions.insert(make_pair(key, &func)); + else if(func.return_type_declaration && i->second->return_type_declaration!=func.return_type_declaration) + { + error(func, format("Conflicting return type '%s' for function '%s'", func.return_type_declaration->name, func.name)); + if(i->second->return_type_declaration) + add_info(*i->second, format("Previously declared as returning '%s'", i->second->return_type_declaration->name)); + } + + if(Statement *previous = find_definition(func.name)) + { + if(!dynamic_cast(previous)) + multiple_definition(format("'%s'", func.name), func, *previous); + } + else + record_definition(func.name, func); + if(func.definition==&func) - check_definition(func.name, func); + check_definition(func.name+func.signature, func); + TraversingVisitor::visit(func); } + +void ReferenceValidator::visit(BasicTypeDeclaration &type) +{ + if(!type.base.empty() && !type.base_type) + error(type, format("Use of undeclared type '%s'", type.base)); +} + +void ReferenceValidator::visit(ImageTypeDeclaration &type) +{ + if(!type.base.empty() && !type.base_type) + error(type, format("Use of undeclared type '%s'", type.base)); +} + +void ReferenceValidator::visit(VariableReference &var) +{ + if(!var.declaration) + error(var, format("Use of undeclared variable '%s'", var.name)); + else if(stage->type!=Stage::VERTEX && var.declaration->interface=="in" && !var.declaration->linked_declaration) + 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 + since references are generated based on existing declarations. */ + if(!iface.declaration) + error(iface, format("Use of undeclared interface block '%s'", iface.name)); + else if(stage->type!=Stage::VERTEX && iface.declaration->interface=="in" && !iface.declaration->linked_block) + error(iface, format("Use of unlinked input block '%s'", iface.name)); +} + +void ReferenceValidator::visit(VariableDeclaration &var) +{ + if(!var.type_declaration) + error(var, format("Use of undeclared type '%s'", var.type)); + 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) + error(func, format("Use of undeclared type '%s'", func.return_type)); + TraversingVisitor::visit(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) + { + if(!unary.type) + error(unary, format("No matching operator '%s' found for '%s'", unary.oper->token, unary.expression->type->name)); + else if((unary.oper->token[1]=='+' || unary.oper->token[1]=='-') && !unary.expression->lvalue) + error(unary, format("Operand of '%s' is not an lvalue", unary.oper->token)); + } + TraversingVisitor::visit(unary); +} + +void ExpressionValidator::visit(BinaryExpression &binary) +{ + if(!binary.type && binary.left->type && binary.right->type) + error(binary, format("No matching operator '%s' found for '%s' and '%s'", + binary.oper->token, binary.left->type->name, binary.right->type->name)); + TraversingVisitor::visit(binary); +} + +void ExpressionValidator::visit(Assignment &assign) +{ + 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 incompatible type '%s'", + var.type_declaration->name, var.init_expression->type->name)); + TraversingVisitor::visit(var); +} + } // namespace SL } // namespace GL } // namespace Msp