source/programcompiler.cpp

   1 #include <msp/core/raii.h>
   2 #include <msp/strings/format.h>
   3 #include <msp/strings/utils.h>
   4 #include "error.h"
   5 #include "program.h"
   6 #include "programcompiler.h"
   7 #include "resources.h"
   8 #include "shader.h"
   9
  10 using namespace std;
  11
  12 namespace {
  13
  14 const char builtins_src[] =
  15         "////// vertex\n"
  16         "out gl_PerVertex {\n"
  17         "  vec4 gl_Position;\n"
  18         "  float gl_ClipDistance[];\n"
  19         "};"
  20         "////// geometry\n"
  21         "in gl_PerVertex {\n"
  22         "  vec4 gl_Position;\n"
  23         "  float gl_ClipDistance[];\n"
  24         "} gl_in[];\n"
  25         "out gl_PerVertex {\n"
  26         "  vec4 gl_Position;\n"
  27         "  float gl_ClipDistance[];\n"
  28         "};\n";
  29
  30 }
  31
  32 namespace Msp {
  33 namespace GL {
  34
  35 using namespace ProgramSyntax;
  36
  37 ProgramCompiler::ProgramCompiler():
  38         resources(0),
  39         module(0)
  40 { }
  41
  42 void ProgramCompiler::compile(const string &source)
  43 {
  44         resources = 0;
  45         module = &parser.parse(source);
  46         process();
  47 }
  48
  49 void ProgramCompiler::compile(IO::Base &io, Resources *res)
  50 {
  51         resources = res;
  52         module = &parser.parse(io);
  53         process();
  54 }
  55
  56 void ProgramCompiler::add_shaders(Program &program)
  57 {
  58         if(!module)
  59                 throw invalid_operation("ProgramCompiler::add_shaders");
  60
  61         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
  62         {
  63                 if(i->type==VERTEX)
  64                         program.attach_shader_owned(new VertexShader(apply<Formatter>(*i)));
  65                 else if(i->type==GEOMETRY)
  66                         program.attach_shader_owned(new GeometryShader(apply<Formatter>(*i)));
  67                 else if(i->type==FRAGMENT)
  68                         program.attach_shader_owned(new FragmentShader(apply<Formatter>(*i)));
  69         }
  70
  71         program.bind_attribute(VERTEX4, "vertex");
  72         program.bind_attribute(NORMAL3, "normal");
  73         program.bind_attribute(COLOR4_FLOAT, "color");
  74         program.bind_attribute(TEXCOORD4, "texcoord");
  75 }
  76
  77 Module *ProgramCompiler::create_builtins_module()
  78 {
  79         ProgramParser parser;
  80         Module *module = new Module(parser.parse(builtins_src));
  81         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
  82         {
  83                 VariableResolver resolver;
  84                 i->content.visit(resolver);
  85                 for(map<string, VariableDeclaration *>::iterator j=i->content.variables.begin(); j!=i->content.variables.end(); ++j)
  86                         j->second->linked_declaration = j->second;
  87         }
  88         return module;
  89 }
  90
  91 Module &ProgramCompiler::get_builtins_module()
  92 {
  93         static RefPtr<Module> builtins_module = create_builtins_module();
  94         return *builtins_module;
  95 }
  96
  97 Stage *ProgramCompiler::get_builtins(StageType type)
  98 {
  99         Module &module = get_builtins_module();
 100         for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
 101                 if(i->type==type)
 102                         return &*i;
 103         return 0;
 104 }
 105
 106 void ProgramCompiler::process()
 107 {
 108         list<Import *> imports = apply<NodeGatherer<Import> >(module->shared);
 109         for(list<Import *>::iterator i=imports.end(); i!=imports.begin(); )
 110                 import((*--i)->module);
 111         apply<NodeRemover>(module->shared, set<Node *>(imports.begin(), imports.end()));
 112
 113         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
 114                 generate(*i);
 115         for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); )
 116         {
 117                 if(optimize(*i))
 118                         i = module->stages.begin();
 119                 else
 120                         ++i;
 121         }
 122 }
 123
 124 void ProgramCompiler::import(const string &name)
 125 {
 126         string fn = name+".glsl";
 127         RefPtr<IO::Seekable> io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn));
 128         if(!io)
 129                 throw runtime_error(format("module %s not found", name));
 130         ProgramParser import_parser;
 131         Module &imported_module = import_parser.parse(*io);
 132
 133         inject_block(module->shared.content, imported_module.shared.content);
 134         apply<DeclarationCombiner>(module->shared);
 135         for(list<Stage>::iterator i=imported_module.stages.begin(); i!=imported_module.stages.end(); ++i)
 136         {
 137                 list<Stage>::iterator j;
 138                 for(j=module->stages.begin(); (j!=module->stages.end() && j->type<i->type); ++j) ;
 139                 if(j==module->stages.end() || j->type>i->type)
 140                 {
 141                         j = module->stages.insert(j, *i);
 142                         list<Stage>::iterator k = j;
 143                         if(++k!=module->stages.end())
 144                                 k->previous = &*j;
 145                         if(j!=module->stages.begin())
 146                                 j->previous = &*--(k=j);
 147                 }
 148                 else
 149                 {
 150                         inject_block(j->content, i->content);
 151                         apply<DeclarationCombiner>(*j);
 152                 }
 153         }
 154 }
 155
 156 void ProgramCompiler::generate(Stage &stage)
 157 {
 158         inject_block(stage.content, module->shared.content);
 159
 160         apply<FunctionResolver>(stage);
 161         apply<VariableResolver>(stage);
 162         apply<InterfaceGenerator>(stage);
 163         apply<VariableResolver>(stage);
 164         apply<VariableRenamer>(stage);
 165         apply<LegacyConverter>(stage);
 166         apply<VariableResolver>(stage);
 167 }
 168
 169 bool ProgramCompiler::optimize(Stage &stage)
 170 {
 171         apply<ConstantConditionEliminator>(stage);
 172         apply<VariableResolver>(stage);
 173
 174         set<Node *> unused = apply<UnusedVariableLocator>(stage);
 175         set<Node *> unused2 = apply<UnusedFunctionLocator>(stage);
 176         unused.insert(unused2.begin(), unused2.end());
 177         apply<NodeRemover>(stage, unused);
 178
 179         return !unused.empty();
 180 }
 181
 182 void ProgramCompiler::inject_block(Block &target, const Block &source)
 183 {
 184         list<NodePtr<Node> >::iterator insert_point = target.body.begin();
 185         for(list<NodePtr<Node> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
 186                 target.body.insert(insert_point, (*i)->clone());
 187 }
 188
 189 template<typename T>
 190 typename T::ResultType ProgramCompiler::apply(Stage &stage)
 191 {
 192         T visitor;
 193         visitor.apply(stage);
 194         return visitor.get_result();
 195 }
 196
 197 template<typename T, typename A>
 198 typename T::ResultType ProgramCompiler::apply(Stage &stage, const A &arg)
 199 {
 200         T visitor(arg);
 201         visitor.apply(stage);
 202         return visitor.get_result();
 203 }
 204
 205
 206 ProgramCompiler::Visitor::Visitor():
 207         stage(0)
 208 { }
 209
 210 void ProgramCompiler::Visitor::apply(Stage &s)
 211 {
 212         SetForScope<Stage *> set(stage, &s);
 213         stage->content.visit(*this);
 214 }
 215
 216
 217 ProgramCompiler::Formatter::Formatter():
 218         indent(0),
 219         parameter_list(false),
 220         else_if(0)
 221 { }
 222
 223 void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s)
 224 {
 225         const Version &ver = s.required_version;
 226         if(ver.major)
 227                 formatted += format("#version %d%d\n", ver.major, ver.minor);
 228         Visitor::apply(s);
 229 }
 230
 231 void ProgramCompiler::Formatter::visit(Literal &literal)
 232 {
 233         formatted += literal.token;
 234 }
 235
 236 void ProgramCompiler::Formatter::visit(ParenthesizedExpression &parexpr)
 237 {
 238         formatted += '(';
 239         parexpr.expression->visit(*this);
 240         formatted += ')';
 241 }
 242
 243 void ProgramCompiler::Formatter::visit(VariableReference &var)
 244 {
 245         formatted += var.name;
 246 }
 247
 248 void ProgramCompiler::Formatter::visit(MemberAccess &memacc)
 249 {
 250         memacc.left->visit(*this);
 251         formatted += format(".%s", memacc.member);
 252 }
 253
 254 void ProgramCompiler::Formatter::visit(UnaryExpression &unary)
 255 {
 256         if(unary.prefix)
 257                 formatted += unary.oper;
 258         unary.expression->visit(*this);
 259         if(!unary.prefix)
 260                 formatted += unary.oper;
 261 }
 262
 263 void ProgramCompiler::Formatter::visit(BinaryExpression &binary)
 264 {
 265         binary.left->visit(*this);
 266         formatted += binary.oper;
 267         binary.right->visit(*this);
 268         formatted += binary.after;
 269 }
 270
 271 void ProgramCompiler::Formatter::visit(Assignment &assign)
 272 {
 273         assign.left->visit(*this);
 274         formatted += format(" %s ", assign.oper);
 275         assign.right->visit(*this);
 276 }
 277
 278 void ProgramCompiler::Formatter::visit(FunctionCall &call)
 279 {
 280         formatted += format("%s(", call.name);
 281         for(vector<NodePtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 282         {
 283                 if(i!=call.arguments.begin())
 284                         formatted += ", ";
 285                 (*i)->visit(*this);
 286         }
 287         formatted += ')';
 288 }
 289
 290 void ProgramCompiler::Formatter::visit(ExpressionStatement &expr)
 291 {
 292         expr.expression->visit(*this);
 293         formatted += ';';
 294 }
 295
 296 void ProgramCompiler::Formatter::visit(Block &block)
 297 {
 298         if(else_if)
 299                 --else_if;
 300
 301         unsigned brace_indent = indent;
 302         bool use_braces = (block.use_braces || (indent && block.body.size()!=1));
 303         if(use_braces)
 304                 formatted += format("%s{\n", string(brace_indent*2, ' '));
 305
 306         SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
 307         string spaces(indent*2, ' ');
 308         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 309         {
 310                 if(i!=block.body.begin())
 311                         formatted += '\n';
 312                 formatted += spaces;
 313                 (*i)->visit(*this);
 314                 else_if = 0;
 315         }
 316
 317         if(use_braces)
 318                 formatted += format("\n%s}", string(brace_indent*2, ' '));
 319 }
 320
 321 void ProgramCompiler::Formatter::visit(Import &import)
 322 {
 323         formatted += format("import %s;", import.module);
 324 }
 325
 326 void ProgramCompiler::Formatter::visit(Layout &layout)
 327 {
 328         formatted += "layout(";
 329         for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
 330         {
 331                 if(i!=layout.qualifiers.begin())
 332                         formatted += ", ";
 333                 formatted += i->identifier;
 334                 if(!i->value.empty())
 335                         formatted += format("=%s", i->value);
 336         }
 337         formatted += format(") %s;", layout.interface);
 338 }
 339
 340 void ProgramCompiler::Formatter::visit(StructDeclaration &strct)
 341 {
 342         formatted += format("struct %s\n", strct.name);
 343         strct.members.visit(*this);
 344         formatted += ';';
 345 }
 346
 347 void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
 348 {
 349         if(var.constant)
 350                 formatted += "const ";
 351         if(!var.sampling.empty())
 352                 formatted += format("%s ", var.sampling);
 353         if(!var.interface.empty() && var.interface!=block_interface)
 354                 formatted += format("%s ", var.interface);
 355         formatted += format("%s %s", var.type, var.name);
 356         if(var.array)
 357         {
 358                 formatted += '[';
 359                 if(var.array_size)
 360                         var.array_size->visit(*this);
 361                 formatted += ']';
 362         }
 363         if(var.init_expression)
 364         {
 365                 formatted += " = ";
 366                 var.init_expression->visit(*this);
 367         }
 368         if(!parameter_list)
 369                 formatted += ';';
 370 }
 371
 372 void ProgramCompiler::Formatter::visit(InterfaceBlock &iface)
 373 {
 374         SetForScope<string> set(block_interface, iface.interface);
 375         formatted += format("%s %s\n", iface.interface, iface.name);
 376         iface.members.visit(*this);
 377         formatted += ';';
 378 }
 379
 380 void ProgramCompiler::Formatter::visit(FunctionDeclaration &func)
 381 {
 382         formatted += format("%s %s(", func.return_type, func.name);
 383         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 384         {
 385                 if(i!=func.parameters.begin())
 386                         formatted += ", ";
 387                 SetFlag set(parameter_list);
 388                 (*i)->visit(*this);
 389         }
 390         formatted += ')';
 391         if(func.definition==&func)
 392         {
 393                 formatted += '\n';
 394                 func.body.visit(*this);
 395         }
 396         else
 397                 formatted += ';';
 398 }
 399
 400 void ProgramCompiler::Formatter::visit(Conditional &cond)
 401 {
 402         if(else_if)
 403                 formatted.replace(formatted.rfind('\n'), string::npos, 1, ' ');
 404
 405         indent -= else_if;
 406
 407         formatted += "if(";
 408         cond.condition->visit(*this);
 409         formatted += ")\n";
 410
 411         cond.body.visit(*this);
 412         if(!cond.else_body.body.empty())
 413         {
 414                 formatted += format("\n%selse\n", string(indent*2, ' '));
 415                 SetForScope<unsigned> set(else_if, 2);
 416                 cond.else_body.visit(*this);
 417         }
 418 }
 419
 420 void ProgramCompiler::Formatter::visit(Iteration &iter)
 421 {
 422         formatted += "for(";
 423         iter.init_statement->visit(*this);
 424         formatted += ' ';
 425         iter.condition->visit(*this);
 426         formatted += "; ";
 427         iter.loop_expression->visit(*this);
 428         formatted += ")\n";
 429         iter.body.visit(*this);
 430 }
 431
 432 void ProgramCompiler::Formatter::visit(Return &ret)
 433 {
 434         formatted += "return ";
 435         ret.expression->visit(*this);
 436         formatted += ';';
 437 }
 438
 439
 440 ProgramCompiler::DeclarationCombiner::DeclarationCombiner():
 441         toplevel(true),
 442         remove_node(false)
 443 { }
 444
 445 void ProgramCompiler::DeclarationCombiner::visit(Block &block)
 446 {
 447         if(!toplevel)
 448                 return;
 449
 450         SetForScope<bool> set(toplevel, false);
 451         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 452         {
 453                 remove_node = false;
 454                 (*i)->visit(*this);
 455                 if(remove_node)
 456                         block.body.erase(i++);
 457                 else
 458                         ++i;
 459         }
 460 }
 461
 462 void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func)
 463 {
 464         vector<FunctionDeclaration *> &decls = functions[func.name];
 465         if(func.definition)
 466         {
 467                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 468                 {
 469                         (*i)->definition = func.definition;
 470                         (*i)->body.body.clear();
 471                 }
 472         }
 473         decls.push_back(&func);
 474 }
 475
 476 void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var)
 477 {
 478         VariableDeclaration *&ptr = variables[var.name];
 479         if(ptr)
 480         {
 481                 ptr->type = var.type;
 482                 if(var.init_expression)
 483                         ptr->init_expression = var.init_expression;
 484                 remove_node = true;
 485         }
 486         else
 487                 ptr = &var;
 488 }
 489
 490
 491 ProgramCompiler::VariableResolver::VariableResolver():
 492         anonymous(false),
 493         record_target(false),
 494         assignment_target(0),
 495         self_referencing(false)
 496 { }
 497
 498 void ProgramCompiler::VariableResolver::apply(Stage &s)
 499 {
 500         SetForScope<Stage *> set(stage, &s);
 501         Stage *builtins = get_builtins(stage->type);
 502         if(builtins)
 503                 blocks.push_back(&builtins->content);
 504         stage->content.visit(*this);
 505         if(builtins)
 506                 blocks.pop_back();
 507 }
 508
 509 void ProgramCompiler::VariableResolver::visit(Block &block)
 510 {
 511         blocks.push_back(&block);
 512         block.variables.clear();
 513         TraversingVisitor::visit(block);
 514         blocks.pop_back();
 515 }
 516
 517 void ProgramCompiler::VariableResolver::visit(VariableReference &var)
 518 {
 519         var.declaration = 0;
 520         type = 0;
 521         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 522         {
 523                 --i;
 524                 map<string, VariableDeclaration *>::iterator j = (*i)->variables.find(var.name);
 525                 if(j!=(*i)->variables.end())
 526                 {
 527                         var.declaration = j->second;
 528                         type = j->second->type_declaration;
 529                         break;
 530                 }
 531         }
 532
 533         if(record_target)
 534         {
 535                 if(assignment_target)
 536                 {
 537                         record_target = false;
 538                         assignment_target = 0;
 539                 }
 540                 else
 541                         assignment_target = var.declaration;
 542         }
 543         else if(var.declaration && var.declaration==assignment_target)
 544                 self_referencing = true;
 545 }
 546
 547 void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc)
 548 {
 549         type = 0;
 550         TraversingVisitor::visit(memacc);
 551         memacc.declaration = 0;
 552         if(type)
 553         {
 554                 map<string, VariableDeclaration *>::iterator i = type->members.variables.find(memacc.member);
 555                 if(i!=type->members.variables.end())
 556                 {
 557                         memacc.declaration = i->second;
 558                         type = i->second->type_declaration;
 559                 }
 560                 else
 561                         type = 0;
 562         }
 563 }
 564
 565 void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary)
 566 {
 567         if(binary.oper=="[")
 568         {
 569                 {
 570                         SetForScope<bool> set(record_target, false);
 571                         binary.right->visit(*this);
 572                 }
 573                 type = 0;
 574                 binary.left->visit(*this);
 575         }
 576         else
 577         {
 578                 TraversingVisitor::visit(binary);
 579                 type = 0;
 580         }
 581 }
 582
 583 void ProgramCompiler::VariableResolver::visit(Assignment &assign)
 584 {
 585         {
 586                 SetFlag set(record_target);
 587                 assignment_target = 0;
 588                 assign.left->visit(*this);
 589         }
 590
 591         self_referencing = false;
 592         assign.right->visit(*this);
 593
 594         assign.self_referencing = (self_referencing || assign.oper!="=");
 595         assign.target_declaration = assignment_target;
 596 }
 597
 598 void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct)
 599 {
 600         TraversingVisitor::visit(strct);
 601         blocks.back()->types[strct.name] = &strct;
 602 }
 603
 604 void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var)
 605 {
 606         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 607         {
 608                 --i;
 609                 map<string, StructDeclaration *>::iterator j = (*i)->types.find(var.type);
 610                 if(j!=(*i)->types.end())
 611                         var.type_declaration = j->second;
 612         }
 613
 614         if(!block_interface.empty() && var.interface.empty())
 615                 var.interface = block_interface;
 616
 617         TraversingVisitor::visit(var);
 618         blocks.back()->variables[var.name] = &var;
 619         if(anonymous && blocks.size()>1)
 620                 blocks[blocks.size()-2]->variables[var.name] = &var;
 621 }
 622
 623 void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
 624 {
 625         SetFlag set(anonymous);
 626         SetForScope<string> set2(block_interface, iface.interface);
 627         TraversingVisitor::visit(iface);
 628 }
 629
 630
 631 void ProgramCompiler::FunctionResolver::visit(FunctionCall &call)
 632 {
 633         map<string, vector<FunctionDeclaration *> >::iterator i = functions.find(call.name);
 634         if(i!=functions.end())
 635                 call.declaration = i->second.back();
 636
 637         TraversingVisitor::visit(call);
 638 }
 639
 640 void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func)
 641 {
 642         vector<FunctionDeclaration *> &decls = functions[func.name];
 643         if(func.definition)
 644         {
 645                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 646                         (*i)->definition = func.definition;
 647                 decls.clear();
 648                 decls.push_back(&func);
 649         }
 650         else if(!decls.empty() && decls.back()->definition)
 651                 func.definition = decls.back()->definition;
 652         else
 653                 decls.push_back(&func);
 654
 655         TraversingVisitor::visit(func);
 656 }
 657
 658
 659 ProgramCompiler::BlockModifier::BlockModifier():
 660         remove_node(false)
 661 { }
 662
 663 void ProgramCompiler::BlockModifier::flatten_block(Block &block)
 664 {
 665         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 666                 insert_nodes.push_back((*i)->clone());
 667         remove_node = true;
 668 }
 669
 670 void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<NodePtr<Node> >::iterator &i)
 671 {
 672         for(list<Node *>::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j)
 673                 block.body.insert(i, *j);
 674         insert_nodes.clear();
 675
 676         if(remove_node)
 677                 block.body.erase(i++);
 678         else
 679                 ++i;
 680         remove_node = false;
 681 }
 682
 683 void ProgramCompiler::BlockModifier::visit(Block &block)
 684 {
 685         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 686         {
 687                 (*i)->visit(*this);
 688                 apply_and_increment(block, i);
 689         }
 690 }
 691
 692
 693 ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
 694         scope_level(0)
 695 { }
 696
 697 string ProgramCompiler::InterfaceGenerator::get_out_prefix(StageType type)
 698 {
 699         if(type==VERTEX)
 700                 return "_vs_out_";
 701         else if(type==GEOMETRY)
 702                 return "_gs_out_";
 703         else
 704                 return string();
 705 }
 706
 707 void ProgramCompiler::InterfaceGenerator::apply(Stage &s)
 708 {
 709         SetForScope<Stage *> set(stage, &s);
 710         if(stage->previous)
 711                 in_prefix = get_out_prefix(stage->previous->type);
 712         out_prefix = get_out_prefix(stage->type);
 713         stage->content.visit(*this);
 714 }
 715
 716 void ProgramCompiler::InterfaceGenerator::visit(Block &block)
 717 {
 718         SetForScope<unsigned> set(scope_level, scope_level+1);
 719         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 720         {
 721                 (*i)->visit(*this);
 722
 723                 if(scope_level==1)
 724                 {
 725                         for(map<string, VariableDeclaration *>::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
 726                         {
 727                                 list<NodePtr<Node> >::iterator k = block.body.insert(i, j->second);
 728                                 (*k)->visit(*this);
 729                         }
 730                         iface_declarations.clear();
 731                 }
 732
 733                 apply_and_increment(block, i);
 734         }
 735 }
 736
 737 string ProgramCompiler::InterfaceGenerator::change_prefix(const string &name, const string &prefix) const
 738 {
 739         unsigned offset = (name.compare(0, in_prefix.size(), in_prefix) ? 0 : in_prefix.size());
 740         return prefix+name.substr(offset);
 741 }
 742
 743 bool ProgramCompiler::InterfaceGenerator::generate_interface(VariableDeclaration &var, const string &iface, const string &name)
 744 {
 745         const map<string, VariableDeclaration *> &stage_vars = (iface=="in" ? stage->in_variables : stage->out_variables);
 746         if(stage_vars.count(name) || iface_declarations.count(name))
 747                 return false;
 748
 749         VariableDeclaration* iface_var = new VariableDeclaration;
 750         iface_var->sampling = var.sampling;
 751         iface_var->interface = iface;
 752         iface_var->type = var.type;
 753         iface_var->type_declaration = var.type_declaration;
 754         iface_var->name = name;
 755         if(stage->type==GEOMETRY)
 756                 iface_var->array = ((var.array && var.interface!="in") || iface=="in");
 757         else
 758                 iface_var->array = var.array;
 759         if(iface_var->array)
 760                 iface_var->array_size = var.array_size;
 761         if(iface=="in")
 762                 iface_var->linked_declaration = &var;
 763         iface_declarations[name] = iface_var;
 764
 765         return true;
 766 }
 767
 768 void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left, ProgramSyntax::Expression *right)
 769 {
 770         Assignment *assign = new Assignment;
 771         VariableReference *ref = new VariableReference;
 772         ref->name = left;
 773         assign->left = ref;
 774         assign->oper = "=";
 775         assign->right = right;
 776
 777         ExpressionStatement *stmt = new ExpressionStatement;
 778         stmt->expression = assign;
 779         insert_nodes.push_back(stmt);
 780 }
 781
 782 void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
 783 {
 784         if(var.declaration || !stage->previous)
 785                 return;
 786         if(iface_declarations.count(var.name))
 787                 return;
 788
 789         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 790         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 791         if(i==prev_out.end())
 792                 i = prev_out.find(in_prefix+var.name);
 793         if(i!=prev_out.end())
 794                 generate_interface(*i->second, "in", var.name);
 795 }
 796
 797 void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
 798 {
 799         if(var.interface=="out")
 800         {
 801                 if(scope_level==1)
 802                         stage->out_variables[var.name] = &var;
 803                 else if(generate_interface(var, "out", change_prefix(var.name, string())))
 804                 {
 805                         remove_node = true;
 806                         if(var.init_expression)
 807                                 insert_assignment(var.name, var.init_expression->clone());
 808                 }
 809         }
 810         else if(var.interface=="in")
 811         {
 812                 stage->in_variables[var.name] = &var;
 813                 if(var.linked_declaration)
 814                         var.linked_declaration->linked_declaration = &var;
 815                 else if(stage->previous)
 816                 {
 817                         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 818                         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 819                         if(i!=prev_out.end())
 820                         {
 821                                 var.linked_declaration = i->second;
 822                                 i->second->linked_declaration = &var;
 823                         }
 824                 }
 825         }
 826
 827         TraversingVisitor::visit(var);
 828 }
 829
 830 void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 831 {
 832         vector<VariableDeclaration *> pass_vars;
 833
 834         for(map<string, VariableDeclaration *>::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i)
 835                 pass_vars.push_back(i->second);
 836         for(map<string, VariableDeclaration *>::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i)
 837                 if(i->second->interface=="in")
 838                         pass_vars.push_back(i->second);
 839
 840         if(stage->previous)
 841         {
 842                 const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 843                 for(map<string, VariableDeclaration *>::const_iterator i=prev_out.begin(); i!=prev_out.end(); ++i)
 844                 {
 845                         bool linked = false;
 846                         for(vector<VariableDeclaration *>::const_iterator j=pass_vars.begin(); (!linked && j!=pass_vars.end()); ++j)
 847                                 linked = ((*j)->linked_declaration==i->second);
 848
 849                         if(!linked && generate_interface(*i->second, "in", i->second->name))
 850                                 pass_vars.push_back(i->second);
 851                 }
 852         }
 853
 854         if(stage->type==GEOMETRY)
 855         {
 856                 VariableReference *ref = new VariableReference;
 857                 ref->name = "gl_in";
 858
 859                 BinaryExpression *subscript = new BinaryExpression;
 860                 subscript->left = ref;
 861                 subscript->oper = "[";
 862                 subscript->right = pass.subscript;
 863                 subscript->after = "]";
 864
 865                 MemberAccess *memacc = new MemberAccess;
 866                 memacc->left = subscript;
 867                 memacc->member = "gl_Position";
 868
 869                 insert_assignment("gl_Position", memacc);
 870         }
 871
 872         for(vector<VariableDeclaration *>::const_iterator i=pass_vars.begin(); i!=pass_vars.end(); ++i)
 873         {
 874                 string out_name = change_prefix((*i)->name, out_prefix);
 875                 generate_interface(**i, "out", out_name);
 876
 877                 VariableReference *ref = new VariableReference;
 878                 ref->name = (*i)->name;
 879                 if(pass.subscript)
 880                 {
 881                         BinaryExpression *subscript = new BinaryExpression;
 882                         subscript->left = ref;
 883                         subscript->oper = "[";
 884                         subscript->right = pass.subscript;
 885                         subscript->after = "]";
 886                         insert_assignment(out_name, subscript);
 887                 }
 888                 else
 889                         insert_assignment(out_name, ref);
 890         }
 891
 892         remove_node = true;
 893 }
 894
 895
 896 void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
 897 {
 898         if(var.declaration)
 899                 var.name = var.declaration->name;
 900 }
 901
 902 void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
 903 {
 904         if(var.linked_declaration)
 905                 var.name = var.linked_declaration->name;
 906         TraversingVisitor::visit(var);
 907 }
 908
 909
 910 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
 911         variable_values(0),
 912         result(0.0f),
 913         result_valid(false)
 914 { }
 915
 916 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
 917         variable_values(&v),
 918         result(0.0f),
 919         result_valid(false)
 920 { }
 921
 922 void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal)
 923 {
 924         if(literal.token=="true")
 925                 result = 1.0f;
 926         else if(literal.token=="false")
 927                 result = 0.0f;
 928         else
 929                 result = lexical_cast<float>(literal.token);
 930         result_valid = true;
 931 }
 932
 933 void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
 934 {
 935         if(!var.declaration)
 936                 return;
 937
 938         if(variable_values)
 939         {
 940                 ValueMap::const_iterator i = variable_values->find(var.declaration);
 941                 if(i!=variable_values->end())
 942                         i->second->visit(*this);
 943         }
 944         else if(var.declaration->init_expression)
 945                 var.declaration->init_expression->visit(*this);
 946 }
 947
 948 void ProgramCompiler::ExpressionEvaluator::visit(UnaryExpression &unary)
 949 {
 950         result_valid = false;
 951         unary.expression->visit(*this);
 952         if(!result_valid)
 953                 return;
 954
 955         if(unary.oper=="!")
 956                 result = !result;
 957         else
 958                 result_valid = false;
 959 }
 960
 961 void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 962 {
 963         result_valid = false;
 964         binary.left->visit(*this);
 965         if(!result_valid)
 966                 return;
 967
 968         float left_result = result;
 969         result_valid = false;
 970         binary.right->visit(*this);
 971         if(!result_valid)
 972                 return;
 973
 974         if(binary.oper=="<")
 975                 result = (left_result<result);
 976         else if(binary.oper=="<=")
 977                 result = (left_result<=result);
 978         else if(binary.oper==">")
 979                 result = (left_result>result);
 980         else if(binary.oper==">=")
 981                 result = (left_result>=result);
 982         else if(binary.oper=="==")
 983                 result = (left_result==result);
 984         else if(binary.oper=="!=")
 985                 result = (left_result!=result);
 986         else if(binary.oper=="&&")
 987                 result = (left_result && result);
 988         else if(binary.oper=="||")
 989                 result = (left_result || result);
 990         else
 991                 result_valid = false;
 992 }
 993
 994
 995 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
 996         scope_level(0)
 997 { }
 998
 999 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
1000 {
1001         SetForScope<unsigned> set(scope_level, scope_level+1);
1002         BlockModifier::visit(block);
1003
1004         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
1005                 variable_values.erase(i->second);
1006 }
1007
1008 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
1009 {
1010         variable_values.erase(assign.target_declaration);
1011 }
1012
1013 void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var)
1014 {
1015         if(var.constant || scope_level>1)
1016                 variable_values[&var] = &*var.init_expression;
1017 }
1018
1019 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
1020 {
1021         ExpressionEvaluator eval(variable_values);
1022         cond.condition->visit(eval);
1023         if(eval.result_valid)
1024                 flatten_block(eval.result ? cond.body : cond.else_body);
1025         else
1026                 TraversingVisitor::visit(cond);
1027 }
1028
1029 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
1030 {
1031         if(iter.condition)
1032         {
1033                 ExpressionEvaluator eval;
1034                 iter.condition->visit(eval);
1035                 if(eval.result_valid && !eval.result)
1036                 {
1037                         remove_node = true;
1038                         return;
1039                 }
1040         }
1041
1042         TraversingVisitor::visit(iter);
1043 }
1044
1045
1046 ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
1047         aggregate(0),
1048         assignment(0),
1049         assignment_target(false)
1050 { }
1051
1052 void ProgramCompiler::UnusedVariableLocator::apply(Stage &s)
1053 {
1054         assignments.push_back(BlockAssignmentMap());
1055         Visitor::apply(s);
1056         assignments.pop_back();
1057 }
1058
1059 void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var)
1060 {
1061         unused_nodes.erase(var.declaration);
1062
1063         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
1064         if(i!=aggregates.end())
1065                 unused_nodes.erase(i->second);
1066
1067         if(assignment_target)
1068                 return;
1069
1070         for(vector<BlockAssignmentMap>::iterator j=assignments.end(); j!=assignments.begin(); )
1071         {
1072                 --j;
1073                 BlockAssignmentMap::iterator k = j->find(var.declaration);
1074                 if(k!=j->end())
1075                 {
1076                         for(vector<Node *>::iterator l=k->second.nodes.begin(); l!=k->second.nodes.end(); ++l)
1077                                 unused_nodes.erase(*l);
1078                         j->erase(k);
1079                         break;
1080                 }
1081         }
1082 }
1083
1084 void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc)
1085 {
1086         TraversingVisitor::visit(memacc);
1087         unused_nodes.erase(memacc.declaration);
1088 }
1089
1090 void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
1091 {
1092         if(binary.oper=="[")
1093         {
1094                 binary.left->visit(*this);
1095                 SetForScope<bool> set(assignment_target, false);
1096                 binary.right->visit(*this);
1097         }
1098         else
1099                 TraversingVisitor::visit(binary);
1100 }
1101
1102 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
1103 {
1104         {
1105                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
1106                 assign.left->visit(*this);
1107         }
1108         assign.right->visit(*this);
1109         assignment = &assign;
1110 }
1111
1112 void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
1113 {
1114         unused_nodes.insert(&node);
1115         BlockAssignmentMap &block_assignments = assignments.back();
1116         AssignmentList &var_assignments = block_assignments[&var];
1117         if(!self_ref)
1118                 var_assignments.nodes.clear();
1119         var_assignments.nodes.push_back(&node);
1120         var_assignments.conditional = false;
1121         var_assignments.self_referencing = self_ref;
1122 }
1123
1124 void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
1125 {
1126         assignment = 0;
1127         TraversingVisitor::visit(expr);
1128         if(assignment && assignment->target_declaration)
1129                 record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
1130 }
1131
1132 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
1133 {
1134         SetForScope<Node *> set(aggregate, &strct);
1135         unused_nodes.insert(&strct);
1136         TraversingVisitor::visit(strct);
1137 }
1138
1139 void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
1140 {
1141         if(aggregate)
1142                 aggregates[&var] = aggregate;
1143         else
1144         {
1145                 unused_nodes.insert(&var);
1146                 if(var.init_expression)
1147                         record_assignment(var, *var.init_expression, false);
1148         }
1149         unused_nodes.erase(var.type_declaration);
1150         TraversingVisitor::visit(var);
1151 }
1152
1153 void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface)
1154 {
1155         SetForScope<Node *> set(aggregate, &iface);
1156         unused_nodes.insert(&iface);
1157         TraversingVisitor::visit(iface);
1158 }
1159
1160 void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
1161 {
1162         assignments.push_back(BlockAssignmentMap());
1163
1164         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1165                 (*i)->visit(*this);
1166         func.body.visit(*this);
1167
1168         BlockAssignmentMap &block_assignments = assignments.back();
1169         for(map<string, VariableDeclaration *>::iterator i=func.body.variables.begin(); i!=func.body.variables.end(); ++i)
1170                 block_assignments.erase(i->second);
1171         for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i)
1172         {
1173                 if(i->first->interface=="out" && stage->type!=FRAGMENT && !i->first->linked_declaration)
1174                         continue;
1175
1176                 for(vector<Node *>::iterator j=i->second.nodes.begin(); j!=i->second.nodes.end(); ++j)
1177                         unused_nodes.erase(*j);
1178         }
1179
1180         assignments.pop_back();
1181 }
1182
1183 void ProgramCompiler::UnusedVariableLocator::merge_down_assignments()
1184 {
1185         BlockAssignmentMap &parent_assignments = assignments[assignments.size()-2];
1186         BlockAssignmentMap &block_assignments = assignments.back();
1187         for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i)
1188         {
1189                 BlockAssignmentMap::iterator j = parent_assignments.find(i->first);
1190                 if(j==parent_assignments.end())
1191                         parent_assignments.insert(*i);
1192                 else if(i->second.self_referencing || i->second.conditional)
1193                 {
1194                         j->second.nodes.insert(j->second.nodes.end(), i->second.nodes.begin(), i->second.nodes.end());
1195                         j->second.conditional |= i->second.conditional;
1196                         j->second.self_referencing |= i->second.self_referencing;
1197                 }
1198                 else
1199                         j->second = i->second;
1200         }
1201         assignments.pop_back();
1202 }
1203
1204 void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond)
1205 {
1206         cond.condition->visit(*this);
1207         assignments.push_back(BlockAssignmentMap());
1208         cond.body.visit(*this);
1209
1210         BlockAssignmentMap if_assignments;
1211         swap(assignments.back(), if_assignments);
1212         cond.else_body.visit(*this);
1213
1214         BlockAssignmentMap &else_assignments = assignments.back();
1215         for(BlockAssignmentMap::iterator i=else_assignments.begin(); i!=else_assignments.end(); ++i)
1216         {
1217                 BlockAssignmentMap::iterator j = if_assignments.find(i->first);
1218                 if(j!=if_assignments.end())
1219                 {
1220                         i->second.nodes.insert(i->second.nodes.end(), j->second.nodes.begin(), j->second.nodes.end());
1221                         i->second.conditional |= j->second.conditional;
1222                         i->second.self_referencing |= j->second.self_referencing;
1223                         if_assignments.erase(j);
1224                 }
1225                 else
1226                         i->second.conditional = true;
1227         }
1228
1229         for(BlockAssignmentMap::iterator i=if_assignments.begin(); i!=if_assignments.end(); ++i)
1230         {
1231                 i->second.conditional = true;
1232                 else_assignments.insert(*i);
1233         }
1234
1235         merge_down_assignments();
1236 }
1237
1238 void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
1239 {
1240         assignments.push_back(BlockAssignmentMap());
1241         TraversingVisitor::visit(iter);
1242         merge_down_assignments();
1243 }
1244
1245
1246 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
1247 {
1248         TraversingVisitor::visit(call);
1249
1250         unused_nodes.erase(call.declaration);
1251         if(call.declaration && call.declaration->definition!=call.declaration)
1252                 used_definitions.insert(call.declaration->definition);
1253 }
1254
1255 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
1256 {
1257         TraversingVisitor::visit(func);
1258
1259         if(func.name!="main" && !used_definitions.count(&func))
1260                 unused_nodes.insert(&func);
1261 }
1262
1263
1264 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
1265         to_remove(r)
1266 { }
1267
1268 void ProgramCompiler::NodeRemover::visit(Block &block)
1269 {
1270         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
1271         {
1272                 (*i)->visit(*this);
1273                 if(to_remove.count(&**i))
1274                         block.body.erase(i++);
1275                 else
1276                         ++i;
1277         }
1278 }
1279
1280 void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
1281 {
1282         if(to_remove.count(&var))
1283         {
1284                 stage->in_variables.erase(var.name);
1285                 stage->out_variables.erase(var.name);
1286                 if(var.linked_declaration)
1287                         var.linked_declaration->linked_declaration = 0;
1288         }
1289         else if(var.init_expression && to_remove.count(&*var.init_expression))
1290                 var.init_expression = 0;
1291 }
1292
1293
1294 ProgramCompiler::LegacyConverter::LegacyConverter():
1295         target_version(get_glsl_version())
1296 { }
1297
1298 ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v):
1299         target_version(v)
1300 { }
1301
1302 bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version)
1303 {
1304         if(target_version<feature_version)
1305                 return false;
1306         else if(stage->required_version<feature_version)
1307                 stage->required_version = feature_version;
1308
1309         return true;
1310 }
1311
1312 void ProgramCompiler::LegacyConverter::visit(VariableReference &var)
1313 {
1314         if(var.name==frag_out_name && !check_version(Version(1, 30)))
1315         {
1316                 var.name = "gl_FragColor";
1317                 var.declaration = 0;
1318                 type = "vec4";
1319         }
1320         else if(var.declaration)
1321                 type = var.declaration->type;
1322         else
1323                 type = string();
1324 }
1325
1326 void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
1327 {
1328         if(call.name=="texture" && !call.declaration && !check_version(Version(1, 30)))
1329         {
1330                 vector<NodePtr<Expression> >::iterator i = call.arguments.begin();
1331                 if(i!=call.arguments.end())
1332                 {
1333                         (*i)->visit(*this);
1334                         if(type=="sampler1D")
1335                                 call.name = "texture1D";
1336                         else if(type=="sampler2D")
1337                                 call.name = "texture2D";
1338                         else if(type=="sampler3D")
1339                                 call.name = "texture3D";
1340                         else if(type=="sampler1DShadow")
1341                                 call.name = "shadow1D";
1342                         else if(type=="sampler2DShadow")
1343                                 call.name = "shadow2D";
1344
1345                         for(; i!=call.arguments.end(); ++i)
1346                                 (*i)->visit(*this);
1347                 }
1348         }
1349         else
1350                 TraversingVisitor::visit(call);
1351 }
1352
1353 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
1354 {
1355         if(var.interface=="in" || var.interface=="out")
1356                 if(!check_version(Version(1, 30)))
1357                 {
1358                         if(stage->type==VERTEX && var.interface=="in")
1359                                 var.interface = "attribute";
1360                         else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in"))
1361                                 var.interface = "varying";
1362                         else if(stage->type==FRAGMENT && var.interface=="out")
1363                         {
1364                                 frag_out_name = var.name;
1365                                 remove_node = true;
1366                         }
1367                 }
1368
1369         TraversingVisitor::visit(var);
1370 }
1371
1372 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)
1373 {
1374         if(!check_version(Version(1, 50)))
1375                 flatten_block(iface.members);
1376 }
1377
1378 } // namespace GL
1379 } // namespace Msp