Source for gnu.java.beans.encoder.ScannerState

   1: /* ScannerState.java
   2:  Copyright (C) 2005 Free Software Foundation, Inc.
   3: 
   4:  This file is part of GNU Classpath.
   5: 
   6:  GNU Classpath is free software; you can redistribute it and/or modify
   7:  it under the terms of the GNU General Public License as published by
   8:  the Free Software Foundation; either version 2, or (at your option)
   9:  any later version.
  10: 
  11:  GNU Classpath is distributed in the hope that it will be useful, but
  12:  WITHOUT ANY WARRANTY; without even the implied warranty of
  13:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14:  General Public License for more details.
  15: 
  16:  You should have received a copy of the GNU General Public License
  17:  along with GNU Classpath; see the file COPYING.  If not, write to the
  18:  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19:  02110-1301 USA.
  20: 
  21:  Linking this library statically or dynamically with other modules is
  22:  making a combined work based on this library.  Thus, the terms and
  23:  conditions of the GNU General Public License cover the whole
  24:  combination.
  25: 
  26:  As a special exception, the copyright holders of this library give you
  27:  permission to link this library with independent modules to produce an
  28:  executable, regardless of the license terms of these independent
  29:  modules, and to copy and distribute the resulting executable under
  30:  terms of your choice, provided that you also meet, for each linked
  31:  independent module, the terms and conditions of the license of that
  32:  module.  An independent module is a module which is not derived from
  33:  or based on this library.  If you modify this library, you may extend
  34:  this exception to your version of the library, but you are not
  35:  obligated to do so.  If you do not wish to do so, delete this
  36:  exception statement from your version. */
  37: 
  38: 
  39: package gnu.java.beans.encoder;
  40: 
  41: import java.util.HashMap;
  42: 
  43: /** <p>Provides the infrastructure for the state machine and the transition
  44:  * mechanism.</p>
  45:  *
  46:  * <p>Each states knows a set of successor. There can be one successor for
  47:  * every transition variant. Furthermore a state knows about a default
  48:  * successor which is taken when there is no special setup for a
  49:  * transition.</p>
  50:  *
  51:  * @author Robert Schuster (robertschuster@fsfe.org)
  52:  *
  53:  */
  54: public abstract class ScannerState
  55: {
  56: 
  57:   static final int TRANSITION_METHOD_INVOCATION = 0;
  58: 
  59:   static final int TRANSITION_STATIC_METHOD_INVOCATION = 1;
  60: 
  61:   static final int TRANSITION_STATIC_FIELD_ACCESS = 2;
  62: 
  63:   static final int TRANSITION_CLASS_RESOLUTION = 3;
  64: 
  65:   static final int TRANSITION_OBJECT_INSTANTIATION = 4;
  66: 
  67:   static final int TRANSITION_PRIMITIVE_INSTANTIATION = 5;
  68: 
  69:   static final int TRANSITION_OBJECT_ARRAY_INSTANTIATION = 6;
  70: 
  71:   static final int TRANSITION_PRIMITIVE_ARRAY_INSTANTIATION = 7;
  72: 
  73:   static final int TRANSITION_ARRAY_SET = 8;
  74: 
  75:   static final int TRANSITION_ARRAY_GET = 9;
  76: 
  77:   static final int TRANSITION_LIST_SET = 10;
  78: 
  79:   static final int TRANSITION_LIST_GET = 11;
  80: 
  81:   static final int TRANSITION_NULL_OBJECT = 12;
  82: 
  83:   static final int TRANSITION_STRING_REFERENCE = 13;
  84: 
  85:   static final int TRANSITION_OBJECT_REFERENCE = 14;
  86: 
  87:   static final int TRANSITION_FIRST = 0;
  88: 
  89:   static final int TRANSITION_LAST = 14;
  90: 
  91:   static final String DEFAULT_STATE_NAME = "default";
  92: 
  93:   String defaultSuccessor = DEFAULT_STATE_NAME;
  94: 
  95:   static String[] transitionNames = { "METHOD_INVOCATION", "STATIC_METHOD_INVOCATION",
  96:                               "STATIC_FIELD_ACCESS", "CLASS_RESOLUTION",
  97:                               "OBJECT_INSTANTIATION",
  98:                               "PRIMITIVE_INSTANTIATION", "OBJECT_ARRAY_INSTANTIATION",
  99:                               "PRIMITIVE_ARRAY_INSTANTIATION",
 100:                               "ARRAY_SET", "ARRAY_GET", "LIST_SET", "LIST_GET",
 101:                               "NULL_OBJECT", "STRING_REFERENCE", "OBJECT_REFERENCE" };
 102: 
 103:   /**
 104:    * Stores the transition setup as the relation
 105:    * transition->successor's state name.
 106:    */
 107:   HashMap transitions = new HashMap();
 108: 
 109:   int calls;
 110: 
 111:   Context context;
 112: 
 113:   String name;
 114: 
 115:   final void init(String newName)
 116:   {
 117:     assert (name == null);
 118: 
 119:     name = newName;
 120:   }
 121: 
 122:   final String getName()
 123:   {
 124:     return name;
 125:   }
 126: 
 127:   final void enter(Context ctx)
 128:   {
 129:     calls++;
 130:     context = ctx;
 131: 
 132:     enterImpl(ctx);
 133:   }
 134: 
 135:   protected void enterImpl(Context ctx)
 136:   {
 137:   }
 138: 
 139:   final Context context()
 140:   {
 141:     return context;
 142:   }
 143: 
 144:   final int getCalls()
 145:   {
 146:     return calls;
 147:   }
 148: 
 149:   /**
 150:    * <p>Stores a successor's state name for a certain transition.</p>
 151:    *
 152:    * <p>This method is only used at the configuration time of the state
 153:    * machine.</p>
 154:    *
 155:    * @param transition One of the transition constants.
 156:    * @param stateName The state name of the successor.
 157:    */
 158:   final void putSuccessor(int transition, String stateName)
 159:   {
 160:     assert (transition >= TRANSITION_FIRST && transition <= TRANSITION_LAST) :
 161:       "Transition identifier '" + transition + "' is unknown.";
 162: 
 163:     transitions.put(new Integer(transition), stateName);
 164:   }
 165: 
 166:   /** <p>Retrieves a the state name of a successor for the given transition
 167:    * constant.</p>
 168:    *
 169:    * <p>Returns the default successor's state name if no special setup was
 170:    * prepared.</p>
 171:    *
 172:    * @param transition One of the transition constants.
 173:    * @return The state name of the successor.
 174:    */
 175:   final String getSuccessor(int transition)
 176:   {
 177:     String state = (String) transitions.get(new Integer(transition));
 178: 
 179:     return (state == null) ? defaultSuccessor : state;
 180:   }
 181: 
 182:   /**
 183:    * Sets the name for the default successor state.
 184:    *
 185:    * @param newDefaultSuccessor The default successor's state name.
 186:    */
 187:   final void setDefaultSuccessor(String newDefaultSuccessor)
 188:   {
 189:     defaultSuccessor = newDefaultSuccessor;
 190:   }
 191: 
 192:   abstract void methodInvocation(String methodName);
 193: 
 194:   abstract void staticMethodInvocation(String className, String methodName);
 195: 
 196:   abstract void staticFieldAccess(String className, String fieldName);
 197: 
 198:   abstract void classResolution(String className);
 199: 
 200:   abstract void objectInstantiation(String className, ObjectId objectId);
 201: 
 202:   abstract void primitiveInstantiation(String primitiveName,
 203:                                        String valueAsString);
 204: 
 205:   abstract void objectArrayInstantiation(String arrayClassName, String lengthAsString, ObjectId objectId);
 206: 
 207:   abstract void primitiveArrayInstantiation(String arrayClassName, String lengthAsString, ObjectId objectId);
 208: 
 209:   abstract void arraySet(String indexAsString);
 210: 
 211:   abstract void arrayGet(String indexAsString);
 212: 
 213:   abstract void listGet();
 214: 
 215:   abstract void listSet();
 216: 
 217:   abstract void nullObject();
 218: 
 219:   abstract void stringReference(String string);
 220: 
 221:   abstract void objectReference(ObjectId id);
 222: 
 223:   /**
 224:    * <p>A special event that does not provoke a direct transition.</p>
 225:    *
 226:    * <p>Instead the transition is done by the <code>ScanEngine</code>: It goes
 227:    * back to the previous state and just uses this method to inform the state
 228:    * about this happening.</p>
 229:    */
 230:   abstract void end();
 231: 
 232:   void enter()
 233:   {
 234:   }
 235: 
 236: }