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