+ scope(GLOBAL),
+ iface_layout(0),
+ iface_block(0),
+ variable(0)
+{ }
+
+const char *DeclarationValidator::describe_variable(ScopeType scope)
+{
+ switch(scope)
+ {
+ case GLOBAL: return "global variable";
+ case STRUCT: return "struct member";
+ case INTERFACE_BLOCK: return "interface block member";
+ case FUNCTION_PARAM: return "function parameter";
+ case FUNCTION: return "local variable";
+ default: return "variable";
+ }
+}
+
+void DeclarationValidator::visit(Layout &layout)
+{
+ for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
+ {
+ bool allowed = false;
+ string err_descr;
+ bool value = true;
+ if(i->name=="location")
+ allowed = (variable && scope==GLOBAL);
+ else if(i->name=="binding" || i->name=="set")
+ {
+ if(i->name=="set")
+ {
+ error(layout, "Layout qualifier 'set' not allowed when targeting OpenGL");
+ continue;
+ }
+
+ if(variable)
+ {
+ TypeDeclaration *type = variable->type_declaration;
+ while(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(type))
+ type = basic->base_type;
+ bool uniform = (variable->interface=="uniform");
+ allowed = (scope==GLOBAL && uniform && dynamic_cast<ImageTypeDeclaration *>(type));
+ err_descr = (uniform ? "variable of non-opaque type" : "non-uniform variable");
+ }
+ else if(iface_block)
+ {
+ allowed = (iface_block->interface=="uniform");
+ err_descr = "non-uniform interface block";
+ }
+ }
+ else if(i->name=="constant_id")
+ {
+ allowed = (variable && scope==GLOBAL);
+ if(allowed)
+ {
+ if(!variable->constant)
+ {
+ allowed = false;
+ err_descr = "non-constant variable";
+ }
+ else
+ {
+ BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(variable->type_declaration);
+ if(!basic || basic->kind<BasicTypeDeclaration::BOOL || basic->kind>BasicTypeDeclaration::INT)
+ {
+ allowed = false;
+ err_descr = format("variable of type '%s'",
+ (variable->type_declaration ? variable->type_declaration->name : variable->type));
+ }
+ }
+ }
+ }
+ else if(i->name=="offset")
+ allowed = (variable && scope==INTERFACE_BLOCK && iface_block->interface=="uniform");
+ else if(i->name=="align")
+ allowed = (scope==INTERFACE_BLOCK && iface_block->interface=="uniform");
+ else if(i->name=="points")
+ {
+ allowed = (stage->type==Stage::GEOMETRY && iface_layout && (iface_layout->interface=="in" || iface_layout->interface=="out"));
+ value = false;
+ }
+ else if(i->name=="lines" || i->name=="lines_adjacency" || i->name=="triangles" || i->name=="triangles_adjacency")
+ {
+ allowed = (stage->type==Stage::GEOMETRY && iface_layout && iface_layout->interface=="in");
+ value = false;
+ }
+ else if(i->name=="line_strip" || i->name=="triangle_strip")
+ {
+ allowed = (stage->type==Stage::GEOMETRY && iface_layout && iface_layout->interface=="out");
+ value = false;
+ }
+ else if(i->name=="invocations")
+ allowed = (stage->type==Stage::GEOMETRY && iface_layout && iface_layout->interface=="in");
+ else if(i->name=="max_vertices")
+ allowed = (stage->type==Stage::GEOMETRY && iface_layout && iface_layout->interface=="out");
+ else if(i->name=="std140" || i->name=="std430")
+ {
+ allowed = (iface_block && !variable && iface_block->interface=="uniform");
+ value = false;
+ }
+ else if(i->name=="column_major" || i->name=="row_major")
+ {
+ allowed = (variable && scope==INTERFACE_BLOCK);
+ if(allowed)
+ {
+ BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(variable->type_declaration);
+ while(basic && basic->kind==BasicTypeDeclaration::ARRAY)
+ basic = dynamic_cast<BasicTypeDeclaration *>(basic->base_type);
+ allowed = (basic && basic->kind==BasicTypeDeclaration::MATRIX);
+ err_descr = "non-matrix variable";
+ }
+ }
+
+ if(!allowed)
+ {
+ if(err_descr.empty())
+ {
+ if(variable)
+ err_descr = describe_variable(scope);
+ else if(iface_block)
+ err_descr = "interface block";
+ else if(iface_layout)
+ err_descr = format("interface '%s'", iface_layout->interface);
+ else
+ err_descr = "unknown declaration";
+ }
+ error(layout, format("Layout qualifier '%s' not allowed on %s", i->name, err_descr));
+ }
+ else if(value && !i->has_value)
+ error(layout, format("Layout qualifier '%s' requires a value", i->name));
+ else if(!value && i->has_value)
+ error(layout, format("Layout qualifier '%s' does not allow a value", i->name));
+ }
+}
+
+void DeclarationValidator::visit(InterfaceLayout &layout)
+{
+ SetForScope<InterfaceLayout *> set_layout(iface_layout, &layout);
+ TraversingVisitor::visit(layout);
+}
+
+void DeclarationValidator::visit(BasicTypeDeclaration &type)
+{
+ BasicTypeDeclaration *basic_base = dynamic_cast<BasicTypeDeclaration *>(type.base_type);
+ BasicTypeDeclaration::Kind base_kind = (basic_base ? basic_base->kind : BasicTypeDeclaration::VOID);
+
+ if(type.kind==BasicTypeDeclaration::VECTOR && (base_kind<BasicTypeDeclaration::BOOL || base_kind>BasicTypeDeclaration::FLOAT))
+ error(type, format("Invalid base type '%s' for vector type '%s'", type.base, type.name));
+ else if(type.kind==BasicTypeDeclaration::MATRIX && base_kind!=BasicTypeDeclaration::VECTOR)
+ error(type, format("Invalid base type '%s' for matrix type '%s'", type.base, type.name));
+ else if(type.kind==BasicTypeDeclaration::ARRAY && basic_base && base_kind==BasicTypeDeclaration::VOID)
+ error(type, format("Invalid base type '%s' for array type '%s'", type.base, type.name));
+}
+
+void DeclarationValidator::visit(ImageTypeDeclaration &type)
+{
+ BasicTypeDeclaration::Kind base_kind = BasicTypeDeclaration::VOID;
+ if(BasicTypeDeclaration *basic_base = dynamic_cast<BasicTypeDeclaration *>(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 DeclarationValidator::visit(StructDeclaration &strct)
+{
+ SetForScope<ScopeType> set_scope(scope, (scope!=INTERFACE_BLOCK ? STRUCT : scope));
+ TraversingVisitor::visit(strct);
+}
+
+void DeclarationValidator::visit(VariableDeclaration &var)
+{
+ SetForScope<VariableDeclaration *> set_var(variable, &var);
+
+ const char *descr = describe_variable(scope);
+
+ if(var.layout)
+ {
+ if(scope!=GLOBAL && scope!=INTERFACE_BLOCK)
+ error(var, format("Layout qualifier not allowed on %s", descr));
+ else
+ var.layout->visit(*this);
+ }
+
+ if(var.constant)
+ {
+ if(scope==STRUCT || scope==INTERFACE_BLOCK)
+ error(var, format("Constant qualifier not allowed on %s", descr));
+ if(!var.init_expression)
+ error(var, "Constant variable must have an initializer");
+ }
+
+ if(!var.interpolation.empty() || !var.sampling.empty())
+ {
+ if(var.interface!="in" && stage->type==Stage::VERTEX)
+ error(var, "Interpolation qualifier not allowed on vertex input");
+ else if(var.interface!="out" && stage->type==Stage::FRAGMENT)
+ error(var, "Interpolation qualifier not allowed on fragment output");
+ else if((var.interface!="in" && var.interface!="out") || (scope==FUNCTION_PARAM || scope==FUNCTION))
+ error(var, "Interpolation qualifier not allowed on non-interpolated variable");
+ }
+
+ if(!var.interface.empty())
+ {
+ if(iface_block && var.interface!=iface_block->interface)
+ error(var, format("Mismatched interface qualifier '%s' inside '%s' block", var.interface, iface_block->interface));
+ else if(scope==STRUCT || scope==FUNCTION)
+ error(var, format("Interface qualifier not allowed on %s", descr));
+ }
+
+ TypeDeclaration *type = var.type_declaration;
+ BasicTypeDeclaration::Kind kind = BasicTypeDeclaration::ALIAS;
+ while(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(type))
+ {
+ kind = basic->kind;
+ type = basic->base_type;
+ }
+ if(dynamic_cast<ImageTypeDeclaration *>(type))
+ {
+ if(scope!=GLOBAL && scope!=FUNCTION_PARAM)
+ error(var, format("Type '%s' not allowed on %s", type->name, descr));
+ else if(scope==GLOBAL && var.interface!="uniform")
+ error(var, format("Type '%s' only allowed with uniform interface", type->name));
+ }
+ else if(kind==BasicTypeDeclaration::VOID)
+ error(var, "Type 'void' not allowed on variable");
+ else if(kind==BasicTypeDeclaration::BOOL && !var.interface.empty() && var.source!=BUILTIN_SOURCE)
+ error(var, "Type 'bool' not allowed on interface variable");
+
+ if(var.init_expression)
+ {
+ if(scope==GLOBAL && !var.constant)
+ error(var, format("Initializer not allowed on non-constant %s", descr));
+ else if(scope!=GLOBAL && scope!=FUNCTION)
+ error(var, format("Initializer not allowed on %s", descr));
+ else
+ var.init_expression->visit(*this);
+ }
+}
+
+void DeclarationValidator::visit(InterfaceBlock &iface)
+{
+ SetForScope<ScopeType> set_scope(scope, INTERFACE_BLOCK);
+ SetForScope<InterfaceBlock *> set_iface(iface_block, &iface);
+
+ if(stage->type==Stage::VERTEX && iface.interface=="in")
+ error(iface, "Interface block not allowed on vertex shader input");
+ else if(stage->type==Stage::FRAGMENT && iface.interface=="out")
+ error(iface, "Interface block not allowed on fragment shader output");
+
+ TraversingVisitor::visit(iface);
+ if(iface.struct_declaration)
+ iface.struct_declaration->visit(*this);
+}
+
+void DeclarationValidator::visit(FunctionDeclaration &func)
+{
+ SetForScope<ScopeType> set_scope(scope, FUNCTION_PARAM);
+ for(NodeArray<VariableDeclaration>::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+ (*i)->visit(*this);
+ scope = FUNCTION;
+ func.body.visit(*this);
+}
+
+
+IdentifierValidator::IdentifierValidator():