SmartThings specific support to reduce state space
[jpf-core.git] / 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         //        System.out.println("Including "+field);
163       }
164     }
165     Iterable<FieldInfo> ret = v;
166     for (InstanceOverride io : instanceOverrides) {
167       if (io.isOverriding(ci)) {
168         ret = io.getMatchedInstanceFields(ci, ret);
169       }
170     }
171     return ret;
172   }
173
174   @Override
175   public Iterable<FieldInfo> getMatchedStaticFields(ClassInfo ci) {
176     int fieldCount = ci.getNumberOfStaticFields();
177     ObjVector<FieldInfo> v = new ObjVector<FieldInfo>(fieldCount); 
178     for (int i = 0; i < fieldCount; i++) {
179       FieldInfo field = ci.getStaticField(i);
180       boolean include = true;
181       for (StaticAmmendment sa : staticAmmendments) {
182         include = sa.ammendFieldInclusion(field, include);
183       }
184       if (include) {
185         v.add(field);
186         //        System.out.println("Including "+field);
187       }
188     }
189     return v;
190   }
191 }