bundles/org.simantics.spreadsheet.common/src/org/simantics/spreadsheet/common/expression/analysis/AnalysisAdapter.java

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