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         global_scope(true)
1217 { }
1218
1219 void ProgramCompiler::UnusedVariableLocator::apply(Stage &s)
1220 {
1221         variables.push_back(BlockVariableMap());
1222         Visitor::apply(s);
1223         BlockVariableMap &global_variables = variables.back();
1224         for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
1225         {
1226                 if(i->first->interface=="out" && (s.type==FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
1227                         continue;
1228                 if(!i->second.referenced)
1229                 {
1230                         unused_nodes.insert(i->first);
1231                         for(vector<Node *>::iterator j=i->second.assignments.begin(); j!=i->second.assignments.end(); ++j)
1232                                 unused_nodes.insert(*j);
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                 var_info.assignments.clear();
1285         var_info.assignments.push_back(&node);
1286         var_info.conditionally_assigned = false;
1287 }
1288
1289 void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
1290 {
1291         assignment = 0;
1292         TraversingVisitor::visit(expr);
1293         if(assignment && assignment->target_declaration)
1294                 record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
1295 }
1296
1297 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
1298 {
1299         SetForScope<Node *> set(aggregate, &strct);
1300         unused_nodes.insert(&strct);
1301         TraversingVisitor::visit(strct);
1302 }
1303
1304 void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
1305 {
1306         if(aggregate)
1307                 aggregates[&var] = aggregate;
1308         else
1309         {
1310                 variables.back()[&var].local = true;
1311                 if(var.init_expression)
1312                         record_assignment(var, *var.init_expression, false);
1313         }
1314         unused_nodes.erase(var.type_declaration);
1315         TraversingVisitor::visit(var);
1316 }
1317
1318 void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface)
1319 {
1320         SetForScope<Node *> set(aggregate, &iface);
1321         unused_nodes.insert(&iface);
1322         TraversingVisitor::visit(iface);
1323 }
1324
1325 void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
1326 {
1327         variables.push_back(BlockVariableMap());
1328
1329         {
1330                 SetForScope<bool> set(global_scope, false);
1331                 for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1332                         (*i)->visit(*this);
1333                 func.body.visit(*this);
1334         }
1335
1336         BlockVariableMap &block_variables = variables.back();
1337         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1338                 i->second.conditionally_assigned = true;
1339         merge_down_variables();
1340 }
1341
1342 void ProgramCompiler::UnusedVariableLocator::merge_down_variables()
1343 {
1344         BlockVariableMap &parent_variables = variables[variables.size()-2];
1345         BlockVariableMap &block_variables = variables.back();
1346         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1347         {
1348                 if(i->second.local)
1349                 {
1350                         if(!i->second.referenced)
1351                                 unused_nodes.insert(i->first);
1352                         for(vector<Node *>::iterator j=i->second.assignments.begin(); j!=i->second.assignments.end(); ++j)
1353                                 unused_nodes.insert(*j);
1354                         continue;
1355                 }
1356
1357                 BlockVariableMap::iterator j = parent_variables.find(i->first);
1358                 if(j==parent_variables.end())
1359                         parent_variables.insert(*i);
1360                 else
1361                 {
1362                         if(!i->second.conditionally_assigned)
1363                         {
1364                                 j->second.assignments.clear();
1365                                 j->second.conditionally_assigned = true;
1366                         }
1367                         j->second.referenced |= i->second.referenced;
1368                         j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
1369                 }
1370         }
1371         variables.pop_back();
1372 }
1373
1374 void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond)
1375 {
1376         cond.condition->visit(*this);
1377         variables.push_back(BlockVariableMap());
1378         cond.body.visit(*this);
1379
1380         BlockVariableMap if_variables;
1381         swap(variables.back(), if_variables);
1382         cond.else_body.visit(*this);
1383
1384         BlockVariableMap &else_variables = variables.back();
1385         for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
1386         {
1387                 BlockVariableMap::iterator j = if_variables.find(i->first);
1388                 if(j!=if_variables.end())
1389                 {
1390                         i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
1391                         i->second.conditionally_assigned |= j->second.conditionally_assigned;
1392                         if_variables.erase(j);
1393                 }
1394                 else
1395                         i->second.conditionally_assigned = true;
1396         }
1397
1398         for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
1399         {
1400                 i->second.conditionally_assigned = true;
1401                 else_variables.insert(*i);
1402         }
1403
1404         merge_down_variables();
1405 }
1406
1407 void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
1408 {
1409         variables.push_back(BlockVariableMap());
1410         TraversingVisitor::visit(iter);
1411
1412         BlockVariableMap &block_variables = variables.back();
1413         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
1414                 if(!i->second.local && i->second.referenced)
1415                         i->second.assignments.clear();
1416
1417         merge_down_variables();
1418 }
1419
1420
1421 ProgramCompiler::UnusedVariableLocator::VariableInfo::VariableInfo():
1422         local(false),
1423         conditionally_assigned(false),
1424         referenced(false)
1425 { }
1426
1427
1428 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
1429 {
1430         TraversingVisitor::visit(call);
1431
1432         unused_nodes.erase(call.declaration);
1433         if(call.declaration && call.declaration->definition!=call.declaration)
1434                 used_definitions.insert(call.declaration->definition);
1435 }
1436
1437 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
1438 {
1439         TraversingVisitor::visit(func);
1440
1441         if(func.name!="main" && !used_definitions.count(&func))
1442                 unused_nodes.insert(&func);
1443 }
1444
1445
1446 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
1447         to_remove(r)
1448 { }
1449
1450 void ProgramCompiler::NodeRemover::visit(Block &block)
1451 {
1452         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
1453         {
1454                 (*i)->visit(*this);
1455                 if(to_remove.count(i->get()))
1456                         block.body.erase(i++);
1457                 else
1458                         ++i;
1459         }
1460 }
1461
1462 void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
1463 {
1464         if(to_remove.count(&var))
1465         {
1466                 stage->in_variables.erase(var.name);
1467                 stage->out_variables.erase(var.name);
1468                 stage->locations.erase(var.name);
1469                 if(var.linked_declaration)
1470                         var.linked_declaration->linked_declaration = 0;
1471         }
1472         else if(var.init_expression && to_remove.count(var.init_expression.get()))
1473                 var.init_expression = 0;
1474 }
1475
1476
1477 ProgramCompiler::LegacyConverter::LegacyConverter():
1478         target_version(get_glsl_version())
1479 { }
1480
1481 ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v):
1482         target_version(v)
1483 { }
1484
1485 bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version)
1486 {
1487         if(target_version<feature_version)
1488                 return false;
1489         else if(stage->required_version<feature_version)
1490                 stage->required_version = feature_version;
1491
1492         return true;
1493 }
1494
1495 void ProgramCompiler::LegacyConverter::visit(VariableReference &var)
1496 {
1497         if(var.name==frag_out_name && !check_version(Version(1, 30)))
1498         {
1499                 var.name = "gl_FragColor";
1500                 var.declaration = 0;
1501                 type = "vec4";
1502         }
1503         else if(var.declaration)
1504                 type = var.declaration->type;
1505         else
1506                 type = string();
1507 }
1508
1509 void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
1510 {
1511         if(call.name=="texture" && !call.declaration && !check_version(Version(1, 30)))
1512         {
1513                 vector<RefPtr<Expression> >::iterator i = call.arguments.begin();
1514                 if(i!=call.arguments.end())
1515                 {
1516                         (*i)->visit(*this);
1517                         if(type=="sampler1D")
1518                                 call.name = "texture1D";
1519                         else if(type=="sampler2D")
1520                                 call.name = "texture2D";
1521                         else if(type=="sampler3D")
1522                                 call.name = "texture3D";
1523                         else if(type=="sampler1DShadow")
1524                                 call.name = "shadow1D";
1525                         else if(type=="sampler2DShadow")
1526                                 call.name = "shadow2D";
1527
1528                         for(; i!=call.arguments.end(); ++i)
1529                                 (*i)->visit(*this);
1530                 }
1531         }
1532         else
1533                 TraversingVisitor::visit(call);
1534 }
1535
1536 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
1537 {
1538         if(var.layout && !check_version(Version(3, 30)))
1539         {
1540                 vector<Layout::Qualifier>::iterator i;
1541                 for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ;
1542                 if(i!=var.layout->qualifiers.end())
1543                 {
1544                         unsigned location = lexical_cast<unsigned>(i->value);
1545                         if(stage->type==VERTEX && var.interface=="in")
1546                         {
1547                                 stage->locations[var.name] = location;
1548                                 var.layout->qualifiers.erase(i);
1549                         }
1550                         else if(stage->type==FRAGMENT && var.interface=="out")
1551                         {
1552                                 stage->locations[var.name] = location;
1553                                 var.layout->qualifiers.erase(i);
1554                         }
1555
1556                         if(var.layout->qualifiers.empty())
1557                                 var.layout = 0;
1558                 }
1559         }
1560
1561         if((var.interface=="in" || var.interface=="out") && !check_version(Version(1, 30)))
1562         {
1563                 if(stage->type==VERTEX && var.interface=="in")
1564                         var.interface = "attribute";
1565                 else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in"))
1566                         var.interface = "varying";
1567                 else if(stage->type==FRAGMENT && var.interface=="out")
1568                 {
1569                         frag_out_name = var.name;
1570                         remove_node = true;
1571                 }
1572         }
1573
1574         TraversingVisitor::visit(var);
1575 }
1576
1577 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)
1578 {
1579         if(!check_version(Version(1, 50)))
1580                 flatten_block(iface.members);
1581 }
1582
1583 } // namespace GL
1584 } // namespace Msp