source/programsyntax.cpp

   1 #include "programsyntax.h"
   2
   3 using namespace std;
   4
   5 namespace Msp {
   6 namespace GL {
   7 namespace ProgramSyntax {
   8
   9 template<typename C>
  10 NodeContainer<C>::NodeContainer(const NodeContainer &c):
  11         C(c)
  12 {
  13         for(typename C::iterator i=this->begin(); i!=this->end(); ++i)
  14                 *i = (*i)->clone();
  15 }
  16
  17
  18 Block::Block():
  19         use_braces(false)
  20 { }
  21
  22 void Block::visit(NodeVisitor &visitor)
  23 {
  24         visitor.visit(*this);
  25 }
  26
  27
  28 void Literal::visit(NodeVisitor &visitor)
  29 {
  30         visitor.visit(*this);
  31 }
  32
  33
  34 void ParenthesizedExpression::visit(NodeVisitor &visitor)
  35 {
  36         visitor.visit(*this);
  37 }
  38
  39
  40 VariableReference::VariableReference():
  41         declaration(0)
  42 { }
  43
  44 void VariableReference::visit(NodeVisitor &visitor)
  45 {
  46         visitor.visit(*this);
  47 }
  48
  49
  50 void MemberAccess::visit(NodeVisitor &visitor)
  51 {
  52         visitor.visit(*this);
  53 }
  54
  55
  56 UnaryExpression::UnaryExpression():
  57         prefix(true)
  58 { }
  59
  60 void UnaryExpression::visit(NodeVisitor &visitor)
  61 {
  62         visitor.visit(*this);
  63 }
  64
  65
  66 void BinaryExpression::visit(NodeVisitor &visitor)
  67 {
  68         visitor.visit(*this);
  69 }
  70
  71
  72 Assignment::Assignment():
  73         self_referencing(false),
  74         target_declaration(0)
  75 { }
  76
  77 void Assignment::visit(NodeVisitor &visitor)
  78 {
  79         visitor.visit(*this);
  80 }
  81
  82
  83 FunctionCall::FunctionCall():
  84         declaration(0),
  85         constructor(false)
  86 { }
  87
  88 void FunctionCall::visit(NodeVisitor &visitor)
  89 {
  90         visitor.visit(*this);
  91 }
  92
  93
  94 void ExpressionStatement::visit(NodeVisitor &visitor)
  95 {
  96         visitor.visit(*this);
  97 }
  98
  99
 100 void Import::visit(NodeVisitor &visitor)
 101 {
 102         visitor.visit(*this);
 103 }
 104
 105
 106 void Precision::visit(NodeVisitor &visitor)
 107 {
 108         visitor.visit(*this);
 109 }
 110
 111
 112 void Layout::visit(NodeVisitor &visitor)
 113 {
 114         visitor.visit(*this);
 115 }
 116
 117
 118 void InterfaceLayout::visit(NodeVisitor &visitor)
 119 {
 120         visitor.visit(*this);
 121 }
 122
 123
 124 StructDeclaration::StructDeclaration()
 125 {
 126         members.use_braces = true;
 127 }
 128
 129 void StructDeclaration::visit(NodeVisitor &visitor)
 130 {
 131         visitor.visit(*this);
 132 }
 133
 134
 135 VariableDeclaration::VariableDeclaration():
 136         constant(false),
 137         type_declaration(0),
 138         array(false),
 139         linked_declaration(0)
 140 { }
 141
 142 void VariableDeclaration::visit(NodeVisitor &visitor)
 143 {
 144         visitor.visit(*this);
 145 }
 146
 147
 148 InterfaceBlock::InterfaceBlock():
 149         array(false)
 150 {
 151         members.use_braces = true;
 152 }
 153
 154 void InterfaceBlock::visit(NodeVisitor &visitor)
 155 {
 156         visitor.visit(*this);
 157 }
 158
 159
 160 FunctionDeclaration::FunctionDeclaration():
 161         definition(0)
 162 { }
 163
 164 FunctionDeclaration::FunctionDeclaration(const FunctionDeclaration &other):
 165         return_type(other.return_type),
 166         name(other.name),
 167         parameters(other.parameters),
 168         definition(other.definition==&other ? this : other.definition),
 169         body(other.body)
 170 { }
 171
 172 void FunctionDeclaration::visit(NodeVisitor &visitor)
 173 {
 174         visitor.visit(*this);
 175 }
 176
 177
 178 void Conditional::visit(NodeVisitor &visitor)
 179 {
 180         visitor.visit(*this);
 181 }
 182
 183
 184 void Iteration::visit(NodeVisitor &visitor)
 185 {
 186         visitor.visit(*this);
 187 }
 188
 189
 190 void Passthrough::visit(NodeVisitor &visitor)
 191 {
 192         visitor.visit(*this);
 193 }
 194
 195
 196 void Return::visit(NodeVisitor &visitor)
 197 {
 198         visitor.visit(*this);
 199 }
 200
 201
 202 void Jump::visit(NodeVisitor &visitor)
 203 {
 204         visitor.visit(*this);
 205 }
 206
 207
 208 void NodeVisitor::visit(Assignment &assign)
 209 {
 210         visit(static_cast<BinaryExpression &>(assign));
 211 }
 212
 213
 214 void TraversingVisitor::visit(Block &block)
 215 {
 216         for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 217                 (*i)->visit(*this);
 218 }
 219
 220 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
 221 {
 222         parexpr.expression->visit(*this);
 223 }
 224
 225 void TraversingVisitor::visit(MemberAccess &memacc)
 226 {
 227         memacc.left->visit(*this);
 228 }
 229
 230 void TraversingVisitor::visit(UnaryExpression &unary)
 231 {
 232         unary.expression->visit(*this);
 233 }
 234
 235 void TraversingVisitor::visit(BinaryExpression &binary)
 236 {
 237         binary.left->visit(*this);
 238         binary.right->visit(*this);
 239 }
 240
 241 void TraversingVisitor::visit(FunctionCall &call)
 242 {
 243         for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 244                 (*i)->visit(*this);
 245 }
 246
 247 void TraversingVisitor::visit(ExpressionStatement &expr)
 248 {
 249         expr.expression->visit(*this);
 250 }
 251
 252 void TraversingVisitor::visit(InterfaceLayout &layout)
 253 {
 254         layout.layout.visit(*this);
 255 }
 256
 257 void TraversingVisitor::visit(StructDeclaration &strct)
 258 {
 259         strct.members.visit(*this);
 260 }
 261
 262 void TraversingVisitor::visit(VariableDeclaration &var)
 263 {
 264         if(var.layout)
 265                 var.layout->visit(*this);
 266         if(var.init_expression)
 267                 var.init_expression->visit(*this);
 268         if(var.array_size)
 269                 var.array_size->visit(*this);
 270 }
 271
 272 void TraversingVisitor::visit(InterfaceBlock &iface)
 273 {
 274         iface.members.visit(*this);
 275 }
 276
 277 void TraversingVisitor::visit(FunctionDeclaration &func)
 278 {
 279         for(vector<RefPtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 280                 (*i)->visit(*this);
 281         func.body.visit(*this);
 282 }
 283
 284 void TraversingVisitor::visit(Conditional &cond)
 285 {
 286         cond.condition->visit(*this);
 287         cond.body.visit(*this);
 288         cond.else_body.visit(*this);
 289 }
 290
 291 void TraversingVisitor::visit(Iteration &iter)
 292 {
 293         iter.init_statement->visit(*this);
 294         if(iter.condition)
 295                 iter.condition->visit(*this);
 296         if(iter.loop_expression)
 297                 iter.loop_expression->visit(*this);
 298         iter.body.visit(*this);
 299 }
 300
 301 void TraversingVisitor::visit(Passthrough &pass)
 302 {
 303         if(pass.subscript)
 304                 pass.subscript->visit(*this);
 305 }
 306
 307 void TraversingVisitor::visit(Return &ret)
 308 {
 309         if(ret.expression)
 310                 ret.expression->visit(*this);
 311 }
 312
 313
 314 Stage::Stage(StageType t):
 315         type(t),
 316         previous(0)
 317 { }
 318
 319
 320 Module::Module():
 321         shared(SHARED)
 322 { }
 323
 324 } // namespace ProgramSyntax
 325 } // namespace GL
 326 } // namespace Msp