X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fsyntax.h;h=f7c8ed29cedc09229be11f5ce774d78f67107ee3;hb=d8bdf61007978e2c3670a22a58e2f105e8347537;hp=25b7e4a0450d8d89e940579a87af356a74ee5ac1;hpb=7a16308e72aef363727b21348779673edf8e5c07;p=libs%2Fgl.git diff --git a/source/glsl/syntax.h b/source/glsl/syntax.h index 25b7e4a0..f7c8ed29 100644 --- a/source/glsl/syntax.h +++ b/source/glsl/syntax.h @@ -3,11 +3,15 @@ #include #include +#include #include #include +#include #include -#include "extension.h" -#include "uniform.h" +#include +#include "features.h" +#include "glsl_error.h" +#include "sourcemap.h" #pragma push_macro("interface") #undef interface @@ -23,30 +27,44 @@ struct Operator NO_OPERATOR, BINARY, PREFIX, - POSTFIX + POSTFIX, + TERNARY }; enum Associativity { LEFT_TO_RIGHT, - RIGHT_TO_LEFT + RIGHT_TO_LEFT, + ASSOCIATIVE }; char token[4]; - unsigned precedence; + char token2[2]; + UInt8 precedence; Type type; Associativity assoc; static const Operator operators[]; + + static const Operator &get_operator(const std::string &, Type); +}; + +enum +{ + INTERNAL_SOURCE = -2, + BUILTIN_SOURCE = -1, + GENERATED_SOURCE = 0 }; struct NodeVisitor; struct Node { -protected: - Node() { } - Node(const Node &) { } + int source; + unsigned line; + + Node(): source(GENERATED_SOURCE), line(1) { } + Node(const Node &n): source(n.source), line(n.line) { } private: Node &operator=(const Node &); public: @@ -78,6 +96,9 @@ class NodeContainer: public C public: NodeContainer() { } NodeContainer(const NodeContainer &); + + void push_back_nocopy(const typename C::value_type &v) + { C::push_back(0); C::back() = v; } }; template @@ -88,17 +109,13 @@ template class NodeArray: public NodeContainer > > { }; -struct StructDeclaration; +struct TypeDeclaration; struct VariableDeclaration; +struct InterfaceBlock; struct FunctionDeclaration; struct Statement: Node { - unsigned source; - unsigned line; - - Statement(); - virtual Statement *clone() const = 0; }; @@ -106,10 +123,12 @@ struct Block: Node { NodeList body; bool use_braces; - std::map types; + std::map variables; + Block *parent; Block(); + Block(const Block &); virtual Block *clone() const { return new Block(*this); } virtual void visit(NodeVisitor &); @@ -117,33 +136,48 @@ struct Block: Node struct Expression: Node { + const Operator *oper; + + TypeDeclaration *type; + bool lvalue; + + Expression(); + virtual Expression *clone() const = 0; }; struct Literal: Expression { std::string token; + Variant value; virtual Literal *clone() const { return new Literal(*this); } virtual void visit(NodeVisitor &); }; -struct ParenthesizedExpression: Expression +struct VariableReference: Expression { - NodePtr expression; + std::string name; - virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); } + VariableDeclaration *declaration; + + VariableReference(); + VariableReference(const VariableReference &); + + virtual VariableReference *clone() const { return new VariableReference(*this); } virtual void visit(NodeVisitor &); }; -struct VariableReference: Expression +struct InterfaceBlockReference: Expression { std::string name; - VariableDeclaration *declaration; - VariableReference(); + InterfaceBlock *declaration; - virtual VariableReference *clone() const { return new VariableReference(*this); } + InterfaceBlockReference(); + InterfaceBlockReference(const InterfaceBlockReference &); + + virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); } virtual void visit(NodeVisitor &); }; @@ -151,19 +185,32 @@ struct MemberAccess: Expression { NodePtr left; std::string member; + VariableDeclaration *declaration; + MemberAccess(); + MemberAccess(const MemberAccess &); + virtual MemberAccess *clone() const { return new MemberAccess(*this); } virtual void visit(NodeVisitor &); }; +struct Swizzle: Expression +{ + NodePtr left; + std::string component_group; + unsigned count; + UInt8 components[4]; + + Swizzle(); + + virtual Swizzle *clone() const { return new Swizzle(*this); } + virtual void visit(NodeVisitor &); +}; + struct UnaryExpression: Expression { - std::string oper; NodePtr expression; - bool prefix; - - UnaryExpression(); virtual UnaryExpression *clone() const { return new UnaryExpression(*this); } virtual void visit(NodeVisitor &); @@ -172,9 +219,7 @@ struct UnaryExpression: Expression struct BinaryExpression: Expression { NodePtr left; - std::string oper; NodePtr right; - std::string after; virtual BinaryExpression *clone() const { return new BinaryExpression(*this); } virtual void visit(NodeVisitor &); @@ -182,23 +227,55 @@ struct BinaryExpression: Expression struct Assignment: BinaryExpression { + struct Target + { + enum ChainType + { + MEMBER = 0x40, + SWIZZLE = 0x80, + ARRAY = 0xC0 + }; + + Statement *declaration; + Msp::UInt8 chain_len; + Msp::UInt8 chain[7]; + + Target(Statement * = 0); + + bool operator<(const Target &) const; + }; + bool self_referencing; - VariableDeclaration *target_declaration; + + Target target; Assignment(); + Assignment(const Assignment &); virtual Assignment *clone() const { return new Assignment(*this); } virtual void visit(NodeVisitor &); }; +struct TernaryExpression: Expression +{ + NodePtr condition; + NodePtr true_expr; + NodePtr false_expr; + + virtual TernaryExpression *clone() const { return new TernaryExpression(*this); } + virtual void visit(NodeVisitor &); +}; + struct FunctionCall: Expression { std::string name; - FunctionDeclaration *declaration; bool constructor; NodeArray arguments; + FunctionDeclaration *declaration; + FunctionCall(); + FunctionCall(const FunctionCall &); virtual FunctionCall *clone() const { return new FunctionCall(*this); } virtual void visit(NodeVisitor &); @@ -233,9 +310,9 @@ struct Layout: Node { struct Qualifier { - // TODO the standard calls this name, not identifier - std::string identifier; - std::string value; + std::string name; + bool has_value; + int value; }; std::vector qualifiers; @@ -253,12 +330,73 @@ struct InterfaceLayout: Statement virtual void visit(NodeVisitor &); }; -struct StructDeclaration: Statement +struct TypeDeclaration: Statement { std::string name; + + virtual TypeDeclaration *clone() const = 0; +}; + +struct BasicTypeDeclaration: TypeDeclaration +{ + enum Kind + { + ALIAS, + VOID, + BOOL, + INT, + FLOAT, + VECTOR, + MATRIX, + ARRAY + }; + + Kind kind; + unsigned size; + std::string base; + + TypeDeclaration *base_type; + + BasicTypeDeclaration(); + BasicTypeDeclaration(const BasicTypeDeclaration &); + + virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); } + virtual void visit(NodeVisitor &); +}; + +struct ImageTypeDeclaration: TypeDeclaration +{ + enum Dimensions + { + ONE = 1, + TWO, + THREE, + CUBE + }; + + Dimensions dimensions; + bool array; + bool sampled; + bool shadow; + std::string base; + + TypeDeclaration *base_type; + + ImageTypeDeclaration(); + + virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); } + virtual void visit(NodeVisitor &); +}; + +struct StructDeclaration: TypeDeclaration +{ Block members; + InterfaceBlock *interface_block; + StructDeclaration(); + StructDeclaration(const StructDeclaration &); + ~StructDeclaration(); virtual StructDeclaration *clone() const { return new StructDeclaration(*this); } virtual void visit(NodeVisitor &); @@ -266,21 +404,24 @@ struct StructDeclaration: Statement struct VariableDeclaration: Statement { + NodePtr layout; bool constant; std::string sampling; std::string interpolation; std::string interface; std::string precision; std::string type; - StructDeclaration *type_declaration; std::string name; bool array; NodePtr array_size; NodePtr init_expression; + + TypeDeclaration *type_declaration; VariableDeclaration *linked_declaration; - NodePtr layout; VariableDeclaration(); + VariableDeclaration(const VariableDeclaration &); + ~VariableDeclaration(); virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); } virtual void visit(NodeVisitor &); @@ -289,12 +430,20 @@ struct VariableDeclaration: Statement struct InterfaceBlock: Statement { std::string interface; - std::string name; - Block members; + std::string block_name; + NodePtr members; std::string instance_name; bool array; + /* An interface block's ultimate base type is always a struct. The + immediate type may be either that same struct or an array of it. */ + TypeDeclaration *type_declaration; + StructDeclaration *struct_declaration; + InterfaceBlock *linked_block; + InterfaceBlock(); + InterfaceBlock(const InterfaceBlock &); + ~InterfaceBlock(); virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); } virtual void visit(NodeVisitor &); @@ -305,9 +454,14 @@ struct FunctionDeclaration: Statement std::string return_type; std::string name; NodeArray parameters; - FunctionDeclaration *definition; + bool virtua; + bool overrd; Block body; + std::string signature; + FunctionDeclaration *definition; + TypeDeclaration *return_type_declaration; + FunctionDeclaration(); FunctionDeclaration(const FunctionDeclaration &); @@ -327,7 +481,7 @@ struct Conditional: Statement struct Iteration: Statement { - NodePtr init_statement; + NodePtr init_statement; NodePtr condition; NodePtr loop_expression; Block body; @@ -373,23 +527,29 @@ struct Stage Type type; Stage *previous; Block content; - std::map in_variables; - std::map out_variables; + std::map types; + std::map interface_blocks; + std::map functions; std::map locations; - Version required_version; - std::vector required_extensions; + Features required_features; + std::vector diagnostics; Stage(Type); + + static const char *get_stage_name(Type); }; struct Module { + SourceMap source_map; Stage shared; std::list stages; Module(); }; +std::string get_unused_variable_name(const Block &, const std::string &); + } // namespace SL } // namespace GL } // namespace Msp