+#include <msp/core/algorithm.h>
#include <msp/core/hash.h>
#include <msp/core/raii.h>
#include "generate.h"
void ConstantIdAssigner::apply(Module &module, const Features &features)
{
- for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
- i->content.visit(*this);
+ for(Stage &s: module.stages)
+ s.content.visit(*this);
- unsigned max_id = features.max_constant_id;
- for(vector<VariableDeclaration *>::iterator i=auto_constants.begin(); i!=auto_constants.end(); ++i)
+ for(VariableDeclaration *v: auto_constants)
{
- unsigned id = hash32((*i)->name)%(max_id+1);
+ unsigned id = hash32(v->name)%features.constant_id_range;
while(used_ids.count(id))
- ++id;
+ id = (id+1)%features.constant_id_range;
- vector<Layout::Qualifier> &qualifiers = (*i)->layout->qualifiers;
- for(vector<Layout::Qualifier>::iterator j=qualifiers.begin(); j!=qualifiers.end(); ++j)
- if(j->name=="constant_id")
- {
- j->value = id;
- break;
- }
+ auto i = find_member(v->layout->qualifiers, string("constant_id"), &Layout::Qualifier::name);
+ if(i!=v->layout->qualifiers.end())
+ i->value = id;
used_ids.insert(id);
}
{
if(var.layout)
{
- vector<Layout::Qualifier> &qualifiers = var.layout->qualifiers;
- for(vector<Layout::Qualifier>::iterator i=qualifiers.begin(); i!=qualifiers.end(); ++i)
- if(i->name=="constant_id" && i->has_value)
- {
- if(i->value==-1)
- auto_constants.push_back(&var);
- else
- used_ids.insert(i->value);
- break;
- }
+ auto i = find_member(var.layout->qualifiers, string("constant_id"), &Layout::Qualifier::name);
+ if(i!=var.layout->qualifiers.end() && i->has_value)
+ {
+ if(i->value==-1)
+ auto_constants.push_back(&var);
+ else
+ used_ids.insert(i->value);
+ }
}
}
-InterfaceGenerator::InterfaceGenerator():
- stage(0),
- function_scope(false),
- copy_block(false),
- iface_target_block(0)
-{ }
-
string InterfaceGenerator::get_out_prefix(Stage::Type type)
{
if(type==Stage::VERTEX)
void InterfaceGenerator::visit(Block &block)
{
SetForScope<Block *> set_block(current_block, &block);
- for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+ for(auto i=block.body.begin(); i!=block.body.end(); ++i)
{
assignment_insert_point = i;
if(&block==&stage->content)
InterfaceBlock *InterfaceGenerator::generate_interface(InterfaceBlock &out_block)
{
- if(stage->interface_blocks.count("in"+out_block.block_name))
+ if(stage->interface_blocks.count("in "+out_block.block_name))
return 0;
InterfaceBlock *in_block = new InterfaceBlock;
}
iface_target_block->body.insert(iface_insert_point, in_block);
- stage->interface_blocks.insert(make_pair("in"+in_block->block_name, in_block));
+ stage->interface_blocks.insert(make_pair("in "+in_block->block_name, in_block));
if(!in_block->instance_name.empty())
- stage->interface_blocks.insert(make_pair("_"+in_block->instance_name, in_block));
+ stage->interface_blocks.insert(make_pair(in_block->instance_name, in_block));
SetFlag set_scope(function_scope, false);
SetForScope<Block *> set_block(current_block, &stage->content);
return;
const map<string, VariableDeclaration *> &prev_vars = stage->previous->content.variables;
- map<string, VariableDeclaration *>::const_iterator i = prev_vars.find(var.name);
+ auto i = prev_vars.find(var.name);
if(i==prev_vars.end() || i->second->interface!="out")
i = prev_vars.find(in_prefix+var.name);
if(i!=prev_vars.end() && i->second->interface=="out")
}
const map<string, InterfaceBlock *> &prev_blocks = stage->previous->interface_blocks;
- map<string, InterfaceBlock *>::const_iterator j = prev_blocks.find("_"+var.name);
+ auto j = prev_blocks.find(var.name);
if(j!=prev_blocks.end() && j->second->interface=="out")
{
generate_interface(*j->second);
return;
}
- for(j=prev_blocks.begin(); j!=prev_blocks.end(); ++j)
- if(j->second->instance_name.empty() && j->second->struct_declaration)
+ for(const auto &kvp: prev_blocks)
+ if(kvp.second->instance_name.empty() && kvp.second->struct_declaration)
{
- const map<string, VariableDeclaration *> &iface_vars = j->second->struct_declaration->members.variables;
+ const map<string, VariableDeclaration *> &iface_vars = kvp.second->struct_declaration->members.variables;
i = iface_vars.find(var.name);
if(i!=iface_vars.end())
{
- generate_interface(*j->second);
+ generate_interface(*kvp.second);
return;
}
}
if(!var.linked_declaration && stage->previous)
{
const map<string, VariableDeclaration *> &prev_vars = stage->previous->content.variables;
- map<string, VariableDeclaration *>::const_iterator i = prev_vars.find(var.name);
+ auto i = prev_vars.find(var.name);
if(i!=prev_vars.end() && i->second->interface=="out")
{
var.linked_declaration = i->second;
if(!iface.linked_block && stage->previous)
{
const map<string, InterfaceBlock *> &prev_blocks = stage->previous->interface_blocks;
- map<string, InterfaceBlock *>::const_iterator i = prev_blocks.find("out"+iface.block_name);
+ auto i = prev_blocks.find("out "+iface.block_name);
if(i!=prev_blocks.end())
{
iface.linked_block = i->second;
if(stage->previous)
{
- const map<string, VariableDeclaration *> &prev_vars = stage->previous->content.variables;
- for(map<string, VariableDeclaration *>::const_iterator i=prev_vars.begin(); i!=prev_vars.end(); ++i)
+ for(const auto &kvp: stage->previous->content.variables)
{
- if(i->second->interface!="out")
+ if(kvp.second->interface!="out")
continue;
/* Pass through output variables from the previous stage, but only
those which are not already linked to an input here. */
- if(!i->second->linked_declaration && generate_interface(*i->second, "in", i->second->name))
- pass_vars.push_back(i->second);
+ if(!kvp.second->linked_declaration && generate_interface(*kvp.second, "in", kvp.second->name))
+ pass_vars.push_back(kvp.second);
}
}
insert_assignment("gl_Position", memacc);
}
- for(vector<VariableDeclaration *>::const_iterator i=pass_vars.begin(); i!=pass_vars.end(); ++i)
+ for(VariableDeclaration *v: pass_vars)
{
- string out_name = change_prefix((*i)->name, out_prefix);
- generate_interface(**i, "out", out_name);
+ string out_name = change_prefix(v->name, out_prefix);
+ generate_interface(*v, "out", out_name);
VariableReference *ref = new VariableReference;
- ref->name = (*i)->name;
+ ref->name = v->name;
if(pass.subscript)
{
BinaryExpression *subscript = new BinaryExpression;
projects / libs / gl.git / blobdiff