X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fsyntax.cpp;h=cb77419763645be5987842b9bd7d654eb30e13c5;hb=041ba4b1acd55337239c5ce24cc310118c621206;hp=9705c989370d87b6672c7fc543a8fc9710c46502;hpb=c1b0303f65ee966a973197cbdbf177c571478674;p=libs%2Fgl.git diff --git a/source/glsl/syntax.cpp b/source/glsl/syntax.cpp index 9705c989..cb774197 100644 --- a/source/glsl/syntax.cpp +++ b/source/glsl/syntax.cpp @@ -1,4 +1,6 @@ +#include #include "syntax.h" +#include "visitor.h" using namespace std; @@ -6,6 +8,64 @@ namespace Msp { namespace GL { namespace SL { +const Operator Operator::operators[] = +{ + { "[", 2, BINARY, LEFT_TO_RIGHT }, + { "(", 2, POSTFIX, LEFT_TO_RIGHT }, + { ".", 2, BINARY, LEFT_TO_RIGHT }, + { "++", 2, POSTFIX, LEFT_TO_RIGHT }, + { "--", 2, POSTFIX, LEFT_TO_RIGHT }, + { "++", 3, PREFIX, RIGHT_TO_LEFT }, + { "--", 3, PREFIX, RIGHT_TO_LEFT }, + { "+", 3, PREFIX, RIGHT_TO_LEFT }, + { "-", 3, PREFIX, RIGHT_TO_LEFT }, + { "~", 3, PREFIX, RIGHT_TO_LEFT }, + { "!", 3, PREFIX, RIGHT_TO_LEFT }, + { "*", 4, BINARY, ASSOCIATIVE }, + { "/", 4, BINARY, LEFT_TO_RIGHT }, + { "%", 4, BINARY, LEFT_TO_RIGHT }, + { "+", 5, BINARY, ASSOCIATIVE }, + { "-", 5, BINARY, LEFT_TO_RIGHT }, + { "<<", 6, BINARY, LEFT_TO_RIGHT }, + { ">>", 6, BINARY, LEFT_TO_RIGHT }, + { "<", 7, BINARY, LEFT_TO_RIGHT }, + { ">", 7, BINARY, LEFT_TO_RIGHT }, + { "<=", 7, BINARY, LEFT_TO_RIGHT }, + { ">=", 7, BINARY, LEFT_TO_RIGHT }, + { "==", 8, BINARY, LEFT_TO_RIGHT }, + { "!=", 8, BINARY, LEFT_TO_RIGHT }, + { "&", 9, BINARY, ASSOCIATIVE }, + { "^", 10, BINARY, ASSOCIATIVE }, + { "|", 11, BINARY, ASSOCIATIVE }, + { "&&", 12, BINARY, ASSOCIATIVE }, + { "^^", 13, BINARY, ASSOCIATIVE }, + { "||", 14, BINARY, ASSOCIATIVE }, + { "?", 15, BINARY, RIGHT_TO_LEFT }, + { ":", 15, BINARY, RIGHT_TO_LEFT }, + { "=", 16, BINARY, RIGHT_TO_LEFT }, + { "+=", 16, BINARY, RIGHT_TO_LEFT }, + { "-=", 16, BINARY, RIGHT_TO_LEFT }, + { "*=", 16, BINARY, RIGHT_TO_LEFT }, + { "/=", 16, BINARY, RIGHT_TO_LEFT }, + { "%=", 16, BINARY, RIGHT_TO_LEFT }, + { "<<=", 16, BINARY, RIGHT_TO_LEFT }, + { ">>=", 16, BINARY, RIGHT_TO_LEFT }, + { "&=", 16, BINARY, RIGHT_TO_LEFT }, + { "^=", 16, BINARY, RIGHT_TO_LEFT }, + { "|=", 16, BINARY, RIGHT_TO_LEFT }, + { ",", 17, BINARY, LEFT_TO_RIGHT }, + { { 0 }, 18, NO_OPERATOR, LEFT_TO_RIGHT } +}; + +const Operator &Operator::get_operator(const string &token, Type type) +{ + for(const Operator *i=operators; i->type; ++i) + if(i->type==type && i->token==token) + return *i; + throw key_error(token); +} + + template NodeContainer::NodeContainer(const NodeContainer &c): C(c) @@ -15,14 +75,16 @@ NodeContainer::NodeContainer(const NodeContainer &c): } -Statement::Statement(): - source(0), - line(1) +Block::Block(): + use_braces(false), + parent(0) { } - -Block::Block(): - use_braces(false) +Block::Block(const Block &other): + Node(other), + body(other.body), + use_braces(other.use_braces), + parent(0) { } void Block::visit(NodeVisitor &visitor) @@ -31,6 +93,13 @@ void Block::visit(NodeVisitor &visitor) } +Expression::Expression(): + oper(0), + type(0), + lvalue(false) +{ } + + void Literal::visit(NodeVisitor &visitor) { visitor.visit(*this); @@ -47,22 +116,51 @@ VariableReference::VariableReference(): declaration(0) { } +VariableReference::VariableReference(const VariableReference &other): + Expression(other), + name(other.name), + declaration(0) +{ } + void VariableReference::visit(NodeVisitor &visitor) { visitor.visit(*this); } -void MemberAccess::visit(NodeVisitor &visitor) +InterfaceBlockReference::InterfaceBlockReference(): + declaration(0) +{ } + +InterfaceBlockReference::InterfaceBlockReference(const InterfaceBlockReference &other): + Expression(other), + name(other.name), + declaration(0) +{ } + +void InterfaceBlockReference::visit(NodeVisitor &visitor) { visitor.visit(*this); } -UnaryExpression::UnaryExpression(): - prefix(true) +MemberAccess::MemberAccess(): + declaration(0) { } +MemberAccess::MemberAccess(const MemberAccess &other): + Expression(other), + left(other.left), + member(other.member), + declaration(0) +{ } + +void MemberAccess::visit(NodeVisitor &visitor) +{ + visitor.visit(*this); +} + + void UnaryExpression::visit(NodeVisitor &visitor) { visitor.visit(*this); @@ -80,6 +178,12 @@ Assignment::Assignment(): target_declaration(0) { } +Assignment::Assignment(const Assignment &other): + BinaryExpression(other), + self_referencing(other.self_referencing), + target_declaration(0) +{ } + void Assignment::visit(NodeVisitor &visitor) { visitor.visit(*this); @@ -87,8 +191,16 @@ void Assignment::visit(NodeVisitor &visitor) FunctionCall::FunctionCall(): - declaration(0), - constructor(false) + constructor(false), + declaration(0) +{ } + +FunctionCall::FunctionCall(const FunctionCall &other): + Expression(other), + name(other.name), + constructor(other.constructor), + arguments(other.arguments), + declaration(0) { } void FunctionCall::visit(NodeVisitor &visitor) @@ -127,11 +239,57 @@ void InterfaceLayout::visit(NodeVisitor &visitor) } -StructDeclaration::StructDeclaration() +BasicTypeDeclaration::BasicTypeDeclaration(): + kind(ALIAS), + size(0), + base_type(0) +{ } + +BasicTypeDeclaration::BasicTypeDeclaration(const BasicTypeDeclaration &other): + TypeDeclaration(other), + kind(other.kind), + size(other.size), + base(other.base), + base_type(0) +{ } + +void BasicTypeDeclaration::visit(NodeVisitor &visitor) +{ + visitor.visit(*this); +} + + +ImageTypeDeclaration::ImageTypeDeclaration(): + dimensions(TWO), + array(false), + sampled(true), + shadow(false) +{ } + +void ImageTypeDeclaration::visit(NodeVisitor &visitor) +{ + visitor.visit(*this); +} + + +StructDeclaration::StructDeclaration(): + interface_block(0) { members.use_braces = true; } +StructDeclaration::StructDeclaration(const StructDeclaration &other): + TypeDeclaration(other), + members(other.members), + interface_block(0) +{ } + +StructDeclaration::~StructDeclaration() +{ + if(interface_block && interface_block->struct_declaration==this) + interface_block->struct_declaration = 0; +} + void StructDeclaration::visit(NodeVisitor &visitor) { visitor.visit(*this); @@ -140,11 +298,34 @@ void StructDeclaration::visit(NodeVisitor &visitor) VariableDeclaration::VariableDeclaration(): constant(false), - type_declaration(0), array(false), + type_declaration(0), + linked_declaration(0) +{ } + +VariableDeclaration::VariableDeclaration(const VariableDeclaration &other): + Statement(other), + layout(other.layout), + constant(other.constant), + sampling(other.sampling), + interpolation(other.interpolation), + interface(other.interface), + precision(other.precision), + type(other.type), + name(other.name), + array(other.array), + array_size(other.array_size), + init_expression(other.init_expression), + type_declaration(0), linked_declaration(0) { } +VariableDeclaration::~VariableDeclaration() +{ + if(linked_declaration && linked_declaration->linked_declaration==this) + linked_declaration->linked_declaration = 0; +} + void VariableDeclaration::visit(NodeVisitor &visitor) { visitor.visit(*this); @@ -152,9 +333,30 @@ void VariableDeclaration::visit(NodeVisitor &visitor) InterfaceBlock::InterfaceBlock(): - array(false) + array(false), + type_declaration(0), + struct_declaration(0), + linked_block(0) +{ } + +InterfaceBlock::InterfaceBlock(const InterfaceBlock &other): + Statement(other), + interface(other.interface), + name(other.name), + members(other.members), + instance_name(other.instance_name), + array(other.array), + type_declaration(0), + struct_declaration(0), + linked_block(0) +{ } + +InterfaceBlock::~InterfaceBlock() { - members.use_braces = true; + if(linked_block && linked_block->linked_block==this) + linked_block->linked_block = 0; + if(struct_declaration && struct_declaration->interface_block==this) + struct_declaration->interface_block = 0; } void InterfaceBlock::visit(NodeVisitor &visitor) @@ -164,15 +366,18 @@ void InterfaceBlock::visit(NodeVisitor &visitor) FunctionDeclaration::FunctionDeclaration(): - definition(0) + definition(0), + return_type_declaration(0) { } FunctionDeclaration::FunctionDeclaration(const FunctionDeclaration &other): + Statement(other), return_type(other.return_type), name(other.name), parameters(other.parameters), - definition(other.definition==&other ? this : other.definition), - body(other.body) + body(other.body), + definition(other.definition==&other ? this : 0), + return_type_declaration(0) { } void FunctionDeclaration::visit(NodeVisitor &visitor) @@ -211,121 +416,20 @@ void Jump::visit(NodeVisitor &visitor) } -void NodeVisitor::visit(Assignment &assign) -{ - visit(static_cast(assign)); -} - - -void TraversingVisitor::visit(Block &block) -{ - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) - (*i)->visit(*this); -} - -void TraversingVisitor::visit(ParenthesizedExpression &parexpr) -{ - parexpr.expression->visit(*this); -} - -void TraversingVisitor::visit(MemberAccess &memacc) -{ - memacc.left->visit(*this); -} - -void TraversingVisitor::visit(UnaryExpression &unary) -{ - unary.expression->visit(*this); -} - -void TraversingVisitor::visit(BinaryExpression &binary) -{ - binary.left->visit(*this); - binary.right->visit(*this); -} - -void TraversingVisitor::visit(FunctionCall &call) -{ - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - (*i)->visit(*this); -} - -void TraversingVisitor::visit(ExpressionStatement &expr) -{ - expr.expression->visit(*this); -} - -void TraversingVisitor::visit(InterfaceLayout &layout) -{ - layout.layout.visit(*this); -} - -void TraversingVisitor::visit(StructDeclaration &strct) -{ - strct.members.visit(*this); -} - -void TraversingVisitor::visit(VariableDeclaration &var) -{ - if(var.layout) - var.layout->visit(*this); - if(var.init_expression) - var.init_expression->visit(*this); - if(var.array_size) - var.array_size->visit(*this); -} - -void TraversingVisitor::visit(InterfaceBlock &iface) -{ - iface.members.visit(*this); -} - -void TraversingVisitor::visit(FunctionDeclaration &func) -{ - for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) - (*i)->visit(*this); - func.body.visit(*this); -} - -void TraversingVisitor::visit(Conditional &cond) -{ - cond.condition->visit(*this); - cond.body.visit(*this); - cond.else_body.visit(*this); -} - -void TraversingVisitor::visit(Iteration &iter) -{ - if(iter.init_statement) - iter.init_statement->visit(*this); - if(iter.condition) - iter.condition->visit(*this); - if(iter.loop_expression) - iter.loop_expression->visit(*this); - iter.body.visit(*this); -} - -void TraversingVisitor::visit(Passthrough &pass) -{ - if(pass.subscript) - pass.subscript->visit(*this); -} - -void TraversingVisitor::visit(Return &ret) -{ - if(ret.expression) - ret.expression->visit(*this); -} - - -Stage::Stage(StageType t): +Stage::Stage(Stage::Type t): type(t), previous(0) { } +const char *Stage::get_stage_name(Type type) +{ + static const char *names[] = { "shared", "vertex", "geometry", "fragment" }; + return names[type]; +} + Module::Module(): - shared(SHARED) + shared(Stage::SHARED) { } } // namespace SL