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