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 {
 115         members.use_braces = true;
 116 }
 117
 118 void InterfaceBlock::visit(NodeVisitor &visitor)
 119 {
 120         visitor.visit(*this);
 121 }
 122
 123
 124 FunctionDeclaration::FunctionDeclaration():
 125         definition(false)
 126 { }
 127
 128 void FunctionDeclaration::visit(NodeVisitor &visitor)
 129 {
 130         visitor.visit(*this);
 131 }
 132
 133
 134 void Conditional::visit(NodeVisitor &visitor)
 135 {
 136         visitor.visit(*this);
 137 }
 138
 139
 140 void Passthrough::visit(NodeVisitor &visitor)
 141 {
 142         visitor.visit(*this);
 143 }
 144
 145
 146 void Return::visit(NodeVisitor &visitor)
 147 {
 148         visitor.visit(*this);
 149 }
 150
 151
 152 void Iteration::visit(NodeVisitor &visitor)
 153 {
 154         visitor.visit(*this);
 155 }
 156
 157
 158 void TraversingVisitor::visit(Block &block)
 159 {
 160         for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 161                 (*i)->visit(*this);
 162 }
 163
 164 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
 165 {
 166         parexpr.expression->visit(*this);
 167 }
 168
 169 void TraversingVisitor::visit(MemberAccess &memacc)
 170 {
 171         memacc.left->visit(*this);
 172 }
 173
 174 void TraversingVisitor::visit(UnaryExpression &unary)
 175 {
 176         unary.expression->visit(*this);
 177 }
 178
 179 void TraversingVisitor::visit(BinaryExpression &binary)
 180 {
 181         binary.left->visit(*this);
 182         binary.right->visit(*this);
 183 }
 184
 185 void TraversingVisitor::visit(FunctionCall &call)
 186 {
 187         for(vector<NodePtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 188                 (*i)->visit(*this);
 189 }
 190
 191 void TraversingVisitor::visit(ExpressionStatement &expr)
 192 {
 193         expr.expression->visit(*this);
 194 }
 195
 196 void TraversingVisitor::visit(StructDeclaration &strct)
 197 {
 198         strct.members.visit(*this);
 199 }
 200
 201 void TraversingVisitor::visit(VariableDeclaration &var)
 202 {
 203         if(var.init_expression)
 204                 var.init_expression->visit(*this);
 205         if(var.array_size)
 206                 var.array_size->visit(*this);
 207 }
 208
 209 void TraversingVisitor::visit(InterfaceBlock &iface)
 210 {
 211         iface.members.visit(*this);
 212 }
 213
 214 void TraversingVisitor::visit(FunctionDeclaration &func)
 215 {
 216         for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 217                 (*i)->visit(*this);
 218         func.body.visit(*this);
 219 }
 220
 221 void TraversingVisitor::visit(Conditional &cond)
 222 {
 223         cond.condition->visit(*this);
 224         cond.body.visit(*this);
 225         cond.else_body.visit(*this);
 226 }
 227
 228 void TraversingVisitor::visit(Iteration &iter)
 229 {
 230         iter.init_statement->visit(*this);
 231         if(iter.condition)
 232                 iter.condition->visit(*this);
 233         if(iter.loop_expression)
 234                 iter.loop_expression->visit(*this);
 235         iter.body.visit(*this);
 236 }
 237
 238 void TraversingVisitor::visit(Passthrough &pass)
 239 {
 240         if(pass.subscript)
 241                 pass.subscript->visit(*this);
 242 }
 243
 244 void TraversingVisitor::visit(Return &ret)
 245 {
 246         if(ret.expression)
 247                 ret.expression->visit(*this);
 248 }
 249
 250
 251 Context::Context(ContextType t):
 252         type(t),
 253         present(false),
 254         previous(0)
 255 { }
 256
 257
 258 Module::Module():
 259         global_context(GLOBAL),
 260         vertex_context(VERTEX),
 261         geometry_context(GEOMETRY),
 262         fragment_context(FRAGMENT)
 263 { }
 264
 265 } // namespace ProgramSyntax
 266 } // namespace GL
 267 } // namespace Msp