source/glsl/syntax.cpp

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