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                 if(var.init_expression)
 482                         ptr->init_expression = var.init_expression;
 483                 remove_node = true;
 484         }
 485         else
 486                 ptr = &var;
 487 }
 488
 489
 490 ProgramCompiler::VariableResolver::VariableResolver():
 491         anonymous(false),
 492         record_target(false),
 493         assignment_target(0),
 494         self_referencing(false)
 495 { }
 496
 497 void ProgramCompiler::VariableResolver::apply(Stage &s)
 498 {
 499         SetForScope<Stage *> set(stage, &s);
 500         Stage *builtins = get_builtins(stage->type);
 501         if(builtins)
 502                 blocks.push_back(&builtins->content);
 503         stage->content.visit(*this);
 504         if(builtins)
 505                 blocks.pop_back();
 506 }
 507
 508 void ProgramCompiler::VariableResolver::visit(Block &block)
 509 {
 510         blocks.push_back(&block);
 511         block.variables.clear();
 512         TraversingVisitor::visit(block);
 513         blocks.pop_back();
 514 }
 515
 516 void ProgramCompiler::VariableResolver::visit(VariableReference &var)
 517 {
 518         var.declaration = 0;
 519         type = 0;
 520         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 521         {
 522                 --i;
 523                 map<string, VariableDeclaration *>::iterator j = (*i)->variables.find(var.name);
 524                 if(j!=(*i)->variables.end())
 525                 {
 526                         var.declaration = j->second;
 527                         type = j->second->type_declaration;
 528                         break;
 529                 }
 530         }
 531
 532         if(record_target)
 533         {
 534                 if(assignment_target)
 535                 {
 536                         record_target = false;
 537                         assignment_target = 0;
 538                 }
 539                 else
 540                         assignment_target = var.declaration;
 541         }
 542         else if(var.declaration && var.declaration==assignment_target)
 543                 self_referencing = true;
 544 }
 545
 546 void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc)
 547 {
 548         type = 0;
 549         TraversingVisitor::visit(memacc);
 550         memacc.declaration = 0;
 551         if(type)
 552         {
 553                 map<string, VariableDeclaration *>::iterator i = type->members.variables.find(memacc.member);
 554                 if(i!=type->members.variables.end())
 555                 {
 556                         memacc.declaration = i->second;
 557                         type = i->second->type_declaration;
 558                 }
 559                 else
 560                         type = 0;
 561         }
 562 }
 563
 564 void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary)
 565 {
 566         if(binary.oper=="[")
 567         {
 568                 {
 569                         SetForScope<bool> set(record_target, false);
 570                         binary.right->visit(*this);
 571                 }
 572                 type = 0;
 573                 binary.left->visit(*this);
 574         }
 575         else
 576         {
 577                 TraversingVisitor::visit(binary);
 578                 type = 0;
 579         }
 580 }
 581
 582 void ProgramCompiler::VariableResolver::visit(Assignment &assign)
 583 {
 584         {
 585                 SetFlag set(record_target);
 586                 assignment_target = 0;
 587                 assign.left->visit(*this);
 588         }
 589
 590         self_referencing = false;
 591         assign.right->visit(*this);
 592
 593         assign.self_referencing = (self_referencing || assign.oper!="=");
 594         assign.target_declaration = assignment_target;
 595 }
 596
 597 void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct)
 598 {
 599         TraversingVisitor::visit(strct);
 600         blocks.back()->types[strct.name] = &strct;
 601 }
 602
 603 void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var)
 604 {
 605         for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
 606         {
 607                 --i;
 608                 map<string, StructDeclaration *>::iterator j = (*i)->types.find(var.type);
 609                 if(j!=(*i)->types.end())
 610                         var.type_declaration = j->second;
 611         }
 612
 613         if(!block_interface.empty() && var.interface.empty())
 614                 var.interface = block_interface;
 615
 616         TraversingVisitor::visit(var);
 617         blocks.back()->variables[var.name] = &var;
 618         if(anonymous && blocks.size()>1)
 619                 blocks[blocks.size()-2]->variables[var.name] = &var;
 620 }
 621
 622 void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
 623 {
 624         SetFlag set(anonymous);
 625         SetForScope<string> set2(block_interface, iface.interface);
 626         TraversingVisitor::visit(iface);
 627 }
 628
 629
 630 void ProgramCompiler::FunctionResolver::visit(FunctionCall &call)
 631 {
 632         map<string, vector<FunctionDeclaration *> >::iterator i = functions.find(call.name);
 633         if(i!=functions.end())
 634                 call.declaration = i->second.back();
 635
 636         TraversingVisitor::visit(call);
 637 }
 638
 639 void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func)
 640 {
 641         vector<FunctionDeclaration *> &decls = functions[func.name];
 642         if(func.definition)
 643         {
 644                 for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 645                         (*i)->definition = func.definition;
 646                 decls.clear();
 647                 decls.push_back(&func);
 648         }
 649         else if(!decls.empty() && decls.back()->definition)
 650                 func.definition = decls.back()->definition;
 651         else
 652                 decls.push_back(&func);
 653
 654         TraversingVisitor::visit(func);
 655 }
 656
 657
 658 ProgramCompiler::BlockModifier::BlockModifier():
 659         remove_node(false)
 660 { }
 661
 662 void ProgramCompiler::BlockModifier::flatten_block(Block &block)
 663 {
 664         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 665                 insert_nodes.push_back((*i)->clone());
 666         remove_node = true;
 667 }
 668
 669 void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<NodePtr<Node> >::iterator &i)
 670 {
 671         for(list<Node *>::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j)
 672                 block.body.insert(i, *j);
 673         insert_nodes.clear();
 674
 675         if(remove_node)
 676                 block.body.erase(i++);
 677         else
 678                 ++i;
 679         remove_node = false;
 680 }
 681
 682 void ProgramCompiler::BlockModifier::visit(Block &block)
 683 {
 684         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 685         {
 686                 (*i)->visit(*this);
 687                 apply_and_increment(block, i);
 688         }
 689 }
 690
 691
 692 ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
 693         scope_level(0)
 694 { }
 695
 696 string ProgramCompiler::InterfaceGenerator::get_out_prefix(StageType type)
 697 {
 698         if(type==VERTEX)
 699                 return "_vs_out_";
 700         else if(type==GEOMETRY)
 701                 return "_gs_out_";
 702         else
 703                 return string();
 704 }
 705
 706 void ProgramCompiler::InterfaceGenerator::apply(Stage &s)
 707 {
 708         SetForScope<Stage *> set(stage, &s);
 709         if(stage->previous)
 710                 in_prefix = get_out_prefix(stage->previous->type);
 711         out_prefix = get_out_prefix(stage->type);
 712         stage->content.visit(*this);
 713 }
 714
 715 void ProgramCompiler::InterfaceGenerator::visit(Block &block)
 716 {
 717         SetForScope<unsigned> set(scope_level, scope_level+1);
 718         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
 719         {
 720                 (*i)->visit(*this);
 721
 722                 if(scope_level==1)
 723                 {
 724                         for(map<string, VariableDeclaration *>::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
 725                         {
 726                                 list<NodePtr<Node> >::iterator k = block.body.insert(i, j->second);
 727                                 (*k)->visit(*this);
 728                         }
 729                         iface_declarations.clear();
 730                 }
 731
 732                 apply_and_increment(block, i);
 733         }
 734 }
 735
 736 string ProgramCompiler::InterfaceGenerator::change_prefix(const string &name, const string &prefix) const
 737 {
 738         unsigned offset = (name.compare(0, in_prefix.size(), in_prefix) ? 0 : in_prefix.size());
 739         return prefix+name.substr(offset);
 740 }
 741
 742 bool ProgramCompiler::InterfaceGenerator::generate_interface(VariableDeclaration &var, const string &iface, const string &name)
 743 {
 744         const map<string, VariableDeclaration *> &stage_vars = (iface=="in" ? stage->in_variables : stage->out_variables);
 745         if(stage_vars.count(name) || iface_declarations.count(name))
 746                 return false;
 747
 748         VariableDeclaration* iface_var = new VariableDeclaration;
 749         iface_var->sampling = var.sampling;
 750         iface_var->interface = iface;
 751         iface_var->type = var.type;
 752         iface_var->type_declaration = var.type_declaration;
 753         iface_var->name = name;
 754         if(stage->type==GEOMETRY)
 755                 iface_var->array = ((var.array && var.interface!="in") || iface=="in");
 756         else
 757                 iface_var->array = var.array;
 758         if(iface_var->array)
 759                 iface_var->array_size = var.array_size;
 760         if(iface=="in")
 761                 iface_var->linked_declaration = &var;
 762         iface_declarations[name] = iface_var;
 763
 764         return true;
 765 }
 766
 767 void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left, ProgramSyntax::Expression *right)
 768 {
 769         Assignment *assign = new Assignment;
 770         VariableReference *ref = new VariableReference;
 771         ref->name = left;
 772         assign->left = ref;
 773         assign->oper = "=";
 774         assign->right = right;
 775
 776         ExpressionStatement *stmt = new ExpressionStatement;
 777         stmt->expression = assign;
 778         insert_nodes.push_back(stmt);
 779 }
 780
 781 void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
 782 {
 783         if(var.declaration || !stage->previous)
 784                 return;
 785         if(iface_declarations.count(var.name))
 786                 return;
 787
 788         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 789         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 790         if(i==prev_out.end())
 791                 i = prev_out.find(in_prefix+var.name);
 792         if(i!=prev_out.end())
 793                 generate_interface(*i->second, "in", var.name);
 794 }
 795
 796 void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
 797 {
 798         if(var.interface=="out")
 799         {
 800                 if(scope_level==1)
 801                         stage->out_variables[var.name] = &var;
 802                 else if(generate_interface(var, "out", change_prefix(var.name, string())))
 803                 {
 804                         remove_node = true;
 805                         if(var.init_expression)
 806                                 insert_assignment(var.name, var.init_expression->clone());
 807                 }
 808         }
 809         else if(var.interface=="in")
 810         {
 811                 stage->in_variables[var.name] = &var;
 812                 if(var.linked_declaration)
 813                         var.linked_declaration->linked_declaration = &var;
 814                 else if(stage->previous)
 815                 {
 816                         const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 817                         map<string, VariableDeclaration *>::const_iterator i = prev_out.find(var.name);
 818                         if(i!=prev_out.end())
 819                         {
 820                                 var.linked_declaration = i->second;
 821                                 i->second->linked_declaration = &var;
 822                         }
 823                 }
 824         }
 825
 826         TraversingVisitor::visit(var);
 827 }
 828
 829 void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 830 {
 831         vector<VariableDeclaration *> pass_vars;
 832
 833         for(map<string, VariableDeclaration *>::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i)
 834                 pass_vars.push_back(i->second);
 835         for(map<string, VariableDeclaration *>::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i)
 836                 if(i->second->interface=="in")
 837                         pass_vars.push_back(i->second);
 838
 839         if(stage->previous)
 840         {
 841                 const map<string, VariableDeclaration *> &prev_out = stage->previous->out_variables;
 842                 for(map<string, VariableDeclaration *>::const_iterator i=prev_out.begin(); i!=prev_out.end(); ++i)
 843                 {
 844                         bool linked = false;
 845                         for(vector<VariableDeclaration *>::const_iterator j=pass_vars.begin(); (!linked && j!=pass_vars.end()); ++j)
 846                                 linked = ((*j)->linked_declaration==i->second);
 847
 848                         if(!linked && generate_interface(*i->second, "in", i->second->name))
 849                                 pass_vars.push_back(i->second);
 850                 }
 851         }
 852
 853         if(stage->type==GEOMETRY)
 854         {
 855                 VariableReference *ref = new VariableReference;
 856                 ref->name = "gl_in";
 857
 858                 BinaryExpression *subscript = new BinaryExpression;
 859                 subscript->left = ref;
 860                 subscript->oper = "[";
 861                 subscript->right = pass.subscript;
 862                 subscript->after = "]";
 863
 864                 MemberAccess *memacc = new MemberAccess;
 865                 memacc->left = subscript;
 866                 memacc->member = "gl_Position";
 867
 868                 insert_assignment("gl_Position", memacc);
 869         }
 870
 871         for(vector<VariableDeclaration *>::const_iterator i=pass_vars.begin(); i!=pass_vars.end(); ++i)
 872         {
 873                 string out_name = change_prefix((*i)->name, out_prefix);
 874                 generate_interface(**i, "out", out_name);
 875
 876                 VariableReference *ref = new VariableReference;
 877                 ref->name = (*i)->name;
 878                 if(pass.subscript)
 879                 {
 880                         BinaryExpression *subscript = new BinaryExpression;
 881                         subscript->left = ref;
 882                         subscript->oper = "[";
 883                         subscript->right = pass.subscript;
 884                         subscript->after = "]";
 885                         insert_assignment(out_name, subscript);
 886                 }
 887                 else
 888                         insert_assignment(out_name, ref);
 889         }
 890
 891         remove_node = true;
 892 }
 893
 894
 895 void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
 896 {
 897         if(var.declaration)
 898                 var.name = var.declaration->name;
 899 }
 900
 901 void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
 902 {
 903         if(var.linked_declaration)
 904                 var.name = var.linked_declaration->name;
 905         TraversingVisitor::visit(var);
 906 }
 907
 908
 909 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
 910         variable_values(0),
 911         result(0.0f),
 912         result_valid(false)
 913 { }
 914
 915 ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
 916         variable_values(&v),
 917         result(0.0f),
 918         result_valid(false)
 919 { }
 920
 921 void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal)
 922 {
 923         if(literal.token=="true")
 924                 result = 1.0f;
 925         else if(literal.token=="false")
 926                 result = 0.0f;
 927         else
 928                 result = lexical_cast<float>(literal.token);
 929         result_valid = true;
 930 }
 931
 932 void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
 933 {
 934         if(!var.declaration)
 935                 return;
 936
 937         if(variable_values)
 938         {
 939                 ValueMap::const_iterator i = variable_values->find(var.declaration);
 940                 if(i!=variable_values->end())
 941                         i->second->visit(*this);
 942         }
 943         else if(var.declaration->init_expression)
 944                 var.declaration->init_expression->visit(*this);
 945 }
 946
 947 void ProgramCompiler::ExpressionEvaluator::visit(UnaryExpression &unary)
 948 {
 949         result_valid = false;
 950         unary.expression->visit(*this);
 951         if(!result_valid)
 952                 return;
 953
 954         if(unary.oper=="!")
 955                 result = !result;
 956         else
 957                 result_valid = false;
 958 }
 959
 960 void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 961 {
 962         result_valid = false;
 963         binary.left->visit(*this);
 964         if(!result_valid)
 965                 return;
 966
 967         float left_result = result;
 968         result_valid = false;
 969         binary.right->visit(*this);
 970         if(!result_valid)
 971                 return;
 972
 973         if(binary.oper=="<")
 974                 result = (left_result<result);
 975         else if(binary.oper=="<=")
 976                 result = (left_result<=result);
 977         else if(binary.oper==">")
 978                 result = (left_result>result);
 979         else if(binary.oper==">=")
 980                 result = (left_result>=result);
 981         else if(binary.oper=="==")
 982                 result = (left_result==result);
 983         else if(binary.oper=="!=")
 984                 result = (left_result!=result);
 985         else if(binary.oper=="&&")
 986                 result = (left_result && result);
 987         else if(binary.oper=="||")
 988                 result = (left_result || result);
 989         else
 990                 result_valid = false;
 991 }
 992
 993
 994 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
 995         scope_level(0)
 996 { }
 997
 998 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
 999 {
1000         SetForScope<unsigned> set(scope_level, scope_level+1);
1001         BlockModifier::visit(block);
1002
1003         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
1004                 variable_values.erase(i->second);
1005 }
1006
1007 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
1008 {
1009         variable_values.erase(assign.target_declaration);
1010 }
1011
1012 void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var)
1013 {
1014         if(var.constant || scope_level>1)
1015                 variable_values[&var] = &*var.init_expression;
1016 }
1017
1018 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
1019 {
1020         ExpressionEvaluator eval(variable_values);
1021         cond.condition->visit(eval);
1022         if(eval.result_valid)
1023                 flatten_block(eval.result ? cond.body : cond.else_body);
1024         else
1025                 TraversingVisitor::visit(cond);
1026 }
1027
1028 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
1029 {
1030         if(iter.condition)
1031         {
1032                 ExpressionEvaluator eval;
1033                 iter.condition->visit(eval);
1034                 if(eval.result_valid && !eval.result)
1035                 {
1036                         remove_node = true;
1037                         return;
1038                 }
1039         }
1040
1041         TraversingVisitor::visit(iter);
1042 }
1043
1044
1045 ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
1046         aggregate(0),
1047         assignment(0),
1048         assignment_target(false)
1049 { }
1050
1051 void ProgramCompiler::UnusedVariableLocator::apply(Stage &s)
1052 {
1053         assignments.push_back(BlockAssignmentMap());
1054         Visitor::apply(s);
1055         assignments.pop_back();
1056 }
1057
1058 void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var)
1059 {
1060         unused_nodes.erase(var.declaration);
1061
1062         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
1063         if(i!=aggregates.end())
1064                 unused_nodes.erase(i->second);
1065
1066         if(assignment_target)
1067                 return;
1068
1069         for(vector<BlockAssignmentMap>::iterator j=assignments.end(); j!=assignments.begin(); )
1070         {
1071                 --j;
1072                 BlockAssignmentMap::iterator k = j->find(var.declaration);
1073                 if(k!=j->end())
1074                 {
1075                         for(vector<Node *>::iterator l=k->second.nodes.begin(); l!=k->second.nodes.end(); ++l)
1076                                 unused_nodes.erase(*l);
1077                         j->erase(k);
1078                         break;
1079                 }
1080         }
1081 }
1082
1083 void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc)
1084 {
1085         TraversingVisitor::visit(memacc);
1086         unused_nodes.erase(memacc.declaration);
1087 }
1088
1089 void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
1090 {
1091         if(binary.oper=="[")
1092         {
1093                 binary.left->visit(*this);
1094                 SetForScope<bool> set(assignment_target, false);
1095                 binary.right->visit(*this);
1096         }
1097         else
1098                 TraversingVisitor::visit(binary);
1099 }
1100
1101 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
1102 {
1103         {
1104                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
1105                 assign.left->visit(*this);
1106         }
1107         assign.right->visit(*this);
1108         assignment = &assign;
1109 }
1110
1111 void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
1112 {
1113         unused_nodes.insert(&node);
1114         BlockAssignmentMap &block_assignments = assignments.back();
1115         AssignmentList &var_assignments = block_assignments[&var];
1116         if(!self_ref)
1117                 var_assignments.nodes.clear();
1118         var_assignments.nodes.push_back(&node);
1119         var_assignments.conditional = false;
1120         var_assignments.self_referencing = self_ref;
1121 }
1122
1123 void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
1124 {
1125         assignment = 0;
1126         TraversingVisitor::visit(expr);
1127         if(assignment && assignment->target_declaration)
1128                 record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
1129 }
1130
1131 void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
1132 {
1133         SetForScope<Node *> set(aggregate, &strct);
1134         unused_nodes.insert(&strct);
1135         TraversingVisitor::visit(strct);
1136 }
1137
1138 void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
1139 {
1140         if(aggregate)
1141                 aggregates[&var] = aggregate;
1142         else
1143         {
1144                 unused_nodes.insert(&var);
1145                 if(var.init_expression)
1146                         record_assignment(var, *var.init_expression, false);
1147         }
1148         unused_nodes.erase(var.type_declaration);
1149         TraversingVisitor::visit(var);
1150 }
1151
1152 void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface)
1153 {
1154         SetForScope<Node *> set(aggregate, &iface);
1155         unused_nodes.insert(&iface);
1156         TraversingVisitor::visit(iface);
1157 }
1158
1159 void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func)
1160 {
1161         assignments.push_back(BlockAssignmentMap());
1162
1163         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
1164                 (*i)->visit(*this);
1165         func.body.visit(*this);
1166
1167         BlockAssignmentMap &block_assignments = assignments.back();
1168         for(map<string, VariableDeclaration *>::iterator i=func.body.variables.begin(); i!=func.body.variables.end(); ++i)
1169                 block_assignments.erase(i->second);
1170         for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i)
1171         {
1172                 if(i->first->interface=="out" && stage->type!=FRAGMENT && !i->first->linked_declaration)
1173                         continue;
1174
1175                 for(vector<Node *>::iterator j=i->second.nodes.begin(); j!=i->second.nodes.end(); ++j)
1176                         unused_nodes.erase(*j);
1177         }
1178
1179         assignments.pop_back();
1180 }
1181
1182 void ProgramCompiler::UnusedVariableLocator::merge_down_assignments()
1183 {
1184         BlockAssignmentMap &parent_assignments = assignments[assignments.size()-2];
1185         BlockAssignmentMap &block_assignments = assignments.back();
1186         for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i)
1187         {
1188                 BlockAssignmentMap::iterator j = parent_assignments.find(i->first);
1189                 if(j==parent_assignments.end())
1190                         parent_assignments.insert(*i);
1191                 else if(i->second.self_referencing || i->second.conditional)
1192                 {
1193                         j->second.nodes.insert(j->second.nodes.end(), i->second.nodes.begin(), i->second.nodes.end());
1194                         j->second.conditional |= i->second.conditional;
1195                         j->second.self_referencing |= i->second.self_referencing;
1196                 }
1197                 else
1198                         j->second = i->second;
1199         }
1200         assignments.pop_back();
1201 }
1202
1203 void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond)
1204 {
1205         cond.condition->visit(*this);
1206         assignments.push_back(BlockAssignmentMap());
1207         cond.body.visit(*this);
1208
1209         BlockAssignmentMap if_assignments;
1210         swap(assignments.back(), if_assignments);
1211         cond.else_body.visit(*this);
1212
1213         BlockAssignmentMap &else_assignments = assignments.back();
1214         for(BlockAssignmentMap::iterator i=else_assignments.begin(); i!=else_assignments.end(); ++i)
1215         {
1216                 BlockAssignmentMap::iterator j = if_assignments.find(i->first);
1217                 if(j!=if_assignments.end())
1218                 {
1219                         i->second.nodes.insert(i->second.nodes.end(), j->second.nodes.begin(), j->second.nodes.end());
1220                         i->second.conditional |= j->second.conditional;
1221                         i->second.self_referencing |= j->second.self_referencing;
1222                         if_assignments.erase(j);
1223                 }
1224                 else
1225                         i->second.conditional = true;
1226         }
1227
1228         for(BlockAssignmentMap::iterator i=if_assignments.begin(); i!=if_assignments.end(); ++i)
1229         {
1230                 i->second.conditional = true;
1231                 else_assignments.insert(*i);
1232         }
1233
1234         merge_down_assignments();
1235 }
1236
1237 void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
1238 {
1239         assignments.push_back(BlockAssignmentMap());
1240         TraversingVisitor::visit(iter);
1241         merge_down_assignments();
1242 }
1243
1244
1245 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
1246 {
1247         TraversingVisitor::visit(call);
1248
1249         unused_nodes.erase(call.declaration);
1250         if(call.declaration && call.declaration->definition!=call.declaration)
1251                 used_definitions.insert(call.declaration->definition);
1252 }
1253
1254 void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
1255 {
1256         TraversingVisitor::visit(func);
1257
1258         if(func.name!="main" && !used_definitions.count(&func))
1259                 unused_nodes.insert(&func);
1260 }
1261
1262
1263 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
1264         to_remove(r)
1265 { }
1266
1267 void ProgramCompiler::NodeRemover::visit(Block &block)
1268 {
1269         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
1270         {
1271                 (*i)->visit(*this);
1272                 if(to_remove.count(&**i))
1273                         block.body.erase(i++);
1274                 else
1275                         ++i;
1276         }
1277 }
1278
1279 void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
1280 {
1281         if(to_remove.count(&var))
1282         {
1283                 stage->in_variables.erase(var.name);
1284                 stage->out_variables.erase(var.name);
1285                 if(var.linked_declaration)
1286                         var.linked_declaration->linked_declaration = 0;
1287         }
1288         else if(var.init_expression && to_remove.count(&*var.init_expression))
1289                 var.init_expression = 0;
1290 }
1291
1292
1293 ProgramCompiler::LegacyConverter::LegacyConverter():
1294         target_version(get_glsl_version())
1295 { }
1296
1297 ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v):
1298         target_version(v)
1299 { }
1300
1301 bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version)
1302 {
1303         if(target_version<feature_version)
1304                 return false;
1305         else if(stage->required_version<feature_version)
1306                 stage->required_version = feature_version;
1307
1308         return true;
1309 }
1310
1311 void ProgramCompiler::LegacyConverter::visit(VariableReference &var)
1312 {
1313         if(var.name==frag_out_name && !check_version(Version(1, 30)))
1314         {
1315                 var.name = "gl_FragColor";
1316                 var.declaration = 0;
1317                 type = "vec4";
1318         }
1319         else if(var.declaration)
1320                 type = var.declaration->type;
1321         else
1322                 type = string();
1323 }
1324
1325 void ProgramCompiler::LegacyConverter::visit(FunctionCall &call)
1326 {
1327         if(call.name=="texture" && !call.declaration && !check_version(Version(1, 30)))
1328         {
1329                 vector<NodePtr<Expression> >::iterator i = call.arguments.begin();
1330                 if(i!=call.arguments.end())
1331                 {
1332                         (*i)->visit(*this);
1333                         if(type=="sampler1D")
1334                                 call.name = "texture1D";
1335                         else if(type=="sampler2D")
1336                                 call.name = "texture2D";
1337                         else if(type=="sampler3D")
1338                                 call.name = "texture3D";
1339                         else if(type=="sampler1DShadow")
1340                                 call.name = "shadow1D";
1341                         else if(type=="sampler2DShadow")
1342                                 call.name = "shadow2D";
1343
1344                         for(; i!=call.arguments.end(); ++i)
1345                                 (*i)->visit(*this);
1346                 }
1347         }
1348         else
1349                 TraversingVisitor::visit(call);
1350 }
1351
1352 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
1353 {
1354         if(var.interface=="in" || var.interface=="out")
1355                 if(!check_version(Version(1, 30)))
1356                 {
1357                         if(stage->type==VERTEX && var.interface=="in")
1358                                 var.interface = "attribute";
1359                         else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in"))
1360                                 var.interface = "varying";
1361                         else if(stage->type==FRAGMENT && var.interface=="out")
1362                         {
1363                                 frag_out_name = var.name;
1364                                 remove_node = true;
1365                         }
1366                 }
1367
1368         TraversingVisitor::visit(var);
1369 }
1370
1371 void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)
1372 {
1373         if(!check_version(Version(1, 50)))
1374                 flatten_block(iface.members);
1375 }
1376
1377 } // namespace GL
1378 } // namespace Msp