source/programcompiler.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/core/raii.h>
   3 #include <msp/gl/extensions/arb_explicit_attrib_location.h>
   4 #include <msp/gl/extensions/arb_gpu_shader5.h>
   5 #include <msp/gl/extensions/arb_uniform_buffer_object.h>
   6 #include <msp/gl/extensions/ext_gpu_shader4.h>
   7 #include <msp/strings/format.h>
   8 #include <msp/strings/utils.h>
   9 #include "error.h"
  10 #include "program.h"
  11 #include "programcompiler.h"
  12 #include "resources.h"
  13 #include "shader.h"
  14
  15 #undef interface
  16
  17 using namespace std;
  18
  19 namespace {
  20
  21 const char builtins_src[] =
  22         "#pragma MSP stage(vertex)\n"
  23         "out gl_PerVertex {\n"
  24         "  vec4 gl_Position;\n"
  25         "  float gl_ClipDistance[];\n"
  26         "};\n"
  27         "#pragma MSP stage(geometry)\n"
  28         "in gl_PerVertex {\n"
  29         "  vec4 gl_Position;\n"
  30         "  float gl_ClipDistance[];\n"
  31         "} gl_in[];\n"
  32         "out gl_PerVertex {\n"
  33         "  vec4 gl_Position;\n"
  34         "  float gl_ClipDistance[];\n"
  35         "};\n";
  36
  37 }
  38
  39 namespace Msp {
  40 namespace GL {
  41
  42 using namespace ProgramSyntax;
  43
  44 ProgramCompiler::ProgramCompiler():
  45         resources(0),
  46         module(0)
  47 { }
  48
  49 ProgramCompiler::~ProgramCompiler()
  50 {
  51         delete module;
  52 }
  53
  54 void ProgramCompiler::compile(const string &source, const string &src_name)
  55 {
  56         resources = 0;
  57         delete module;
  58         module = new Module();
  59         ProgramParser parser;
  60         imported_names.insert(src_name);
  61         append_module(parser.parse(source, src_name));
  62         process();
  63 }
  64
  65 void ProgramCompiler::compile(IO::Base &io, Resources *res, const string &src_name)
  66 {
  67         resources = res;
  68         delete module;
  69         module = new Module();
  70         ProgramParser parser;
  71         imported_names.insert(src_name);
  72         append_module(parser.parse(io, src_name));
  73         process();
  74 }
  75
  76 void ProgramCompiler::compile(IO::Base &io, const string &src_name)
  77 {
  78         compile(io, 0, src_name);
  79 }
  80
  81 void ProgramCompiler::add_shaders(Program &program)
  82 {
  83         if(!module)
  84                 throw invalid_operation("ProgramCompiler::add_shaders");
  85
  86         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
  87         {
  88                 if(i->type==VERTEX)
  89                 {
  90                         program.attach_shader_owned(new VertexShader(apply<Formatter>(*i)));
  91                         for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
  92                                 program.bind_attribute(j->second, j->first);
  93                 }
  94                 else if(i->type==GEOMETRY)
  95                         program.attach_shader_owned(new GeometryShader(apply<Formatter>(*i)));
  96                 else if(i->type==FRAGMENT)
  97                 {
  98                         program.attach_shader_owned(new FragmentShader(apply<Formatter>(*i)));
  99                         if(EXT_gpu_shader4)
 100                         {
 101                                 for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
 102                                         program.bind_fragment_data(j->second, j->first);
 103                         }
 104                 }
 105         }
 106 }
 107
 108 Module *ProgramCompiler::create_builtins_module()
 109 {
 110         ProgramParser parser;
 111         Module *module = new Module(parser.parse(builtins_src, "<builtin>"));
 112         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
 113         {
 114                 VariableResolver resolver;
 115                 i->content.visit(resolver);
 116                 for(map<string, VariableDeclaration *>::iterator j=i->content.variables.begin(); j!=i->content.variables.end(); ++j)
 117                         j->second->linked_declaration = j->second;
 118         }
 119         return module;
 120 }
 121
 122 Module &ProgramCompiler::get_builtins_module()
 123 {
 124         static RefPtr<Module> builtins_module = create_builtins_module();
 125         return *builtins_module;
 126 }
 127
 128 Stage *ProgramCompiler::get_builtins(StageType type)
 129 {
 130         Module &module = get_builtins_module();
 131         for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
 132                 if(i->type==type)
 133                         return &*i;
 134         return 0;
 135 }
 136
 137 void ProgramCompiler::append_module(ProgramSyntax::Module &mod)
 138 {
 139         vector<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
 140         for(vector<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
 141                 import((*i)->module);
 142         apply<NodeRemover>(mod.shared, set<Node *>(imports.begin(), imports.end()));
 143
 144         append_stage(mod.shared);
 145         for(list<Stage>::iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i)
 146                 append_stage(*i);
 147 }
 148
 149 void ProgramCompiler::append_stage(Stage &stage)
 150 {
 151         Stage *target = 0;
 152         if(stage.type==SHARED)
 153                 target = &module->shared;
 154         else
 155         {
 156                 list<Stage>::iterator i;
 157                 for(i=module->stages.begin(); (i!=module->stages.end() && i->type<stage.type); ++i) ;
 158                 if(i==module->stages.end() || i->type>stage.type)
 159                 {
 160                         list<Stage>::iterator j = module->stages.insert(i, stage.type);
 161                         if(i!=module->stages.end())
 162                                 i->previous = &*j;
 163                         i = j;
 164                         if(i!=module->stages.begin())
 165                                 i->previous = &*--j;
 166                 }
 167
 168                 target = &*i;
 169         }
 170
 171         for(NodeList<Statement>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
 172                 target->content.body.push_back(*i);
 173         apply<DeclarationCombiner>(*target);
 174 }
 175
 176 void ProgramCompiler::process()
 177 {
 178         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
 179                 generate(*i);
 180         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); )
 181         {
 182                 if(optimize(*i))
 183                         i = module->stages.begin();
 184                 else
 185                         ++i;
 186         }
 187         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
 188                 finalize(*i);
 189 }
 190
 191 void ProgramCompiler::import(const string &name)
 192 {
 193         string fn = name+".glsl";
 194         if(imported_names.count(fn))
 195                 return;
 196         imported_names.insert(fn);
 197
 198         RefPtr<IO::Seekable> io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn));
 199         if(!io)
 200                 throw runtime_error(format("module %s not found", name));
 201         ProgramParser import_parser;
 202         append_module(import_parser.parse(*io, fn));
 203 }
 204
 205 void ProgramCompiler::generate(Stage &stage)
 206 {
 207         inject_block(stage.content, module->shared.content);
 208
 209         apply<DeclarationReorderer>(stage);
 210         apply<FunctionResolver>(stage);
 211         apply<VariableResolver>(stage);
 212         apply<InterfaceGenerator>(stage);
 213         apply<VariableResolver>(stage);
 214         apply<DeclarationReorderer>(stage);
 215         apply<FunctionResolver>(stage);
 216         apply<LegacyConverter>(stage);
 217 }
 218
 219 bool ProgramCompiler::optimize(Stage &stage)
 220 {
 221         apply<ConstantConditionEliminator>(stage);
 222
 223         set<FunctionDeclaration *> inlineable = apply<InlineableFunctionLocator>(stage);
 224         apply<FunctionInliner>(stage, inlineable);
 225
 226         set<Node *> unused = apply<UnusedVariableLocator>(stage);
 227         set<Node *> unused2 = apply<UnusedFunctionLocator>(stage);
 228         unused.insert(unused2.begin(), unused2.end());
 229         apply<NodeRemover>(stage, unused);
 230
 231         return !unused.empty();
 232 }
 233
 234 void ProgramCompiler::finalize(Stage &stage)
 235 {
 236         if(get_gl_api()==OPENGL_ES2)
 237                 apply<DefaultPrecisionGenerator>(stage);
 238         else
 239                 apply<PrecisionRemover>(stage);
 240 }
 241
 242 void ProgramCompiler::inject_block(Block &target, const Block &source)
 243 {
 244         NodeList<Statement>::iterator insert_point = target.body.begin();
 245         for(NodeList<Statement>::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
 246                 target.body.insert(insert_point, (*i)->clone());
 247 }
 248
 249 template<typename T>
 250 typename T::ResultType ProgramCompiler::apply(Stage &stage)
 251 {
 252         T visitor;
 253         visitor.apply(stage);
 254         return visitor.get_result();
 255 }
 256
 257 template<typename T, typename A>
 258 typename T::ResultType ProgramCompiler::apply(Stage &stage, const A &arg)
 259 {
 260         T visitor(arg);
 261         visitor.apply(stage);
 262         return visitor.get_result();
 263 }
 264
 265
 266 ProgramCompiler::Visitor::Visitor():
 267         stage(0)
 268 { }
 269
 270 void ProgramCompiler::Visitor::apply(Stage &s)
 271 {
 272         SetForScope<Stage *> set(stage, &s);
 273         stage->content.visit(*this);
 274 }
 275
 276
 277 ProgramCompiler::BlockModifier::BlockModifier():
 278         remove_node(false)
 279 { }
 280
 281 void ProgramCompiler::BlockModifier::flatten_block(Block &block)
 282 {
 283         insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
 284         remove_node = true;
 285 }
 286
 287 void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, NodeList<Statement>::iterator &i)
 288 {
 289         block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
 290         insert_nodes.clear();
 291
 292         if(remove_node)
 293                 block.body.erase(i++);
 294         else
 295                 ++i;
 296         remove_node = false;
 297 }
 298
 299 void ProgramCompiler::BlockModifier::visit(Block &block)
 300 {
 301         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 302         {
 303                 (*i)->visit(*this);
 304                 apply_and_increment(block, i);
 305         }
 306 }
 307
 308
 309 ProgramCompiler::Formatter::Formatter():
 310         indent(0),
 311         parameter_list(false),
 312         else_if(0)
 313 { }
 314
 315 void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s)
 316 {
 317         GLApi api = get_gl_api();
 318         const Version &ver = s.required_version;
 319
 320         if(ver)
 321         {
 322                 formatted += format("#version %d%02d", ver.major, ver.minor);
 323                 if(api==OPENGL_ES2 && ver>=Version(3, 0))
 324                         formatted += " es";
 325                 formatted += '\n';
 326         }
 327
 328         for(vector<const Extension *>::const_iterator i=s.required_extensions.begin(); i!=s.required_extensions.end(); ++i)
 329                 formatted += format("#extension %s: require\n", (*i)->get_name());
 330         if(!s.required_extensions.empty())
 331                 formatted += '\n';
 332
 333         Visitor::apply(s);
 334 }
 335
 336 void ProgramCompiler::Formatter::visit(Literal &literal)
 337 {
 338         formatted += literal.token;
 339 }
 340
 341 void ProgramCompiler::Formatter::visit(ParenthesizedExpression &parexpr)
 342 {
 343         formatted += '(';
 344         parexpr.expression->visit(*this);
 345         formatted += ')';
 346 }
 347
 348 void ProgramCompiler::Formatter::visit(VariableReference &var)
 349 {
 350         formatted += var.name;
 351 }
 352
 353 void ProgramCompiler::Formatter::visit(MemberAccess &memacc)
 354 {
 355         memacc.left->visit(*this);
 356         formatted += format(".%s", memacc.member);
 357 }
 358
 359 void ProgramCompiler::Formatter::visit(UnaryExpression &unary)
 360 {
 361         if(unary.prefix)
 362                 formatted += unary.oper;
 363         unary.expression->visit(*this);
 364         if(!unary.prefix)
 365                 formatted += unary.oper;
 366 }
 367
 368 void ProgramCompiler::Formatter::visit(BinaryExpression &binary)
 369 {
 370         binary.left->visit(*this);
 371         formatted += binary.oper;
 372         binary.right->visit(*this);
 373         formatted += binary.after;
 374 }
 375
 376 void ProgramCompiler::Formatter::visit(Assignment &assign)
 377 {
 378         assign.left->visit(*this);
 379         formatted += format(" %s ", assign.oper);
 380         assign.right->visit(*this);
 381 }
 382
 383 void ProgramCompiler::Formatter::visit(FunctionCall &call)
 384 {
 385         formatted += format("%s(", call.name);
 386         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 387         {
 388                 if(i!=call.arguments.begin())
 389                         formatted += ", ";
 390                 (*i)->visit(*this);
 391         }
 392         formatted += ')';
 393 }
 394
 395 void ProgramCompiler::Formatter::visit(ExpressionStatement &expr)
 396 {
 397         expr.expression->visit(*this);
 398         formatted += ';';
 399 }
 400
 401 void ProgramCompiler::Formatter::visit(Block &block)
 402 {
 403         if(else_if)
 404                 --else_if;
 405
 406         unsigned brace_indent = indent;
 407         bool use_braces = (block.use_braces || (indent && block.body.size()!=1));
 408         if(use_braces)
 409                 formatted += format("%s{\n", string(brace_indent*2, ' '));
 410
 411         SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
 412         string spaces(indent*2, ' ');
 413         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 414         {
 415                 if(i!=block.body.begin())
 416                         formatted += '\n';
 417                 formatted += spaces;
 418                 (*i)->visit(*this);
 419                 else_if = 0;
 420         }
 421
 422         if(use_braces)
 423                 formatted += format("\n%s}", string(brace_indent*2, ' '));
 424 }
 425
 426 void ProgramCompiler::Formatter::visit(Import &import)
 427 {
 428         formatted += format("import %s;", import.module);
 429 }
 430
 431 void ProgramCompiler::Formatter::visit(Precision &prec)
 432 {
 433         formatted += format("precision %s %s;", prec.precision, prec.type);
 434 }
 435
 436 void ProgramCompiler::Formatter::visit(Layout &layout)
 437 {
 438         formatted += "layout(";
 439         for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
 440         {
 441                 if(i!=layout.qualifiers.begin())
 442                         formatted += ", ";
 443                 formatted += i->identifier;
 444                 if(!i->value.empty())
 445                         formatted += format("=%s", i->value);
 446         }
 447         formatted += ')';
 448 }
 449
 450 void ProgramCompiler::Formatter::visit(InterfaceLayout &layout)
 451 {
 452         layout.layout.visit(*this);
 453         formatted += format(" %s;", layout.interface);
 454 }
 455
 456 void ProgramCompiler::Formatter::visit(StructDeclaration &strct)
 457 {
 458         formatted += format("struct %s\n", strct.name);
 459         strct.members.visit(*this);
 460         formatted += ';';
 461 }
 462
 463 void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
 464 {
 465         if(var.layout)
 466         {
 467                 var.layout->visit(*this);
 468                 formatted += ' ';
 469         }
 470         if(var.constant)
 471                 formatted += "const ";
 472         if(!var.interpolation.empty())
 473                 formatted += format("%s ", var.interpolation);
 474         if(!var.sampling.empty())
 475                 formatted += format("%s ", var.sampling);
 476         if(!var.interface.empty() && var.interface!=block_interface)
 477         {
 478                 string interface = var.interface;
 479                 if(stage->required_version<Version(1, 30))
 480                 {
 481                         if(stage->type==VERTEX && var.interface=="in")
 482                                 interface = "attribute";
 483                         else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in"))
 484                                 interface = "varying";
 485                 }
 486                 formatted += format("%s ", interface);
 487         }
 488         if(!var.precision.empty())
 489                 formatted += format("%s ", var.precision);
 490         formatted += format("%s %s", var.type, var.name);
 491         if(var.array)
 492         {
 493                 formatted += '[';
 494                 if(var.array_size)
 495                         var.array_size->visit(*this);
 496                 formatted += ']';
 497         }
 498         if(var.init_expression)
 499         {
 500                 formatted += " = ";
 501                 var.init_expression->visit(*this);
 502         }
 503         if(!parameter_list)
 504                 formatted += ';';
 505 }
 506
 507 void ProgramCompiler::Formatter::visit(InterfaceBlock &iface)
 508 {
 509         SetForScope<string> set(block_interface, iface.interface);
 510         formatted += format("%s %s\n", iface.interface, iface.name);
 511         iface.members.visit(*this);
 512         formatted += ';';
 513 }
 514
 515 void ProgramCompiler::Formatter::visit(FunctionDeclaration &func)
 516 {
 517         formatted += format("%s %s(", func.return_type, func.name);
 518         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 519         {
 520                 if(i!=func.parameters.begin())
 521                         formatted += ", ";
 522                 SetFlag set(parameter_list);
 523                 (*i)->visit(*this);
 524         }
 525         formatted += ')';
 526         if(func.definition==&func)
 527         {
 528                 formatted += '\n';
 529                 func.body.visit(*this);
 530         }
 531         else
 532                 formatted += ';';
 533 }
 534
 535 void ProgramCompiler::Formatter::visit(Conditional &cond)
 536 {
 537         if(else_if)
 538                 formatted.replace(formatted.rfind('\n'), string::npos, 1, ' ');
 539
 540         indent -= else_if;
 541
 542         formatted += "if(";
 543         cond.condition->visit(*this);
 544         formatted += ")\n";
 545
 546         cond.body.visit(*this);
 547         if(!cond.else_body.body.empty())
 548         {
 549                 formatted += format("\n%selse\n", string(indent*2, ' '));
 550                 SetForScope<unsigned> set(else_if, 2);
 551                 cond.else_body.visit(*this);
 552         }
 553 }
 554
 555 void ProgramCompiler::Formatter::visit(Iteration &iter)
 556 {
 557         if(!iter.init_statement && iter.condition && !iter.loop_expression)
 558         {
 559                 formatted += "while(";
 560                 iter.condition->visit(*this);
 561                 formatted += ')';
 562         }
 563         else
 564         {
 565                 formatted += "for(";
 566                 if(iter.init_statement)
 567                         iter.init_statement->visit(*this);
 568                 else
 569                         formatted += ';';
 570                 if(iter.condition)
 571                 {
 572                         formatted += ' ';
 573                         iter.condition->visit(*this);
 574                 }
 575                 formatted += ';';
 576                 if(iter.loop_expression)
 577                 {
 578                         formatted += ' ';
 579                         iter.loop_expression->visit(*this);
 580                 }
 581                 formatted += ')';
 582         }
 583
 584         if(iter.body.body.empty())
 585                 formatted += " { }";
 586         else
 587         {
 588                 formatted += '\n';
 589                 iter.body.visit(*this);
 590         }
 591 }
 592
 593 void ProgramCompiler::Formatter::visit(Return &ret)
 594 {
 595         formatted += "return";
 596         if(ret.expression)
 597         {
 598                 formatted += ' ';
 599                 ret.expression->visit(*this);
 600         }
 601         formatted += ';';
 602 }
 603
 604 void ProgramCompiler::Formatter::visit(Jump &jump)
 605 {
 606         formatted += jump.keyword;
 607         formatted += ';';
 608 }
 609
 610
 611 ProgramCompiler::DeclarationCombiner::DeclarationCombiner():
 612         toplevel(true)
 613 { }
 614
 615 void ProgramCompiler::DeclarationCombiner::visit(Block &block)
 616 {
 617         if(!toplevel)
 618                 return;
 619
 620         SetForScope<bool> set(toplevel, false);
 621         BlockModifier::visit(block);
 622 }
 623
 624 void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func)
 625 {
 626         vector<FunctionDeclaration *> &decls = functions[func.name];
 627         if(func.definition)
 628         {
 629                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 630                 {
 631                         (*i)->definition = func.definition;
 632                         (*i)->body.body.clear();
 633                 }
 634         }
 635         decls.push_back(&func);
 636 }
 637
 638 void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var)
 639 {
 640         VariableDeclaration *&ptr = variables[var.name];
 641         if(ptr)
 642         {
 643                 ptr->type = var.type;
 644                 if(var.init_expression)
 645                         ptr->init_expression = var.init_expression;
 646                 if(var.layout)
 647                 {
 648                         if(ptr->layout)
 649                         {
 650                                 for(vector<Layout::Qualifier>::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i)
 651                                 {
 652                                         bool found = false;
 653                                         for(vector<Layout::Qualifier>::iterator j=ptr->layout->qualifiers.begin(); (!found && j!=ptr->layout->qualifiers.end()); ++j)
 654                                                 if(j->identifier==i->identifier)
 655                                                 {
 656                                                         j->value = i->value;
 657                                                         found = true;
 658                                                 }
 659
 660                                         if(!found)
 661                                                 ptr->layout->qualifiers.push_back(*i);
 662                                 }
 663                         }
 664                         else
 665                                 ptr->layout = var.layout;
 666                 }
 667                 remove_node = true;
 668         }
 669         else
 670                 ptr = &var;
 671 }
 672
 673
 674 ProgramCompiler::VariableResolver::VariableResolver():
 675         anonymous(false),
 676         record_target(false),
 677         assignment_target(0),
 678         self_referencing(false)
 679 { }
 680
 681 void ProgramCompiler::VariableResolver::apply(Stage &s)
 682 {
 683         SetForScope<Stage *> set(stage, &s);
 684         Stage *builtins = get_builtins(stage->type);
 685         if(builtins)
 686                 blocks.push_back(&builtins->content);
 687         stage->content.visit(*this);
 688         if(builtins)
 689                 blocks.pop_back();
 690 }
 691
 692 void ProgramCompiler::VariableResolver::visit(Block &block)
 693 {
 694         blocks.push_back(&block);
 695         block.variables.clear();
 696         TraversingVisitor::visit(block);
 697         blocks.pop_back();
 698 }
 699
 700 void ProgramCompiler::VariableResolver::visit(VariableReference &var)
 701 {
 702         var.declaration = 0;
 703         type = 0;
 704         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 705         {
 706                 --i;
 707                 map<string, VariableDeclaration *>::iterator j = (*i)->variables.find(var.name);
 708                 if(j!=(*i)->variables.end())
 709                 {
 710                         var.declaration = j->second;
 711                         type = j->second->type_declaration;
 712                         break;
 713                 }
 714         }
 715
 716         if(record_target)
 717         {
 718                 if(assignment_target)
 719                 {
 720                         record_target = false;
 721                         assignment_target = 0;
 722                 }
 723                 else
 724                         assignment_target = var.declaration;
 725         }
 726         else if(var.declaration && var.declaration==assignment_target)
 727                 self_referencing = true;
 728 }
 729
 730 void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc)
 731 {
 732         type = 0;
 733         TraversingVisitor::visit(memacc);
 734         memacc.declaration = 0;
 735         if(type)
 736         {
 737                 map<string, VariableDeclaration *>::iterator i = type->members.variables.find(memacc.member);
 738                 if(i!=type->members.variables.end())
 739                 {
 740                         memacc.declaration = i->second;
 741                         type = i->second->type_declaration;
 742                 }
 743                 else
 744                         type = 0;
 745         }
 746 }
 747
 748 void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary)
 749 {
 750         if(binary.oper=="[")
 751         {
 752                 {
 753                         SetForScope<bool> set(record_target, false);
 754                         binary.right->visit(*this);
 755                 }
 756                 type = 0;
 757                 binary.left->visit(*this);
 758         }
 759         else
 760         {
 761                 TraversingVisitor::visit(binary);
 762                 type = 0;
 763         }
 764 }
 765
 766 void ProgramCompiler::VariableResolver::visit(Assignment &assign)
 767 {
 768         {
 769                 SetFlag set(record_target);
 770                 assignment_target = 0;
 771                 assign.left->visit(*this);
 772         }
 773
 774         self_referencing = false;
 775         assign.right->visit(*this);
 776
 777         assign.self_referencing = (self_referencing || assign.oper!="=");
 778         assign.target_declaration = assignment_target;
 779 }
 780
 781 void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct)
 782 {
 783         TraversingVisitor::visit(strct);
 784         blocks.back()->types[strct.name] = &strct;
 785 }
 786
 787 void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var)
 788 {
 789         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 790         {
 791                 --i;
 792                 map<string, StructDeclaration *>::iterator j = (*i)->types.find(var.type);
 793                 if(j!=(*i)->types.end())
 794                         var.type_declaration = j->second;
 795         }
 796
 797         if(!block_interface.empty() && var.interface.empty())
 798                 var.interface = block_interface;
 799
 800         TraversingVisitor::visit(var);
 801         blocks.back()->variables[var.name] = &var;
 802         if(anonymous && blocks.size()>1)
 803                 blocks[blocks.size()-2]->variables[var.name] = &var;
 804 }
 805
 806 void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
 807 {
 808         SetFlag set(anonymous);
 809         SetForScope<string> set2(block_interface, iface.interface);
 810         TraversingVisitor::visit(iface);
 811 }
 812
 813
 814 void ProgramCompiler::FunctionResolver::visit(FunctionCall &call)
 815 {
 816         map<string, vector<FunctionDeclaration *> >::iterator i = functions.find(call.name);
 817         if(i!=functions.end())
 818                 call.declaration = i->second.back();
 819
 820         TraversingVisitor::visit(call);
 821 }
 822
 823 void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func)
 824 {
 825         vector<FunctionDeclaration *> &decls = functions[func.name];
 826         if(func.definition)
 827         {
 828                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 829                         (*i)->definition = func.definition;
 830                 decls.clear();
 831                 decls.push_back(&func);
 832         }
 833         else if(!decls.empty() && decls.back()->definition)
 834                 func.definition = decls.back()->definition;
 835         else
 836                 decls.push_back(&func);
 837
 838         TraversingVisitor::visit(func);
 839 }
 840
 841
 842 ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
 843         scope_level(0)
 844 { }
 845
 846 string ProgramCompiler::InterfaceGenerator::get_out_prefix(StageType type)
 847 {
 848         if(type==VERTEX)
 849                 return "_vs_out_";
 850         else if(type==GEOMETRY)
 851                 return "_gs_out_";
 852         else
 853                 return string();
 854 }
 855
 856 void ProgramCompiler::InterfaceGenerator::apply(Stage &s)
 857 {
 858         SetForScope<Stage *> set(stage, &s);
 859         if(stage->previous)
 860                 in_prefix = get_out_prefix(stage->previous->type);
 861         out_prefix = get_out_prefix(stage->type);
 862         stage->content.visit(*this);
 863 }
 864
 865 void ProgramCompiler::InterfaceGenerator::visit(Block &block)
 866 {
 867         SetForScope<unsigned> set(scope_level, scope_level+1);
 868         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 869         {
 870                 (*i)->visit(*this);
 871
 872                 if(scope_level==1)
 873                 {
 874                         for(map<string, RefPtr<VariableDeclaration> >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
 875                         {
 876                                 NodeList<Statement>::iterator k = block.body.insert(i, j->second);
 877                                 (*k)->visit(*this);
 878                         }
 879                         iface_declarations.clear();
 880                 }
 881
 882                 apply_and_increment(block, i);
 883         }
 884 }
 885
 886 string ProgramCompiler::InterfaceGenerator::change_prefix(const string &name, const string &prefix) const
 887 {
 888         unsigned offset = (name.compare(0, in_prefix.size(), in_prefix) ? 0 : in_prefix.size());
 889         return prefix+name.substr(offset);
 890 }
 891
 892 bool ProgramCompiler::InterfaceGenerator::generate_interface(VariableDeclaration &var, const string &iface, const string &name)
 893 {
 894         const map<string, VariableDeclaration *> &stage_vars = (iface=="in" ? stage->in_variables : stage->out_variables);
 895         if(stage_vars.count(name) || iface_declarations.count(name))
 896                 return false;
 897
 898         VariableDeclaration* iface_var = new VariableDeclaration;
 899         iface_var->sampling = var.sampling;
 900         iface_var->interface = iface;
 901         iface_var->type = var.type;
 902         iface_var->type_declaration = var.type_declaration;
 903         iface_var->name = name;
 904         if(stage->type==GEOMETRY)
 905                 iface_var->array = ((var.array && var.interface!="in") || iface=="in");
 906         else
 907                 iface_var->array = var.array;
 908         if(iface_var->array)
 909                 iface_var->array_size = var.array_size;
 910         if(iface=="in")
 911                 iface_var->linked_declaration = &var;
 912         iface_declarations[name] = iface_var;
 913
 914         return true;
 915 }
 916
 917 void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left, ProgramSyntax::Expression *right)
 918 {
 919         Assignment *assign = new Assignment;
 920         VariableReference *ref = new VariableReference;
 921         ref->name = left;
 922         assign->left = ref;
 923         assign->oper = "=";
 924         assign->right = right;
 925
 926         ExpressionStatement *stmt = new ExpressionStatement;
 927         stmt->expression = assign;
 928         stmt->visit(*this);
 929         insert_nodes.push_back(stmt);
 930 }
 931
 932 void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
 933 {
 934         if(var.declaration || !stage->previous)
 935                 return;
 936         if(iface_declarations.count(var.name))
 937                 return;
 938
 939         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 940         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 941         if(i==prev_out.end())
 942                 i = prev_out.find(in_prefix+var.name);
 943         if(i!=prev_out.end())
 944         {
 945                 generate_interface(*i->second, "in", i->second->name);
 946                 var.name = i->second->name;
 947         }
 948 }
 949
 950 void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
 951 {
 952         if(var.interface=="out")
 953         {
 954                 if(scope_level==1)
 955                         stage->out_variables[var.name] = &var;
 956                 else if(generate_interface(var, "out", change_prefix(var.name, string())))
 957                 {
 958                         remove_node = true;
 959                         if(var.init_expression)
 960                         {
 961                                 insert_assignment(var.name, var.init_expression->clone());
 962                                 return;
 963                         }
 964                 }
 965         }
 966         else if(var.interface=="in")
 967         {
 968                 stage->in_variables[var.name] = &var;
 969                 if(var.linked_declaration)
 970                         var.linked_declaration->linked_declaration = &var;
 971                 else if(stage->previous)
 972                 {
 973                         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 974                         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 975                         if(i!=prev_out.end())
 976                         {
 977                                 var.linked_declaration = i->second;
 978                                 i->second->linked_declaration = &var;
 979                         }
 980                 }
 981         }
 982
 983         TraversingVisitor::visit(var);
 984 }
 985
 986 void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 987 {
 988         vector<VariableDeclaration *> pass_vars;
 989
 990         for(map<string, VariableDeclaration *>::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i)
 991                 pass_vars.push_back(i->second);
 992         for(map<string, RefPtr<VariableDeclaration> >::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i)
 993                 if(i->second->interface=="in")
 994                         pass_vars.push_back(i->second.get());
 995
 996         if(stage->previous)
 997         {
 998                 const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 999                 for(map<string, VariableDeclaration *>::const_iterator i=prev_out.begin(); i!=prev_out.end(); ++i)
1000                 {
1001                         bool linked = false;
1002                         for(vector<VariableDeclaration *>::const_iterator j=pass_vars.begin(); (!linked && j!=pass_vars.end()); ++j)
1003                                 linked = ((*j)->linked_declaration==i->second);
1004
1005                         if(!linked && generate_interface(*i->second, "in", i->second->name))
1006                                 pass_vars.push_back(i->second);
1007                 }
1008         }
1009
1010         if(stage->type==GEOMETRY)
1011         {
1012                 VariableReference *ref = new VariableReference;
1013                 ref->name = "gl_in";
1014
1015                 BinaryExpression *subscript = new BinaryExpression;
1016                 subscript->left = ref;
1017                 subscript->oper = "[";
1018                 subscript->right = pass.subscript;
1019                 subscript->after = "]";
1020
1021                 MemberAccess *memacc = new MemberAccess;
1022                 memacc->left = subscript;
1023                 memacc->member = "gl_Position";
1024
1025                 insert_assignment("gl_Position", memacc);
1026         }
1027
1028         for(vector<VariableDeclaration *>::const_iterator i=pass_vars.begin(); i!=pass_vars.end(); ++i)
1029         {
1030                 string out_name = change_prefix((*i)->name, out_prefix);
1031                 generate_interface(**i, "out", out_name);
1032
1033                 VariableReference *ref = new VariableReference;
1034                 ref->name = (*i)->name;
1035                 if(pass.subscript)
1036                 {
1037                         BinaryExpression *subscript = new BinaryExpression;
1038                         subscript->left = ref;
1039                         subscript->oper = "[";
1040                         subscript->right = pass.subscript;
1041                         subscript->after = "]";
1042                         insert_assignment(out_name, subscript);
1043                 }
1044                 else
1045                         insert_assignment(out_name, ref);
1046         }
1047
1048         remove_node = true;
1049 }
1050
1051
1052 ProgramCompiler::DeclarationReorderer::DeclarationReorderer():
1053         scope_level(0),
1054         kind(NO_DECLARATION)
1055 { }
1056
1057 void ProgramCompiler::DeclarationReorderer::visit(FunctionCall &call)
1058 {
1059         FunctionDeclaration *def = call.declaration;
1060         if(def)
1061                 def = def->definition;
1062         if(def && !ordered_funcs.count(def))
1063                 needed_funcs.insert(def);
1064 }
1065
1066 void ProgramCompiler::DeclarationReorderer::visit(Block &block)
1067 {
1068         SetForScope<unsigned> set(scope_level, scope_level+1);
1069         if(scope_level>1)
1070                 return Visitor::visit(block);
1071
1072         NodeList<Statement>::iterator struct_insert_point = block.body.end();
1073         NodeList<Statement>::iterator variable_insert_point = block.body.end();
1074         NodeList<Statement>::iterator function_insert_point = block.body.end();
1075         unsigned unordered_func_count = 0;
1076         bool ordered_any_funcs = false;
1077
1078         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
1079         {
1080                 kind = NO_DECLARATION;
1081                 (*i)->visit(*this);
1082
1083                 bool moved = false;
1084                 if(kind==STRUCT && struct_insert_point!=block.body.end())
1085                 {
1086                         block.body.insert(struct_insert_point, *i);
1087                         moved = true;
1088                 }
1089                 else if(kind>STRUCT && struct_insert_point==block.body.end())
1090                         struct_insert_point = i;
1091
1092                 if(kind==VARIABLE && variable_insert_point!=block.body.end())
1093                 {
1094                         block.body.insert(variable_insert_point, *i);
1095                         moved = true;
1096                 }
1097                 else if(kind>VARIABLE && variable_insert_point==block.body.end())
1098                         variable_insert_point = i;
1099
1100                 if(kind==FUNCTION)
1101                 {
1102                         if(function_insert_point==block.body.end())
1103                                 function_insert_point = i;
1104
1105                         if(needed_funcs.empty())
1106                         {
1107                                 ordered_funcs.insert(i->get());
1108                                 if(i!=function_insert_point)
1109                                 {
1110                                         block.body.insert(function_insert_point, *i);
1111                                         moved = true;
1112                                 }
1113                                 else
1114                                         ++function_insert_point;
1115                                 ordered_any_funcs = true;
1116                         }
1117                         else
1118                                 ++unordered_func_count;
1119                 }
1120
1121                 if(moved)
1122                 {
1123                         if(function_insert_point==i)
1124                                 ++function_insert_point;
1125                         block.body.erase(i++);
1126                 }
1127                 else
1128                         ++i;
1129
1130                 if(i==block.body.end() && unordered_func_count)
1131                 {
1132                         if(!ordered_any_funcs)
1133                                 // A subset of the remaining functions forms a recursive loop
1134                                 /* TODO pick a function and move it up, adding any necessary
1135                                 declarations */
1136                                 break;
1137
1138                         i = function_insert_point;
1139                         unordered_func_count = 0;
1140                 }
1141         }
1142 }
1143
1144 void ProgramCompiler::DeclarationReorderer::visit(ProgramSyntax::VariableDeclaration &var)
1145 {
1146         Visitor::visit(var);
1147         kind = VARIABLE;
1148 }
1149
1150 void ProgramCompiler::DeclarationReorderer::visit(FunctionDeclaration &func)
1151 {
1152         needed_funcs.clear();
1153         func.body.visit(*this);
1154         needed_funcs.erase(&func);
1155         kind = FUNCTION;
1156 }
1157
1158
1159 ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator():
1160         in_function(0)
1161 { }
1162
1163 void ProgramCompiler::InlineableFunctionLocator::visit(FunctionCall &call)
1164 {
1165         FunctionDeclaration *def = call.declaration;
1166         if(def && def->definition!=def)
1167                 def = def->definition;
1168
1169         if(def)
1170         {
1171                 unsigned &count = refcounts[def];
1172                 ++count;
1173                 if(count>1 || def==in_function)
1174                         inlineable.erase(def);
1175         }
1176
1177         TraversingVisitor::visit(call);
1178 }
1179
1180 void ProgramCompiler::InlineableFunctionLocator::visit(FunctionDeclaration &func)
1181 {
1182         unsigned &count = refcounts[func.definition];
1183         if(!count && func.parameters.empty())
1184                 inlineable.insert(func.definition);
1185
1186         SetForScope<FunctionDeclaration *> set(in_function, &func);
1187         TraversingVisitor::visit(func);
1188 }
1189
1190
1191 ProgramCompiler::FunctionInliner::FunctionInliner():
1192         extract_result(0)
1193 { }
1194
1195 ProgramCompiler::FunctionInliner::FunctionInliner(const set<FunctionDeclaration *> &in):
1196         inlineable(in),
1197         extract_result(0)
1198 { }
1199
1200 void ProgramCompiler::FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
1201 {
1202         inline_result = 0;
1203         ptr->visit(*this);
1204         if(inline_result)
1205                 ptr = inline_result;
1206 }
1207
1208 void ProgramCompiler::FunctionInliner::visit(Block &block)
1209 {
1210         if(extract_result)
1211                 --extract_result;
1212
1213         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
1214         {
1215                 (*i)->visit(*this);
1216                 if(extract_result)
1217                         --extract_result;
1218         }
1219 }
1220
1221 void ProgramCompiler::FunctionInliner::visit(UnaryExpression &unary)
1222 {
1223         visit_and_inline(unary.expression);
1224         inline_result = 0;
1225 }
1226
1227 void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary)
1228 {
1229         visit_and_inline(binary.left);
1230         visit_and_inline(binary.right);
1231         inline_result = 0;
1232 }
1233
1234 void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
1235 {
1236         visit_and_inline(memacc.left);
1237         inline_result = 0;
1238 }
1239
1240 void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
1241 {
1242         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
1243                 visit_and_inline(*i);
1244
1245         FunctionDeclaration *def = call.declaration;
1246         if(def && def->definition!=def)
1247                 def = def->definition;
1248
1249         if(def && inlineable.count(def))
1250         {
1251                 extract_result = 2;
1252                 def->visit(*this);
1253         }
1254         else
1255                 inline_result = 0;
1256 }
1257
1258 void ProgramCompiler::FunctionInliner::visit(VariableDeclaration &var)
1259 {
1260         if(var.init_expression)
1261                 visit_and_inline(var.init_expression);
1262         inline_result = 0;
1263 }
1264
1265 void ProgramCompiler::FunctionInliner::visit(Return &ret)
1266 {
1267         TraversingVisitor::visit(ret);
1268
1269         if(extract_result)
1270                 inline_result = ret.expression->clone();
1271 }
1272
1273
1274 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
1275         variable_values(0),
1276         result(0.0f),
1277         result_valid(false)
1278 { }
1279
1280 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
1281         variable_values(&v),
1282         result(0.0f),
1283         result_valid(false)
1284 { }
1285
1286 void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal)
1287 {
1288         if(literal.token=="true")
1289                 result = 1.0f;
1290         else if(literal.token=="false")
1291                 result = 0.0f;
1292         else
1293                 result = lexical_cast<float>(literal.token);
1294         result_valid = true;
1295 }
1296
1297 void ProgramCompiler::ExpressionEvaluator::visit(ParenthesizedExpression &parexp)
1298 {
1299         parexp.expression->visit(*this);
1300 }
1301
1302 void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
1303 {
1304         if(!var.declaration)
1305                 return;
1306
1307         if(variable_values)
1308         {
1309                 ValueMap::const_iterator i = variable_values->find(var.declaration);
1310                 if(i!=variable_values->end())
1311                         i->second->visit(*this);
1312         }
1313         else if(var.declaration->init_expression)
1314                 var.declaration->init_expression->visit(*this);
1315 }
1316
1317 void ProgramCompiler::ExpressionEvaluator::visit(UnaryExpression &unary)
1318 {
1319         result_valid = false;
1320         unary.expression->visit(*this);
1321         if(!result_valid)
1322                 return;
1323
1324         if(unary.oper=="!")
1325                 result = !result;
1326         else
1327                 result_valid = false;
1328 }
1329
1330 void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
1331 {
1332         result_valid = false;
1333         binary.left->visit(*this);
1334         if(!result_valid)
1335                 return;
1336
1337         float left_result = result;
1338         result_valid = false;
1339         binary.right->visit(*this);
1340         if(!result_valid)
1341                 return;
1342
1343         if(binary.oper=="<")
1344                 result = (left_result<result);
1345         else if(binary.oper=="<=")
1346                 result = (left_result<=result);
1347         else if(binary.oper==">")
1348                 result = (left_result>result);
1349         else if(binary.oper==">=")
1350                 result = (left_result>=result);
1351         else if(binary.oper=="==")
1352                 result = (left_result==result);
1353         else if(binary.oper=="!=")
1354                 result = (left_result!=result);
1355         else if(binary.oper=="&&")
1356                 result = (left_result && result);
1357         else if(binary.oper=="||")
1358                 result = (left_result || result);
1359         else
1360                 result_valid = false;
1361 }
1362
1363
1364 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
1365         scope_level(0),
1366         record_only(false)
1367 { }
1368
1369 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
1370 {
1371         SetForScope<unsigned> set(scope_level, scope_level+1);
1372         BlockModifier::visit(block);
1373
1374         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
1375                 variable_values.erase(i->second);
1376 }
1377
1378 void ProgramCompiler::ConstantConditionEliminator::visit(UnaryExpression &unary)
1379 {
1380         if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
1381                 if(unary.oper=="++" || unary.oper=="--")
1382                         variable_values.erase(var->declaration);
1383 }
1384
1385 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
1386 {
1387         variable_values.erase(assign.target_declaration);
1388 }
1389
1390 void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var)
1391 {
1392         if(var.constant || scope_level>1)
1393                 variable_values[&var] = var.init_expression.get();
1394 }
1395
1396 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
1397 {
1398         if(!record_only)
1399         {
1400                 ExpressionEvaluator eval(variable_values);
1401                 cond.condition->visit(eval);
1402                 if(eval.result_valid)
1403                 {
1404                         flatten_block(eval.result ? cond.body : cond.else_body);
1405                         return;
1406                 }
1407         }
1408
1409         TraversingVisitor::visit(cond);
1410 }
1411
1412 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
1413 {
1414         if(!record_only)
1415         {
1416                 if(iter.condition)
1417                 {
1418                         /* If the loop condition is always false on the first iteration, the
1419                         entire loop can be removed */
1420                         if(iter.init_statement)
1421                                 iter.init_statement->visit(*this);
1422                         ExpressionEvaluator eval(variable_values);
1423                         iter.condition->visit(eval);
1424                         if(eval.result_valid && !eval.result)
1425                         {
1426                                 remove_node = true;
1427                                 return;
1428                         }
1429                 }
1430
1431                 /* Record all assignments that occur inside the loop body so those
1432                 variables won't be considered as constant */
1433                 SetFlag set_record(record_only);
1434                 TraversingVisitor::visit(iter);
1435         }
1436
1437         TraversingVisitor::visit(iter);
1438
1439         if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
1440                 variable_values.erase(init_decl);
1441 }
1442
1443
1444 ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
1445         aggregate(0),
1446         assignment(0),
1447         assignment_target(false),
1448         assign_to_subscript(false),
1449         global_scope(true)
1450 { }
1451
1452 void ProgramCompiler::UnusedVariableLocator::apply(Stage &s)
1453 {
1454         variables.push_back(BlockVariableMap());
1455         Visitor::apply(s);
1456         BlockVariableMap &global_variables = variables.back();
1457         for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
1458         {
1459                 if(i->first->interface=="out" && (s.type==FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
1460                         continue;
1461                 if(!i->second.referenced)
1462                 {
1463                         unused_nodes.insert(i->first);
1464                         clear_assignments(i->second, true);
1465                 }
1466         }
1467         variables.pop_back();
1468 }
1469
1470 void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var)
1471 {
1472         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
1473         if(i!=aggregates.end())
1474                 unused_nodes.erase(i->second);
1475
1476         if(var.declaration && !assignment_target)
1477         {
1478                 VariableInfo &var_info = variables.back()[var.declaration];
1479                 var_info.assignments.clear();
1480                 var_info.referenced = true;
1481         }
1482 }
1483
1484 void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc)
1485 {
1486         TraversingVisitor::visit(memacc);
1487         unused_nodes.erase(memacc.declaration);
1488 }
1489
1490 void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
1491 {
1492         if(binary.oper=="[")
1493         {
1494                 if(assignment_target)
1495                         assign_to_subscript = true;
1496                 binary.left->visit(*this);
1497                 SetForScope<bool> set(assignment_target, false);
1498                 binary.right->visit(*this);
1499         }
1500         else
1501                 TraversingVisitor::visit(binary);
1502 }
1503
1504 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
1505 {
1506         {
1507                 assign_to_subscript = false;
1508                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
1509                 assign.left->visit(*this);
1510         }
1511         assign.right->visit(*this);
1512         assignment = &assign;
1513 }
1514
1515 void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool chained)
1516 {
1517         VariableInfo &var_info = variables.back()[&var];
1518         if(!chained)
1519                 clear_assignments(var_info, true);
1520         var_info.assignments.push_back(&node);
1521         var_info.conditionally_assigned = false;
1522 }
1523
1524 void ProgramCompiler::UnusedVariableLocator::clear_assignments(VariableInfo &var_info, bool mark_unused)
1525 {
1526         if(mark_unused)
1527         {
1528                 for(vector<Node *>::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
1529                         unused_nodes.insert(*i);
1530         }
1531         var_info.assignments.clear();
1532 }
1533
1534 void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
1535 {
1536         assignment = 0;
1537         TraversingVisitor::visit(expr);
1538         if(assignment && assignment->target_declaration)
1539                 record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
1540 }
1541
1542 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
1543 {
1544         SetForScope<Node *> set(aggregate, &strct);
1545         unused_nodes.insert(&strct);
1546         TraversingVisitor::visit(strct);
1547 }
1548
1549 void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
1550 {
1551         if(aggregate)
1552                 aggregates[&var] = aggregate;
1553         else
1554         {
1555                 variables.back()[&var].local = true;
1556                 if(var.init_expression)
1557                         record_assignment(var, *var.init_expression, false);
1558         }
1559         unused_nodes.erase(var.type_declaration);
1560         TraversingVisitor::visit(var);
1561 }
1562
1563 void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface)
1564 {
1565         SetForScope<Node *> set(aggregate, &iface);
1566         unused_nodes.insert(&iface);
1567         TraversingVisitor::visit(iface);
1568 }
1569
1570 void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
1571 {
1572         variables.push_back(BlockVariableMap());
1573
1574         {
1575                 SetForScope<bool> set(global_scope, false);
1576                 for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1577                         (*i)->visit(*this);
1578                 func.body.visit(*this);
1579         }
1580
1581         BlockVariableMap &block_variables = variables.back();
1582         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1583                 i->second.conditionally_assigned = true;
1584         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1585                 block_variables[i->get()].referenced = true;
1586         merge_down_variables();
1587 }
1588
1589 void ProgramCompiler::UnusedVariableLocator::merge_down_variables()
1590 {
1591         BlockVariableMap &parent_variables = variables[variables.size()-2];
1592         BlockVariableMap &block_variables = variables.back();
1593         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1594         {
1595                 if(i->second.local)
1596                 {
1597                         if(!i->second.referenced)
1598                                 unused_nodes.insert(i->first);
1599                         clear_assignments(i->second, true);
1600                         continue;
1601                 }
1602
1603                 BlockVariableMap::iterator j = parent_variables.find(i->first);
1604                 if(j==parent_variables.end())
1605                         parent_variables.insert(*i);
1606                 else
1607                 {
1608                         if(i->second.referenced || !i->second.conditionally_assigned)
1609                                 clear_assignments(j->second, !i->second.referenced);
1610                         j->second.conditionally_assigned = i->second.conditionally_assigned;
1611                         j->second.referenced |= i->second.referenced;
1612                         j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
1613                 }
1614         }
1615         variables.pop_back();
1616 }
1617
1618 void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond)
1619 {
1620         cond.condition->visit(*this);
1621         variables.push_back(BlockVariableMap());
1622         cond.body.visit(*this);
1623
1624         BlockVariableMap if_variables;
1625         swap(variables.back(), if_variables);
1626         cond.else_body.visit(*this);
1627
1628         BlockVariableMap &else_variables = variables.back();
1629         for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
1630         {
1631                 BlockVariableMap::iterator j = if_variables.find(i->first);
1632                 if(j!=if_variables.end())
1633                 {
1634                         i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
1635                         i->second.conditionally_assigned |= j->second.conditionally_assigned;
1636                         if_variables.erase(j);
1637                 }
1638                 else
1639                         i->second.conditionally_assigned = true;
1640         }
1641
1642         for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
1643         {
1644                 i->second.conditionally_assigned = true;
1645                 else_variables.insert(*i);
1646         }
1647
1648         merge_down_variables();
1649 }
1650
1651 void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
1652 {
1653         variables.push_back(BlockVariableMap());
1654         TraversingVisitor::visit(iter);
1655
1656         BlockVariableMap &block_variables = variables.back();
1657         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1658                 if(!i->second.local && i->second.referenced)
1659                         i->second.assignments.clear();
1660
1661         merge_down_variables();
1662 }
1663
1664
1665 ProgramCompiler::UnusedVariableLocator::VariableInfo::VariableInfo():
1666         local(false),
1667         conditionally_assigned(false),
1668         referenced(false)
1669 { }
1670
1671
1672 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
1673 {
1674         TraversingVisitor::visit(call);
1675
1676         unused_nodes.erase(call.declaration);
1677         if(call.declaration && call.declaration->definition!=call.declaration)
1678                 used_definitions.insert(call.declaration->definition);
1679 }
1680
1681 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
1682 {
1683         TraversingVisitor::visit(func);
1684
1685         if((func.name!="main" || func.body.body.empty()) && !used_definitions.count(&func))
1686                 unused_nodes.insert(&func);
1687 }
1688
1689
1690 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
1691         to_remove(r)
1692 { }
1693
1694 void ProgramCompiler::NodeRemover::visit(Block &block)
1695 {
1696         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
1697         {
1698                 (*i)->visit(*this);
1699                 if(to_remove.count(i->get()))
1700                         block.body.erase(i++);
1701                 else
1702                         ++i;
1703         }
1704 }
1705
1706 void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
1707 {
1708         if(to_remove.count(&var))
1709         {
1710                 stage->in_variables.erase(var.name);
1711                 stage->out_variables.erase(var.name);
1712                 stage->locations.erase(var.name);
1713                 if(var.linked_declaration)
1714                         var.linked_declaration->linked_declaration = 0;
1715         }
1716         else if(var.init_expression && to_remove.count(var.init_expression.get()))
1717                 var.init_expression = 0;
1718 }
1719
1720 void ProgramCompiler::NodeRemover::visit(Iteration &iter)
1721 {
1722         if(to_remove.count(iter.init_statement.get()))
1723                 iter.init_statement = 0;
1724         TraversingVisitor::visit(iter);
1725 }
1726
1727
1728 void ProgramCompiler::PrecisionRemover::visit(Precision &)
1729 {
1730         remove_node = true;
1731 }
1732
1733 void ProgramCompiler::PrecisionRemover::visit(VariableDeclaration &var)
1734 {
1735         var.precision.clear();
1736 }
1737
1738
1739 ProgramCompiler::DefaultPrecisionGenerator::DefaultPrecisionGenerator():
1740         toplevel(true)
1741 { }
1742
1743 void ProgramCompiler::DefaultPrecisionGenerator::visit(Block &block)
1744 {
1745         if(toplevel)
1746         {
1747                 SetForScope<bool> set(toplevel, false);
1748                 BlockModifier::visit(block);
1749         }
1750         else
1751                 Visitor::visit(block);
1752 }
1753
1754 void ProgramCompiler::DefaultPrecisionGenerator::visit(Precision &prec)
1755 {
1756         have_default.insert(prec.type);
1757 }
1758
1759 void ProgramCompiler::DefaultPrecisionGenerator::visit(VariableDeclaration &var)
1760 {
1761         if(var.type_declaration)
1762                 return;
1763
1764         string type = var.type;
1765         if(!type.compare(0, 3, "vec") || !type.compare(0, 3, "mat"))
1766                 type = "float";
1767         else if(!type.compare(0, 3, "ivec") || type=="uint")
1768                 type = "int";
1769
1770         if(!have_default.count(type))
1771         {
1772                 Precision *prec = new Precision;
1773                 if(!type.compare(0, 7, "sampler"))
1774                         prec->precision = "lowp";
1775                 else if(stage->type==FRAGMENT)
1776                         prec->precision = "mediump";
1777                 else
1778                         prec->precision = "highp";
1779                 prec->type = type;
1780                 insert_nodes.push_back(prec);
1781
1782                 have_default.insert(type);
1783         }
1784 }
1785
1786
1787 ProgramCompiler::LegacyConverter::LegacyConverter():
1788         target_api(get_gl_api()),
1789         target_version(get_glsl_version()),
1790         frag_out(0)
1791 { }
1792
1793 ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v):
1794         target_api(get_gl_api()),
1795         target_version(v),
1796         frag_out(0)
1797 { }
1798
1799 bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) const
1800 {
1801         if(target_version<feature_version)
1802                 return false;
1803         else if(stage->required_version<feature_version)
1804                 stage->required_version = feature_version;
1805
1806         return true;
1807 }
1808
1809 bool ProgramCompiler::LegacyConverter::check_extension(const Extension &extension) const
1810 {
1811         if(!extension)
1812                 return false;
1813
1814         vector<const Extension *>::iterator i = find(stage->required_extensions, &extension);
1815         if(i==stage->required_extensions.end())
1816                 stage->required_extensions.push_back(&extension);
1817
1818         return true;
1819 }
1820
1821 bool ProgramCompiler::LegacyConverter::supports_unified_interface_syntax() const
1822 {
1823         if(target_api==OPENGL_ES2)
1824                 return check_version(Version(3, 0));
1825         else
1826                 return check_version(Version(1, 30));
1827 }
1828
1829 void ProgramCompiler::LegacyConverter::visit(VariableReference &var)
1830 {
1831         if(var.declaration==frag_out && !supports_unified_interface_syntax())
1832         {
1833                 var.name = "gl_FragColor";
1834                 var.declaration = 0;
1835                 type = "vec4";
1836         }
1837         else if(var.declaration)
1838                 type = var.declaration->type;
1839         else
1840                 type = string();
1841 }
1842
1843 void ProgramCompiler::LegacyConverter::visit(Assignment &assign)
1844 {
1845         TraversingVisitor::visit(assign);
1846         if(assign.target_declaration==frag_out && !supports_unified_interface_syntax())
1847                 assign.target_declaration = 0;
1848 }
1849
1850 bool ProgramCompiler::LegacyConverter::supports_unified_sampling_functions() const
1851 {
1852         if(target_api==OPENGL_ES2)
1853                 return check_version(Version(3, 0));
1854         else
1855                 return check_version(Version(1, 30));
1856 }
1857
1858 void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
1859 {
1860         if(call.name=="texture" && !call.declaration && !supports_unified_sampling_functions())
1861         {
1862                 NodeArray<Expression>::iterator i = call.arguments.begin();
1863                 if(i!=call.arguments.end())
1864                 {
1865                         (*i)->visit(*this);
1866                         if(type=="sampler1D")
1867                                 call.name = "texture1D";
1868                         else if(type=="sampler2D")
1869                                 call.name = "texture2D";
1870                         else if(type=="sampler3D")
1871                                 call.name = "texture3D";
1872                         else if(type=="sampler1DShadow")
1873                                 call.name = "shadow1D";
1874                         else if(type=="sampler2DShadow")
1875                                 call.name = "shadow2D";
1876
1877                         for(; i!=call.arguments.end(); ++i)
1878                                 (*i)->visit(*this);
1879                 }
1880         }
1881         else
1882                 TraversingVisitor::visit(call);
1883 }
1884
1885 bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const
1886 {
1887         if(target_api==OPENGL_ES2)
1888                 return check_version(Version(3, 0));
1889         else if(check_version(Version(3, 30)))
1890                 return true;
1891         else
1892                 return check_extension(ARB_explicit_attrib_location);
1893 }
1894
1895 bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
1896 {
1897         if(target_api==OPENGL_ES2)
1898                 return check_version(Version(3, 0));
1899         else if(check_version(Version(1, 20)))
1900                 return true;
1901         else
1902                 return check_extension(EXT_gpu_shader4);
1903 }
1904
1905 bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
1906 {
1907         if(target_api==OPENGL_ES2)
1908                 return check_version(Version(3, 20));
1909         else if(check_version(Version(4, 0)))
1910                 return true;
1911         else
1912                 return check_extension(ARB_gpu_shader5);
1913 }
1914
1915 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
1916 {
1917         if(var.layout && !supports_interface_layouts())
1918         {
1919                 vector<Layout::Qualifier>::iterator i;
1920                 for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ;
1921                 if(i!=var.layout->qualifiers.end())
1922                 {
1923                         unsigned location = lexical_cast<unsigned>(i->value);
1924                         if(stage->type==VERTEX && var.interface=="in")
1925                         {
1926                                 stage->locations[var.name] = location;
1927                                 var.layout->qualifiers.erase(i);
1928                         }
1929                         else if(stage->type==FRAGMENT && var.interface=="out")
1930                         {
1931                                 if(location!=0)
1932                                         static Require _req(EXT_gpu_shader4);
1933                                 stage->locations[var.name] = location;
1934                                 var.layout->qualifiers.erase(i);
1935                         }
1936
1937                         if(var.layout->qualifiers.empty())
1938                                 var.layout = 0;
1939                 }
1940         }
1941
1942         if(var.sampling=="centroid")
1943         {
1944                 if(!supports_centroid_sampling())
1945                         var.sampling = string();
1946         }
1947         else if(var.sampling=="sample")
1948         {
1949                 if(!supports_sample_sampling())
1950                         var.sampling = string();
1951         }
1952
1953         if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
1954         {
1955                 if(stage->type==FRAGMENT && var.interface=="out")
1956                 {
1957                         frag_out = &var;
1958                         remove_node = true;
1959                 }
1960         }
1961
1962         TraversingVisitor::visit(var);
1963 }
1964
1965 bool ProgramCompiler::LegacyConverter::supports_interface_blocks(const string &iface) const
1966 {
1967         if(target_api==OPENGL_ES2)
1968         {
1969                 if(iface=="uniform")
1970                         return check_version(Version(3, 0));
1971                 else
1972                         return check_version(Version(3, 20));
1973         }
1974         else if(check_version(Version(1, 50)))
1975                 return true;
1976         else if(iface=="uniform")
1977                 return check_extension(ARB_uniform_buffer_object);
1978         else
1979                 return false;
1980 }
1981
1982 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)
1983 {
1984         if(!supports_interface_blocks(iface.interface))
1985                 flatten_block(iface.members);
1986 }
1987
1988 } // namespace GL
1989 } // namespace Msp