source/programcompiler.cpp

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