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