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