1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "Matcher" 18 19 #include <stdlib.h> 20 21 #include "IcuUtilities.h" 22 #include "JNIHelp.h" 23 #include "JniConstants.h" 24 #include "JniException.h" 25 #include "ScopedPrimitiveArray.h" 26 #include "UniquePtr.h" 27 #include "jni.h" 28 #include "unicode/parseerr.h" 29 #include "unicode/regex.h" 30 31 // ICU documentation: http://icu-project.org/apiref/icu4c/classRegexMatcher.html 32 33 static RegexMatcher* toRegexMatcher(jlong address) { 34 return reinterpret_cast<RegexMatcher*>(static_cast<uintptr_t>(address)); 35 } 36 37 /** 38 * We use ICU4C's RegexMatcher class, but our input is on the Java heap and potentially moving 39 * around between calls. This wrapper class ensures that our RegexMatcher is always pointing at 40 * the current location of the char[]. Earlier versions of Android simply copied the data to the 41 * native heap, but that's wasteful and hides allocations from the garbage collector. 42 */ 43 class MatcherAccessor { 44 public: 45 MatcherAccessor(JNIEnv* env, jlong address, jstring javaInput, bool reset) { 46 init(env, address); 47 48 mJavaInput = javaInput; 49 mChars = env->GetStringChars(mJavaInput, NULL); 50 if (mChars == NULL) { 51 return; 52 } 53 54 mUText = utext_openUChars(NULL, mChars, env->GetStringLength(mJavaInput), &mStatus); 55 if (mUText == NULL) { 56 return; 57 } 58 59 if (reset) { 60 mMatcher->reset(mUText); 61 } else { 62 mMatcher->refreshInputText(mUText, mStatus); 63 } 64 } 65 66 MatcherAccessor(JNIEnv* env, jlong address) { 67 init(env, address); 68 } 69 70 ~MatcherAccessor() { 71 utext_close(mUText); 72 if (mJavaInput) { 73 mEnv->ReleaseStringChars(mJavaInput, mChars); 74 } 75 maybeThrowIcuException(mEnv, "utext_close", mStatus); 76 } 77 78 RegexMatcher* operator->() { 79 return mMatcher; 80 } 81 82 UErrorCode& status() { 83 return mStatus; 84 } 85 86 void updateOffsets(jintArray javaOffsets) { 87 ScopedIntArrayRW offsets(mEnv, javaOffsets); 88 if (offsets.get() == NULL) { 89 return; 90 } 91 92 for (size_t i = 0, groupCount = mMatcher->groupCount(); i <= groupCount; ++i) { 93 offsets[2*i + 0] = mMatcher->start(i, mStatus); 94 offsets[2*i + 1] = mMatcher->end(i, mStatus); 95 } 96 } 97 98 private: 99 void init(JNIEnv* env, jlong address) { 100 mEnv = env; 101 mJavaInput = NULL; 102 mMatcher = toRegexMatcher(address); 103 mChars = NULL; 104 mStatus = U_ZERO_ERROR; 105 mUText = NULL; 106 } 107 108 JNIEnv* mEnv; 109 jstring mJavaInput; 110 RegexMatcher* mMatcher; 111 const jchar* mChars; 112 UErrorCode mStatus; 113 UText* mUText; 114 115 // Disallow copy and assignment. 116 MatcherAccessor(const MatcherAccessor&); 117 void operator=(const MatcherAccessor&); 118 }; 119 120 static void Matcher_closeImpl(JNIEnv*, jclass, jlong address) { 121 delete toRegexMatcher(address); 122 } 123 124 static jint Matcher_findImpl(JNIEnv* env, jclass, jlong addr, jstring javaText, jint startIndex, jintArray offsets) { 125 MatcherAccessor matcher(env, addr, javaText, false); 126 UBool result = matcher->find(startIndex, matcher.status()); 127 if (result) { 128 matcher.updateOffsets(offsets); 129 } 130 return result; 131 } 132 133 static jint Matcher_findNextImpl(JNIEnv* env, jclass, jlong addr, jstring javaText, jintArray offsets) { 134 MatcherAccessor matcher(env, addr, javaText, false); 135 if (matcher.status() != U_ZERO_ERROR) { 136 return -1; 137 } 138 UBool result = matcher->find(); 139 if (result) { 140 matcher.updateOffsets(offsets); 141 } 142 return result; 143 } 144 145 static jint Matcher_groupCountImpl(JNIEnv* env, jclass, jlong addr) { 146 MatcherAccessor matcher(env, addr); 147 return matcher->groupCount(); 148 } 149 150 static jint Matcher_hitEndImpl(JNIEnv* env, jclass, jlong addr) { 151 MatcherAccessor matcher(env, addr); 152 return matcher->hitEnd(); 153 } 154 155 static jint Matcher_lookingAtImpl(JNIEnv* env, jclass, jlong addr, jstring javaText, jintArray offsets) { 156 MatcherAccessor matcher(env, addr, javaText, false); 157 UBool result = matcher->lookingAt(matcher.status()); 158 if (result) { 159 matcher.updateOffsets(offsets); 160 } 161 return result; 162 } 163 164 static jint Matcher_matchesImpl(JNIEnv* env, jclass, jlong addr, jstring javaText, jintArray offsets) { 165 MatcherAccessor matcher(env, addr, javaText, false); 166 UBool result = matcher->matches(matcher.status()); 167 if (result) { 168 matcher.updateOffsets(offsets); 169 } 170 return result; 171 } 172 173 static jlong Matcher_openImpl(JNIEnv* env, jclass, jlong patternAddr) { 174 RegexPattern* pattern = reinterpret_cast<RegexPattern*>(static_cast<uintptr_t>(patternAddr)); 175 UErrorCode status = U_ZERO_ERROR; 176 RegexMatcher* result = pattern->matcher(status); 177 maybeThrowIcuException(env, "RegexPattern::matcher", status); 178 return reinterpret_cast<uintptr_t>(result); 179 } 180 181 static jint Matcher_requireEndImpl(JNIEnv* env, jclass, jlong addr) { 182 MatcherAccessor matcher(env, addr); 183 return matcher->requireEnd(); 184 } 185 186 static void Matcher_setInputImpl(JNIEnv* env, jclass, jlong addr, jstring javaText, jint start, jint end) { 187 MatcherAccessor matcher(env, addr, javaText, true); 188 matcher->region(start, end, matcher.status()); 189 } 190 191 static void Matcher_useAnchoringBoundsImpl(JNIEnv* env, jclass, jlong addr, jboolean value) { 192 MatcherAccessor matcher(env, addr); 193 matcher->useAnchoringBounds(value); 194 } 195 196 static void Matcher_useTransparentBoundsImpl(JNIEnv* env, jclass, jlong addr, jboolean value) { 197 MatcherAccessor matcher(env, addr); 198 matcher->useTransparentBounds(value); 199 } 200 201 static JNINativeMethod gMethods[] = { 202 NATIVE_METHOD(Matcher, closeImpl, "(J)V"), 203 NATIVE_METHOD(Matcher, findImpl, "(JLjava/lang/String;I[I)Z"), 204 NATIVE_METHOD(Matcher, findNextImpl, "(JLjava/lang/String;[I)Z"), 205 NATIVE_METHOD(Matcher, groupCountImpl, "(J)I"), 206 NATIVE_METHOD(Matcher, hitEndImpl, "(J)Z"), 207 NATIVE_METHOD(Matcher, lookingAtImpl, "(JLjava/lang/String;[I)Z"), 208 NATIVE_METHOD(Matcher, matchesImpl, "(JLjava/lang/String;[I)Z"), 209 NATIVE_METHOD(Matcher, openImpl, "(J)J"), 210 NATIVE_METHOD(Matcher, requireEndImpl, "(J)Z"), 211 NATIVE_METHOD(Matcher, setInputImpl, "(JLjava/lang/String;II)V"), 212 NATIVE_METHOD(Matcher, useAnchoringBoundsImpl, "(JZ)V"), 213 NATIVE_METHOD(Matcher, useTransparentBoundsImpl, "(JZ)V"), 214 }; 215 void register_java_util_regex_Matcher(JNIEnv* env) { 216 jniRegisterNativeMethods(env, "java/util/regex/Matcher", gMethods, NELEM(gMethods)); 217 } 218
