X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=92dec9c778913388620f2bcd0dde7e6903a4a276;hb=a36992487d018d8801ead6980b362b00a2f5f5c5;hp=b08f1737e4d542610d1a9401f37ac3df90e580cd;hpb=6e6ee01b68056b23c6709d7f60396710dd7623b9;p=libs%2Fgl.git diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp index b08f1737..92dec9c7 100644 --- a/source/programcompiler.cpp +++ b/source/programcompiler.cpp @@ -1,3 +1,4 @@ +#include #include #include #include "error.h" @@ -19,11 +20,13 @@ ProgramCompiler::ProgramCompiler(): void ProgramCompiler::compile(const string &source) { module = &parser.parse(source); + process(); } void ProgramCompiler::compile(IO::Base &io) { module = &parser.parse(io); + process(); } void ProgramCompiler::add_shaders(Program &program) @@ -31,13 +34,13 @@ void ProgramCompiler::add_shaders(Program &program) if(!module) throw invalid_operation("ProgramCompiler::add_shaders"); - string global_source = "#version 150\n"+format_context(module->global_context); + string head = "#version 150\n"; if(module->vertex_context.present) - program.attach_shader_owned(new VertexShader(global_source+"\n"+format_context(module->vertex_context))); + program.attach_shader_owned(new VertexShader(head+format_context(module->vertex_context))); if(module->geometry_context.present) - program.attach_shader_owned(new GeometryShader(global_source+"\n"+format_context(module->geometry_context))); + program.attach_shader_owned(new GeometryShader(head+format_context(module->geometry_context))); if(module->fragment_context.present) - program.attach_shader_owned(new FragmentShader(global_source+"\n"+format_context(module->fragment_context))); + program.attach_shader_owned(new FragmentShader(head+format_context(module->fragment_context))); program.bind_attribute(VERTEX4, "vertex"); program.bind_attribute(NORMAL3, "normal"); @@ -45,6 +48,44 @@ void ProgramCompiler::add_shaders(Program &program) program.bind_attribute(TEXCOORD4, "texcoord"); } +void ProgramCompiler::process() +{ + if(module->vertex_context.present) + process(module->vertex_context); + if(module->geometry_context.present) + process(module->geometry_context); + if(module->fragment_context.present) + process(module->fragment_context); +} + +void ProgramCompiler::process(Context &context) +{ + inject_block(context.content, module->global_context.content); + + VariableResolver resolver; + context.content.visit(resolver); + + while(1) + { + UnusedVariableLocator unused_locator; + context.content.visit(unused_locator); + + NodeRemover remover; + remover.to_remove.insert(unused_locator.unused_variables.begin(), unused_locator.unused_variables.end()); + context.content.visit(remover); + + if(!remover.n_removed) + break; + } +} + +void ProgramCompiler::inject_block(Block &target, const Block &source) +{ + list >::iterator insert_point = target.body.begin(); + for(list >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) + target.body.insert(insert_point, (*i)->clone()); +} + string ProgramCompiler::format_context(Context &context) { Formatter formatter; @@ -59,14 +100,65 @@ ProgramCompiler::Formatter::Formatter(): else_if(false) { } -string ProgramCompiler::Formatter::format_expression(Expression &expr) +void ProgramCompiler::Formatter::visit(Literal &literal) +{ + formatted += literal.token; +} + +void ProgramCompiler::Formatter::visit(ParenthesizedExpression &parexpr) +{ + formatted += '('; + parexpr.expression->visit(*this); + formatted += ')'; +} + +void ProgramCompiler::Formatter::visit(VariableReference &var) +{ + formatted += var.name; +} + +void ProgramCompiler::Formatter::visit(MemberAccess &memacc) +{ + memacc.left->visit(*this); + formatted += format(".%s", memacc.member); +} + +void ProgramCompiler::Formatter::visit(UnaryExpression &unary) +{ + if(unary.prefix) + formatted += unary.oper; + unary.expression->visit(*this); + if(!unary.prefix) + formatted += unary.oper; +} + +void ProgramCompiler::Formatter::visit(BinaryExpression &binary) { - return join(expr.tokens.begin(), expr.tokens.end(), string()); + binary.left->visit(*this); + if(binary.assignment) + formatted += format(" %s ", binary.oper); + else + formatted += binary.oper; + binary.right->visit(*this); + formatted += binary.after; +} + +void ProgramCompiler::Formatter::visit(FunctionCall &call) +{ + formatted += format("%s(", call.name); + for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + { + if(i!=call.arguments.begin()) + formatted += ", "; + (*i)->visit(*this); + } + formatted += ')'; } void ProgramCompiler::Formatter::visit(ExpressionStatement &expr) { - formatted += format("%s;", format_expression(expr.expression)); + expr.expression->visit(*this); + formatted += ';'; } void ProgramCompiler::Formatter::visit(Block &block) @@ -84,7 +176,7 @@ void ProgramCompiler::Formatter::visit(Block &block) bool change_indent = (!formatted.empty() && !else_if); indent += change_indent; string spaces(indent*2, ' '); - for(vector::const_iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) { if(i!=block.body.begin()) formatted += '\n'; @@ -129,9 +221,17 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var) formatted += format("%s ", var.interface); formatted += format("%s %s", var.type, var.name); if(var.array) - formatted += format("[%s]", format_expression(var.array_size)); - if(!var.init_expression.empty()) - formatted += format(" = %s", format_expression(var.init_expression)); + { + formatted += '['; + if(var.array_size) + var.array_size->visit(*this); + formatted += ']'; + } + if(var.init_expression) + { + formatted += " = "; + var.init_expression->visit(*this); + } if(!parameter_list) formatted += ';'; } @@ -146,14 +246,13 @@ void ProgramCompiler::Formatter::visit(InterfaceBlock &iface) void ProgramCompiler::Formatter::visit(FunctionDeclaration &func) { formatted += format("%s %s(", func.return_type, func.name); - parameter_list = true; - for(vector::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) { if(i!=func.parameters.begin()) formatted += ", "; + SetFlag set(parameter_list); (*i)->visit(*this); } - parameter_list = false; formatted += ')'; if(func.definition) { @@ -171,14 +270,17 @@ void ProgramCompiler::Formatter::visit(Conditional &cond) formatted += ' '; else_if = false; } - formatted += format("if(%s)\n", format_expression(cond.condition)); + + formatted += "if("; + cond.condition->visit(*this); + formatted += ")\n"; + cond.body.visit(*this); if(!cond.else_body.body.empty()) { formatted += format("\n%selse", string(indent*2, ' ')); - else_if = true; + SetFlag set(else_if); cond.else_body.visit(*this); - else_if = false; } } @@ -186,13 +288,171 @@ void ProgramCompiler::Formatter::visit(Iteration &iter) { formatted += "for("; iter.init_statement->visit(*this); - formatted += format(" %s; %s)\n", format_expression(iter.condition), format_expression(iter.loop_expression)); + formatted += ' '; + iter.condition->visit(*this); + formatted += "; "; + iter.loop_expression->visit(*this); + formatted += ")\n"; iter.body.visit(*this); } void ProgramCompiler::Formatter::visit(Return &ret) { - formatted += format("return %s;", format_expression(ret.expression)); + formatted += "return "; + ret.expression->visit(*this); + formatted += ';'; +} + + +ProgramCompiler::VariableResolver::VariableResolver(): + anonymous(false) +{ } + +void ProgramCompiler::VariableResolver::visit(Block &block) +{ + blocks.push_back(&block); + block.variables.clear(); + TraversingVisitor::visit(block); + blocks.pop_back(); +} + +void ProgramCompiler::VariableResolver::visit(VariableReference &var) +{ + var.declaration = 0; + type = 0; + for(vector::iterator i=blocks.end(); i!=blocks.begin(); ) + { + --i; + map::iterator j = (*i)->variables.find(var.name); + if(j!=(*i)->variables.end()) + { + var.declaration = j->second; + type = j->second->type_declaration; + break; + } + } +} + +void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc) +{ + type = 0; + TraversingVisitor::visit(memacc); + memacc.declaration = 0; + if(type) + { + map::iterator i = type->members.variables.find(memacc.member); + if(i!=type->members.variables.end()) + { + memacc.declaration = i->second; + type = i->second->type_declaration; + } + else + type = 0; + } +} + +void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary) +{ + if(binary.oper=="[") + { + binary.right->visit(*this); + type = 0; + binary.left->visit(*this); + } + else + { + TraversingVisitor::visit(binary); + type = 0; + } +} + +void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct) +{ + TraversingVisitor::visit(strct); + blocks.back()->types[strct.name] = &strct; +} + +void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var) +{ + for(vector::iterator i=blocks.end(); i!=blocks.begin(); ) + { + --i; + map::iterator j = (*i)->types.find(var.type); + if(j!=(*i)->types.end()) + var.type_declaration = j->second; + } + + TraversingVisitor::visit(var); + blocks.back()->variables[var.name] = &var; + if(anonymous && blocks.size()>1) + blocks[blocks.size()-2]->variables[var.name] = &var; +} + +void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface) +{ + SetFlag set(anonymous); + TraversingVisitor::visit(iface); +} + + +void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var) +{ + unused_variables.erase(var.declaration); +} + +void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc) +{ + TraversingVisitor::visit(memacc); + unused_variables.erase(memacc.declaration); +} + +void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var) +{ + unused_variables.insert(&var); + TraversingVisitor::visit(var); +} + + +ProgramCompiler::NodeRemover::NodeRemover(): + n_removed(0), + immutable_block(false), + remove_block(false) +{ } + +void ProgramCompiler::NodeRemover::visit(Block &block) +{ + remove_block = immutable_block; + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + { + bool remove = false; + if(to_remove.count(&**i)) + remove = !immutable_block; + else + { + remove_block = false; + (*i)->visit(*this); + remove = remove_block; + } + + if(remove) + block.body.erase(i++); + else + ++i; + + n_removed += remove; + } +} + +void ProgramCompiler::NodeRemover::visit(StructDeclaration &strct) +{ + SetFlag set(immutable_block); + TraversingVisitor::visit(strct); +} + +void ProgramCompiler::NodeRemover::visit(InterfaceBlock &iface) +{ + SetFlag set(immutable_block); + TraversingVisitor::visit(iface); } } // namespace GL