source/glsl/parser.cpp

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