1 #include <msp/strings/format.h>
2 #include <msp/strings/regex.h>
3 #include <msp/strings/utils.h>
4 #include "glsl_error.h"
16 preprocessor(tokenizer),
19 tokenizer.signal_preprocess.connect(sigc::mem_fun(&preprocessor, &Preprocessor::preprocess));
20 preprocessor.signal_version.connect(sigc::mem_fun(this, &Parser::set_required_version));
21 preprocessor.signal_source.connect(sigc::mem_fun(this, &Parser::source_reference));
22 preprocessor.signal_stage_change.connect(sigc::mem_fun(this, &Parser::stage_change));
23 preprocessor.signal_line.connect(sigc::mem_fun(this, &Parser::line_change));
31 Module &Parser::parse(const string &s, const string &n, unsigned i)
38 Module &Parser::parse(IO::Base &io, const string &n, unsigned i)
44 unsigned len = io.read(buffer, sizeof(buffer));
45 source.append(buffer, len);
51 void Parser::parse_source(const string &name, unsigned index)
55 cur_stage = &module->shared;
58 source_reference(1, name);
59 tokenizer.begin(name, source);
60 while(RefPtr<Statement> statement = parse_global_declaration())
61 cur_stage->content.body.push_back(statement);
64 void Parser::set_required_version(const Version &ver)
66 cur_stage->required_features.glsl_version = ver;
69 void Parser::source_reference(unsigned index, const string &name)
72 throw invalid_shader_source(tokenizer.get_location(), "Invalid source reference");
74 module->source_map.set_name(base_index+index-1, name);
77 void Parser::stage_change(Stage::Type stage)
79 if(!allow_stage_change)
80 throw invalid_shader_source(tokenizer.get_location(), "Changing stage not allowed here");
81 else if(stage<=cur_stage->type)
82 throw invalid_shader_source(tokenizer.get_location(), "Stage '%s' not allowed here", Stage::get_stage_name(stage));
84 module->stages.push_back(stage);
86 if(cur_stage->type!=Stage::SHARED)
87 module->stages.back().previous = cur_stage;
88 cur_stage = &module->stages.back();
91 void Parser::line_change(int index, unsigned line)
94 source_index = base_index+index-1;
100 string name = module->source_map.get_name(index);
102 name = format("<%d>", index);
103 tokenizer.set_location(Location(name, line));
106 string Parser::expect_type()
108 string token = tokenizer.parse_token();
110 throw parse_error(tokenizer.get_location(), token, "a type");
114 string Parser::expect_identifier()
116 string token = tokenizer.parse_token();
117 if(!is_identifier(token))
118 throw parse_error(tokenizer.get_location(), token, "an identifier");
122 int Parser::expect_integer()
124 string token = tokenizer.parse_token();
126 throw parse_error(tokenizer.get_location(), token, "an integer literal");
127 return lexical_cast<int>(token);
130 bool Parser::check(const string &token)
132 bool result = (tokenizer.peek_token()==token);
134 tokenizer.parse_token();
138 bool Parser::is_interface_qualifier(const string &token)
140 return (token=="uniform" || token=="in" || token=="out");
143 bool Parser::is_sampling_qualifier(const string &token)
145 return (token=="centroid" || token=="sample");
148 bool Parser::is_interpolation_qualifier(const string &token)
150 return (token=="smooth" || token=="flat" || token=="noperspective");
153 bool Parser::is_precision_qualifier(const string &token)
155 return (token=="highp" || token=="mediump" || token=="lowp");
158 bool Parser::is_qualifier(const string &token)
160 return (token=="const" ||
161 is_interface_qualifier(token) ||
162 is_sampling_qualifier(token) ||
163 is_interpolation_qualifier(token) ||
164 is_precision_qualifier(token));
167 bool Parser::is_builtin_type(const string &token)
169 static Regex re("^(void|float|int|bool|[ib]?vec[234]|mat[234](x[234])?|sampler((1D|2D|Cube)(Array)?(Shadow)?|3D))$");
170 return re.match(token);
173 bool Parser::is_type(const string &token)
175 return is_builtin_type(token) || declared_types.count(token);
178 bool Parser::is_identifier(const string &token)
180 static Regex re("^[a-zA-Z_][a-zA-Z0-9_]*$");
181 return re.match(token);
184 RefPtr<Statement> Parser::parse_global_declaration()
186 allow_stage_change = true;
187 string token = tokenizer.peek_token();
188 allow_stage_change = false;
191 return parse_import();
192 else if(token=="precision")
193 return parse_precision();
194 else if(token=="layout")
196 RefPtr<Layout> layout = parse_layout();
197 token = tokenizer.peek_token();
198 if(is_interface_qualifier(token) && tokenizer.peek_token(1)==";")
200 RefPtr<InterfaceLayout> iface_lo = new InterfaceLayout;
201 iface_lo->source = source_index;
202 iface_lo->line = tokenizer.get_location().line;
203 iface_lo->layout.qualifiers = layout->qualifiers;
204 iface_lo->interface = tokenizer.parse_token();
205 tokenizer.expect(";");
210 RefPtr<VariableDeclaration> var = parse_variable_declaration();
211 var->layout = layout;
215 else if(token=="struct")
216 return parse_struct_declaration();
217 else if(is_interface_qualifier(token))
219 string next = tokenizer.peek_token(1);
220 if(is_type(next) || is_qualifier(next))
221 return parse_variable_declaration();
223 return parse_interface_block();
225 else if(is_qualifier(token))
226 return parse_variable_declaration();
227 else if(is_type(token))
229 if(tokenizer.peek_token(2)=="(")
230 return parse_function_declaration();
232 return parse_variable_declaration();
234 else if(token.empty())
237 throw parse_error(tokenizer.get_location(), token, "a global declaration");
240 RefPtr<Statement> Parser::parse_statement()
242 string token = tokenizer.peek_token();
244 return parse_conditional();
245 else if(token=="for")
247 else if(token=="while")
248 return parse_while();
249 else if(token=="passthrough")
250 return parse_passthrough();
251 else if(token=="return")
252 return parse_return();
253 else if(token=="break" || token=="continue" || token=="discard")
255 RefPtr<Jump> jump = new Jump;
256 jump->source = source_index;
257 jump->line = tokenizer.get_location().line;
258 jump->keyword = tokenizer.parse_token();
259 tokenizer.expect(";");
263 else if(is_qualifier(token) || is_type(token))
264 return parse_variable_declaration();
265 else if(!token.empty())
267 RefPtr<ExpressionStatement> expr = new ExpressionStatement;
268 expr->source = source_index;
269 expr->line = tokenizer.get_location().line;
270 expr->expression = parse_expression();
271 tokenizer.expect(";");
276 throw parse_error(tokenizer.get_location(), token, "a statement");
279 RefPtr<Import> Parser::parse_import()
281 if(cur_stage->type!=Stage::SHARED)
282 throw invalid_shader_source(tokenizer.get_location(), "Imports are only allowed in the shared section");
284 tokenizer.expect("import");
285 RefPtr<Import> import = new Import;
286 import->source = source_index;
287 import->line = tokenizer.get_location().line;
288 import->module = expect_identifier();
289 tokenizer.expect(";");
293 RefPtr<Precision> Parser::parse_precision()
295 tokenizer.expect("precision");
296 RefPtr<Precision> precision = new Precision;
297 precision->source = source_index;
298 precision->line = tokenizer.get_location().line;
300 precision->precision = tokenizer.parse_token();
301 if(!is_precision_qualifier(precision->precision))
302 throw parse_error(tokenizer.get_location(), precision->precision, "a precision qualifier");
304 precision->type = tokenizer.parse_token();
305 // Not entirely accurate; only float, int and sampler types are allowed
306 if(!is_builtin_type(precision->type))
307 throw parse_error(tokenizer.get_location(), precision->type, "a builtin type");
309 tokenizer.expect(";");
314 RefPtr<Layout> Parser::parse_layout()
316 tokenizer.expect("layout");
317 tokenizer.expect("(");
318 RefPtr<Layout> layout = new Layout;
321 string token = tokenizer.parse_token();
323 throw parse_error(tokenizer.get_location(), token, "a layout qualifier name");
325 layout->qualifiers.push_back(Layout::Qualifier());
326 Layout::Qualifier &qual = layout->qualifiers.back();
329 if((qual.has_value = check("=")))
331 if(qual.name=="constant_id" && tokenizer.peek_token()=="auto")
334 tokenizer.parse_token();
337 qual.value = expect_integer();
340 if(tokenizer.peek_token()==")")
343 tokenizer.expect(",");
345 tokenizer.expect(")");
351 void Parser::parse_block(Block &block, bool require_braces, RefPtr<T> (Parser::*parse_content)())
353 bool have_braces = (require_braces || tokenizer.peek_token()=="{");
355 tokenizer.expect("{");
359 while(tokenizer.peek_token()!="}")
360 block.body.push_back((this->*parse_content)());
363 block.body.push_back((this->*parse_content)());
365 block.use_braces = (require_braces || block.body.size()!=1);
368 tokenizer.expect("}");
371 RefPtr<Expression> Parser::parse_expression(unsigned precedence)
373 RefPtr<Expression> left;
374 VariableReference *left_var = 0;
377 string token = tokenizer.peek_token();
379 const Operator *oper = 0;
380 for(const Operator *i=Operator::operators; (!oper && i->type); ++i)
381 if(token==i->token && (!left || i->type!=Operator::PREFIX) && (left || i->type!=Operator::POSTFIX))
384 if(token==";" || token==")" || token=="]" || token=="," || (oper && precedence && oper->precedence>=precedence))
389 throw parse_error(tokenizer.get_location(), token, "an expression");
396 throw invalid_shader_source(tokenizer.get_location(), "Syntax error before '(': function name must be an identifier");
397 left = parse_function_call(*left_var);
401 RefPtr<MemberAccess> memacc = new MemberAccess;
403 tokenizer.parse_token();
404 memacc->member = expect_identifier();
407 else if(oper && oper->type==Operator::POSTFIX)
409 RefPtr<UnaryExpression> unary = new UnaryExpression;
410 unary->oper = tokenizer.parse_token();
411 unary->prefix = false;
412 unary->expression = left;
415 else if(oper && oper->type==Operator::BINARY)
416 left = parse_binary(left, oper);
418 throw parse_error(tokenizer.get_location(), token, "an operator");
425 tokenizer.parse_token();
426 RefPtr<ParenthesizedExpression> parexpr = new ParenthesizedExpression;
427 parexpr->expression = parse_expression();
428 tokenizer.expect(")");
431 else if(isdigit(token[0]) || token=="true" || token=="false")
433 RefPtr<Literal> literal = new Literal;
434 literal->token = tokenizer.parse_token();
437 else if(is_identifier(token))
439 RefPtr<VariableReference> var = new VariableReference;
440 var->name = expect_identifier();
442 left_var = var.get();
444 else if(oper && oper->type==Operator::PREFIX)
446 RefPtr<UnaryExpression> unary = new UnaryExpression;
447 unary->oper = tokenizer.parse_token();
448 unary->prefix = true;
449 unary->expression = parse_expression(oper->precedence);
453 throw parse_error(tokenizer.get_location(), token, "an expression");
458 RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator *oper)
460 RefPtr<BinaryExpression> binary = (oper->precedence==16 ? new Assignment : new BinaryExpression);
462 binary->oper = tokenizer.parse_token();
463 if(binary->oper=="[")
465 binary->right = parse_expression();
466 tokenizer.expect("]");
470 binary->right = parse_expression(oper->precedence+(oper->assoc==Operator::RIGHT_TO_LEFT));
474 RefPtr<FunctionCall> Parser::parse_function_call(const VariableReference &var)
476 RefPtr<FunctionCall> call = new FunctionCall;
477 call->name = var.name;
478 call->constructor = is_type(call->name);
479 tokenizer.expect("(");
480 while(tokenizer.peek_token()!=")")
482 if(!call->arguments.empty())
483 tokenizer.expect(",");
484 call->arguments.push_back(parse_expression());
486 tokenizer.expect(")");
490 RefPtr<StructDeclaration> Parser::parse_struct_declaration()
492 tokenizer.expect("struct");
493 RefPtr<StructDeclaration> strct = new StructDeclaration;
494 strct->source = source_index;
495 strct->line = tokenizer.get_location().line;
497 strct->name = expect_identifier();
498 parse_block(strct->members, true, &Parser::parse_variable_declaration);
499 tokenizer.expect(";");
501 declared_types.insert(strct->name);
505 RefPtr<VariableDeclaration> Parser::parse_variable_declaration()
507 RefPtr<VariableDeclaration> var = new VariableDeclaration;
508 var->source = source_index;
509 var->line = tokenizer.get_location().line;
511 string token = tokenizer.peek_token();
512 while(is_qualifier(token))
514 tokenizer.parse_token();
515 if(is_interface_qualifier(token))
516 var->interface = token;
517 else if(is_sampling_qualifier(token))
518 var->sampling = token;
519 else if(is_interpolation_qualifier(token))
520 var->interpolation = token;
521 else if(is_precision_qualifier(token))
522 var->precision = token;
523 else if(token=="const")
524 var->constant = true;
525 token = tokenizer.peek_token();
528 var->type = expect_type();
529 var->name = expect_identifier();
536 var->array_size = parse_expression();
537 tokenizer.expect("]");
542 var->init_expression = parse_expression();
544 tokenizer.expect(";");
548 RefPtr<VariableDeclaration> Parser::parse_variable_declaration_with_layout()
550 RefPtr<Layout> layout;
551 if(tokenizer.peek_token()=="layout")
552 layout = parse_layout();
554 RefPtr<VariableDeclaration> var = parse_variable_declaration();
555 var->layout = layout;
560 RefPtr<FunctionDeclaration> Parser::parse_function_declaration()
562 RefPtr<FunctionDeclaration> func = new FunctionDeclaration;
563 func->source = source_index;
564 func->line = tokenizer.get_location().line;
566 func->return_type = expect_type();
567 func->name = expect_identifier();
568 tokenizer.expect("(");
569 while(tokenizer.peek_token()!=")")
571 if(!func->parameters.empty())
572 tokenizer.expect(",");
574 RefPtr<VariableDeclaration> var = new VariableDeclaration;
575 string token = tokenizer.peek_token();
576 if(token=="in" || token=="out" || token=="inout")
577 var->interface = tokenizer.parse_token();
578 var->type = expect_type();
579 var->name = expect_identifier();
580 func->parameters.push_back(var);
582 tokenizer.expect(")");
584 string token = tokenizer.peek_token();
587 func->definition = func.get();
588 parse_block(func->body, true, &Parser::parse_statement);
591 tokenizer.parse_token();
593 throw parse_error(tokenizer.get_location(), token, "'{' or ';'");
598 RefPtr<InterfaceBlock> Parser::parse_interface_block()
600 RefPtr<InterfaceBlock> iface = new InterfaceBlock;
601 iface->source = source_index;
602 iface->line = tokenizer.get_location().line;
604 iface->interface = tokenizer.parse_token();
605 if(!is_interface_qualifier(iface->interface))
606 throw parse_error(tokenizer.get_location(), iface->interface, "an interface qualifier");
608 iface->name = expect_identifier();
609 parse_block(iface->members, true, &Parser::parse_variable_declaration_with_layout);
612 iface->instance_name = expect_identifier();
616 tokenizer.expect("]");
618 tokenizer.expect(";");
624 RefPtr<Conditional> Parser::parse_conditional()
626 tokenizer.expect("if");
627 RefPtr<Conditional> cond = new Conditional;
628 cond->source = source_index;
629 cond->line = tokenizer.get_location().line;
630 tokenizer.expect("(");
631 cond->condition = parse_expression();
632 tokenizer.expect(")");
634 parse_block(cond->body, false, &Parser::parse_statement);
636 string token = tokenizer.peek_token();
639 tokenizer.parse_token();
640 parse_block(cond->else_body, false, &Parser::parse_statement);
646 RefPtr<Iteration> Parser::parse_for()
648 tokenizer.expect("for");
649 RefPtr<Iteration> loop = new Iteration;
650 loop->source = source_index;
651 loop->line = tokenizer.get_location().line;
652 tokenizer.expect("(");
653 string token = tokenizer.peek_token();
655 loop->init_statement = parse_statement();
660 RefPtr<ExpressionStatement> expr = new ExpressionStatement;
661 expr->expression = parse_expression();
662 loop->init_statement = expr;
664 tokenizer.expect(";");
666 if(tokenizer.peek_token()!=";")
667 loop->condition = parse_expression();
668 tokenizer.expect(";");
669 if(tokenizer.peek_token()!=")")
670 loop->loop_expression = parse_expression();
671 tokenizer.expect(")");
673 parse_block(loop->body, false, &Parser::parse_statement);
678 RefPtr<Iteration> Parser::parse_while()
680 tokenizer.expect("while");
681 RefPtr<Iteration> loop = new Iteration;
682 loop->source = source_index;
683 loop->line = tokenizer.get_location().line;
684 tokenizer.expect("(");
685 loop->condition = parse_expression();
686 tokenizer.expect(")");
688 parse_block(loop->body, false, &Parser::parse_statement);
693 RefPtr<Passthrough> Parser::parse_passthrough()
695 tokenizer.expect("passthrough");
696 RefPtr<Passthrough> pass = new Passthrough;
697 pass->source = source_index;
698 pass->line = tokenizer.get_location().line;
699 if(cur_stage->type==Stage::GEOMETRY)
701 tokenizer.expect("[");
702 pass->subscript = parse_expression();
703 tokenizer.expect("]");
705 tokenizer.expect(";");
709 RefPtr<Return> Parser::parse_return()
711 tokenizer.expect("return");
712 RefPtr<Return> ret = new Return;
713 ret->source = source_index;
714 ret->line = tokenizer.get_location().line;
715 if(tokenizer.peek_token()!=";")
716 ret->expression = parse_expression();
717 tokenizer.expect(";");