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