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 void BinaryExpression::visit(NodeVisitor &visitor)
  58 {
  59         visitor.visit(*this);
  60 }
  61
  62
  63 Assignment::Assignment():
  64         self_referencing(false),
  65         target_declaration(0)
  66 { }
  67
  68 void Assignment::visit(NodeVisitor &visitor)
  69 {
  70         visitor.visit(*this);
  71 }
  72
  73
  74 FunctionCall::FunctionCall():
  75         constructor(false)
  76 { }
  77
  78 void FunctionCall::visit(NodeVisitor &visitor)
  79 {
  80         visitor.visit(*this);
  81 }
  82
  83
  84 void ExpressionStatement::visit(NodeVisitor &visitor)
  85 {
  86         visitor.visit(*this);
  87 }
  88
  89
  90 void Import::visit(NodeVisitor &visitor)
  91 {
  92         visitor.visit(*this);
  93 }
  94
  95
  96 void Layout::visit(NodeVisitor &visitor)
  97 {
  98         visitor.visit(*this);
  99 }
 100
 101
 102 StructDeclaration::StructDeclaration()
 103 {
 104         members.use_braces = true;
 105 }
 106
 107 void StructDeclaration::visit(NodeVisitor &visitor)
 108 {
 109         visitor.visit(*this);
 110 }
 111
 112
 113 VariableDeclaration::VariableDeclaration():
 114         constant(false),
 115         type_declaration(0),
 116         array(false),
 117         linked_declaration(0)
 118 { }
 119
 120 void VariableDeclaration::visit(NodeVisitor &visitor)
 121 {
 122         visitor.visit(*this);
 123 }
 124
 125
 126 InterfaceBlock::InterfaceBlock():
 127         array(false)
 128 {
 129         members.use_braces = true;
 130 }
 131
 132 void InterfaceBlock::visit(NodeVisitor &visitor)
 133 {
 134         visitor.visit(*this);
 135 }
 136
 137
 138 FunctionDeclaration::FunctionDeclaration():
 139         definition(0)
 140 { }
 141
 142 FunctionDeclaration::FunctionDeclaration(const FunctionDeclaration &other):
 143         return_type(other.return_type),
 144         name(other.name),
 145         parameters(other.parameters),
 146         definition(other.definition==&other ? this : other.definition),
 147         body(other.body)
 148 { }
 149
 150 void FunctionDeclaration::visit(NodeVisitor &visitor)
 151 {
 152         visitor.visit(*this);
 153 }
 154
 155
 156 void Conditional::visit(NodeVisitor &visitor)
 157 {
 158         visitor.visit(*this);
 159 }
 160
 161
 162 void Iteration::visit(NodeVisitor &visitor)
 163 {
 164         visitor.visit(*this);
 165 }
 166
 167
 168 void Passthrough::visit(NodeVisitor &visitor)
 169 {
 170         visitor.visit(*this);
 171 }
 172
 173
 174 void Return::visit(NodeVisitor &visitor)
 175 {
 176         visitor.visit(*this);
 177 }
 178
 179
 180 void NodeVisitor::visit(Assignment &assign)
 181 {
 182         visit(static_cast<BinaryExpression &>(assign));
 183 }
 184
 185
 186 void TraversingVisitor::visit(Block &block)
 187 {
 188         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 189                 (*i)->visit(*this);
 190 }
 191
 192 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
 193 {
 194         parexpr.expression->visit(*this);
 195 }
 196
 197 void TraversingVisitor::visit(MemberAccess &memacc)
 198 {
 199         memacc.left->visit(*this);
 200 }
 201
 202 void TraversingVisitor::visit(UnaryExpression &unary)
 203 {
 204         unary.expression->visit(*this);
 205 }
 206
 207 void TraversingVisitor::visit(BinaryExpression &binary)
 208 {
 209         binary.left->visit(*this);
 210         binary.right->visit(*this);
 211 }
 212
 213 void TraversingVisitor::visit(FunctionCall &call)
 214 {
 215         for(vector<NodePtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 216                 (*i)->visit(*this);
 217 }
 218
 219 void TraversingVisitor::visit(ExpressionStatement &expr)
 220 {
 221         expr.expression->visit(*this);
 222 }
 223
 224 void TraversingVisitor::visit(StructDeclaration &strct)
 225 {
 226         strct.members.visit(*this);
 227 }
 228
 229 void TraversingVisitor::visit(VariableDeclaration &var)
 230 {
 231         if(var.init_expression)
 232                 var.init_expression->visit(*this);
 233         if(var.array_size)
 234                 var.array_size->visit(*this);
 235 }
 236
 237 void TraversingVisitor::visit(InterfaceBlock &iface)
 238 {
 239         iface.members.visit(*this);
 240 }
 241
 242 void TraversingVisitor::visit(FunctionDeclaration &func)
 243 {
 244         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 245                 (*i)->visit(*this);
 246         func.body.visit(*this);
 247 }
 248
 249 void TraversingVisitor::visit(Conditional &cond)
 250 {
 251         cond.condition->visit(*this);
 252         cond.body.visit(*this);
 253         cond.else_body.visit(*this);
 254 }
 255
 256 void TraversingVisitor::visit(Iteration &iter)
 257 {
 258         iter.init_statement->visit(*this);
 259         if(iter.condition)
 260                 iter.condition->visit(*this);
 261         if(iter.loop_expression)
 262                 iter.loop_expression->visit(*this);
 263         iter.body.visit(*this);
 264 }
 265
 266 void TraversingVisitor::visit(Passthrough &pass)
 267 {
 268         if(pass.subscript)
 269                 pass.subscript->visit(*this);
 270 }
 271
 272 void TraversingVisitor::visit(Return &ret)
 273 {
 274         if(ret.expression)
 275                 ret.expression->visit(*this);
 276 }
 277
 278
 279 Stage::Stage(StageType t):
 280         type(t),
 281         previous(0)
 282 { }
 283
 284
 285 Module::Module():
 286         shared(SHARED)
 287 { }
 288
 289 } // namespace ProgramSyntax
 290 } // namespace GL
 291 } // namespace Msp