source/glsl/parser.cpp

   1 #include <msp/core/raii.h>
   2 #include <msp/strings/format.h>
   3 #include <msp/strings/regex.h>
   4 #include <msp/strings/utils.h>
   5 #include "builtin.h"
   6 #include "glsl_error.h"
   7 #include "parser.h"
   8
   9 #undef interface
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GL {
  15 namespace SL {
  16
  17 Parser::Parser():
  18         preprocessor(tokenizer),
  19         module(0)
  20 {
  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));
  26 }
  27
  28 Parser::~Parser()
  29 {
  30         delete module;
  31 }
  32
  33 Module &Parser::parse(const string &s, const string &n, int i)
  34 {
  35         source = s;
  36         parse_source(n, i);
  37         return *module;
  38 }
  39
  40 Module &Parser::parse(IO::Base &io, const string &n, int i)
  41 {
  42         source = string();
  43         while(!io.eof())
  44         {
  45                 char buffer[4096];
  46                 unsigned len = io.read(buffer, sizeof(buffer));
  47                 source.append(buffer, len);
  48         }
  49         parse_source(n, i);
  50         return *module;
  51 }
  52
  53 void Parser::parse_source(const string &name, int index)
  54 {
  55         delete module;
  56         module = new Module;
  57
  58         cur_stage = &module->shared;
  59         base_index = index;
  60         source_index = index;
  61         if(index>=0)
  62                 source_reference(1, name);
  63
  64         // TODO Need to somehow get type names from imports
  65         if(const Stage *builtin = get_builtins(Stage::SHARED))
  66         {
  67                 for(map<string, TypeDeclaration *>::const_iterator i=builtin->types.begin(); i!=builtin->types.end(); ++i)
  68                         declared_types.insert(i->first);
  69         }
  70         else
  71         {
  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");
  77         }
  78
  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);
  84
  85         if(!errors.empty())
  86                 throw invalid_shader_source(join(errors.begin(), errors.end(), "\n"));
  87 }
  88
  89 void Parser::set_required_version(const Version &ver)
  90 {
  91         cur_stage->required_features.glsl_version = ver;
  92 }
  93
  94 void Parser::source_reference(unsigned index, const string &name)
  95 {
  96         if(index<1 || base_index<0)
  97                 throw invalid_shader_source(tokenizer.get_location(), "Invalid source reference");
  98
  99         module->source_map.set_name(base_index+index-1, name);
 100 }
 101
 102 void Parser::stage_change(Stage::Type stage)
 103 {
 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));
 108
 109         module->stages.push_back(stage);
 110
 111         if(cur_stage->type!=Stage::SHARED)
 112                 module->stages.back().previous = cur_stage;
 113         cur_stage = &module->stages.back();
 114 }
 115
 116 void Parser::line_change(int index, unsigned line)
 117 {
 118         if(index>0)
 119                 source_index = base_index+index-1;
 120         else if(index==0)
 121                 source_index = 0;
 122         else
 123                 index = source_index;
 124
 125         string name = module->source_map.get_name(index);
 126         if(name.empty())
 127                 name = format("<%d>", index);
 128         tokenizer.set_location(Location(name, line));
 129 }
 130
 131 string Parser::expect_type()
 132 {
 133         string token = tokenizer.parse_token();
 134         if(!is_type(token))
 135                 throw parse_error(tokenizer.get_location(), token, "a type");
 136         return token;
 137 }
 138
 139 string Parser::expect_identifier()
 140 {
 141         string token = tokenizer.parse_token();
 142         if(!is_identifier(token))
 143                 throw parse_error(tokenizer.get_location(), token, "an identifier");
 144         return token;
 145 }
 146
 147 int Parser::expect_integer()
 148 {
 149         string token = tokenizer.parse_token();
 150         if(!isnumrc(token))
 151                 throw parse_error(tokenizer.get_location(), token, "an integer literal");
 152         return lexical_cast<int>(token);
 153 }
 154
 155 bool Parser::check(const string &token)
 156 {
 157         bool result = (tokenizer.peek_token()==token);
 158         if(result)
 159                 tokenizer.parse_token();
 160         return result;
 161 }
 162
 163 bool Parser::is_interface_qualifier(const string &token)
 164 {
 165         return (token=="uniform" || token=="in" || token=="out");
 166 }
 167
 168 bool Parser::is_sampling_qualifier(const string &token)
 169 {
 170         return (token=="centroid" || token=="sample");
 171 }
 172
 173 bool Parser::is_interpolation_qualifier(const string &token)
 174 {
 175         return (token=="smooth" || token=="flat" || token=="noperspective");
 176 }
 177
 178 bool Parser::is_precision_qualifier(const string &token)
 179 {
 180         return (token=="highp" || token=="mediump" || token=="lowp");
 181 }
 182
 183 bool Parser::is_qualifier(const string &token)
 184 {
 185         return (token=="const" ||
 186                 is_interface_qualifier(token) ||
 187                 is_sampling_qualifier(token) ||
 188                 is_interpolation_qualifier(token) ||
 189                 is_precision_qualifier(token));
 190 }
 191
 192 bool Parser::is_type(const string &token)
 193 {
 194         return declared_types.count(token);
 195 }
 196
 197 bool Parser::is_identifier(const string &token)
 198 {
 199         static Regex re("^[a-zA-Z_][a-zA-Z0-9_]*$");
 200         return re.match(token);
 201 }
 202
 203 template<typename T>
 204 RefPtr<T> Parser::create_node()
 205 {
 206         RefPtr<T> node = new T;
 207         node->source = source_index;
 208         node->line = tokenizer.get_location().line;
 209         return node;
 210 }
 211
 212 template<typename T>
 213 RefPtr<T> Parser::parse_with_recovery(RefPtr<T> (Parser::*parse_func)())
 214 {
 215         tokenizer.clear_progress_mark();
 216         try
 217         {
 218                 return (this->*parse_func)();
 219         }
 220         catch(const invalid_shader_source &exc)
 221         {
 222                 errors.push_back(exc.what());
 223         }
 224
 225         if(tokenizer.get_last_token()!=";" || !tokenizer.get_progress_mark())
 226         {
 227                 unsigned scope_level = 0;
 228                 while(1)
 229                 {
 230                         if(tokenizer.peek_token()=="}" && scope_level==0)
 231                         {
 232                                 if(!tokenizer.get_progress_mark())
 233                                         tokenizer.parse_token();
 234                                 break;
 235                         }
 236
 237                         string token = tokenizer.parse_token();
 238                         if(token=="}")
 239                         {
 240                                 --scope_level;
 241                                 if(scope_level==0)
 242                                         break;
 243                         }
 244                         else if(token=="{")
 245                                 ++scope_level;
 246                         else if(token==";" && scope_level==0)
 247                                 break;
 248                         else if(token.empty())
 249                                 break;
 250                 }
 251         }
 252
 253         return RefPtr<T>();
 254 }
 255
 256 RefPtr<Statement> Parser::parse_global_declaration()
 257 {
 258         string token = tokenizer.peek_token();
 259         SetFlag disallow(allow_stage_change, false);
 260
 261         if(token=="import")
 262                 return parse_import();
 263         else if(token=="precision")
 264                 return parse_precision();
 265         else if(token=="layout")
 266         {
 267                 RefPtr<Layout> layout = parse_layout();
 268                 token = tokenizer.peek_token();
 269                 if(is_interface_qualifier(token) && tokenizer.peek_token(1)==";")
 270                 {
 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(";");
 277                         return iface_lo;
 278                 }
 279                 else if(is_interface_qualifier(token) && tokenizer.peek_token(2)=="{")
 280                 {
 281                         RefPtr<InterfaceBlock> iface = parse_interface_block();
 282                         iface->layout = layout;
 283                         return iface;
 284                 }
 285                 else
 286                 {
 287                         RefPtr<VariableDeclaration> var = parse_variable_declaration();
 288                         var->layout = layout;
 289                         return var;
 290                 }
 291         }
 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))
 297         {
 298                 string next = tokenizer.peek_token(1);
 299                 if(is_type(next) || is_qualifier(next))
 300                         return parse_variable_declaration();
 301                 else
 302                         return parse_interface_block();
 303         }
 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))
 309         {
 310                 if(tokenizer.peek_token(2)=="(")
 311                         return parse_function_declaration();
 312                 else
 313                         return parse_variable_declaration();
 314         }
 315         else if(token.empty())
 316                 return 0;
 317         else
 318                 throw parse_error(tokenizer.get_location(), token, "a global declaration");
 319 }
 320
 321 RefPtr<Statement> Parser::parse_statement()
 322 {
 323         string token = tokenizer.peek_token();
 324         if(token=="if")
 325                 return parse_conditional();
 326         else if(token=="for")
 327                 return parse_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")
 335         {
 336                 RefPtr<Jump> jump = create_node<Jump>();
 337                 jump->keyword = tokenizer.parse_token();
 338                 tokenizer.expect(";");
 339
 340                 return jump;
 341         }
 342         else if(is_qualifier(token) || is_type(token))
 343                 return parse_variable_declaration();
 344         else if(token==";")
 345         {
 346                 tokenizer.parse_token();
 347                 throw invalid_shader_source(tokenizer.get_location(), "Empty statement not allowed");
 348         }
 349         else if(!token.empty())
 350         {
 351                 RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
 352                 expr->expression = parse_expression();
 353                 tokenizer.expect(";");
 354
 355                 return expr;
 356         }
 357         else
 358                 throw parse_error(tokenizer.get_location(), token, "a statement");
 359 }
 360
 361 RefPtr<Import> Parser::parse_import()
 362 {
 363         if(cur_stage->type!=Stage::SHARED)
 364                 throw invalid_shader_source(tokenizer.get_location(), "Imports are only allowed in the shared section");
 365
 366         tokenizer.expect("import");
 367         RefPtr<Import> import = create_node<Import>();
 368         import->module = expect_identifier();
 369         tokenizer.expect(";");
 370         return import;
 371 }
 372
 373 RefPtr<Precision> Parser::parse_precision()
 374 {
 375         tokenizer.expect("precision");
 376         RefPtr<Precision> precision = create_node<Precision>();
 377
 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");
 381
 382         // TODO Add validation for this
 383         precision->type = expect_type();
 384
 385         tokenizer.expect(";");
 386
 387         return precision;
 388 }
 389
 390 RefPtr<Layout> Parser::parse_layout()
 391 {
 392         tokenizer.expect("layout");
 393         tokenizer.expect("(");
 394         RefPtr<Layout> layout = create_node<Layout>();
 395         while(1)
 396         {
 397                 string token = tokenizer.parse_token();
 398                 if(token==")")
 399                         throw parse_error(tokenizer.get_location(), token, "a layout qualifier name");
 400
 401                 layout->qualifiers.push_back(token);
 402                 Layout::Qualifier &qual = layout->qualifiers.back();
 403
 404                 if((qual.has_value = check("=")))
 405                 {
 406                         if(qual.name=="constant_id" && tokenizer.peek_token()=="auto")
 407                         {
 408                                 qual.value = -1;
 409                                 tokenizer.parse_token();
 410                         }
 411                         else
 412                                 qual.value = expect_integer();
 413                 }
 414
 415                 if(tokenizer.peek_token()==")")
 416                         break;
 417
 418                 tokenizer.expect(",");
 419         }
 420         tokenizer.expect(")");
 421
 422         return layout;
 423 }
 424
 425 template<typename T>
 426 void Parser::parse_block(Block &block, bool require_braces, RefPtr<T> (Parser::*parse_content)())
 427 {
 428         bool have_braces = (require_braces || tokenizer.peek_token()=="{");
 429         if(have_braces)
 430                 tokenizer.expect("{");
 431
 432         if(have_braces)
 433         {
 434                 while(tokenizer.peek_token()!="}")
 435                         if(RefPtr<Statement> node = parse_with_recovery(parse_content))
 436                                 block.body.push_back(node);
 437         }
 438         else
 439                 block.body.push_back((this->*parse_content)());
 440
 441         block.use_braces = (require_braces || block.body.size()!=1);
 442
 443         if(have_braces)
 444                 tokenizer.expect("}");
 445 }
 446
 447 RefPtr<Expression> Parser::parse_expression(const Operator *outer_oper)
 448 {
 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;
 452         while(1)
 453         {
 454                 string token = tokenizer.peek_token();
 455
 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))
 459                                 oper = i;
 460
 461                 bool lower_precedence = (oper && oper->type!=Operator::PREFIX && oper->precedence>=outer_precedence);
 462                 if(token==";" || token==")" || token=="]" || token=="," || token==":" || lower_precedence)
 463                 {
 464                         if(left)
 465                                 return left;
 466                         else
 467                                 throw parse_error(tokenizer.get_location(), token, "an expression");
 468                 }
 469                 else if(left)
 470                 {
 471                         if(token=="(")
 472                         {
 473                                 if(!left_var)
 474                                         throw invalid_shader_source(tokenizer.get_location(), "Syntax error before '(': function name must be an identifier");
 475                                 left = parse_function_call(*left_var);
 476                         }
 477                         else if(token==".")
 478                         {
 479                                 RefPtr<MemberAccess> memacc = create_node<MemberAccess>();
 480                                 memacc->left = left;
 481                                 memacc->oper = oper;
 482                                 tokenizer.parse_token();
 483                                 memacc->member = expect_identifier();
 484                                 left = memacc;
 485                         }
 486                         else if(oper && oper->type==Operator::POSTFIX)
 487                         {
 488                                 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
 489                                 unary->oper = oper;
 490                                 tokenizer.parse_token();
 491                                 unary->expression = left;
 492                                 left = unary;
 493                         }
 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);
 498                         else
 499                                 throw parse_error(tokenizer.get_location(), token, "an operator");
 500                         left_var = 0;
 501                 }
 502                 else
 503                 {
 504                         if(token=="(")
 505                         {
 506                                 tokenizer.parse_token();
 507                                 left = parse_expression();
 508                                 tokenizer.expect(")");
 509                         }
 510                         else if(isdigit(token[0]) || token=="true" || token=="false")
 511                                 left = parse_literal();
 512                         else if(is_identifier(token))
 513                         {
 514                                 RefPtr<VariableReference> var = create_node<VariableReference>();
 515                                 var->name = expect_identifier();
 516                                 left = var;
 517                                 left_var = var.get();
 518                         }
 519                         else if(oper && oper->type==Operator::PREFIX)
 520                         {
 521                                 RefPtr<UnaryExpression> unary = create_node<UnaryExpression>();
 522                                 unary->oper = oper;
 523                                 tokenizer.parse_token();
 524                                 unary->expression = parse_expression(oper);
 525                                 left = unary;
 526                         }
 527                         else
 528                                 throw parse_error(tokenizer.get_location(), token, "an expression");
 529                 }
 530         }
 531 }
 532
 533 RefPtr<Literal> Parser::parse_literal()
 534 {
 535         RefPtr<Literal> literal = create_node<Literal>();
 536         literal->token = tokenizer.parse_token();
 537         if(isdigit(literal->token[0]))
 538         {
 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);
 546                 else
 547                         literal->value = lexical_cast<int>(literal->token);
 548         }
 549         else if(literal->token=="true" || literal->token=="false")
 550                 literal->value = (literal->token=="true");
 551         else
 552                 throw parse_error(tokenizer.get_location(), literal->token, "a literal");
 553
 554         return literal;
 555 }
 556
 557 RefPtr<BinaryExpression> Parser::parse_binary(const RefPtr<Expression> &left, const Operator &oper)
 558 {
 559         RefPtr<BinaryExpression> binary = (oper.precedence==16 ?
 560                 static_cast<RefPtr<BinaryExpression> >(create_node<Assignment>()) : create_node<BinaryExpression>());
 561         binary->left = left;
 562         binary->oper = &oper;
 563         tokenizer.expect(oper.token);
 564         if(oper.token2[0])
 565         {
 566                 binary->right = parse_expression();
 567                 tokenizer.expect(oper.token2);
 568         }
 569         else
 570                 binary->right = parse_expression(&oper);
 571         return binary;
 572 }
 573
 574 RefPtr<TernaryExpression> Parser::parse_ternary(const RefPtr<Expression> &cond, const Operator &oper)
 575 {
 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);
 583         return ternary;
 584 }
 585
 586 RefPtr<FunctionCall> Parser::parse_function_call(const VariableReference &var)
 587 {
 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()!=")")
 593         {
 594                 if(!call->arguments.empty())
 595                         tokenizer.expect(",");
 596                 call->arguments.push_back(parse_expression());
 597         }
 598         tokenizer.expect(")");
 599         return call;
 600 }
 601
 602 RefPtr<TypeDeclaration> Parser::parse_type_declaration()
 603 {
 604         tokenizer.expect("typedef");
 605
 606         RefPtr<TypeDeclaration> type;
 607         if(tokenizer.peek_token()=="image")
 608                 type = parse_image_type_declaration();
 609         else
 610                 type = parse_basic_type_declaration();
 611
 612         tokenizer.expect(";");
 613         declared_types.insert(type->name);
 614         return type;
 615 }
 616
 617 RefPtr<BasicTypeDeclaration> Parser::parse_basic_type_declaration()
 618 {
 619         RefPtr<BasicTypeDeclaration> type = create_node<BasicTypeDeclaration>();
 620
 621         if(tokenizer.peek_token()=="vector")
 622         {
 623                 type->kind = BasicTypeDeclaration::VECTOR;
 624
 625                 tokenizer.parse_token();
 626                 tokenizer.expect("(");
 627                 type->size = expect_integer();
 628                 tokenizer.expect(")");
 629         }
 630
 631         type->base = expect_type();
 632         type->name = expect_identifier();
 633
 634         if(type->kind==BasicTypeDeclaration::ALIAS && check("["))
 635         {
 636                 type->kind = BasicTypeDeclaration::ARRAY;
 637                 tokenizer.expect("]");
 638         }
 639
 640         return type;
 641 }
 642
 643 RefPtr<ImageTypeDeclaration> Parser::parse_image_type_declaration()
 644 {
 645         tokenizer.expect("image");
 646         tokenizer.expect("(");
 647
 648         RefPtr<ImageTypeDeclaration> type = create_node<ImageTypeDeclaration>();
 649         while(1)
 650         {
 651                 string token = tokenizer.parse_token();
 652                 if(token=="dimensions")
 653                 {
 654                         tokenizer.expect("=");
 655                         token = tokenizer.parse_token();
 656                         if(token=="1")
 657                                 type->dimensions = ImageTypeDeclaration::ONE;
 658                         else if(token=="2")
 659                                 type->dimensions = ImageTypeDeclaration::TWO;
 660                         else if(token=="3")
 661                                 type->dimensions = ImageTypeDeclaration::THREE;
 662                         else if(token=="cube")
 663                                 type->dimensions = ImageTypeDeclaration::CUBE;
 664                         else
 665                                 throw parse_error(tokenizer.get_location(), token, "dimensions");
 666
 667                         if(check("["))
 668                         {
 669                                 type->array = true;
 670                                 tokenizer.expect("]");
 671                         }
 672                 }
 673                 else if(token=="sampled")
 674                         type->sampled = true;
 675                 else if(token=="shadow")
 676                         type->shadow = true;
 677                 else
 678                         throw parse_error(tokenizer.get_location(), token, "image type attribute");
 679
 680                 token = tokenizer.peek_token();
 681                 if(token==")")
 682                         break;
 683
 684                 tokenizer.expect(",");
 685         }
 686         tokenizer.expect(")");
 687
 688         type->base = expect_type();
 689         type->name = expect_identifier();
 690
 691         return type;
 692 }
 693
 694 RefPtr<StructDeclaration> Parser::parse_struct_declaration()
 695 {
 696         tokenizer.expect("struct");
 697         RefPtr<StructDeclaration> strct = create_node<StructDeclaration>();
 698
 699         strct->name = expect_identifier();
 700         parse_block(strct->members, true, &Parser::parse_variable_declaration);
 701         tokenizer.expect(";");
 702
 703         declared_types.insert(strct->name);
 704         return strct;
 705 }
 706
 707 RefPtr<VariableDeclaration> Parser::parse_variable_declaration()
 708 {
 709         RefPtr<VariableDeclaration> var = create_node<VariableDeclaration>();
 710
 711         string token = tokenizer.peek_token();
 712         while(is_qualifier(token))
 713         {
 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();
 726         }
 727
 728         var->type = expect_type();
 729         var->name = expect_identifier();
 730
 731         if(check("["))
 732         {
 733                 var->array = true;
 734                 if(!check("]"))
 735                 {
 736                         var->array_size = parse_expression();
 737                         tokenizer.expect("]");
 738                 }
 739         }
 740
 741         if(check("="))
 742                 var->init_expression = parse_expression();
 743
 744         tokenizer.expect(";");
 745         return var;
 746 }
 747
 748 RefPtr<VariableDeclaration> Parser::parse_variable_declaration_with_layout()
 749 {
 750         RefPtr<Layout> layout;
 751         if(tokenizer.peek_token()=="layout")
 752                 layout = parse_layout();
 753
 754         RefPtr<VariableDeclaration> var = parse_variable_declaration();
 755         var->layout = layout;
 756
 757         return var;
 758 }
 759
 760 RefPtr<FunctionDeclaration> Parser::parse_function_declaration()
 761 {
 762         RefPtr<FunctionDeclaration> func = create_node<FunctionDeclaration>();
 763
 764         func->virtua = check("virtual");
 765         func->return_type = expect_type();
 766         func->name = expect_identifier();
 767         tokenizer.expect("(");
 768         while(tokenizer.peek_token()!=")")
 769         {
 770                 if(!func->parameters.empty())
 771                         tokenizer.expect(",");
 772
 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);
 780         }
 781         tokenizer.expect(")");
 782
 783         func->overrd = check("override");
 784
 785         string token = tokenizer.peek_token();
 786         if(token=="{")
 787         {
 788                 func->definition = func.get();
 789                 parse_block(func->body, true, &Parser::parse_statement);
 790         }
 791         else if(token==";")
 792                 tokenizer.parse_token();
 793         else
 794                 throw parse_error(tokenizer.get_location(), token, "'{' or ';'");
 795
 796         return func;
 797 }
 798
 799 RefPtr<InterfaceBlock> Parser::parse_interface_block()
 800 {
 801         RefPtr<InterfaceBlock> iface = create_node<InterfaceBlock>();
 802
 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");
 806
 807         iface->block_name = expect_identifier();
 808         iface->members = new Block;
 809         parse_block(*iface->members, true, &Parser::parse_variable_declaration_with_layout);
 810         if(!check(";"))
 811         {
 812                 iface->instance_name = expect_identifier();
 813                 if(check("["))
 814                 {
 815                         iface->array = true;
 816                         tokenizer.expect("]");
 817                 }
 818                 tokenizer.expect(";");
 819         }
 820
 821         return iface;
 822 }
 823
 824 RefPtr<Conditional> Parser::parse_conditional()
 825 {
 826         tokenizer.expect("if");
 827         RefPtr<Conditional> cond = create_node<Conditional>();
 828         tokenizer.expect("(");
 829         cond->condition = parse_expression();
 830         tokenizer.expect(")");
 831
 832         parse_block(cond->body, false, &Parser::parse_statement);
 833
 834         string token = tokenizer.peek_token();
 835         if(token=="else")
 836         {
 837                 tokenizer.parse_token();
 838                 parse_block(cond->else_body, false, &Parser::parse_statement);
 839         }
 840
 841         return cond;
 842 }
 843
 844 RefPtr<Iteration> Parser::parse_for()
 845 {
 846         tokenizer.expect("for");
 847         RefPtr<Iteration> loop = create_node<Iteration>();
 848         tokenizer.expect("(");
 849         string token = tokenizer.peek_token();
 850         if(is_type(token))
 851                 loop->init_statement = parse_statement();
 852         else
 853         {
 854                 if(token!=";")
 855                 {
 856                         RefPtr<ExpressionStatement> expr = create_node<ExpressionStatement>();
 857                         expr->expression = parse_expression();
 858                         loop->init_statement = expr;
 859                 }
 860                 tokenizer.expect(";");
 861         }
 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(")");
 868
 869         parse_block(loop->body, false, &Parser::parse_statement);
 870
 871         return loop;
 872 }
 873
 874 RefPtr<Iteration> Parser::parse_while()
 875 {
 876         tokenizer.expect("while");
 877         RefPtr<Iteration> loop = create_node<Iteration>();
 878         tokenizer.expect("(");
 879         loop->condition = parse_expression();
 880         tokenizer.expect(")");
 881
 882         parse_block(loop->body, false, &Parser::parse_statement);
 883
 884         return loop;
 885 }
 886
 887 RefPtr<Passthrough> Parser::parse_passthrough()
 888 {
 889         tokenizer.expect("passthrough");
 890         RefPtr<Passthrough> pass = create_node<Passthrough>();
 891         if(cur_stage->type==Stage::GEOMETRY)
 892         {
 893                 tokenizer.expect("[");
 894                 pass->subscript = parse_expression();
 895                 tokenizer.expect("]");
 896         }
 897         tokenizer.expect(";");
 898         return pass;
 899 }
 900
 901 RefPtr<Return> Parser::parse_return()
 902 {
 903         tokenizer.expect("return");
 904         RefPtr<Return> ret = create_node<Return>();
 905         if(tokenizer.peek_token()!=";")
 906                 ret->expression = parse_expression();
 907         tokenizer.expect(";");
 908         return ret;
 909 }
 910
 911 } // namespace SL
 912 } // namespace GL
 913 } // namespace Msp