source/programsyntax.cpp

   1 #include "programsyntax.h"
   2
   3 using namespace std;
   4
   5 namespace Msp {
   6 namespace GL {
   7 namespace ProgramSyntax {
   8
   9 Block::Block():
  10         use_braces(false)
  11 { }
  12
  13 void Block::visit(NodeVisitor &visitor)
  14 {
  15         visitor.visit(*this);
  16 }
  17
  18
  19 void Literal::visit(NodeVisitor &visitor)
  20 {
  21         visitor.visit(*this);
  22 }
  23
  24
  25 void ParenthesizedExpression::visit(NodeVisitor &visitor)
  26 {
  27         visitor.visit(*this);
  28 }
  29
  30
  31 VariableReference::VariableReference():
  32         declaration(0)
  33 { }
  34
  35 void VariableReference::visit(NodeVisitor &visitor)
  36 {
  37         visitor.visit(*this);
  38 }
  39
  40
  41 void MemberAccess::visit(NodeVisitor &visitor)
  42 {
  43         visitor.visit(*this);
  44 }
  45
  46
  47 UnaryExpression::UnaryExpression():
  48         prefix(true)
  49 { }
  50
  51 void UnaryExpression::visit(NodeVisitor &visitor)
  52 {
  53         visitor.visit(*this);
  54 }
  55
  56
  57 BinaryExpression::BinaryExpression():
  58         assignment(false)
  59 { }
  60
  61 void BinaryExpression::visit(NodeVisitor &visitor)
  62 {
  63         visitor.visit(*this);
  64 }
  65
  66
  67 FunctionCall::FunctionCall():
  68         constructor(false)
  69 { }
  70
  71 void FunctionCall::visit(NodeVisitor &visitor)
  72 {
  73         visitor.visit(*this);
  74 }
  75
  76
  77 void ExpressionStatement::visit(NodeVisitor &visitor)
  78 {
  79         visitor.visit(*this);
  80 }
  81
  82
  83 void Layout::visit(NodeVisitor &visitor)
  84 {
  85         visitor.visit(*this);
  86 }
  87
  88
  89 StructDeclaration::StructDeclaration()
  90 {
  91         members.use_braces = true;
  92 }
  93
  94 void StructDeclaration::visit(NodeVisitor &visitor)
  95 {
  96         visitor.visit(*this);
  97 }
  98
  99
 100 VariableDeclaration::VariableDeclaration():
 101         constant(false),
 102         type_declaration(0),
 103         array(false)
 104 { }
 105
 106 void VariableDeclaration::visit(NodeVisitor &visitor)
 107 {
 108         visitor.visit(*this);
 109 }
 110
 111
 112 InterfaceBlock::InterfaceBlock()
 113 {
 114         members.use_braces = true;
 115 }
 116
 117 void InterfaceBlock::visit(NodeVisitor &visitor)
 118 {
 119         visitor.visit(*this);
 120 }
 121
 122
 123 FunctionDeclaration::FunctionDeclaration():
 124         definition(false)
 125 { }
 126
 127 void FunctionDeclaration::visit(NodeVisitor &visitor)
 128 {
 129         visitor.visit(*this);
 130 }
 131
 132
 133 void Conditional::visit(NodeVisitor &visitor)
 134 {
 135         visitor.visit(*this);
 136 }
 137
 138
 139 void Return::visit(NodeVisitor &visitor)
 140 {
 141         visitor.visit(*this);
 142 }
 143
 144
 145 void Iteration::visit(NodeVisitor &visitor)
 146 {
 147         visitor.visit(*this);
 148 }
 149
 150
 151 void TraversingVisitor::visit(Block &block)
 152 {
 153         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 154                 (*i)->visit(*this);
 155 }
 156
 157 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
 158 {
 159         parexpr.expression->visit(*this);
 160 }
 161
 162 void TraversingVisitor::visit(MemberAccess &memacc)
 163 {
 164         memacc.left->visit(*this);
 165 }
 166
 167 void TraversingVisitor::visit(UnaryExpression &unary)
 168 {
 169         unary.expression->visit(*this);
 170 }
 171
 172 void TraversingVisitor::visit(BinaryExpression &binary)
 173 {
 174         binary.left->visit(*this);
 175         binary.right->visit(*this);
 176 }
 177
 178 void TraversingVisitor::visit(FunctionCall &call)
 179 {
 180         for(vector<NodePtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 181                 (*i)->visit(*this);
 182 }
 183
 184 void TraversingVisitor::visit(ExpressionStatement &expr)
 185 {
 186         expr.expression->visit(*this);
 187 }
 188
 189 void TraversingVisitor::visit(StructDeclaration &strct)
 190 {
 191         strct.members.visit(*this);
 192 }
 193
 194 void TraversingVisitor::visit(VariableDeclaration &var)
 195 {
 196         if(var.init_expression)
 197                 var.init_expression->visit(*this);
 198         if(var.array_size)
 199                 var.array_size->visit(*this);
 200 }
 201
 202 void TraversingVisitor::visit(InterfaceBlock &iface)
 203 {
 204         iface.members.visit(*this);
 205 }
 206
 207 void TraversingVisitor::visit(FunctionDeclaration &func)
 208 {
 209         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 210                 (*i)->visit(*this);
 211         func.body.visit(*this);
 212 }
 213
 214 void TraversingVisitor::visit(Conditional &cond)
 215 {
 216         cond.condition->visit(*this);
 217         cond.body.visit(*this);
 218         cond.else_body.visit(*this);
 219 }
 220
 221 void TraversingVisitor::visit(Iteration &iter)
 222 {
 223         iter.init_statement->visit(*this);
 224         if(iter.condition)
 225                 iter.condition->visit(*this);
 226         if(iter.loop_expression)
 227                 iter.loop_expression->visit(*this);
 228         iter.body.visit(*this);
 229 }
 230
 231 void TraversingVisitor::visit(Return &ret)
 232 {
 233         if(ret.expression)
 234                 ret.expression->visit(*this);
 235 }
 236
 237
 238 Context::Context(ContextType t):
 239         type(t),
 240         present(false)
 241 { }
 242
 243
 244 Module::Module():
 245         global_context(GLOBAL),
 246         vertex_context(VERTEX),
 247         geometry_context(GEOMETRY),
 248         fragment_context(FRAGMENT)
 249 { }
 250
 251 } // namespace ProgramSyntax
 252 } // namespace GL
 253 } // namespace Msp