source/programcompiler.cpp

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