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"
18 preprocessor(tokenizer),
21 tokenizer.signal_preprocess.connect(sigc::mem_fun(&preprocessor, &Preprocessor::preprocess));
22 preprocessor.signal_version.connect(sigc::mem_fun(this, &Parser::set_required_version));
23 preprocessor.signal_source.connect(sigc::mem_fun(this, &Parser::source_reference));
24 preprocessor.signal_stage_change.connect(sigc::mem_fun(this, &Parser::stage_change));
25 preprocessor.signal_line.connect(sigc::mem_fun(this, &Parser::line_change));
33 Module &Parser::parse(const string &s, const string &n, int i)
40 Module &Parser::parse(IO::Base &io, const string &n, int i)
46 unsigned len = io.read(buffer, sizeof(buffer));
47 source.append(buffer, len);
53 void Parser::parse_source(const string &name, int index)
58 cur_stage = &module->shared;
62 source_reference(1, name);
64 // TODO Need to somehow get type names from imports
65 if(const Stage *builtin = get_builtins(Stage::SHARED))
67 for(map<string, TypeDeclaration *>::const_iterator i=builtin->types.begin(); i!=builtin->types.end(); ++i)
68 declared_types.insert(i->first);
72 declared_types.insert("void");
73 declared_types.insert("bool");
74 declared_types.insert("int");
75 declared_types.insert("uint");
76 declared_types.insert("float");
79 tokenizer.begin(source, name);
80 allow_stage_change = true;
81 while(!tokenizer.peek_token().empty())
82 if(RefPtr<Statement> statement = parse_with_recovery(&Parser::parse_global_declaration))
83 cur_stage->content.body.push_back(statement);
86 throw invalid_shader_source(join(errors.begin(), errors.end(), "\n"));
89 void Parser::set_required_version(const Version &ver)
91 cur_stage->required_features.glsl_version = ver;
94 void Parser::source_reference(unsigned index, const string &name)
96 if(index<1 || base_index<0)
97 throw invalid_shader_source(tokenizer.get_location(), "Invalid source reference");
99 module->source_map.set_name(base_index+index-1, name);
102 void Parser::stage_change(Stage::Type stage)
104 if(!allow_stage_change)
105 throw invalid_shader_source(tokenizer.get_location(), "Changing stage not allowed here");
106 else if(stage<=cur_stage->type)
107 throw invalid_shader_source(tokenizer.get_location(), "Stage '%s' not allowed here", Stage::get_stage_name(stage));
109 module->stages.push_back(stage);
111 if(cur_stage->type!=Stage::SHARED)
112 module->stages.back().previous = cur_stage;
113 cur_stage = &module->stages.back();
116 void Parser::line_change(int index, unsigned line)
119 source_index = base_index+index-1;
123 index = source_index;
125 string name = module->source_map.get_name(index);
127 name = format("<%d>", index);
128 tokenizer.set_location(Location(name, line));
131 string Parser::expect_type()
133 string token = tokenizer.parse_token();
135 throw parse_error(tokenizer.get_location(), token, "a type");
139 string Parser::expect_identifier()
141 string token = tokenizer.parse_token();
142 if(!is_identifier(token))
143 throw parse_error(tokenizer.get_location(), token, "an identifier");
147 int Parser::expect_integer()
149 string token = tokenizer.parse_token();
151 throw parse_error(tokenizer.get_location(), token, "an integer literal");
152 return lexical_cast<int>(token);
155 bool Parser::check(const string &token)
157 bool result = (tokenizer.peek_token()==token);
159 tokenizer.parse_token();
163 bool Parser::is_interface_qualifier(const string &token)
165 return (token=="uniform" || token=="in" || token=="out");
168 bool Parser::is_sampling_qualifier(const string &token)
170 return (token=="centroid" || token=="sample");
173 bool Parser::is_interpolation_qualifier(const string &token)
175 return (token=="smooth" || token=="flat" || token=="noperspective");
178 bool Parser::is_precision_qualifier(const string &token)
180 return (token=="highp" || token=="mediump" || token=="lowp");
183 bool Parser::is_qualifier(const string &token)
185 return (token=="const" ||
186 is_interface_qualifier(token) ||
187 is_sampling_qualifier(token) ||
188 is_interpolation_qualifier(token) ||
189 is_precision_qualifier(token));
192 bool Parser::is_type(const string &token)
194 return declared_types.count(token);
197 bool Parser::is_identifier(const string &token)
199 static Regex re("^[a-zA-Z_][a-zA-Z0-9_]*$");
200 return re.match(token);
204 RefPtr<T> Parser::create_node()
206 RefPtr<T> node = new T;
207 node->source = source_index;
208 node->line = tokenizer.get_location().line;
213 RefPtr<T> Parser::parse_with_recovery(RefPtr<T> (Parser::*parse_func)())
215 tokenizer.clear_progress_mark();
218 return (this->*parse_func)();
220 catch(const invalid_shader_source &exc)
222 errors.push_back(exc.what());
225 if(tokenizer.get_last_token()!=";" || !tokenizer.get_progress_mark())
227 unsigned scope_level = 0;
230 if(tokenizer.peek_token()=="}" && scope_level==0)
232 if(!tokenizer.get_progress_mark())
233 tokenizer.parse_token();
237 string token = tokenizer.parse_token();
246 else if(token==";" && scope_level==0)
248 else if(token.empty())
256 RefPtr<Statement> Parser::parse_global_declaration()
258 string token = tokenizer.peek_token();
259 SetFlag disallow(allow_stage_change, false);
262 return parse_import();
263 else if(token=="precision")
264 return parse_precision();
265 else if(token=="layout")
267 RefPtr<Layout> layout = parse_layout();
268 token = tokenizer.peek_token();
269 if(is_interface_qualifier(token) && tokenizer.peek_token(1)==";")
271 RefPtr<InterfaceLayout> iface_lo = create_node<InterfaceLayout>();
272 iface_lo->layout.source = layout->source;
273 iface_lo->layout.line = layout->line;
274 iface_lo->layout.qualifiers = layout->qualifiers;
275 iface_lo->interface = tokenizer.parse_token();
276 tokenizer.expect(";");
279 else if(is_interface_qualifier(token) && tokenizer.peek_token(2)=="{")
281 RefPtr<InterfaceBlock> iface = parse_interface_block();
282 iface->layout = layout;
287 RefPtr<VariableDeclaration> var = parse_variable_declaration();
288 var->layout = layout;
292 else if(token=="typedef")
293 return parse_type_declaration();
294 else if(token=="struct")
295 return parse_struct_declaration();
296 else if(is_interface_qualifier(token))
298 string next = tokenizer.peek_token(1);
299 if(is_type(next) || is_qualifier(next))
300 return parse_variable_declaration();
302 return parse_interface_block();
304 else if(is_qualifier(token))
305 return parse_variable_declaration();
306 else if(token=="virtual")
307 return parse_function_declaration();
308 else if(is_type(token))
310 if(tokenizer.peek_token(2)=="(")
311 return parse_function_declaration();
313 return parse_variable_declaration();
315 else if(token.empty())
318 throw parse_error(tokenizer.get_location(), token, "a global declaration");
321 RefPtr<Statement> Parser::parse_statement()
323 string token = tokenizer.peek_token();
325 return parse_conditional();
326 else if(token=="for")
328 else if(token=="while")
329 return parse_while();
330 else if(token=="passthrough")
331 return parse_passthrough();
332 else if(token=="return")
333 return parse_return();
334 else if(token=="break" || token=="continue" || token=="discard")
336 RefPtr<Jump> jump = create_node<Jump>();
337 jump->keyword = tokenizer.parse_token();
338 tokenizer.expect(";");
342 else if(is_qualifier(token) || is_type(token))
343 return parse_variable_declaration();
346 tokenizer.parse_token();
347 throw invalid_shader_source(tokenizer.get_location(), "Empty statement not allowed");
349 else if(!token.empty())
351 RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
352 expr->expression = parse_expression();
353 tokenizer.expect(";");
358 throw parse_error(tokenizer.get_location(), token, "a statement");
361 RefPtr<Import> Parser::parse_import()
363 if(cur_stage->type!=Stage::SHARED)
364 throw invalid_shader_source(tokenizer.get_location(), "Imports are only allowed in the shared section");
366 tokenizer.expect("import");
367 RefPtr<Import> import = create_node<Import>();
368 import->module = expect_identifier();
369 tokenizer.expect(";");
373 RefPtr<Precision> Parser::parse_precision()
375 tokenizer.expect("precision");
376 RefPtr<Precision> precision = create_node<Precision>();
378 precision->precision = tokenizer.parse_token();
379 if(!is_precision_qualifier(precision->precision))
380 throw parse_error(tokenizer.get_location(), precision->precision, "a precision qualifier");
382 // TODO Add validation for this
383 precision->type = expect_type();
385 tokenizer.expect(";");
390 RefPtr<Layout> Parser::parse_layout()
392 tokenizer.expect("layout");
393 tokenizer.expect("(");
394 RefPtr<Layout> layout = create_node<Layout>();
397 string token = tokenizer.parse_token();
399 throw parse_error(tokenizer.get_location(), token, "a layout qualifier name");
401 layout->qualifiers.push_back(token);
402 Layout::Qualifier &qual = layout->qualifiers.back();
404 if((qual.has_value = check("=")))
406 if(qual.name=="constant_id" && tokenizer.peek_token()=="auto")
409 tokenizer.parse_token();
412 qual.value = expect_integer();
415 if(tokenizer.peek_token()==")")
418 tokenizer.expect(",");
420 tokenizer.expect(")");
426 void Parser::parse_block(Block &block, bool require_braces, RefPtr<T> (Parser::*parse_content)())
428 bool have_braces = (require_braces || tokenizer.peek_token()=="{");
430 tokenizer.expect("{");
434 while(tokenizer.peek_token()!="}")
435 if(RefPtr<Statement> node = parse_with_recovery(parse_content))
436 block.body.push_back(node);
439 block.body.push_back((this->*parse_content)());
441 block.use_braces = (require_braces || block.body.size()!=1);
444 tokenizer.expect("}");
447 RefPtr<Expression> Parser::parse_expression(const Operator *outer_oper)
449 unsigned outer_precedence = (outer_oper ? outer_oper->precedence+(outer_oper->assoc==Operator::RIGHT_TO_LEFT) : 20);
450 RefPtr<Expression> left;
451 VariableReference *left_var = 0;
454 string token = tokenizer.peek_token();
456 const Operator *oper = 0;
457 for(const Operator *i=Operator::operators; (!oper && i->type); ++i)
458 if(token==i->token && (!left || i->type!=Operator::PREFIX) && (left || i->type!=Operator::POSTFIX))
461 bool lower_precedence = (oper && oper->type!=Operator::PREFIX && oper->precedence>=outer_precedence);
462 if(token==";" || token==")" || token=="]" || token=="," || token==":" || lower_precedence)
467 throw parse_error(tokenizer.get_location(), token, "an expression");
474 throw invalid_shader_source(tokenizer.get_location(), "Syntax error before '(': function name must be an identifier");
475 left = parse_function_call(*left_var);
479 RefPtr<MemberAccess> memacc = create_node<MemberAccess>();
482 tokenizer.parse_token();
483 memacc->member = expect_identifier();
486 else if(oper && oper->type==Operator::POSTFIX)
488 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
490 tokenizer.parse_token();
491 unary->expression = left;
494 else if(oper && oper->type==Operator::BINARY)
495 left = parse_binary(left, *oper);
496 else if(oper && oper->type==Operator::TERNARY)
497 left = parse_ternary(left, *oper);
499 throw parse_error(tokenizer.get_location(), token, "an operator");
506 tokenizer.parse_token();
507 left = parse_expression();
508 tokenizer.expect(")");
510 else if(isdigit(token[0]) || token=="true" || token=="false")
511 left = parse_literal();
512 else if(is_identifier(token))
514 RefPtr<VariableReference> var = create_node<VariableReference>();
515 var->name = expect_identifier();
517 left_var = var.get();
519 else if(oper && oper->type==Operator::PREFIX)
521 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
523 tokenizer.parse_token();
524 unary->expression = parse_expression(oper);
528 throw parse_error(tokenizer.get_location(), token, "an expression");
533 RefPtr<Literal> Parser::parse_literal()
535 RefPtr<Literal> literal = create_node<Literal>();
536 literal->token = tokenizer.parse_token();
537 if(isdigit(literal->token[0]))
539 // TODO have the tokenizer return the type of the token
540 if(literal->token.back()=='u')
541 literal->value = lexical_cast<unsigned>(literal->token.substr(0, literal->token.size()-1));
542 else if(literal->token.back()=='f')
543 literal->value = lexical_cast<float>(literal->token.substr(0, literal->token.size()-1));
544 else if(literal->token.find('.')!=string::npos)
545 literal->value = lexical_cast<float>(literal->token);
547 literal->value = lexical_cast<int>(literal->token);
549 else if(literal->token=="true" || literal->token=="false")
550 literal->value = (literal->token=="true");
552 throw parse_error(tokenizer.get_location(), literal->token, "a literal");
557 RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator &oper)
559 RefPtr<BinaryExpression> binary = (oper.precedence==16 ?
560 static_cast<RefPtr<BinaryExpression> >(create_node<Assignment>()) : create_node<BinaryExpression>());
562 binary->oper = &oper;
563 tokenizer.expect(oper.token);
566 binary->right = parse_expression();
567 tokenizer.expect(oper.token2);
570 binary->right = parse_expression(&oper);
574 RefPtr<TernaryExpression> Parser::parse_ternary(const RefPtr<Expression> &cond, const Operator &oper)
576 RefPtr<TernaryExpression> ternary = create_node<TernaryExpression>();
577 ternary->condition = cond;
578 ternary->oper = &oper;
579 tokenizer.expect("?");
580 ternary->true_expr = parse_expression(&oper);
581 tokenizer.expect(":");
582 ternary->false_expr = parse_expression(&oper);
586 RefPtr<FunctionCall> Parser::parse_function_call(const VariableReference &var)
588 RefPtr<FunctionCall> call = create_node<FunctionCall>();
589 call->name = var.name;
590 call->oper = &Operator::get_operator("(", Operator::POSTFIX);
591 tokenizer.expect("(");
592 while(tokenizer.peek_token()!=")")
594 if(!call->arguments.empty())
595 tokenizer.expect(",");
596 call->arguments.push_back(parse_expression());
598 tokenizer.expect(")");
602 RefPtr<TypeDeclaration> Parser::parse_type_declaration()
604 tokenizer.expect("typedef");
606 RefPtr<TypeDeclaration> type;
607 if(tokenizer.peek_token()=="image")
608 type = parse_image_type_declaration();
610 type = parse_basic_type_declaration();
612 tokenizer.expect(";");
613 declared_types.insert(type->name);
617 RefPtr<BasicTypeDeclaration> Parser::parse_basic_type_declaration()
619 RefPtr<BasicTypeDeclaration> type = create_node<BasicTypeDeclaration>();
621 if(tokenizer.peek_token()=="vector")
623 type->kind = BasicTypeDeclaration::VECTOR;
625 tokenizer.parse_token();
626 tokenizer.expect("(");
627 type->size = expect_integer();
628 tokenizer.expect(")");
631 type->base = expect_type();
632 type->name = expect_identifier();
634 if(type->kind==BasicTypeDeclaration::ALIAS && check("["))
636 type->kind = BasicTypeDeclaration::ARRAY;
637 tokenizer.expect("]");
643 RefPtr<ImageTypeDeclaration> Parser::parse_image_type_declaration()
645 tokenizer.expect("image");
646 tokenizer.expect("(");
648 RefPtr<ImageTypeDeclaration> type = create_node<ImageTypeDeclaration>();
651 string token = tokenizer.parse_token();
652 if(token=="dimensions")
654 tokenizer.expect("=");
655 token = tokenizer.parse_token();
657 type->dimensions = ImageTypeDeclaration::ONE;
659 type->dimensions = ImageTypeDeclaration::TWO;
661 type->dimensions = ImageTypeDeclaration::THREE;
662 else if(token=="cube")
663 type->dimensions = ImageTypeDeclaration::CUBE;
665 throw parse_error(tokenizer.get_location(), token, "dimensions");
670 tokenizer.expect("]");
673 else if(token=="sampled")
674 type->sampled = true;
675 else if(token=="shadow")
678 throw parse_error(tokenizer.get_location(), token, "image type attribute");
680 token = tokenizer.peek_token();
684 tokenizer.expect(",");
686 tokenizer.expect(")");
688 type->base = expect_type();
689 type->name = expect_identifier();
694 RefPtr<StructDeclaration> Parser::parse_struct_declaration()
696 tokenizer.expect("struct");
697 RefPtr<StructDeclaration> strct = create_node<StructDeclaration>();
699 strct->name = expect_identifier();
700 parse_block(strct->members, true, &Parser::parse_variable_declaration);
701 tokenizer.expect(";");
703 declared_types.insert(strct->name);
707 RefPtr<VariableDeclaration> Parser::parse_variable_declaration()
709 RefPtr<VariableDeclaration> var = create_node<VariableDeclaration>();
711 string token = tokenizer.peek_token();
712 while(is_qualifier(token))
714 tokenizer.parse_token();
715 if(is_interface_qualifier(token))
716 var->interface = token;
717 else if(is_sampling_qualifier(token))
718 var->sampling = token;
719 else if(is_interpolation_qualifier(token))
720 var->interpolation = token;
721 else if(is_precision_qualifier(token))
722 var->precision = token;
723 else if(token=="const")
724 var->constant = true;
725 token = tokenizer.peek_token();
728 var->type = expect_type();
729 var->name = expect_identifier();
736 var->array_size = parse_expression();
737 tokenizer.expect("]");
742 var->init_expression = parse_expression();
744 tokenizer.expect(";");
748 RefPtr<VariableDeclaration> Parser::parse_variable_declaration_with_layout()
750 RefPtr<Layout> layout;
751 if(tokenizer.peek_token()=="layout")
752 layout = parse_layout();
754 RefPtr<VariableDeclaration> var = parse_variable_declaration();
755 var->layout = layout;
760 RefPtr<FunctionDeclaration> Parser::parse_function_declaration()
762 RefPtr<FunctionDeclaration> func = create_node<FunctionDeclaration>();
764 func->virtua = check("virtual");
765 func->return_type = expect_type();
766 func->name = expect_identifier();
767 tokenizer.expect("(");
768 while(tokenizer.peek_token()!=")")
770 if(!func->parameters.empty())
771 tokenizer.expect(",");
773 RefPtr<VariableDeclaration> var = create_node<VariableDeclaration>();
774 string token = tokenizer.peek_token();
775 if(token=="in" || token=="out" || token=="inout")
776 var->interface = tokenizer.parse_token();
777 var->type = expect_type();
778 var->name = expect_identifier();
779 func->parameters.push_back(var);
781 tokenizer.expect(")");
783 func->overrd = check("override");
785 string token = tokenizer.peek_token();
788 func->definition = func.get();
789 parse_block(func->body, true, &Parser::parse_statement);
792 tokenizer.parse_token();
794 throw parse_error(tokenizer.get_location(), token, "'{' or ';'");
799 RefPtr<InterfaceBlock> Parser::parse_interface_block()
801 RefPtr<InterfaceBlock> iface = create_node<InterfaceBlock>();
803 iface->interface = tokenizer.parse_token();
804 if(!is_interface_qualifier(iface->interface))
805 throw parse_error(tokenizer.get_location(), iface->interface, "an interface qualifier");
807 iface->block_name = expect_identifier();
808 iface->members = new Block;
809 parse_block(*iface->members, true, &Parser::parse_variable_declaration_with_layout);
812 iface->instance_name = expect_identifier();
816 tokenizer.expect("]");
818 tokenizer.expect(";");
824 RefPtr<Conditional> Parser::parse_conditional()
826 tokenizer.expect("if");
827 RefPtr<Conditional> cond = create_node<Conditional>();
828 tokenizer.expect("(");
829 cond->condition = parse_expression();
830 tokenizer.expect(")");
832 parse_block(cond->body, false, &Parser::parse_statement);
834 string token = tokenizer.peek_token();
837 tokenizer.parse_token();
838 parse_block(cond->else_body, false, &Parser::parse_statement);
844 RefPtr<Iteration> Parser::parse_for()
846 tokenizer.expect("for");
847 RefPtr<Iteration> loop = create_node<Iteration>();
848 tokenizer.expect("(");
849 string token = tokenizer.peek_token();
851 loop->init_statement = parse_statement();
856 RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
857 expr->expression = parse_expression();
858 loop->init_statement = expr;
860 tokenizer.expect(";");
862 if(tokenizer.peek_token()!=";")
863 loop->condition = parse_expression();
864 tokenizer.expect(";");
865 if(tokenizer.peek_token()!=")")
866 loop->loop_expression = parse_expression();
867 tokenizer.expect(")");
869 parse_block(loop->body, false, &Parser::parse_statement);
874 RefPtr<Iteration> Parser::parse_while()
876 tokenizer.expect("while");
877 RefPtr<Iteration> loop = create_node<Iteration>();
878 tokenizer.expect("(");
879 loop->condition = parse_expression();
880 tokenizer.expect(")");
882 parse_block(loop->body, false, &Parser::parse_statement);
887 RefPtr<Passthrough> Parser::parse_passthrough()
889 tokenizer.expect("passthrough");
890 RefPtr<Passthrough> pass = create_node<Passthrough>();
891 if(cur_stage->type==Stage::GEOMETRY)
893 tokenizer.expect("[");
894 pass->subscript = parse_expression();
895 tokenizer.expect("]");
897 tokenizer.expect(";");
901 RefPtr<Return> Parser::parse_return()
903 tokenizer.expect("return");
904 RefPtr<Return> ret = create_node<Return>();
905 if(tokenizer.peek_token()!=";")
906 ret->expression = parse_expression();
907 tokenizer.expect(";");