src/peers/gov/nasa/jpf/vm/JPF_java_util_regex_Matcher.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
  19 package gov.nasa.jpf.vm;
  20
  21 import gov.nasa.jpf.Config;
  22 import gov.nasa.jpf.annotation.MJI;
  23 import gov.nasa.jpf.vm.MJIEnv;
  24 import gov.nasa.jpf.vm.NativePeer;
  25
  26 import java.util.HashMap;
  27 import java.util.regex.Matcher;
  28 import java.util.regex.Pattern;
  29
  30 /**
  31  * native peer for a regex Matcher
  32  * this is just a delegatee peer
  33  */
  34 public class JPF_java_util_regex_Matcher extends NativePeer {
  35
  36   HashMap<Integer, Matcher> matchers;
  37
  38   public JPF_java_util_regex_Matcher (Config conf) {
  39     matchers = new HashMap<Integer,Matcher>();
  40   }
  41
  42   Pattern getPatternFromMatcher(MJIEnv env, int objref) {
  43     int patRef = env.getReferenceField(objref, "pattern");
  44
  45     int regexRef = env.getReferenceField(patRef, "regex");
  46     String regex = env.getStringObject(regexRef);
  47     int flags = env.getIntField(patRef, "flags");
  48
  49     return Pattern.compile(regex, flags);
  50   }
  51
  52   void putInstance (MJIEnv env, int objref, Matcher matcher) {
  53     int id = env.getIntField(objref,  "id");
  54     matchers.put(id, matcher);
  55   }
  56
  57   Matcher getInstance (MJIEnv env, int objref) {
  58
  59     int id = env.getIntField(objref,  "id");
  60     return matchers.get(id);
  61   }
  62
  63   @MJI
  64   public void register____V (MJIEnv env, int objref) {
  65     Pattern pat = getPatternFromMatcher(env, objref);
  66
  67     int inputRef = env.getReferenceField(objref, "input");
  68     String input = env.getStringObject(inputRef);
  69
  70     Matcher matcher = pat.matcher(input);
  71     putInstance(env, objref, matcher);
  72   }
  73
  74   @MJI
  75   public boolean matches____Z (MJIEnv env, int objref) {
  76     Matcher matcher = getInstance( env, objref);
  77     return matcher.matches();
  78   }
  79
  80   @MJI
  81   public boolean find__I__Z (MJIEnv env, int objref, int i) {
  82         Matcher matcher = getInstance( env, objref);
  83     return matcher.find(i);
  84   }
  85
  86   @MJI
  87   public boolean find____Z (MJIEnv env, int objref) {
  88         Matcher matcher = getInstance( env, objref);
  89     return matcher.find();
  90   }
  91
  92   @MJI
  93   public boolean lookingAt____Z(MJIEnv env, int objref) {
  94     Matcher matcher = getInstance(env, objref);
  95     return matcher.lookingAt();
  96   }
  97
  98   @MJI
  99   public int start__I__I(MJIEnv env, int objref, int group) {
 100     Matcher matcher = getInstance(env, objref);
 101     return matcher.start(group);
 102   }
 103
 104   @MJI
 105   public int end__I__I(MJIEnv env, int objref, int group) {
 106     Matcher matcher = getInstance(env, objref);
 107     return matcher.end(group);
 108   }
 109
 110   @MJI
 111   public int regionStart____I(MJIEnv env, int objref) {
 112     Matcher matcher = getInstance(env, objref);
 113     return matcher.regionStart();
 114   }
 115
 116   @MJI
 117   public int regionEnd____I(MJIEnv env, int objref) {
 118     Matcher matcher = getInstance(env, objref);
 119     return matcher.regionEnd();
 120   }
 121
 122   @MJI
 123   public int region__II__Ljava_util_regex_Matcher_2(MJIEnv env, int objref, int start, int end) {
 124     Matcher matcher = getInstance(env, objref);
 125     matcher = matcher.region(start, end);
 126     putInstance(env, objref, matcher);
 127
 128     return objref;
 129   }
 130
 131   @MJI
 132   public int reset____Ljava_util_regex_Matcher_2 (MJIEnv env, int objref) {
 133     Matcher matcher = getInstance( env, objref);
 134
 135     int inputRef = env.getReferenceField(objref, "input");
 136     String input = env.getStringObject(inputRef);
 137
 138     matcher = matcher.reset(input);
 139     putInstance(env, objref, matcher);
 140
 141     return objref;
 142   }
 143
 144   @MJI
 145   public int groupCount____I (MJIEnv env, int objref) {
 146     Matcher matcher = getInstance(env, objref);
 147     return matcher.groupCount();
 148   }
 149
 150   @MJI
 151   public int group__I__Ljava_lang_String_2 (MJIEnv env, int objref, int i) {
 152     Matcher matcher = getInstance( env, objref);
 153     String grp = matcher.group(i);
 154
 155     return env.newString(grp);
 156   }
 157
 158   @MJI
 159   public int quoteReplacement__Ljava_lang_String_2__Ljava_lang_String_2 (MJIEnv env, int clsObjref, int string) {
 160     String parm = env.getStringObject(string);
 161     String result = Matcher.quoteReplacement(parm);
 162     return env.newString(result);
 163   }
 164
 165   @MJI
 166   public int replaceAll__Ljava_lang_String_2__Ljava_lang_String_2 (MJIEnv env, int objref, int string) {
 167     Matcher matcher = getInstance(env, objref);
 168     String replacement = env.getStringObject(string);
 169     String result = matcher.replaceAll(replacement);
 170
 171     int resultref = env.newString(result);
 172     return resultref;
 173   }
 174
 175   @MJI
 176   public int replaceFirst__Ljava_lang_String_2__Ljava_lang_String_2(MJIEnv env, int objref, int string) {
 177     Matcher matcher = getInstance(env, objref);
 178     String replacement = env.getStringObject(string);
 179     String result = matcher.replaceFirst(replacement);
 180
 181     int resultref = env.newString(result);
 182     return resultref;
 183   }
 184
 185   @MJI
 186   public boolean hasTransparentBounds____Z(MJIEnv env, int objref) {
 187     Matcher matcher = getInstance(env, objref);
 188     return matcher.hasTransparentBounds();
 189   }
 190
 191   @MJI
 192   public int useTransparentBounds__Z__Ljava_util_regex_Matcher_2(MJIEnv env, int objref, boolean b) {
 193     Matcher matcher = getInstance(env, objref);
 194     matcher = matcher.useTransparentBounds(b);
 195     putInstance(env, objref, matcher);
 196
 197     return objref;
 198   }
 199
 200   @MJI
 201   public boolean hasAnchoringBounds____Z(MJIEnv env, int objref) {
 202     Matcher matcher = getInstance(env, objref);
 203     return matcher.hasTransparentBounds();
 204   }
 205
 206   @MJI
 207   public int useAnchoringBounds__Z__Ljava_util_regex_Matcher_2(MJIEnv env, int objref, boolean b) {
 208     Matcher matcher = getInstance(env, objref);
 209     matcher = matcher.useAnchoringBounds(b);
 210     putInstance(env, objref, matcher);
 211
 212     return objref;
 213   }
 214
 215   @MJI
 216   public int updatePattern____Ljava_util_regex_Matcher_2(MJIEnv env, int objref) {
 217     //We get the newly updated pattern
 218     Pattern pat = getPatternFromMatcher(env, objref);
 219
 220     //We update the matcher with the new pattern
 221     Matcher matcher = getInstance(env, objref);
 222     matcher = matcher.usePattern(pat);
 223     putInstance(env, objref, matcher);
 224
 225     return objref;
 226   }
 227
 228   @MJI
 229   public int toString____Ljava_lang_String_2 (MJIEnv env, int objref) {
 230     Matcher matcher = getInstance(env, objref);
 231     String str = matcher.toString();
 232
 233     return env.newString(str);
 234   }
 235
 236   @MJI
 237   public boolean hitEnd____Z (MJIEnv env, int objref) {
 238     Matcher matcher = getInstance( env, objref);
 239     return matcher.hitEnd();
 240   }
 241
 242   @MJI
 243   public boolean requireEnd____Z (MJIEnv env, int objref) {
 244     Matcher matcher = getInstance( env, objref);
 245     return matcher.requireEnd();
 246   }
 247 }