X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.h;h=d38849012e26fd4569919eaff31588fb144c3559;hp=bf2677e8d1cd993f67a5fa1936c4aeb37c0f32f1;hb=c4aeeced7b397d46772577775bd3a0d6c4706cba;hpb=9bec9da4ec633a541cf6048beed99629fefae2b9 diff --git a/source/glsl/validate.h b/source/glsl/validate.h index bf2677e8..d3884901 100644 --- a/source/glsl/validate.h +++ b/source/glsl/validate.h @@ -10,28 +10,72 @@ namespace Msp { namespace GL { namespace SL { +/** Base class for validators. Contains some utilities for adding diagnostic +messages. */ class Validator: protected TraversingVisitor { protected: Stage *stage; + Node *last_provoker; Validator(); - void diagnose(Node &, Diagnostic::Severity, const std::string &); + void diagnose(Node &, Node &, Diagnostic::Severity, const std::string &); + void diagnose(Node &n, Diagnostic::Severity s, const std::string &m) { diagnose(n, n, s, m); } void error(Node &n, const std::string &m) { diagnose(n, Diagnostic::ERR, m); } + void add_info(Node &, const std::string &); }; +/** Verifies that declarations are valid in isolation. */ class DeclarationValidator: private Validator { +private: + enum ScopeType + { + GLOBAL, + STRUCT, + INTERFACE_BLOCK, + FUNCTION_PARAM, + FUNCTION + }; + + ScopeType scope; + InterfaceLayout *iface_layout; + InterfaceBlock *iface_block; + VariableDeclaration *variable; + +public: + DeclarationValidator(); + + void apply(Stage &s) { stage = &s; s.content.visit(*this); } + +private: + static const char *describe_variable(ScopeType); + + virtual void visit(Layout &); + virtual void visit(InterfaceLayout &); + virtual void visit(BasicTypeDeclaration &); + virtual void visit(ImageTypeDeclaration &); + virtual void visit(StructDeclaration &); + virtual void visit(VariableDeclaration &); + virtual void visit(InterfaceBlock &); + virtual void visit(FunctionDeclaration &); +}; + +/** Verifies that identifiers are unique or, in the case of functions, are +overloaded only in valid ways. */ +class IdentifierValidator: private Validator +{ private: typedef std::map BlockDeclarationMap; std::map declarations; std::map interface_blocks; + std::map overloaded_functions; bool anonymous_block; public: - DeclarationValidator(); + IdentifierValidator(); void apply(Stage &s) { stage = &s; s.content.visit(*this); } @@ -50,15 +94,123 @@ private: virtual void visit(FunctionDeclaration &); }; +/** Verifies that there are no unresolved references. */ class ReferenceValidator: private Validator { public: void apply(Stage &s) { stage = &s; s.content.visit(*this); } private: + virtual void visit(BasicTypeDeclaration &); + virtual void visit(ImageTypeDeclaration &); virtual void visit(VariableReference &); + virtual void visit(MemberAccess &); virtual void visit(InterfaceBlockReference &); + virtual void visit(FunctionCall &); virtual void visit(VariableDeclaration &); + virtual void visit(InterfaceBlock &); + virtual void visit(FunctionDeclaration &); +}; + +/** Verifies that expressions are valid. In most cases an invalid expression +is indicated by a null result type. */ +class ExpressionValidator: private Validator +{ +private: + FunctionDeclaration *current_function; + bool constant_expression; + +public: + ExpressionValidator(); + + void apply(Stage &s) { stage = &s; s.content.visit(*this); } + +private: + virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); + virtual void visit(Swizzle &); + virtual void visit(UnaryExpression &); + virtual void visit(BinaryExpression &); + virtual void visit(Assignment &); + virtual void visit(TernaryExpression &); + virtual void visit(VariableDeclaration &); + virtual void visit(FunctionDeclaration &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); + virtual void visit(Return &); +}; + +/** Verifies flow control constructs. Functions returning non-void must have +return statements. Warnings are given about dead code. */ +class FlowControlValidator: private Validator +{ +private: + bool reachable; + +public: + FlowControlValidator(); + + void apply(Stage &s) { stage = &s; s.content.visit(*this); } + +private: + virtual void visit(Block &); + virtual void visit(FunctionDeclaration &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); + virtual void visit(Return &) { reachable = false; } + virtual void visit(Jump &) { reachable = false; } +}; + +/** Verifies that stage input and output interfaces are valid. Linked +variables must have matching types and locations and there must not be any +overlap in locations. */ +class StageInterfaceValidator: private Validator +{ +private: + std::map > used_locations; + +public: + void apply(Stage &s) { stage = &s; s.content.visit(*this); } + +private: + int get_location(const Layout &); + + virtual void visit(VariableDeclaration &); + virtual void visit(FunctionDeclaration &) { } +}; + +/** Verifies that uniform interfaces are valid across the entire module. +Variables declared with the same binding must have the same name and type. */ +class GlobalInterfaceValidator: private Validator +{ +private: + struct Uniform + { + Node *node; + TypeDeclaration *type; + std::string name; + int location; + unsigned loc_count; + int desc_set; + int bind_point; + + Uniform(): node(0), type(0), location(-1), loc_count(1), desc_set(0), bind_point(-1) { } + }; + + std::list uniforms; + std::map used_names; + std::map used_locations; + std::map > used_bindings; + +public: + void apply(Module &); + +private: + void check_uniform(const Uniform &); + + virtual void visit(VariableDeclaration &); + virtual void visit(InterfaceBlock &); + virtual void visit(FunctionDeclaration &) { } }; } // namespace SL