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