src/main/gov/nasa/jpf/vm/serialize/AmmendableFilterConfiguration.java

   1 /*
   2  * Copyright (C) 2014, United States Government, as represented by the
   3  * Administrator of the National Aeronautics and Space Administration.
   4  * All rights reserved.
   5  *
   6  * The Java Pathfinder core (jpf-core) platform is licensed under the
   7  * Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance with the License. You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0.
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 package gov.nasa.jpf.vm.serialize;
  19
  20 import gov.nasa.jpf.Config;
  21 import gov.nasa.jpf.util.ObjVector;
  22 import gov.nasa.jpf.vm.ClassInfo;
  23 import gov.nasa.jpf.vm.FieldInfo;
  24 import gov.nasa.jpf.vm.MethodInfo;
  25
  26 import java.util.ArrayList;
  27
  28 public class AmmendableFilterConfiguration implements FilterConfiguration {
  29   public interface Ammendment {
  30     public static final boolean POLICY_IGNORE = false;
  31     public static final boolean POLICY_INCLUDE = true;
  32   }
  33
  34   public interface FrameAmmendment extends Ammendment {
  35     FramePolicy ammendFramePolicy(MethodInfo mi, FramePolicy sofar);
  36
  37     //BitArray ammendLocalInclusion(MethodInfo mi, BitArray sofar);
  38   }
  39
  40   public interface InstanceAmmendment extends Ammendment {
  41     boolean ammendFieldInclusion(FieldInfo fi, boolean sofar);
  42   }
  43
  44   public interface StaticAmmendment extends Ammendment {
  45     boolean ammendFieldInclusion(FieldInfo fi, boolean sofar);
  46   }
  47
  48   // convience for implementing both
  49   public interface FieldAmmendment extends InstanceAmmendment, StaticAmmendment {}
  50
  51   public interface InstanceOverride {
  52     boolean isOverriding(ClassInfo ci);
  53
  54     Iterable<FieldInfo> getMatchedInstanceFields(ClassInfo ci,
  55                                   Iterable<FieldInfo> preOverride);
  56   }
  57
  58
  59   protected final ObjVector<FrameAmmendment> frameAmmendments =
  60     new ObjVector<FrameAmmendment>(0);
  61
  62   protected final ObjVector<InstanceAmmendment> instanceAmmendments =
  63     new ObjVector<InstanceAmmendment>(0);
  64
  65   protected final ObjVector<StaticAmmendment> staticAmmendments =
  66     new ObjVector<StaticAmmendment>(0);
  67
  68   protected final ObjVector<InstanceOverride> instanceOverrides =
  69     new ObjVector<InstanceOverride>(0);
  70
  71
  72   // configuration stuff
  73
  74   @Override
  75   public void init(Config config)  {
  76     appendConfiguredFrameAmmendments(config);
  77     appendConfiguredInstanceAmmendments(config);
  78     appendConfiguredStaticAmmendments(config);
  79     appendConfiguredInstanceOverrides(config);
  80   }
  81
  82   protected void appendConfiguredFrameAmmendments(Config config) {
  83     ArrayList<FrameAmmendment> fas =
  84       config.getInstances("filter.frame_ammendments", FrameAmmendment.class);
  85     if (fas != null) frameAmmendments.append(fas);
  86   }
  87
  88   protected void appendConfiguredInstanceAmmendments(Config config) {
  89     ArrayList<InstanceAmmendment> ias =
  90       config.getInstances("filter.instance_ammendments", InstanceAmmendment.class);
  91     if (ias != null) instanceAmmendments.append(ias);
  92   }
  93
  94   protected void appendConfiguredStaticAmmendments(Config config) {
  95     ArrayList<StaticAmmendment> sas =
  96       config.getInstances("filter.static_ammendments", StaticAmmendment.class);
  97     if (sas != null) staticAmmendments.append(sas);
  98   }
  99
 100   protected void appendConfiguredInstanceOverrides(Config config) {
 101     ArrayList<InstanceOverride> ios =
 102       config.getInstances("filter.instance_overrides", InstanceOverride.class);
 103     if (ios != null) instanceOverrides.append(ios);
 104   }
 105
 106
 107   // public API for adding to configuration
 108   public void appendFrameAmmendment(FrameAmmendment fa) {
 109     frameAmmendments.add(fa);
 110   }
 111
 112   public void appendInstanceAmmendment(InstanceAmmendment ia) {
 113     instanceAmmendments.add(ia);
 114   }
 115
 116   public void appendStaticAmmendment(StaticAmmendment sa) {
 117     staticAmmendments.add(sa);
 118   }
 119
 120   public void appendFieldAmmendment(FieldAmmendment fa) {
 121     staticAmmendments.add(fa);
 122     instanceAmmendments.add(fa);
 123   }
 124
 125   public void appendInstanceOverride(InstanceOverride io) {
 126     instanceOverrides.add(io);
 127   }
 128
 129
 130   // FilterConfiguration Stuff
 131   @Override
 132   public FramePolicy getFramePolicy(MethodInfo mi) {
 133     FramePolicy policy = new FramePolicy();
 134     for (FrameAmmendment fa : frameAmmendments) {
 135       policy = fa.ammendFramePolicy(mi, policy);
 136     }
 137     return policy;
 138   }
 139
 140   // not implemented
 141   /*public BitArray getFrameLocalInclusion(MethodInfo mi) {
 142     BitArray cur = new BitArray(mi.getMaxLocals());
 143     cur.setAll(); // by default include everything
 144     for (FrameAmmendment fa : frameAmmendments) {
 145       cur = fa.ammendLocalInclusion(mi, cur);
 146     }
 147     return cur;
 148   }*/
 149
 150   @Override
 151   public Iterable<FieldInfo> getMatchedInstanceFields(ClassInfo ci) {
 152     int fieldCount = ci.getNumberOfInstanceFields();
 153     ObjVector<FieldInfo> v = new ObjVector<FieldInfo>(fieldCount);
 154     for (int i = 0; i < fieldCount; i++) {
 155       FieldInfo field = ci.getInstanceField(i);
 156       boolean include = true;
 157       for (InstanceAmmendment ia : instanceAmmendments) {
 158         include = ia.ammendFieldInclusion(field, include);
 159       }
 160       if (include) {
 161         v.add(field);
 162       }
 163     }
 164     Iterable<FieldInfo> ret = v;
 165     for (InstanceOverride io : instanceOverrides) {
 166       if (io.isOverriding(ci)) {
 167         ret = io.getMatchedInstanceFields(ci, ret);
 168       }
 169     }
 170     return ret;
 171   }
 172
 173   @Override
 174   public Iterable<FieldInfo> getMatchedStaticFields(ClassInfo ci) {
 175     int fieldCount = ci.getNumberOfStaticFields();
 176     ObjVector<FieldInfo> v = new ObjVector<FieldInfo>(fieldCount);
 177     for (int i = 0; i < fieldCount; i++) {
 178       FieldInfo field = ci.getStaticField(i);
 179       boolean include = true;
 180       for (StaticAmmendment sa : staticAmmendments) {
 181         include = sa.ammendFieldInclusion(field, include);
 182       }
 183       if (include) {
 184         v.add(field);
 185       }
 186     }
 187     return v;
 188   }
 189 }