X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.cpp;h=b0c6e3d67acb29cb178bbdeb1e7d2812ea16f5be;hb=041ba4b1acd55337239c5ce24cc310118c621206;hp=6368c069244629217b32f04bb78987d3784f39b7;hpb=1f09306906fbf57c05dccb27189264706cc64cfa;p=libs%2Fgl.git diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp index 6368c069..b0c6e3d6 100644 --- a/source/glsl/validate.cpp +++ b/source/glsl/validate.cpp @@ -1,3 +1,4 @@ +#include #include #include #include "validate.h" @@ -12,24 +13,78 @@ Validator::Validator(): stage(0) { } -void Validator::diagnose(Statement *statement, Diagnostic::Severity severity, const string &message) +void Validator::diagnose(Node &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.message = message; stage->diagnostics.push_back(diag); } +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); +} + + DeclarationValidator::DeclarationValidator(): anonymous_block(false) { } +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"); +} + Statement *DeclarationValidator::find_definition(const string &name) { BlockDeclarationMap *decls = &declarations[current_block]; @@ -45,15 +100,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 +131,152 @@ 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) { - if(func.definition==&func) - check_definition(func.name, func); + if(Statement *previous = find_definition(func.name)) + { + 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); + + 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(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(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