1 #include <msp/core/raii.h>
2 #include <msp/strings/format.h>
3 #include <msp/strings/regex.h>
4 #include <msp/strings/utils.h>
6 #include "glsl_error.h"
7 #include "modulecache.h"
18 Parser::Parser(ModuleCache *s):
20 preprocessor(tokenizer),
23 tokenizer.signal_preprocess.connect(sigc::mem_fun(&preprocessor, &Preprocessor::preprocess));
24 preprocessor.signal_version.connect(sigc::mem_fun(this, &Parser::set_required_version));
25 preprocessor.signal_source.connect(sigc::mem_fun(this, &Parser::source_reference));
26 preprocessor.signal_stage_change.connect(sigc::mem_fun(this, &Parser::stage_change));
27 preprocessor.signal_line.connect(sigc::mem_fun(this, &Parser::line_change));
30 void Parser::parse(Module &m, const string &s, const string &n, int i)
32 SetForScope<Module *> set_module(module, &m);
37 void Parser::parse(Module &m, IO::Base &io, const string &n, int i)
39 SetForScope<Module *> set_module(module, &m);
44 unsigned len = io.read(buffer, sizeof(buffer));
45 source.append(buffer, len);
50 void Parser::parse_source(const string &name, int index)
52 cur_stage = &module->shared;
56 source_reference(1, name);
58 // TODO Need to somehow get type names from imports
59 if(const Stage *builtin = get_builtins(Stage::SHARED))
61 for(map<string, TypeDeclaration *>::const_iterator i=builtin->types.begin(); i!=builtin->types.end(); ++i)
62 declared_types.insert(i->first);
66 declared_types.insert("void");
67 declared_types.insert("bool");
68 declared_types.insert("int");
69 declared_types.insert("uint");
70 declared_types.insert("float");
73 tokenizer.begin(source, name);
74 allow_stage_change = true;
75 while(!tokenizer.peek_token().empty())
76 if(RefPtr<Statement> statement = parse_with_recovery(&Parser::parse_global_declaration))
77 cur_stage->content.body.push_back(statement);
80 throw invalid_shader_source(join(errors.begin(), errors.end(), "\n"));
83 void Parser::set_required_version(const Version &ver)
85 cur_stage->required_features.glsl_version = ver;
88 void Parser::source_reference(unsigned index, const string &name)
90 if(index<1 || base_index<0)
91 throw invalid_shader_source(tokenizer.get_location(), "Invalid source reference");
93 module->source_map.set_name(base_index+index-1, name);
96 void Parser::stage_change(Stage::Type stage)
98 if(!allow_stage_change)
99 throw invalid_shader_source(tokenizer.get_location(), "Changing stage not allowed here");
100 else if(stage<=cur_stage->type)
101 throw invalid_shader_source(tokenizer.get_location(), "Stage '%s' not allowed here", Stage::get_stage_name(stage));
103 module->stages.push_back(stage);
105 if(cur_stage->type!=Stage::SHARED)
106 module->stages.back().previous = cur_stage;
107 cur_stage = &module->stages.back();
110 void Parser::line_change(int index, unsigned line)
113 source_index = base_index+index-1;
117 index = source_index;
119 string name = module->source_map.get_name(index);
121 name = format("<%d>", index);
122 tokenizer.set_location(Location(name, line));
125 string Parser::expect_type()
127 string token = tokenizer.parse_token();
129 throw parse_error(tokenizer.get_location(), token, "a type");
133 string Parser::expect_identifier()
135 string token = tokenizer.parse_token();
136 if(!is_identifier(token))
137 throw parse_error(tokenizer.get_location(), token, "an identifier");
141 int Parser::expect_integer()
143 string token = tokenizer.parse_token();
145 throw parse_error(tokenizer.get_location(), token, "an integer literal");
146 return lexical_cast<int>(token);
149 bool Parser::check(const string &token)
151 bool result = (tokenizer.peek_token()==token);
153 tokenizer.parse_token();
157 bool Parser::is_interface_qualifier(const string &token)
159 return (token=="uniform" || token=="in" || token=="out");
162 bool Parser::is_sampling_qualifier(const string &token)
164 return (token=="centroid" || token=="sample");
167 bool Parser::is_interpolation_qualifier(const string &token)
169 return (token=="smooth" || token=="flat" || token=="noperspective");
172 bool Parser::is_precision_qualifier(const string &token)
174 return (token=="highp" || token=="mediump" || token=="lowp");
177 bool Parser::is_qualifier(const string &token)
179 return (token=="const" ||
180 is_interface_qualifier(token) ||
181 is_sampling_qualifier(token) ||
182 is_interpolation_qualifier(token) ||
183 is_precision_qualifier(token));
186 bool Parser::is_type(const string &token)
188 return declared_types.count(token);
191 bool Parser::is_identifier(const string &token)
193 static Regex re("^[a-zA-Z_][a-zA-Z0-9_]*$");
194 return re.match(token);
198 RefPtr<T> Parser::create_node()
200 RefPtr<T> node = new T;
201 node->source = source_index;
202 node->line = tokenizer.get_location().line;
207 RefPtr<T> Parser::parse_with_recovery(RefPtr<T> (Parser::*parse_func)())
209 tokenizer.clear_progress_mark();
212 return (this->*parse_func)();
214 catch(const invalid_shader_source &exc)
216 errors.push_back(exc.what());
219 if(tokenizer.get_last_token()!=";" || !tokenizer.get_progress_mark())
221 unsigned scope_level = 0;
224 if(tokenizer.peek_token()=="}" && scope_level==0)
226 if(!tokenizer.get_progress_mark())
227 tokenizer.parse_token();
231 string token = tokenizer.parse_token();
240 else if(token==";" && scope_level==0)
242 else if(token.empty())
250 RefPtr<Statement> Parser::parse_global_declaration()
252 string token = tokenizer.peek_token();
253 SetFlag disallow(allow_stage_change, false);
256 return parse_import();
257 else if(token=="precision")
258 return parse_precision();
259 else if(token=="layout")
261 RefPtr<Layout> layout = parse_layout();
262 token = tokenizer.peek_token();
263 if(is_interface_qualifier(token) && tokenizer.peek_token(1)==";")
265 RefPtr<InterfaceLayout> iface_lo = create_node<InterfaceLayout>();
266 iface_lo->layout.source = layout->source;
267 iface_lo->layout.line = layout->line;
268 iface_lo->layout.qualifiers = layout->qualifiers;
269 iface_lo->interface = tokenizer.parse_token();
270 tokenizer.expect(";");
273 else if(is_interface_qualifier(token) && tokenizer.peek_token(2)=="{")
275 RefPtr<InterfaceBlock> iface = parse_interface_block();
276 iface->layout = layout;
281 RefPtr<VariableDeclaration> var = parse_variable_declaration();
282 var->layout = layout;
286 else if(token=="typedef")
287 return parse_type_declaration();
288 else if(token=="struct")
289 return parse_struct_declaration();
290 else if(is_interface_qualifier(token))
292 string next = tokenizer.peek_token(1);
293 if(is_type(next) || is_qualifier(next))
294 return parse_variable_declaration();
296 return parse_interface_block();
298 else if(is_qualifier(token))
299 return parse_variable_declaration();
300 else if(token=="virtual")
301 return parse_function_declaration();
302 else if(is_type(token))
304 if(tokenizer.peek_token(2)=="(")
305 return parse_function_declaration();
307 return parse_variable_declaration();
309 else if(token.empty())
312 throw parse_error(tokenizer.get_location(), token, "a global declaration");
315 RefPtr<Statement> Parser::parse_statement()
317 string token = tokenizer.peek_token();
319 return parse_conditional();
320 else if(token=="for")
322 else if(token=="while")
323 return parse_while();
324 else if(token=="passthrough")
325 return parse_passthrough();
326 else if(token=="return")
327 return parse_return();
328 else if(token=="break" || token=="continue" || token=="discard")
330 RefPtr<Jump> jump = create_node<Jump>();
331 jump->keyword = tokenizer.parse_token();
332 tokenizer.expect(";");
336 else if(is_qualifier(token) || is_type(token))
337 return parse_variable_declaration();
340 tokenizer.parse_token();
341 throw invalid_shader_source(tokenizer.get_location(), "Empty statement not allowed");
343 else if(!token.empty())
345 RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
346 expr->expression = parse_expression();
347 tokenizer.expect(";");
352 throw parse_error(tokenizer.get_location(), token, "a statement");
355 RefPtr<Import> Parser::parse_import()
357 if(cur_stage->type!=Stage::SHARED)
358 throw invalid_shader_source(tokenizer.get_location(), "Imports are only allowed in the shared section");
360 tokenizer.expect("import");
361 RefPtr<Import> import = create_node<Import>();
362 import->module = expect_identifier();
363 tokenizer.expect(";");
367 RefPtr<Precision> Parser::parse_precision()
369 tokenizer.expect("precision");
370 RefPtr<Precision> precision = create_node<Precision>();
372 precision->precision = tokenizer.parse_token();
373 if(!is_precision_qualifier(precision->precision))
374 throw parse_error(tokenizer.get_location(), precision->precision, "a precision qualifier");
376 // TODO Add validation for this
377 precision->type = expect_type();
379 tokenizer.expect(";");
384 RefPtr<Layout> Parser::parse_layout()
386 tokenizer.expect("layout");
387 tokenizer.expect("(");
388 RefPtr<Layout> layout = create_node<Layout>();
391 string token = tokenizer.parse_token();
393 throw parse_error(tokenizer.get_location(), token, "a layout qualifier name");
395 layout->qualifiers.push_back(token);
396 Layout::Qualifier &qual = layout->qualifiers.back();
398 if((qual.has_value = check("=")))
400 if(qual.name=="constant_id" && tokenizer.peek_token()=="auto")
403 tokenizer.parse_token();
406 qual.value = expect_integer();
409 if(tokenizer.peek_token()==")")
412 tokenizer.expect(",");
414 tokenizer.expect(")");
420 void Parser::parse_block(Block &block, bool require_braces, RefPtr<T> (Parser::*parse_content)())
422 bool have_braces = (require_braces || tokenizer.peek_token()=="{");
424 tokenizer.expect("{");
428 while(tokenizer.peek_token()!="}")
429 if(RefPtr<Statement> node = parse_with_recovery(parse_content))
430 block.body.push_back(node);
433 block.body.push_back((this->*parse_content)());
435 block.use_braces = (require_braces || block.body.size()!=1);
438 tokenizer.expect("}");
441 RefPtr<Expression> Parser::parse_expression(const Operator *outer_oper)
443 unsigned outer_precedence = (outer_oper ? outer_oper->precedence+(outer_oper->assoc==Operator::RIGHT_TO_LEFT) : 20);
444 RefPtr<Expression> left;
445 VariableReference *left_var = 0;
448 string token = tokenizer.peek_token();
450 const Operator *oper = 0;
451 for(const Operator *i=Operator::operators; (!oper && i->type); ++i)
452 if(token==i->token && (!left || i->type!=Operator::PREFIX) && (left || i->type!=Operator::POSTFIX))
455 bool lower_precedence = (oper && oper->type!=Operator::PREFIX && oper->precedence>=outer_precedence);
456 if(token==";" || token==")" || token=="]" || token=="," || token==":" || lower_precedence)
461 throw parse_error(tokenizer.get_location(), token, "an expression");
468 throw invalid_shader_source(tokenizer.get_location(), "Syntax error before '(': function name must be an identifier");
469 left = parse_function_call(*left_var);
473 RefPtr<MemberAccess> memacc = create_node<MemberAccess>();
476 tokenizer.parse_token();
477 memacc->member = expect_identifier();
480 else if(oper && oper->type==Operator::POSTFIX)
482 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
484 tokenizer.parse_token();
485 unary->expression = left;
488 else if(oper && oper->type==Operator::BINARY)
489 left = parse_binary(left, *oper);
490 else if(oper && oper->type==Operator::TERNARY)
491 left = parse_ternary(left, *oper);
493 throw parse_error(tokenizer.get_location(), token, "an operator");
500 tokenizer.parse_token();
501 left = parse_expression();
502 tokenizer.expect(")");
504 else if(isdigit(token[0]) || token=="true" || token=="false")
505 left = parse_literal();
506 else if(is_identifier(token))
508 RefPtr<VariableReference> var = create_node<VariableReference>();
509 var->name = expect_identifier();
511 left_var = var.get();
513 else if(oper && oper->type==Operator::PREFIX)
515 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
517 tokenizer.parse_token();
518 unary->expression = parse_expression(oper);
522 throw parse_error(tokenizer.get_location(), token, "an expression");
527 RefPtr<Literal> Parser::parse_literal()
529 RefPtr<Literal> literal = create_node<Literal>();
530 literal->token = tokenizer.parse_token();
531 if(isdigit(literal->token[0]))
533 // TODO have the tokenizer return the type of the token
534 if(literal->token.back()=='u')
535 literal->value = lexical_cast<unsigned>(literal->token.substr(0, literal->token.size()-1));
536 else if(literal->token.back()=='f')
537 literal->value = lexical_cast<float>(literal->token.substr(0, literal->token.size()-1));
538 else if(literal->token.find('.')!=string::npos)
539 literal->value = lexical_cast<float>(literal->token);
541 literal->value = lexical_cast<int>(literal->token);
543 else if(literal->token=="true" || literal->token=="false")
544 literal->value = (literal->token=="true");
546 throw parse_error(tokenizer.get_location(), literal->token, "a literal");
551 RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator &oper)
553 RefPtr<BinaryExpression> binary = (oper.precedence==16 ?
554 static_cast<RefPtr<BinaryExpression> >(create_node<Assignment>()) : create_node<BinaryExpression>());
556 binary->oper = &oper;
557 tokenizer.expect(oper.token);
560 binary->right = parse_expression();
561 tokenizer.expect(oper.token2);
564 binary->right = parse_expression(&oper);
568 RefPtr<TernaryExpression> Parser::parse_ternary(const RefPtr<Expression> &cond, const Operator &oper)
570 RefPtr<TernaryExpression> ternary = create_node<TernaryExpression>();
571 ternary->condition = cond;
572 ternary->oper = &oper;
573 tokenizer.expect("?");
574 ternary->true_expr = parse_expression(&oper);
575 tokenizer.expect(":");
576 ternary->false_expr = parse_expression(&oper);
580 RefPtr<FunctionCall> Parser::parse_function_call(const VariableReference &var)
582 RefPtr<FunctionCall> call = create_node<FunctionCall>();
583 call->name = var.name;
584 call->oper = &Operator::get_operator("(", Operator::POSTFIX);
585 tokenizer.expect("(");
586 while(tokenizer.peek_token()!=")")
588 if(!call->arguments.empty())
589 tokenizer.expect(",");
590 call->arguments.push_back(parse_expression());
592 tokenizer.expect(")");
596 RefPtr<TypeDeclaration> Parser::parse_type_declaration()
598 tokenizer.expect("typedef");
600 RefPtr<TypeDeclaration> type;
601 if(tokenizer.peek_token()=="image")
602 type = parse_image_type_declaration();
604 type = parse_basic_type_declaration();
606 tokenizer.expect(";");
607 declared_types.insert(type->name);
611 RefPtr<BasicTypeDeclaration> Parser::parse_basic_type_declaration()
613 RefPtr<BasicTypeDeclaration> type = create_node<BasicTypeDeclaration>();
615 if(tokenizer.peek_token()=="vector")
617 type->kind = BasicTypeDeclaration::VECTOR;
619 tokenizer.parse_token();
620 tokenizer.expect("(");
621 type->size = expect_integer();
622 tokenizer.expect(")");
625 type->base = expect_type();
626 type->name = expect_identifier();
628 if(type->kind==BasicTypeDeclaration::ALIAS && check("["))
630 type->kind = BasicTypeDeclaration::ARRAY;
631 tokenizer.expect("]");
637 RefPtr<ImageTypeDeclaration> Parser::parse_image_type_declaration()
639 tokenizer.expect("image");
640 tokenizer.expect("(");
642 RefPtr<ImageTypeDeclaration> type = create_node<ImageTypeDeclaration>();
645 string token = tokenizer.parse_token();
646 if(token=="dimensions")
648 tokenizer.expect("=");
649 token = tokenizer.parse_token();
651 type->dimensions = ImageTypeDeclaration::ONE;
653 type->dimensions = ImageTypeDeclaration::TWO;
655 type->dimensions = ImageTypeDeclaration::THREE;
656 else if(token=="cube")
657 type->dimensions = ImageTypeDeclaration::CUBE;
659 throw parse_error(tokenizer.get_location(), token, "dimensions");
664 tokenizer.expect("]");
667 else if(token=="sampled")
668 type->sampled = true;
669 else if(token=="shadow")
672 throw parse_error(tokenizer.get_location(), token, "image type attribute");
674 token = tokenizer.peek_token();
678 tokenizer.expect(",");
680 tokenizer.expect(")");
682 type->base = expect_type();
683 type->name = expect_identifier();
688 RefPtr<StructDeclaration> Parser::parse_struct_declaration()
690 tokenizer.expect("struct");
691 RefPtr<StructDeclaration> strct = create_node<StructDeclaration>();
693 strct->name = expect_identifier();
694 parse_block(strct->members, true, &Parser::parse_variable_declaration);
695 tokenizer.expect(";");
697 declared_types.insert(strct->name);
701 RefPtr<VariableDeclaration> Parser::parse_variable_declaration()
703 RefPtr<VariableDeclaration> var = create_node<VariableDeclaration>();
705 string token = tokenizer.peek_token();
706 while(is_qualifier(token))
708 tokenizer.parse_token();
709 if(is_interface_qualifier(token))
710 var->interface = token;
711 else if(is_sampling_qualifier(token))
712 var->sampling = token;
713 else if(is_interpolation_qualifier(token))
714 var->interpolation = token;
715 else if(is_precision_qualifier(token))
716 var->precision = token;
717 else if(token=="const")
718 var->constant = true;
719 token = tokenizer.peek_token();
722 var->type = expect_type();
723 var->name = expect_identifier();
730 var->array_size = parse_expression();
731 tokenizer.expect("]");
736 var->init_expression = parse_expression();
738 tokenizer.expect(";");
742 RefPtr<VariableDeclaration> Parser::parse_variable_declaration_with_layout()
744 RefPtr<Layout> layout;
745 if(tokenizer.peek_token()=="layout")
746 layout = parse_layout();
748 RefPtr<VariableDeclaration> var = parse_variable_declaration();
749 var->layout = layout;
754 RefPtr<FunctionDeclaration> Parser::parse_function_declaration()
756 RefPtr<FunctionDeclaration> func = create_node<FunctionDeclaration>();
758 func->virtua = check("virtual");
759 func->return_type = expect_type();
760 func->name = expect_identifier();
761 tokenizer.expect("(");
762 while(tokenizer.peek_token()!=")")
764 if(!func->parameters.empty())
765 tokenizer.expect(",");
767 RefPtr<VariableDeclaration> var = create_node<VariableDeclaration>();
768 string token = tokenizer.peek_token();
769 if(token=="in" || token=="out" || token=="inout")
770 var->interface = tokenizer.parse_token();
771 var->type = expect_type();
772 var->name = expect_identifier();
773 func->parameters.push_back(var);
775 tokenizer.expect(")");
777 func->overrd = check("override");
779 string token = tokenizer.peek_token();
782 func->definition = func.get();
783 parse_block(func->body, true, &Parser::parse_statement);
786 tokenizer.parse_token();
788 throw parse_error(tokenizer.get_location(), token, "'{' or ';'");
793 RefPtr<InterfaceBlock> Parser::parse_interface_block()
795 RefPtr<InterfaceBlock> iface = create_node<InterfaceBlock>();
797 iface->interface = tokenizer.parse_token();
798 if(!is_interface_qualifier(iface->interface))
799 throw parse_error(tokenizer.get_location(), iface->interface, "an interface qualifier");
801 iface->block_name = expect_identifier();
802 iface->members = new Block;
803 parse_block(*iface->members, true, &Parser::parse_variable_declaration_with_layout);
806 iface->instance_name = expect_identifier();
810 tokenizer.expect("]");
812 tokenizer.expect(";");
818 RefPtr<Conditional> Parser::parse_conditional()
820 tokenizer.expect("if");
821 RefPtr<Conditional> cond = create_node<Conditional>();
822 tokenizer.expect("(");
823 cond->condition = parse_expression();
824 tokenizer.expect(")");
826 parse_block(cond->body, false, &Parser::parse_statement);
828 string token = tokenizer.peek_token();
831 tokenizer.parse_token();
832 parse_block(cond->else_body, false, &Parser::parse_statement);
838 RefPtr<Iteration> Parser::parse_for()
840 tokenizer.expect("for");
841 RefPtr<Iteration> loop = create_node<Iteration>();
842 tokenizer.expect("(");
843 string token = tokenizer.peek_token();
845 loop->init_statement = parse_statement();
850 RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
851 expr->expression = parse_expression();
852 loop->init_statement = expr;
854 tokenizer.expect(";");
856 if(tokenizer.peek_token()!=";")
857 loop->condition = parse_expression();
858 tokenizer.expect(";");
859 if(tokenizer.peek_token()!=")")
860 loop->loop_expression = parse_expression();
861 tokenizer.expect(")");
863 parse_block(loop->body, false, &Parser::parse_statement);
868 RefPtr<Iteration> Parser::parse_while()
870 tokenizer.expect("while");
871 RefPtr<Iteration> loop = create_node<Iteration>();
872 tokenizer.expect("(");
873 loop->condition = parse_expression();
874 tokenizer.expect(")");
876 parse_block(loop->body, false, &Parser::parse_statement);
881 RefPtr<Passthrough> Parser::parse_passthrough()
883 tokenizer.expect("passthrough");
884 RefPtr<Passthrough> pass = create_node<Passthrough>();
885 if(cur_stage->type==Stage::GEOMETRY)
887 tokenizer.expect("[");
888 pass->subscript = parse_expression();
889 tokenizer.expect("]");
891 tokenizer.expect(";");
895 RefPtr<Return> Parser::parse_return()
897 tokenizer.expect("return");
898 RefPtr<Return> ret = create_node<Return>();
899 if(tokenizer.peek_token()!=";")
900 ret->expression = parse_expression();
901 tokenizer.expect(";");