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