]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/parser.h
Clear load ID when assigning to a component
[libs/gl.git] / source / glsl / parser.h
1 #ifndef MSP_GL_SL_PARSER_H_
2 #define MSP_GL_SL_PARSER_H_
3
4 #include <set>
5 #include <string>
6 #include <msp/io/base.h>
7 #include "preprocessor.h"
8 #include "syntax.h"
9 #include "tokenizer.h"
10
11 namespace Msp {
12 namespace GL {
13 namespace SL {
14
15 class ModuleCache;
16
17 class Parser
18 {
19 private:
20         ModuleCache *mod_cache;
21         std::string source;
22         int base_index;
23         int source_index;
24         Tokenizer tokenizer;
25         Preprocessor preprocessor;
26         bool allow_stage_change;
27         Module *module;
28         std::vector<const Module *> imported_modules;
29         Stage *cur_stage;
30         std::set<std::string> global_types;
31         std::set<std::string> stage_types;
32         std::vector<std::string> errors;
33         RefPtr<Statement> next_global_declaration;
34
35 public:
36         Parser(ModuleCache *);
37
38         void parse(Module &, const std::string &, const std::string &, int);
39         void parse(Module &, IO::Base &, const std::string &, int);
40
41 private:
42         void parse_source(const std::string &, int);
43         void set_required_version(const Version &);
44         void source_reference(unsigned, const std::string &);
45         void stage_change(Stage::Type);
46         void line_change(int, unsigned);
47
48         std::string expect_type();
49         std::string expect_identifier();
50         int expect_integer();
51         bool check(const std::string &);
52
53         static bool is_interface_qualifier(const std::string &);
54         static bool is_sampling_qualifier(const std::string &);
55         static bool is_interpolation_qualifier(const std::string &);
56         static bool is_precision_qualifier(const std::string &);
57         static bool is_qualifier(const std::string &);
58         bool is_type(const std::string &);
59         bool is_identifier(const std::string &);
60
61         void preprocess();
62         void preprocess_version();
63         void preprocess_pragma();
64         void preprocess_pragma_msp();
65         void preprocess_stage();
66
67         template<typename T>
68         RefPtr<T> create_node();
69         template<typename T>
70         RefPtr<T> parse_with_recovery(RefPtr<T> (Parser::*)());
71         RefPtr<Statement> parse_global_declaration();
72         RefPtr<Statement> parse_statement();
73         RefPtr<Import> parse_import();
74         RefPtr<Precision> parse_precision();
75         RefPtr<Layout> parse_layout();
76         template<typename T>
77         void parse_block(Block &, bool, RefPtr<T> (Parser::*)());
78         RefPtr<Expression> parse_expression(const Operator * = 0);
79         RefPtr<Literal> parse_literal();
80         RefPtr<BinaryExpression> parse_binary(const RefPtr<Expression> &, const Operator &);
81         RefPtr<TernaryExpression> parse_ternary(const RefPtr<Expression> &, const Operator &);
82         RefPtr<FunctionCall> parse_function_call(const VariableReference &);
83         void add_type(TypeDeclaration &);
84         RefPtr<TypeDeclaration> parse_type_declaration();
85         RefPtr<BasicTypeDeclaration> parse_basic_type_declaration();
86         RefPtr<ImageTypeDeclaration> parse_image_type_declaration();
87         RefPtr<StructDeclaration> parse_struct_declaration();
88         RefPtr<VariableDeclaration> parse_variable_declaration();
89         RefPtr<VariableDeclaration> parse_variable_declaration_with_layout();
90         RefPtr<FunctionDeclaration> parse_function_declaration();
91         RefPtr<StructDeclaration> parse_interface_block();
92         RefPtr<Conditional> parse_conditional();
93         RefPtr<Iteration> parse_for();
94         RefPtr<Iteration> parse_while();
95         RefPtr<Passthrough> parse_passthrough();
96         RefPtr<Return> parse_return();
97 };
98
99 } // namespace SL
100 } // namespace GL
101 } // namespace Msp
102
103 #endif