source/programcompiler.cpp

   1 #include <msp/core/raii.h>
   2 #include <msp/strings/format.h>
   3 #include <msp/strings/utils.h>
   4 #include "error.h"
   5 #include "program.h"
   6 #include "programcompiler.h"
   7 #include "resources.h"
   8 #include "shader.h"
   9
  10 using namespace std;
  11
  12 namespace {
  13
  14 const char builtins_src[] =
  15         "////// vertex\n"
  16         "out gl_PerVertex {\n"
  17         "  vec4 gl_Position;\n"
  18         "  float gl_ClipDistance[];\n"
  19         "};"
  20         "////// geometry\n"
  21         "in gl_PerVertex {\n"
  22         "  vec4 gl_Position;\n"
  23         "  float gl_ClipDistance[];\n"
  24         "} gl_in[];\n"
  25         "out gl_PerVertex {\n"
  26         "  vec4 gl_Position;\n"
  27         "  float gl_ClipDistance[];\n"
  28         "};\n";
  29
  30 }
  31
  32 namespace Msp {
  33 namespace GL {
  34
  35 using namespace ProgramSyntax;
  36
  37 ProgramCompiler::ProgramCompiler():
  38         resources(0),
  39         module(0)
  40 { }
  41
  42 void ProgramCompiler::compile(const string &source)
  43 {
  44         resources = 0;
  45         module = &parser.parse(source);
  46         process();
  47 }
  48
  49 void ProgramCompiler::compile(IO::Base &io, Resources *res)
  50 {
  51         resources = res;
  52         module = &parser.parse(io);
  53         process();
  54 }
  55
  56 void ProgramCompiler::add_shaders(Program &program)
  57 {
  58         if(!module)
  59                 throw invalid_operation("ProgramCompiler::add_shaders");
  60
  61         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
  62         {
  63                 if(i->type==VERTEX)
  64                 {
  65                         program.attach_shader_owned(new VertexShader(apply<Formatter>(*i)));
  66                         for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
  67                                 program.bind_attribute(j->second, j->first);
  68                 }
  69                 else if(i->type==GEOMETRY)
  70                         program.attach_shader_owned(new GeometryShader(apply<Formatter>(*i)));
  71                 else if(i->type==FRAGMENT)
  72                 {
  73                         program.attach_shader_owned(new FragmentShader(apply<Formatter>(*i)));
  74                         for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
  75                                 program.bind_fragment_data(j->second, j->first);
  76                 }
  77         }
  78 }
  79
  80 Module *ProgramCompiler::create_builtins_module()
  81 {
  82         ProgramParser parser;
  83         Module *module = new Module(parser.parse(builtins_src));
  84         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
  85         {
  86                 VariableResolver resolver;
  87                 i->content.visit(resolver);
  88                 for(map<string, VariableDeclaration *>::iterator j=i->content.variables.begin(); j!=i->content.variables.end(); ++j)
  89                         j->second->linked_declaration = j->second;
  90         }
  91         return module;
  92 }
  93
  94 Module &ProgramCompiler::get_builtins_module()
  95 {
  96         static RefPtr<Module> builtins_module = create_builtins_module();
  97         return *builtins_module;
  98 }
  99
 100 Stage *ProgramCompiler::get_builtins(StageType type)
 101 {
 102         Module &module = get_builtins_module();
 103         for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
 104                 if(i->type==type)
 105                         return &*i;
 106         return 0;
 107 }
 108
 109 void ProgramCompiler::process()
 110 {
 111         list<Import *> imports = apply<NodeGatherer<Import> >(module->shared);
 112         for(list<Import *>::iterator i=imports.end(); i!=imports.begin(); )
 113                 import((*--i)->module);
 114         apply<NodeRemover>(module->shared, set<Node *>(imports.begin(), imports.end()));
 115
 116         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
 117                 generate(*i);
 118         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); )
 119         {
 120                 if(optimize(*i))
 121                         i = module->stages.begin();
 122                 else
 123                         ++i;
 124         }
 125 }
 126
 127 void ProgramCompiler::import(const string &name)
 128 {
 129         string fn = name+".glsl";
 130         RefPtr<IO::Seekable> io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn));
 131         if(!io)
 132                 throw runtime_error(format("module %s not found", name));
 133         ProgramParser import_parser;
 134         Module &imported_module = import_parser.parse(*io);
 135
 136         inject_block(module->shared.content, imported_module.shared.content);
 137         apply<DeclarationCombiner>(module->shared);
 138         for(list<Stage>::iterator i=imported_module.stages.begin(); i!=imported_module.stages.end(); ++i)
 139         {
 140                 list<Stage>::iterator j;
 141                 for(j=module->stages.begin(); (j!=module->stages.end() && j->type<i->type); ++j) ;
 142                 if(j==module->stages.end() || j->type>i->type)
 143                 {
 144                         j = module->stages.insert(j, *i);
 145                         list<Stage>::iterator k = j;
 146                         if(++k!=module->stages.end())
 147                                 k->previous = &*j;
 148                         if(j!=module->stages.begin())
 149                                 j->previous = &*--(k=j);
 150                 }
 151                 else
 152                 {
 153                         inject_block(j->content, i->content);
 154                         apply<DeclarationCombiner>(*j);
 155                 }
 156         }
 157 }
 158
 159 void ProgramCompiler::generate(Stage &stage)
 160 {
 161         inject_block(stage.content, module->shared.content);
 162
 163         apply<DeclarationReorderer>(stage);
 164         apply<FunctionResolver>(stage);
 165         apply<VariableResolver>(stage);
 166         apply<InterfaceGenerator>(stage);
 167         apply<VariableResolver>(stage);
 168         apply<VariableRenamer>(stage);
 169         apply<DeclarationReorderer>(stage);
 170         apply<LegacyConverter>(stage);
 171 }
 172
 173 bool ProgramCompiler::optimize(Stage &stage)
 174 {
 175         apply<ConstantConditionEliminator>(stage);
 176
 177         set<FunctionDeclaration *> inlineable = apply<InlineableFunctionLocator>(stage);
 178         apply<FunctionInliner>(stage, inlineable);
 179
 180         set<Node *> unused = apply<UnusedVariableLocator>(stage);
 181         set<Node *> unused2 = apply<UnusedFunctionLocator>(stage);
 182         unused.insert(unused2.begin(), unused2.end());
 183         apply<NodeRemover>(stage, unused);
 184
 185         return !unused.empty();
 186 }
 187
 188 void ProgramCompiler::inject_block(Block &target, const Block &source)
 189 {
 190         list<RefPtr<Node> >::iterator insert_point = target.body.begin();
 191         for(list<RefPtr<Node> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
 192                 target.body.insert(insert_point, (*i)->clone());
 193 }
 194
 195 template<typename T>
 196 typename T::ResultType ProgramCompiler::apply(Stage &stage)
 197 {
 198         T visitor;
 199         visitor.apply(stage);
 200         return visitor.get_result();
 201 }
 202
 203 template<typename T, typename A>
 204 typename T::ResultType ProgramCompiler::apply(Stage &stage, const A &arg)
 205 {
 206         T visitor(arg);
 207         visitor.apply(stage);
 208         return visitor.get_result();
 209 }
 210
 211
 212 ProgramCompiler::Visitor::Visitor():
 213         stage(0)
 214 { }
 215
 216 void ProgramCompiler::Visitor::apply(Stage &s)
 217 {
 218         SetForScope<Stage *> set(stage, &s);
 219         stage->content.visit(*this);
 220 }
 221
 222
 223 ProgramCompiler::Formatter::Formatter():
 224         indent(0),
 225         parameter_list(false),
 226         else_if(0)
 227 { }
 228
 229 void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s)
 230 {
 231         const Version &ver = s.required_version;
 232         if(ver.major)
 233                 formatted += format("#version %d%d\n", ver.major, ver.minor);
 234         Visitor::apply(s);
 235 }
 236
 237 void ProgramCompiler::Formatter::visit(Literal &literal)
 238 {
 239         formatted += literal.token;
 240 }
 241
 242 void ProgramCompiler::Formatter::visit(ParenthesizedExpression &parexpr)
 243 {
 244         formatted += '(';
 245         parexpr.expression->visit(*this);
 246         formatted += ')';
 247 }
 248
 249 void ProgramCompiler::Formatter::visit(VariableReference &var)
 250 {
 251         formatted += var.name;
 252 }
 253
 254 void ProgramCompiler::Formatter::visit(MemberAccess &memacc)
 255 {
 256         memacc.left->visit(*this);
 257         formatted += format(".%s", memacc.member);
 258 }
 259
 260 void ProgramCompiler::Formatter::visit(UnaryExpression &unary)
 261 {
 262         if(unary.prefix)
 263                 formatted += unary.oper;
 264         unary.expression->visit(*this);
 265         if(!unary.prefix)
 266                 formatted += unary.oper;
 267 }
 268
 269 void ProgramCompiler::Formatter::visit(BinaryExpression &binary)
 270 {
 271         binary.left->visit(*this);
 272         formatted += binary.oper;
 273         binary.right->visit(*this);
 274         formatted += binary.after;
 275 }
 276
 277 void ProgramCompiler::Formatter::visit(Assignment &assign)
 278 {
 279         assign.left->visit(*this);
 280         formatted += format(" %s ", assign.oper);
 281         assign.right->visit(*this);
 282 }
 283
 284 void ProgramCompiler::Formatter::visit(FunctionCall &call)
 285 {
 286         formatted += format("%s(", call.name);
 287         for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 288         {
 289                 if(i!=call.arguments.begin())
 290                         formatted += ", ";
 291                 (*i)->visit(*this);
 292         }
 293         formatted += ')';
 294 }
 295
 296 void ProgramCompiler::Formatter::visit(ExpressionStatement &expr)
 297 {
 298         expr.expression->visit(*this);
 299         formatted += ';';
 300 }
 301
 302 void ProgramCompiler::Formatter::visit(Block &block)
 303 {
 304         if(else_if)
 305                 --else_if;
 306
 307         unsigned brace_indent = indent;
 308         bool use_braces = (block.use_braces || (indent && block.body.size()!=1));
 309         if(use_braces)
 310                 formatted += format("%s{\n", string(brace_indent*2, ' '));
 311
 312         SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
 313         string spaces(indent*2, ' ');
 314         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 315         {
 316                 if(i!=block.body.begin())
 317                         formatted += '\n';
 318                 formatted += spaces;
 319                 (*i)->visit(*this);
 320                 else_if = 0;
 321         }
 322
 323         if(use_braces)
 324                 formatted += format("\n%s}", string(brace_indent*2, ' '));
 325 }
 326
 327 void ProgramCompiler::Formatter::visit(Import &import)
 328 {
 329         formatted += format("import %s;", import.module);
 330 }
 331
 332 void ProgramCompiler::Formatter::visit(Layout &layout)
 333 {
 334         formatted += "layout(";
 335         for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
 336         {
 337                 if(i!=layout.qualifiers.begin())
 338                         formatted += ", ";
 339                 formatted += i->identifier;
 340                 if(!i->value.empty())
 341                         formatted += format("=%s", i->value);
 342         }
 343         formatted += ')';
 344 }
 345
 346 void ProgramCompiler::Formatter::visit(InterfaceLayout &layout)
 347 {
 348         layout.layout.visit(*this);
 349         formatted += format(" %s;", layout.interface);
 350 }
 351
 352 void ProgramCompiler::Formatter::visit(StructDeclaration &strct)
 353 {
 354         formatted += format("struct %s\n", strct.name);
 355         strct.members.visit(*this);
 356         formatted += ';';
 357 }
 358
 359 void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
 360 {
 361         if(var.layout)
 362         {
 363                 var.layout->visit(*this);
 364                 formatted += ' ';
 365         }
 366         if(var.constant)
 367                 formatted += "const ";
 368         if(!var.sampling.empty())
 369                 formatted += format("%s ", var.sampling);
 370         if(!var.interface.empty() && var.interface!=block_interface)
 371                 formatted += format("%s ", var.interface);
 372         formatted += format("%s %s", var.type, var.name);
 373         if(var.array)
 374         {
 375                 formatted += '[';
 376                 if(var.array_size)
 377                         var.array_size->visit(*this);
 378                 formatted += ']';
 379         }
 380         if(var.init_expression)
 381         {
 382                 formatted += " = ";
 383                 var.init_expression->visit(*this);
 384         }
 385         if(!parameter_list)
 386                 formatted += ';';
 387 }
 388
 389 void ProgramCompiler::Formatter::visit(InterfaceBlock &iface)
 390 {
 391         SetForScope<string> set(block_interface, iface.interface);
 392         formatted += format("%s %s\n", iface.interface, iface.name);
 393         iface.members.visit(*this);
 394         formatted += ';';
 395 }
 396
 397 void ProgramCompiler::Formatter::visit(FunctionDeclaration &func)
 398 {
 399         formatted += format("%s %s(", func.return_type, func.name);
 400         for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 401         {
 402                 if(i!=func.parameters.begin())
 403                         formatted += ", ";
 404                 SetFlag set(parameter_list);
 405                 (*i)->visit(*this);
 406         }
 407         formatted += ')';
 408         if(func.definition==&func)
 409         {
 410                 formatted += '\n';
 411                 func.body.visit(*this);
 412         }
 413         else
 414                 formatted += ';';
 415 }
 416
 417 void ProgramCompiler::Formatter::visit(Conditional &cond)
 418 {
 419         if(else_if)
 420                 formatted.replace(formatted.rfind('\n'), string::npos, 1, ' ');
 421
 422         indent -= else_if;
 423
 424         formatted += "if(";
 425         cond.condition->visit(*this);
 426         formatted += ")\n";
 427
 428         cond.body.visit(*this);
 429         if(!cond.else_body.body.empty())
 430         {
 431                 formatted += format("\n%selse\n", string(indent*2, ' '));
 432                 SetForScope<unsigned> set(else_if, 2);
 433                 cond.else_body.visit(*this);
 434         }
 435 }
 436
 437 void ProgramCompiler::Formatter::visit(Iteration &iter)
 438 {
 439         formatted += "for(";
 440         iter.init_statement->visit(*this);
 441         formatted += ' ';
 442         iter.condition->visit(*this);
 443         formatted += "; ";
 444         iter.loop_expression->visit(*this);
 445         formatted += ")\n";
 446         iter.body.visit(*this);
 447 }
 448
 449 void ProgramCompiler::Formatter::visit(Return &ret)
 450 {
 451         formatted += "return ";
 452         ret.expression->visit(*this);
 453         formatted += ';';
 454 }
 455
 456 void ProgramCompiler::Formatter::visit(Jump &jump)
 457 {
 458         formatted += jump.keyword;
 459         formatted += ';';
 460 }
 461
 462
 463 ProgramCompiler::DeclarationCombiner::DeclarationCombiner():
 464         toplevel(true),
 465         remove_node(false)
 466 { }
 467
 468 void ProgramCompiler::DeclarationCombiner::visit(Block &block)
 469 {
 470         if(!toplevel)
 471                 return;
 472
 473         SetForScope<bool> set(toplevel, false);
 474         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 475         {
 476                 remove_node = false;
 477                 (*i)->visit(*this);
 478                 if(remove_node)
 479                         block.body.erase(i++);
 480                 else
 481                         ++i;
 482         }
 483 }
 484
 485 void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func)
 486 {
 487         vector<FunctionDeclaration *> &decls = functions[func.name];
 488         if(func.definition)
 489         {
 490                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 491                 {
 492                         (*i)->definition = func.definition;
 493                         (*i)->body.body.clear();
 494                 }
 495         }
 496         decls.push_back(&func);
 497 }
 498
 499 void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var)
 500 {
 501         VariableDeclaration *&ptr = variables[var.name];
 502         if(ptr)
 503         {
 504                 ptr->type = var.type;
 505                 if(var.init_expression)
 506                         ptr->init_expression = var.init_expression;
 507                 remove_node = true;
 508         }
 509         else
 510                 ptr = &var;
 511 }
 512
 513
 514 ProgramCompiler::VariableResolver::VariableResolver():
 515         anonymous(false),
 516         record_target(false),
 517         assignment_target(0),
 518         self_referencing(false)
 519 { }
 520
 521 void ProgramCompiler::VariableResolver::apply(Stage &s)
 522 {
 523         SetForScope<Stage *> set(stage, &s);
 524         Stage *builtins = get_builtins(stage->type);
 525         if(builtins)
 526                 blocks.push_back(&builtins->content);
 527         stage->content.visit(*this);
 528         if(builtins)
 529                 blocks.pop_back();
 530 }
 531
 532 void ProgramCompiler::VariableResolver::visit(Block &block)
 533 {
 534         blocks.push_back(&block);
 535         block.variables.clear();
 536         TraversingVisitor::visit(block);
 537         blocks.pop_back();
 538 }
 539
 540 void ProgramCompiler::VariableResolver::visit(VariableReference &var)
 541 {
 542         var.declaration = 0;
 543         type = 0;
 544         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 545         {
 546                 --i;
 547                 map<string, VariableDeclaration *>::iterator j = (*i)->variables.find(var.name);
 548                 if(j!=(*i)->variables.end())
 549                 {
 550                         var.declaration = j->second;
 551                         type = j->second->type_declaration;
 552                         break;
 553                 }
 554         }
 555
 556         if(record_target)
 557         {
 558                 if(assignment_target)
 559                 {
 560                         record_target = false;
 561                         assignment_target = 0;
 562                 }
 563                 else
 564                         assignment_target = var.declaration;
 565         }
 566         else if(var.declaration && var.declaration==assignment_target)
 567                 self_referencing = true;
 568 }
 569
 570 void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc)
 571 {
 572         type = 0;
 573         TraversingVisitor::visit(memacc);
 574         memacc.declaration = 0;
 575         if(type)
 576         {
 577                 map<string, VariableDeclaration *>::iterator i = type->members.variables.find(memacc.member);
 578                 if(i!=type->members.variables.end())
 579                 {
 580                         memacc.declaration = i->second;
 581                         type = i->second->type_declaration;
 582                 }
 583                 else
 584                         type = 0;
 585         }
 586 }
 587
 588 void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary)
 589 {
 590         if(binary.oper=="[")
 591         {
 592                 {
 593                         SetForScope<bool> set(record_target, false);
 594                         binary.right->visit(*this);
 595                 }
 596                 type = 0;
 597                 binary.left->visit(*this);
 598         }
 599         else
 600         {
 601                 TraversingVisitor::visit(binary);
 602                 type = 0;
 603         }
 604 }
 605
 606 void ProgramCompiler::VariableResolver::visit(Assignment &assign)
 607 {
 608         {
 609                 SetFlag set(record_target);
 610                 assignment_target = 0;
 611                 assign.left->visit(*this);
 612         }
 613
 614         self_referencing = false;
 615         assign.right->visit(*this);
 616
 617         assign.self_referencing = (self_referencing || assign.oper!="=");
 618         assign.target_declaration = assignment_target;
 619 }
 620
 621 void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct)
 622 {
 623         TraversingVisitor::visit(strct);
 624         blocks.back()->types[strct.name] = &strct;
 625 }
 626
 627 void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var)
 628 {
 629         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 630         {
 631                 --i;
 632                 map<string, StructDeclaration *>::iterator j = (*i)->types.find(var.type);
 633                 if(j!=(*i)->types.end())
 634                         var.type_declaration = j->second;
 635         }
 636
 637         if(!block_interface.empty() && var.interface.empty())
 638                 var.interface = block_interface;
 639
 640         TraversingVisitor::visit(var);
 641         blocks.back()->variables[var.name] = &var;
 642         if(anonymous && blocks.size()>1)
 643                 blocks[blocks.size()-2]->variables[var.name] = &var;
 644 }
 645
 646 void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
 647 {
 648         SetFlag set(anonymous);
 649         SetForScope<string> set2(block_interface, iface.interface);
 650         TraversingVisitor::visit(iface);
 651 }
 652
 653
 654 void ProgramCompiler::FunctionResolver::visit(FunctionCall &call)
 655 {
 656         map<string, vector<FunctionDeclaration *> >::iterator i = functions.find(call.name);
 657         if(i!=functions.end())
 658                 call.declaration = i->second.back();
 659
 660         TraversingVisitor::visit(call);
 661 }
 662
 663 void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func)
 664 {
 665         vector<FunctionDeclaration *> &decls = functions[func.name];
 666         if(func.definition)
 667         {
 668                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 669                         (*i)->definition = func.definition;
 670                 decls.clear();
 671                 decls.push_back(&func);
 672         }
 673         else if(!decls.empty() && decls.back()->definition)
 674                 func.definition = decls.back()->definition;
 675         else
 676                 decls.push_back(&func);
 677
 678         TraversingVisitor::visit(func);
 679 }
 680
 681
 682 ProgramCompiler::BlockModifier::BlockModifier():
 683         remove_node(false)
 684 { }
 685
 686 void ProgramCompiler::BlockModifier::flatten_block(Block &block)
 687 {
 688         insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
 689         remove_node = true;
 690 }
 691
 692 void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
 693 {
 694         block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
 695         insert_nodes.clear();
 696
 697         if(remove_node)
 698                 block.body.erase(i++);
 699         else
 700                 ++i;
 701         remove_node = false;
 702 }
 703
 704 void ProgramCompiler::BlockModifier::visit(Block &block)
 705 {
 706         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 707         {
 708                 (*i)->visit(*this);
 709                 apply_and_increment(block, i);
 710         }
 711 }
 712
 713
 714 ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
 715         scope_level(0)
 716 { }
 717
 718 string ProgramCompiler::InterfaceGenerator::get_out_prefix(StageType type)
 719 {
 720         if(type==VERTEX)
 721                 return "_vs_out_";
 722         else if(type==GEOMETRY)
 723                 return "_gs_out_";
 724         else
 725                 return string();
 726 }
 727
 728 void ProgramCompiler::InterfaceGenerator::apply(Stage &s)
 729 {
 730         SetForScope<Stage *> set(stage, &s);
 731         if(stage->previous)
 732                 in_prefix = get_out_prefix(stage->previous->type);
 733         out_prefix = get_out_prefix(stage->type);
 734         stage->content.visit(*this);
 735 }
 736
 737 void ProgramCompiler::InterfaceGenerator::visit(Block &block)
 738 {
 739         SetForScope<unsigned> set(scope_level, scope_level+1);
 740         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 741         {
 742                 (*i)->visit(*this);
 743
 744                 if(scope_level==1)
 745                 {
 746                         for(map<string, RefPtr<VariableDeclaration> >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
 747                         {
 748                                 list<RefPtr<Node> >::iterator k = block.body.insert(i, j->second);
 749                                 (*k)->visit(*this);
 750                         }
 751                         iface_declarations.clear();
 752                 }
 753
 754                 apply_and_increment(block, i);
 755         }
 756 }
 757
 758 string ProgramCompiler::InterfaceGenerator::change_prefix(const string &name, const string &prefix) const
 759 {
 760         unsigned offset = (name.compare(0, in_prefix.size(), in_prefix) ? 0 : in_prefix.size());
 761         return prefix+name.substr(offset);
 762 }
 763
 764 bool ProgramCompiler::InterfaceGenerator::generate_interface(VariableDeclaration &var, const string &iface, const string &name)
 765 {
 766         const map<string, VariableDeclaration *> &stage_vars = (iface=="in" ? stage->in_variables : stage->out_variables);
 767         if(stage_vars.count(name) || iface_declarations.count(name))
 768                 return false;
 769
 770         VariableDeclaration* iface_var = new VariableDeclaration;
 771         iface_var->sampling = var.sampling;
 772         iface_var->interface = iface;
 773         iface_var->type = var.type;
 774         iface_var->type_declaration = var.type_declaration;
 775         iface_var->name = name;
 776         if(stage->type==GEOMETRY)
 777                 iface_var->array = ((var.array && var.interface!="in") || iface=="in");
 778         else
 779                 iface_var->array = var.array;
 780         if(iface_var->array)
 781                 iface_var->array_size = var.array_size;
 782         if(iface=="in")
 783                 iface_var->linked_declaration = &var;
 784         iface_declarations[name] = iface_var;
 785
 786         return true;
 787 }
 788
 789 void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left, ProgramSyntax::Expression *right)
 790 {
 791         Assignment *assign = new Assignment;
 792         VariableReference *ref = new VariableReference;
 793         ref->name = left;
 794         assign->left = ref;
 795         assign->oper = "=";
 796         assign->right = right;
 797
 798         ExpressionStatement *stmt = new ExpressionStatement;
 799         stmt->expression = assign;
 800         insert_nodes.push_back(stmt);
 801 }
 802
 803 void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
 804 {
 805         if(var.declaration || !stage->previous)
 806                 return;
 807         if(iface_declarations.count(var.name))
 808                 return;
 809
 810         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 811         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 812         if(i==prev_out.end())
 813                 i = prev_out.find(in_prefix+var.name);
 814         if(i!=prev_out.end())
 815                 generate_interface(*i->second, "in", var.name);
 816 }
 817
 818 void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
 819 {
 820         if(var.interface=="out")
 821         {
 822                 if(scope_level==1)
 823                         stage->out_variables[var.name] = &var;
 824                 else if(generate_interface(var, "out", change_prefix(var.name, string())))
 825                 {
 826                         remove_node = true;
 827                         if(var.init_expression)
 828                                 insert_assignment(var.name, var.init_expression->clone());
 829                 }
 830         }
 831         else if(var.interface=="in")
 832         {
 833                 stage->in_variables[var.name] = &var;
 834                 if(var.linked_declaration)
 835                         var.linked_declaration->linked_declaration = &var;
 836                 else if(stage->previous)
 837                 {
 838                         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 839                         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 840                         if(i!=prev_out.end())
 841                         {
 842                                 var.linked_declaration = i->second;
 843                                 i->second->linked_declaration = &var;
 844                         }
 845                 }
 846         }
 847
 848         TraversingVisitor::visit(var);
 849 }
 850
 851 void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 852 {
 853         vector<VariableDeclaration *> pass_vars;
 854
 855         for(map<string, VariableDeclaration *>::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i)
 856                 pass_vars.push_back(i->second);
 857         for(map<string, RefPtr<VariableDeclaration> >::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i)
 858                 if(i->second->interface=="in")
 859                         pass_vars.push_back(i->second.get());
 860
 861         if(stage->previous)
 862         {
 863                 const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 864                 for(map<string, VariableDeclaration *>::const_iterator i=prev_out.begin(); i!=prev_out.end(); ++i)
 865                 {
 866                         bool linked = false;
 867                         for(vector<VariableDeclaration *>::const_iterator j=pass_vars.begin(); (!linked && j!=pass_vars.end()); ++j)
 868                                 linked = ((*j)->linked_declaration==i->second);
 869
 870                         if(!linked && generate_interface(*i->second, "in", i->second->name))
 871                                 pass_vars.push_back(i->second);
 872                 }
 873         }
 874
 875         if(stage->type==GEOMETRY)
 876         {
 877                 VariableReference *ref = new VariableReference;
 878                 ref->name = "gl_in";
 879
 880                 BinaryExpression *subscript = new BinaryExpression;
 881                 subscript->left = ref;
 882                 subscript->oper = "[";
 883                 subscript->right = pass.subscript;
 884                 subscript->after = "]";
 885
 886                 MemberAccess *memacc = new MemberAccess;
 887                 memacc->left = subscript;
 888                 memacc->member = "gl_Position";
 889
 890                 insert_assignment("gl_Position", memacc);
 891         }
 892
 893         for(vector<VariableDeclaration *>::const_iterator i=pass_vars.begin(); i!=pass_vars.end(); ++i)
 894         {
 895                 string out_name = change_prefix((*i)->name, out_prefix);
 896                 generate_interface(**i, "out", out_name);
 897
 898                 VariableReference *ref = new VariableReference;
 899                 ref->name = (*i)->name;
 900                 if(pass.subscript)
 901                 {
 902                         BinaryExpression *subscript = new BinaryExpression;
 903                         subscript->left = ref;
 904                         subscript->oper = "[";
 905                         subscript->right = pass.subscript;
 906                         subscript->after = "]";
 907                         insert_assignment(out_name, subscript);
 908                 }
 909                 else
 910                         insert_assignment(out_name, ref);
 911         }
 912
 913         remove_node = true;
 914 }
 915
 916
 917 void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
 918 {
 919         if(var.declaration)
 920                 var.name = var.declaration->name;
 921 }
 922
 923 void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
 924 {
 925         if(var.linked_declaration)
 926                 var.name = var.linked_declaration->name;
 927         TraversingVisitor::visit(var);
 928 }
 929
 930
 931 ProgramCompiler::DeclarationReorderer::DeclarationReorderer():
 932         kind(NO_DECLARATION)
 933 { }
 934
 935 void ProgramCompiler::DeclarationReorderer::visit(Block &block)
 936 {
 937         list<RefPtr<Node> >::iterator struct_insert_point = block.body.end();
 938         list<RefPtr<Node> >::iterator variable_insert_point = block.body.end();
 939
 940         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 941         {
 942                 kind = NO_DECLARATION;
 943                 (*i)->visit(*this);
 944
 945                 bool moved = false;
 946                 if(kind==STRUCT && struct_insert_point!=block.body.end())
 947                 {
 948                         block.body.insert(struct_insert_point, *i);
 949                         moved = true;
 950                 }
 951                 else if(kind>STRUCT && struct_insert_point==block.body.end())
 952                         struct_insert_point = i;
 953
 954                 if(kind==VARIABLE && variable_insert_point!=block.body.end())
 955                 {
 956                         block.body.insert(variable_insert_point, *i);
 957                         moved = true;
 958                 }
 959                 else if(kind>VARIABLE && variable_insert_point==block.body.end())
 960                         variable_insert_point = i;
 961
 962                 if(moved)
 963                         block.body.erase(i++);
 964                 else
 965                         ++i;
 966         }
 967 }
 968
 969
 970 ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator():
 971         in_function(0)
 972 { }
 973
 974 void ProgramCompiler::InlineableFunctionLocator::visit(FunctionCall &call)
 975 {
 976         FunctionDeclaration *def = call.declaration;
 977         if(def && def->definition!=def)
 978                 def = def->definition;
 979
 980         if(def)
 981         {
 982                 unsigned &count = refcounts[def];
 983                 ++count;
 984                 if(count>1 || def==in_function)
 985                         inlineable.erase(def);
 986         }
 987
 988         TraversingVisitor::visit(call);
 989 }
 990
 991 void ProgramCompiler::InlineableFunctionLocator::visit(FunctionDeclaration &func)
 992 {
 993         unsigned &count = refcounts[func.definition];
 994         if(!count && func.parameters.empty())
 995                 inlineable.insert(func.definition);
 996
 997         SetForScope<FunctionDeclaration *> set(in_function, &func);
 998         TraversingVisitor::visit(func);
 999 }
1000
1001
1002 ProgramCompiler::FunctionInliner::FunctionInliner():
1003         extract_result(0)
1004 { }
1005
1006 ProgramCompiler::FunctionInliner::FunctionInliner(const set<FunctionDeclaration *> &in):
1007         inlineable(in),
1008         extract_result(0)
1009 { }
1010
1011 void ProgramCompiler::FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
1012 {
1013         inline_result = 0;
1014         ptr->visit(*this);
1015         if(inline_result)
1016                 ptr = inline_result;
1017 }
1018
1019 void ProgramCompiler::FunctionInliner::visit(Block &block)
1020 {
1021         if(extract_result)
1022                 --extract_result;
1023
1024         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
1025         {
1026                 (*i)->visit(*this);
1027                 if(extract_result)
1028                         --extract_result;
1029         }
1030 }
1031
1032 void ProgramCompiler::FunctionInliner::visit(UnaryExpression &unary)
1033 {
1034         visit_and_inline(unary.expression);
1035         inline_result = 0;
1036 }
1037
1038 void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary)
1039 {
1040         visit_and_inline(binary.left);
1041         visit_and_inline(binary.right);
1042         inline_result = 0;
1043 }
1044
1045 void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
1046 {
1047         for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
1048                 visit_and_inline(*i);
1049
1050         FunctionDeclaration *def = call.declaration;
1051         if(def && def->definition!=def)
1052                 def = def->definition;
1053
1054         if(def && inlineable.count(def))
1055         {
1056                 extract_result = 2;
1057                 def->visit(*this);
1058         }
1059         else
1060                 inline_result = 0;
1061 }
1062
1063 void ProgramCompiler::FunctionInliner::visit(Return &ret)
1064 {
1065         TraversingVisitor::visit(ret);
1066
1067         if(extract_result)
1068                 inline_result = ret.expression->clone();
1069 }
1070
1071
1072 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
1073         variable_values(0),
1074         result(0.0f),
1075         result_valid(false)
1076 { }
1077
1078 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
1079         variable_values(&v),
1080         result(0.0f),
1081         result_valid(false)
1082 { }
1083
1084 void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal)
1085 {
1086         if(literal.token=="true")
1087                 result = 1.0f;
1088         else if(literal.token=="false")
1089                 result = 0.0f;
1090         else
1091                 result = lexical_cast<float>(literal.token);
1092         result_valid = true;
1093 }
1094
1095 void ProgramCompiler::ExpressionEvaluator::visit(ParenthesizedExpression &parexp)
1096 {
1097         parexp.expression->visit(*this);
1098 }
1099
1100 void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
1101 {
1102         if(!var.declaration)
1103                 return;
1104
1105         if(variable_values)
1106         {
1107                 ValueMap::const_iterator i = variable_values->find(var.declaration);
1108                 if(i!=variable_values->end())
1109                         i->second->visit(*this);
1110         }
1111         else if(var.declaration->init_expression)
1112                 var.declaration->init_expression->visit(*this);
1113 }
1114
1115 void ProgramCompiler::ExpressionEvaluator::visit(UnaryExpression &unary)
1116 {
1117         result_valid = false;
1118         unary.expression->visit(*this);
1119         if(!result_valid)
1120                 return;
1121
1122         if(unary.oper=="!")
1123                 result = !result;
1124         else
1125                 result_valid = false;
1126 }
1127
1128 void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
1129 {
1130         result_valid = false;
1131         binary.left->visit(*this);
1132         if(!result_valid)
1133                 return;
1134
1135         float left_result = result;
1136         result_valid = false;
1137         binary.right->visit(*this);
1138         if(!result_valid)
1139                 return;
1140
1141         if(binary.oper=="<")
1142                 result = (left_result<result);
1143         else if(binary.oper=="<=")
1144                 result = (left_result<=result);
1145         else if(binary.oper==">")
1146                 result = (left_result>result);
1147         else if(binary.oper==">=")
1148                 result = (left_result>=result);
1149         else if(binary.oper=="==")
1150                 result = (left_result==result);
1151         else if(binary.oper=="!=")
1152                 result = (left_result!=result);
1153         else if(binary.oper=="&&")
1154                 result = (left_result && result);
1155         else if(binary.oper=="||")
1156                 result = (left_result || result);
1157         else
1158                 result_valid = false;
1159 }
1160
1161
1162 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
1163         scope_level(0)
1164 { }
1165
1166 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
1167 {
1168         SetForScope<unsigned> set(scope_level, scope_level+1);
1169         BlockModifier::visit(block);
1170
1171         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
1172                 variable_values.erase(i->second);
1173 }
1174
1175 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
1176 {
1177         variable_values.erase(assign.target_declaration);
1178 }
1179
1180 void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var)
1181 {
1182         if(var.constant || scope_level>1)
1183                 variable_values[&var] = var.init_expression.get();
1184 }
1185
1186 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
1187 {
1188         ExpressionEvaluator eval(variable_values);
1189         cond.condition->visit(eval);
1190         if(eval.result_valid)
1191                 flatten_block(eval.result ? cond.body : cond.else_body);
1192         else
1193                 TraversingVisitor::visit(cond);
1194 }
1195
1196 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
1197 {
1198         if(iter.condition)
1199         {
1200                 ExpressionEvaluator eval;
1201                 iter.condition->visit(eval);
1202                 if(eval.result_valid && !eval.result)
1203                 {
1204                         remove_node = true;
1205                         return;
1206                 }
1207         }
1208
1209         TraversingVisitor::visit(iter);
1210 }
1211
1212
1213 ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
1214         aggregate(0),
1215         assignment(0),
1216         assignment_target(false),
1217         global_scope(true)
1218 { }
1219
1220 void ProgramCompiler::UnusedVariableLocator::apply(Stage &s)
1221 {
1222         variables.push_back(BlockVariableMap());
1223         Visitor::apply(s);
1224         BlockVariableMap &global_variables = variables.back();
1225         for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
1226         {
1227                 if(i->first->interface=="out" && (s.type==FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
1228                         continue;
1229                 if(!i->second.referenced)
1230                 {
1231                         unused_nodes.insert(i->first);
1232                         clear_assignments(i->second, true);
1233                 }
1234         }
1235         variables.pop_back();
1236 }
1237
1238 void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var)
1239 {
1240         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
1241         if(i!=aggregates.end())
1242                 unused_nodes.erase(i->second);
1243
1244         if(var.declaration && !assignment_target)
1245         {
1246                 VariableInfo &var_info = variables.back()[var.declaration];
1247                 var_info.assignments.clear();
1248                 var_info.referenced = true;
1249         }
1250 }
1251
1252 void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc)
1253 {
1254         TraversingVisitor::visit(memacc);
1255         unused_nodes.erase(memacc.declaration);
1256 }
1257
1258 void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
1259 {
1260         if(binary.oper=="[")
1261         {
1262                 binary.left->visit(*this);
1263                 SetForScope<bool> set(assignment_target, false);
1264                 binary.right->visit(*this);
1265         }
1266         else
1267                 TraversingVisitor::visit(binary);
1268 }
1269
1270 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
1271 {
1272         {
1273                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
1274                 assign.left->visit(*this);
1275         }
1276         assign.right->visit(*this);
1277         assignment = &assign;
1278 }
1279
1280 void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
1281 {
1282         VariableInfo &var_info = variables.back()[&var];
1283         if(!self_ref)
1284                 clear_assignments(var_info, true);
1285         var_info.assignments.push_back(&node);
1286         var_info.conditionally_assigned = false;
1287 }
1288
1289 void ProgramCompiler::UnusedVariableLocator::clear_assignments(VariableInfo &var_info, bool mark_unused)
1290 {
1291         if(mark_unused)
1292         {
1293                 for(vector<Node *>::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
1294                         unused_nodes.insert(*i);
1295         }
1296         var_info.assignments.clear();
1297 }
1298
1299 void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
1300 {
1301         assignment = 0;
1302         TraversingVisitor::visit(expr);
1303         if(assignment && assignment->target_declaration)
1304                 record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
1305 }
1306
1307 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
1308 {
1309         SetForScope<Node *> set(aggregate, &strct);
1310         unused_nodes.insert(&strct);
1311         TraversingVisitor::visit(strct);
1312 }
1313
1314 void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
1315 {
1316         if(aggregate)
1317                 aggregates[&var] = aggregate;
1318         else
1319         {
1320                 variables.back()[&var].local = true;
1321                 if(var.init_expression)
1322                         record_assignment(var, *var.init_expression, false);
1323         }
1324         unused_nodes.erase(var.type_declaration);
1325         TraversingVisitor::visit(var);
1326 }
1327
1328 void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface)
1329 {
1330         SetForScope<Node *> set(aggregate, &iface);
1331         unused_nodes.insert(&iface);
1332         TraversingVisitor::visit(iface);
1333 }
1334
1335 void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
1336 {
1337         variables.push_back(BlockVariableMap());
1338
1339         {
1340                 SetForScope<bool> set(global_scope, false);
1341                 for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1342                         (*i)->visit(*this);
1343                 func.body.visit(*this);
1344         }
1345
1346         BlockVariableMap &block_variables = variables.back();
1347         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1348                 i->second.conditionally_assigned = true;
1349         merge_down_variables();
1350 }
1351
1352 void ProgramCompiler::UnusedVariableLocator::merge_down_variables()
1353 {
1354         BlockVariableMap &parent_variables = variables[variables.size()-2];
1355         BlockVariableMap &block_variables = variables.back();
1356         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1357         {
1358                 if(i->second.local)
1359                 {
1360                         if(!i->second.referenced)
1361                                 unused_nodes.insert(i->first);
1362                         clear_assignments(i->second, true);
1363                         continue;
1364                 }
1365
1366                 BlockVariableMap::iterator j = parent_variables.find(i->first);
1367                 if(j==parent_variables.end())
1368                         parent_variables.insert(*i);
1369                 else
1370                 {
1371                         if(i->second.referenced || !i->second.conditionally_assigned)
1372                                 clear_assignments(j->second, !i->second.referenced);
1373                         j->second.conditionally_assigned = i->second.conditionally_assigned;
1374                         j->second.referenced |= i->second.referenced;
1375                         j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
1376                 }
1377         }
1378         variables.pop_back();
1379 }
1380
1381 void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond)
1382 {
1383         cond.condition->visit(*this);
1384         variables.push_back(BlockVariableMap());
1385         cond.body.visit(*this);
1386
1387         BlockVariableMap if_variables;
1388         swap(variables.back(), if_variables);
1389         cond.else_body.visit(*this);
1390
1391         BlockVariableMap &else_variables = variables.back();
1392         for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
1393         {
1394                 BlockVariableMap::iterator j = if_variables.find(i->first);
1395                 if(j!=if_variables.end())
1396                 {
1397                         i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
1398                         i->second.conditionally_assigned |= j->second.conditionally_assigned;
1399                         if_variables.erase(j);
1400                 }
1401                 else
1402                         i->second.conditionally_assigned = true;
1403         }
1404
1405         for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
1406         {
1407                 i->second.conditionally_assigned = true;
1408                 else_variables.insert(*i);
1409         }
1410
1411         merge_down_variables();
1412 }
1413
1414 void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
1415 {
1416         variables.push_back(BlockVariableMap());
1417         TraversingVisitor::visit(iter);
1418
1419         BlockVariableMap &block_variables = variables.back();
1420         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1421                 if(!i->second.local && i->second.referenced)
1422                         i->second.assignments.clear();
1423
1424         merge_down_variables();
1425 }
1426
1427
1428 ProgramCompiler::UnusedVariableLocator::VariableInfo::VariableInfo():
1429         local(false),
1430         conditionally_assigned(false),
1431         referenced(false)
1432 { }
1433
1434
1435 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
1436 {
1437         TraversingVisitor::visit(call);
1438
1439         unused_nodes.erase(call.declaration);
1440         if(call.declaration && call.declaration->definition!=call.declaration)
1441                 used_definitions.insert(call.declaration->definition);
1442 }
1443
1444 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
1445 {
1446         TraversingVisitor::visit(func);
1447
1448         if(func.name!="main" && !used_definitions.count(&func))
1449                 unused_nodes.insert(&func);
1450 }
1451
1452
1453 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
1454         to_remove(r)
1455 { }
1456
1457 void ProgramCompiler::NodeRemover::visit(Block &block)
1458 {
1459         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
1460         {
1461                 (*i)->visit(*this);
1462                 if(to_remove.count(i->get()))
1463                         block.body.erase(i++);
1464                 else
1465                         ++i;
1466         }
1467 }
1468
1469 void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
1470 {
1471         if(to_remove.count(&var))
1472         {
1473                 stage->in_variables.erase(var.name);
1474                 stage->out_variables.erase(var.name);
1475                 stage->locations.erase(var.name);
1476                 if(var.linked_declaration)
1477                         var.linked_declaration->linked_declaration = 0;
1478         }
1479         else if(var.init_expression && to_remove.count(var.init_expression.get()))
1480                 var.init_expression = 0;
1481 }
1482
1483
1484 ProgramCompiler::LegacyConverter::LegacyConverter():
1485         target_version(get_glsl_version())
1486 { }
1487
1488 ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v):
1489         target_version(v)
1490 { }
1491
1492 bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version)
1493 {
1494         if(target_version<feature_version)
1495                 return false;
1496         else if(stage->required_version<feature_version)
1497                 stage->required_version = feature_version;
1498
1499         return true;
1500 }
1501
1502 void ProgramCompiler::LegacyConverter::visit(VariableReference &var)
1503 {
1504         if(var.name==frag_out_name && !check_version(Version(1, 30)))
1505         {
1506                 var.name = "gl_FragColor";
1507                 var.declaration = 0;
1508                 type = "vec4";
1509         }
1510         else if(var.declaration)
1511                 type = var.declaration->type;
1512         else
1513                 type = string();
1514 }
1515
1516 void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
1517 {
1518         if(call.name=="texture" && !call.declaration && !check_version(Version(1, 30)))
1519         {
1520                 vector<RefPtr<Expression> >::iterator i = call.arguments.begin();
1521                 if(i!=call.arguments.end())
1522                 {
1523                         (*i)->visit(*this);
1524                         if(type=="sampler1D")
1525                                 call.name = "texture1D";
1526                         else if(type=="sampler2D")
1527                                 call.name = "texture2D";
1528                         else if(type=="sampler3D")
1529                                 call.name = "texture3D";
1530                         else if(type=="sampler1DShadow")
1531                                 call.name = "shadow1D";
1532                         else if(type=="sampler2DShadow")
1533                                 call.name = "shadow2D";
1534
1535                         for(; i!=call.arguments.end(); ++i)
1536                                 (*i)->visit(*this);
1537                 }
1538         }
1539         else
1540                 TraversingVisitor::visit(call);
1541 }
1542
1543 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
1544 {
1545         if(var.layout && !check_version(Version(3, 30)))
1546         {
1547                 vector<Layout::Qualifier>::iterator i;
1548                 for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ;
1549                 if(i!=var.layout->qualifiers.end())
1550                 {
1551                         unsigned location = lexical_cast<unsigned>(i->value);
1552                         if(stage->type==VERTEX && var.interface=="in")
1553                         {
1554                                 stage->locations[var.name] = location;
1555                                 var.layout->qualifiers.erase(i);
1556                         }
1557                         else if(stage->type==FRAGMENT && var.interface=="out")
1558                         {
1559                                 stage->locations[var.name] = location;
1560                                 var.layout->qualifiers.erase(i);
1561                         }
1562
1563                         if(var.layout->qualifiers.empty())
1564                                 var.layout = 0;
1565                 }
1566         }
1567
1568         if((var.interface=="in" || var.interface=="out") && !check_version(Version(1, 30)))
1569         {
1570                 if(stage->type==VERTEX && var.interface=="in")
1571                         var.interface = "attribute";
1572                 else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in"))
1573                         var.interface = "varying";
1574                 else if(stage->type==FRAGMENT && var.interface=="out")
1575                 {
1576                         frag_out_name = var.name;
1577                         remove_node = true;
1578                 }
1579         }
1580
1581         TraversingVisitor::visit(var);
1582 }
1583
1584 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)
1585 {
1586         if(!check_version(Version(1, 50)))
1587                 flatten_block(iface.members);
1588 }
1589
1590 } // namespace GL
1591 } // namespace Msp