bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/analysis/AnalysisAdapter.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 AnalysisAdapter implements Analysis
   9 {
  10     private Hashtable<Node,Object> in;
  11     private Hashtable<Node,Object> out;
  12
  13     public Object getIn(Node node)
  14     {
  15         if(this.in == null)
  16         {
  17             return null;
  18         }
  19
  20         return this.in.get(node);
  21     }
  22
  23     public void setIn(Node node, Object o)
  24     {
  25         if(this.in == null)
  26         {
  27             this.in = new Hashtable<Node,Object>(1);
  28         }
  29
  30         if(o != null)
  31         {
  32             this.in.put(node, o);
  33         }
  34         else
  35         {
  36             this.in.remove(node);
  37         }
  38     }
  39
  40     public Object getOut(Node node)
  41     {
  42         if(this.out == null)
  43         {
  44             return null;
  45         }
  46
  47         return this.out.get(node);
  48     }
  49
  50     public void setOut(Node node, Object o)
  51     {
  52         if(this.out == null)
  53         {
  54             this.out = new Hashtable<Node,Object>(1);
  55         }
  56
  57         if(o != null)
  58         {
  59             this.out.put(node, o);
  60         }
  61         else
  62         {
  63             this.out.remove(node);
  64         }
  65     }
  66
  67     public void caseStart(Start node)
  68     {
  69         defaultCase(node);
  70     }
  71
  72     public void caseAMultExpression(AMultExpression node)
  73     {
  74         defaultCase(node);
  75     }
  76
  77     public void caseAPlusExpression(APlusExpression node)
  78     {
  79         defaultCase(node);
  80     }
  81
  82     public void caseAMinusExpression(AMinusExpression node)
  83     {
  84         defaultCase(node);
  85     }
  86
  87     public void caseAUnaryMultiplicative(AUnaryMultiplicative node)
  88     {
  89         defaultCase(node);
  90     }
  91
  92     public void caseAMultMultiplicative(AMultMultiplicative node)
  93     {
  94         defaultCase(node);
  95     }
  96
  97     public void caseADivMultiplicative(ADivMultiplicative node)
  98     {
  99         defaultCase(node);
 100     }
 101
 102     public void caseAPrimaryUnary(APrimaryUnary node)
 103     {
 104         defaultCase(node);
 105     }
 106
 107     public void caseAUnaryplusUnary(AUnaryplusUnary node)
 108     {
 109         defaultCase(node);
 110     }
 111
 112     public void caseAUnaryminusUnary(AUnaryminusUnary node)
 113     {
 114         defaultCase(node);
 115     }
 116
 117     public void caseASingleArgList(ASingleArgList node)
 118     {
 119         defaultCase(node);
 120     }
 121
 122     public void caseASequenceArgList(ASequenceArgList node)
 123     {
 124         defaultCase(node);
 125     }
 126
 127     public void caseAValuePrimary(AValuePrimary node)
 128     {
 129         defaultCase(node);
 130     }
 131
 132     public void caseAVariablePrimary(AVariablePrimary node)
 133     {
 134         defaultCase(node);
 135     }
 136
 137     public void caseAFunctionPrimary(AFunctionPrimary node)
 138     {
 139         defaultCase(node);
 140     }
 141
 142     public void caseASingleRange(ASingleRange node)
 143     {
 144         defaultCase(node);
 145     }
 146
 147     public void caseAMultiRange(AMultiRange node)
 148     {
 149         defaultCase(node);
 150     }
 151
 152     public void caseARviValue(ARviValue node)
 153     {
 154         defaultCase(node);
 155     }
 156
 157     public void caseAStringValue(AStringValue node)
 158     {
 159         defaultCase(node);
 160     }
 161
 162     public void caseAConstantValue(AConstantValue node)
 163     {
 164         defaultCase(node);
 165     }
 166
 167     public void caseARangeValue(ARangeValue node)
 168     {
 169         defaultCase(node);
 170     }
 171
 172     public void caseAAddressValue(AAddressValue node)
 173     {
 174         defaultCase(node);
 175     }
 176
 177     public void caseAExprValue(AExprValue node)
 178     {
 179         defaultCase(node);
 180     }
 181
 182     public void caseTLessThan(TLessThan node)
 183     {
 184         defaultCase(node);
 185     }
 186
 187     public void caseTGreaterThan(TGreaterThan node)
 188     {
 189         defaultCase(node);
 190     }
 191
 192     public void caseTEqual(TEqual node)
 193     {
 194         defaultCase(node);
 195     }
 196
 197     public void caseTPlus(TPlus node)
 198     {
 199         defaultCase(node);
 200     }
 201
 202     public void caseTMinus(TMinus node)
 203     {
 204         defaultCase(node);
 205     }
 206
 207     public void caseTMult(TMult node)
 208     {
 209         defaultCase(node);
 210     }
 211
 212     public void caseTDiv(TDiv node)
 213     {
 214         defaultCase(node);
 215     }
 216
 217     public void caseTAmpersand(TAmpersand node)
 218     {
 219         defaultCase(node);
 220     }
 221
 222     public void caseTComma(TComma node)
 223     {
 224         defaultCase(node);
 225     }
 226
 227     public void caseTColon(TColon node)
 228     {
 229         defaultCase(node);
 230     }
 231
 232     public void caseTLPar(TLPar node)
 233     {
 234         defaultCase(node);
 235     }
 236
 237     public void caseTRPar(TRPar node)
 238     {
 239         defaultCase(node);
 240     }
 241
 242     public void caseTVariable(TVariable node)
 243     {
 244         defaultCase(node);
 245     }
 246
 247     public void caseTFunc(TFunc node)
 248     {
 249         defaultCase(node);
 250     }
 251
 252     public void caseTCell(TCell node)
 253     {
 254         defaultCase(node);
 255     }
 256
 257     public void caseTRvi(TRvi node)
 258     {
 259         defaultCase(node);
 260     }
 261
 262     public void caseTNumber(TNumber node)
 263     {
 264         defaultCase(node);
 265     }
 266
 267     public void caseTString(TString node)
 268     {
 269         defaultCase(node);
 270     }
 271
 272     public void caseTNewLine(TNewLine node)
 273     {
 274         defaultCase(node);
 275     }
 276
 277     public void caseTBlank(TBlank node)
 278     {
 279         defaultCase(node);
 280     }
 281
 282     public void caseEOF(EOF node)
 283     {
 284         defaultCase(node);
 285     }
 286
 287     public void defaultCase(@SuppressWarnings("unused") Node node)
 288     {
 289         // do nothing
 290     }
 291 }