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