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