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