bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/analysis/ReversedDepthFirstAdapter.java

   1 /* This file was generated by SableCC (http://www.sablecc.org/). */
   2
   3 package org.simantics.basicexpression.analysis;
   4
   5 import java.util.*;
   6 import org.simantics.basicexpression.node.*;
   7
   8 public class ReversedDepthFirstAdapter extends AnalysisAdapter
   9 {
  10     public void inStart(Start node)
  11     {
  12         defaultIn(node);
  13     }
  14
  15     public void outStart(Start node)
  16     {
  17         defaultOut(node);
  18     }
  19
  20     public void defaultIn(@SuppressWarnings("unused") Node node)
  21     {
  22         // Do nothing
  23     }
  24
  25     public void defaultOut(@SuppressWarnings("unused") Node node)
  26     {
  27         // Do nothing
  28     }
  29
  30     @Override
  31     public void caseStart(Start node)
  32     {
  33         inStart(node);
  34         node.getEOF().apply(this);
  35         node.getPExpression().apply(this);
  36         outStart(node);
  37     }
  38
  39     public void inAMultExpression(AMultExpression node)
  40     {
  41         defaultIn(node);
  42     }
  43
  44     public void outAMultExpression(AMultExpression node)
  45     {
  46         defaultOut(node);
  47     }
  48
  49     @Override
  50     public void caseAMultExpression(AMultExpression node)
  51     {
  52         inAMultExpression(node);
  53         if(node.getMultiplicative() != null)
  54         {
  55             node.getMultiplicative().apply(this);
  56         }
  57         outAMultExpression(node);
  58     }
  59
  60     public void inAPlusExpression(APlusExpression node)
  61     {
  62         defaultIn(node);
  63     }
  64
  65     public void outAPlusExpression(APlusExpression node)
  66     {
  67         defaultOut(node);
  68     }
  69
  70     @Override
  71     public void caseAPlusExpression(APlusExpression node)
  72     {
  73         inAPlusExpression(node);
  74         if(node.getRight() != null)
  75         {
  76             node.getRight().apply(this);
  77         }
  78         if(node.getPlus() != null)
  79         {
  80             node.getPlus().apply(this);
  81         }
  82         if(node.getLeft() != null)
  83         {
  84             node.getLeft().apply(this);
  85         }
  86         outAPlusExpression(node);
  87     }
  88
  89     public void inAMinusExpression(AMinusExpression node)
  90     {
  91         defaultIn(node);
  92     }
  93
  94     public void outAMinusExpression(AMinusExpression node)
  95     {
  96         defaultOut(node);
  97     }
  98
  99     @Override
 100     public void caseAMinusExpression(AMinusExpression node)
 101     {
 102         inAMinusExpression(node);
 103         if(node.getMultiplicative() != null)
 104         {
 105             node.getMultiplicative().apply(this);
 106         }
 107         if(node.getMinus() != null)
 108         {
 109             node.getMinus().apply(this);
 110         }
 111         if(node.getExpression() != null)
 112         {
 113             node.getExpression().apply(this);
 114         }
 115         outAMinusExpression(node);
 116     }
 117
 118     public void inAUnaryMultiplicative(AUnaryMultiplicative node)
 119     {
 120         defaultIn(node);
 121     }
 122
 123     public void outAUnaryMultiplicative(AUnaryMultiplicative node)
 124     {
 125         defaultOut(node);
 126     }
 127
 128     @Override
 129     public void caseAUnaryMultiplicative(AUnaryMultiplicative node)
 130     {
 131         inAUnaryMultiplicative(node);
 132         if(node.getUnary() != null)
 133         {
 134             node.getUnary().apply(this);
 135         }
 136         outAUnaryMultiplicative(node);
 137     }
 138
 139     public void inAMultMultiplicative(AMultMultiplicative node)
 140     {
 141         defaultIn(node);
 142     }
 143
 144     public void outAMultMultiplicative(AMultMultiplicative node)
 145     {
 146         defaultOut(node);
 147     }
 148
 149     @Override
 150     public void caseAMultMultiplicative(AMultMultiplicative node)
 151     {
 152         inAMultMultiplicative(node);
 153         if(node.getRight() != null)
 154         {
 155             node.getRight().apply(this);
 156         }
 157         if(node.getMult() != null)
 158         {
 159             node.getMult().apply(this);
 160         }
 161         if(node.getLeft() != null)
 162         {
 163             node.getLeft().apply(this);
 164         }
 165         outAMultMultiplicative(node);
 166     }
 167
 168     public void inADivMultiplicative(ADivMultiplicative node)
 169     {
 170         defaultIn(node);
 171     }
 172
 173     public void outADivMultiplicative(ADivMultiplicative node)
 174     {
 175         defaultOut(node);
 176     }
 177
 178     @Override
 179     public void caseADivMultiplicative(ADivMultiplicative node)
 180     {
 181         inADivMultiplicative(node);
 182         if(node.getRight() != null)
 183         {
 184             node.getRight().apply(this);
 185         }
 186         if(node.getDiv() != null)
 187         {
 188             node.getDiv().apply(this);
 189         }
 190         if(node.getLeft() != null)
 191         {
 192             node.getLeft().apply(this);
 193         }
 194         outADivMultiplicative(node);
 195     }
 196
 197     public void inAPrimaryUnary(APrimaryUnary node)
 198     {
 199         defaultIn(node);
 200     }
 201
 202     public void outAPrimaryUnary(APrimaryUnary node)
 203     {
 204         defaultOut(node);
 205     }
 206
 207     @Override
 208     public void caseAPrimaryUnary(APrimaryUnary node)
 209     {
 210         inAPrimaryUnary(node);
 211         if(node.getPrimary() != null)
 212         {
 213             node.getPrimary().apply(this);
 214         }
 215         outAPrimaryUnary(node);
 216     }
 217
 218     public void inAUnaryplusUnary(AUnaryplusUnary node)
 219     {
 220         defaultIn(node);
 221     }
 222
 223     public void outAUnaryplusUnary(AUnaryplusUnary node)
 224     {
 225         defaultOut(node);
 226     }
 227
 228     @Override
 229     public void caseAUnaryplusUnary(AUnaryplusUnary node)
 230     {
 231         inAUnaryplusUnary(node);
 232         if(node.getUnary() != null)
 233         {
 234             node.getUnary().apply(this);
 235         }
 236         if(node.getPlus() != null)
 237         {
 238             node.getPlus().apply(this);
 239         }
 240         outAUnaryplusUnary(node);
 241     }
 242
 243     public void inAUnaryminusUnary(AUnaryminusUnary node)
 244     {
 245         defaultIn(node);
 246     }
 247
 248     public void outAUnaryminusUnary(AUnaryminusUnary node)
 249     {
 250         defaultOut(node);
 251     }
 252
 253     @Override
 254     public void caseAUnaryminusUnary(AUnaryminusUnary node)
 255     {
 256         inAUnaryminusUnary(node);
 257         if(node.getUnary() != null)
 258         {
 259             node.getUnary().apply(this);
 260         }
 261         if(node.getMinus() != null)
 262         {
 263             node.getMinus().apply(this);
 264         }
 265         outAUnaryminusUnary(node);
 266     }
 267
 268     public void inASingleArgList(ASingleArgList node)
 269     {
 270         defaultIn(node);
 271     }
 272
 273     public void outASingleArgList(ASingleArgList node)
 274     {
 275         defaultOut(node);
 276     }
 277
 278     @Override
 279     public void caseASingleArgList(ASingleArgList node)
 280     {
 281         inASingleArgList(node);
 282         if(node.getExpression() != null)
 283         {
 284             node.getExpression().apply(this);
 285         }
 286         outASingleArgList(node);
 287     }
 288
 289     public void inASequenceArgList(ASequenceArgList node)
 290     {
 291         defaultIn(node);
 292     }
 293
 294     public void outASequenceArgList(ASequenceArgList node)
 295     {
 296         defaultOut(node);
 297     }
 298
 299     @Override
 300     public void caseASequenceArgList(ASequenceArgList node)
 301     {
 302         inASequenceArgList(node);
 303         if(node.getExpression() != null)
 304         {
 305             node.getExpression().apply(this);
 306         }
 307         if(node.getComma() != null)
 308         {
 309             node.getComma().apply(this);
 310         }
 311         if(node.getArgList() != null)
 312         {
 313             node.getArgList().apply(this);
 314         }
 315         outASequenceArgList(node);
 316     }
 317
 318     public void inAValuePrimary(AValuePrimary node)
 319     {
 320         defaultIn(node);
 321     }
 322
 323     public void outAValuePrimary(AValuePrimary node)
 324     {
 325         defaultOut(node);
 326     }
 327
 328     @Override
 329     public void caseAValuePrimary(AValuePrimary node)
 330     {
 331         inAValuePrimary(node);
 332         if(node.getValue() != null)
 333         {
 334             node.getValue().apply(this);
 335         }
 336         outAValuePrimary(node);
 337     }
 338
 339     public void inAVariablePrimary(AVariablePrimary node)
 340     {
 341         defaultIn(node);
 342     }
 343
 344     public void outAVariablePrimary(AVariablePrimary node)
 345     {
 346         defaultOut(node);
 347     }
 348
 349     @Override
 350     public void caseAVariablePrimary(AVariablePrimary node)
 351     {
 352         inAVariablePrimary(node);
 353         if(node.getVariable() != null)
 354         {
 355             node.getVariable().apply(this);
 356         }
 357         outAVariablePrimary(node);
 358     }
 359
 360     public void inAFunctionPrimary(AFunctionPrimary node)
 361     {
 362         defaultIn(node);
 363     }
 364
 365     public void outAFunctionPrimary(AFunctionPrimary node)
 366     {
 367         defaultOut(node);
 368     }
 369
 370     @Override
 371     public void caseAFunctionPrimary(AFunctionPrimary node)
 372     {
 373         inAFunctionPrimary(node);
 374         if(node.getRPar() != null)
 375         {
 376             node.getRPar().apply(this);
 377         }
 378         if(node.getArgList() != null)
 379         {
 380             node.getArgList().apply(this);
 381         }
 382         if(node.getFunc() != null)
 383         {
 384             node.getFunc().apply(this);
 385         }
 386         outAFunctionPrimary(node);
 387     }
 388
 389     public void inASingleRange(ASingleRange node)
 390     {
 391         defaultIn(node);
 392     }
 393
 394     public void outASingleRange(ASingleRange node)
 395     {
 396         defaultOut(node);
 397     }
 398
 399     @Override
 400     public void caseASingleRange(ASingleRange node)
 401     {
 402         inASingleRange(node);
 403         if(node.getCell() != null)
 404         {
 405             node.getCell().apply(this);
 406         }
 407         outASingleRange(node);
 408     }
 409
 410     public void inAMultiRange(AMultiRange node)
 411     {
 412         defaultIn(node);
 413     }
 414
 415     public void outAMultiRange(AMultiRange node)
 416     {
 417         defaultOut(node);
 418     }
 419
 420     @Override
 421     public void caseAMultiRange(AMultiRange node)
 422     {
 423         inAMultiRange(node);
 424         if(node.getRight() != null)
 425         {
 426             node.getRight().apply(this);
 427         }
 428         if(node.getColon() != null)
 429         {
 430             node.getColon().apply(this);
 431         }
 432         if(node.getLeft() != null)
 433         {
 434             node.getLeft().apply(this);
 435         }
 436         outAMultiRange(node);
 437     }
 438
 439     public void inARviValue(ARviValue node)
 440     {
 441         defaultIn(node);
 442     }
 443
 444     public void outARviValue(ARviValue node)
 445     {
 446         defaultOut(node);
 447     }
 448
 449     @Override
 450     public void caseARviValue(ARviValue node)
 451     {
 452         inARviValue(node);
 453         if(node.getRvi() != null)
 454         {
 455             node.getRvi().apply(this);
 456         }
 457         outARviValue(node);
 458     }
 459
 460     public void inAStringValue(AStringValue node)
 461     {
 462         defaultIn(node);
 463     }
 464
 465     public void outAStringValue(AStringValue node)
 466     {
 467         defaultOut(node);
 468     }
 469
 470     @Override
 471     public void caseAStringValue(AStringValue node)
 472     {
 473         inAStringValue(node);
 474         if(node.getString() != null)
 475         {
 476             node.getString().apply(this);
 477         }
 478         outAStringValue(node);
 479     }
 480
 481     public void inAConstantValue(AConstantValue node)
 482     {
 483         defaultIn(node);
 484     }
 485
 486     public void outAConstantValue(AConstantValue node)
 487     {
 488         defaultOut(node);
 489     }
 490
 491     @Override
 492     public void caseAConstantValue(AConstantValue node)
 493     {
 494         inAConstantValue(node);
 495         if(node.getNumber() != null)
 496         {
 497             node.getNumber().apply(this);
 498         }
 499         outAConstantValue(node);
 500     }
 501
 502     public void inARangeValue(ARangeValue node)
 503     {
 504         defaultIn(node);
 505     }
 506
 507     public void outARangeValue(ARangeValue node)
 508     {
 509         defaultOut(node);
 510     }
 511
 512     @Override
 513     public void caseARangeValue(ARangeValue node)
 514     {
 515         inARangeValue(node);
 516         if(node.getRange() != null)
 517         {
 518             node.getRange().apply(this);
 519         }
 520         outARangeValue(node);
 521     }
 522
 523     public void inAAddressValue(AAddressValue node)
 524     {
 525         defaultIn(node);
 526     }
 527
 528     public void outAAddressValue(AAddressValue node)
 529     {
 530         defaultOut(node);
 531     }
 532
 533     @Override
 534     public void caseAAddressValue(AAddressValue node)
 535     {
 536         inAAddressValue(node);
 537         if(node.getRange() != null)
 538         {
 539             node.getRange().apply(this);
 540         }
 541         if(node.getAmpersand() != null)
 542         {
 543             node.getAmpersand().apply(this);
 544         }
 545         outAAddressValue(node);
 546     }
 547
 548     public void inAExprValue(AExprValue node)
 549     {
 550         defaultIn(node);
 551     }
 552
 553     public void outAExprValue(AExprValue node)
 554     {
 555         defaultOut(node);
 556     }
 557
 558     @Override
 559     public void caseAExprValue(AExprValue node)
 560     {
 561         inAExprValue(node);
 562         if(node.getRPar() != null)
 563         {
 564             node.getRPar().apply(this);
 565         }
 566         if(node.getExpression() != null)
 567         {
 568             node.getExpression().apply(this);
 569         }
 570         if(node.getLPar() != null)
 571         {
 572             node.getLPar().apply(this);
 573         }
 574         outAExprValue(node);
 575     }
 576 }