From 86d174264b9360a40eff776bef71a8ea90b2625f Mon Sep 17 00:00:00 2001 From: badlogicgames Date: Mon, 26 Dec 2011 00:59:53 +0000 Subject: [PATCH] [added] AntPathMatcher from Spring project [fixed] cleaned up NativeCodeGenerator, for a very small value of clean. --- .../com/badlogic/gdx/jnigen/AntPathMatcher.java | 338 +++++++++++++++++++++ .../badlogic/gdx/jnigen/NativeCodeGenerator.java | 39 --- 2 files changed, 338 insertions(+), 39 deletions(-) create mode 100644 extensions/jnigen/src/com/badlogic/gdx/jnigen/AntPathMatcher.java diff --git a/extensions/jnigen/src/com/badlogic/gdx/jnigen/AntPathMatcher.java b/extensions/jnigen/src/com/badlogic/gdx/jnigen/AntPathMatcher.java new file mode 100644 index 000000000..bbf53a457 --- /dev/null +++ b/extensions/jnigen/src/com/badlogic/gdx/jnigen/AntPathMatcher.java @@ -0,0 +1,338 @@ +/* + * Copyright 2002-2005 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.badlogic.gdx.jnigen; + +import java.util.ArrayList; +import java.util.List; +import java.util.StringTokenizer; + +/** + * PathMatcher implementation for Ant-style path patterns. Examples are provided + * below. + * + *

+ * Part of this mapping code has been kindly borrowed from Apache Ant. + * + *

+ * The mapping matches URLs using the following rules:
+ *

+ * + *

+ * Some examples:
+ *

+ * + * @author Alef Arendsen + * @author Juergen Hoeller + * @since 16.07.2003 + */ +public class AntPathMatcher { + + public boolean isPattern(String str) { + return (str.indexOf('*') != -1 || str.indexOf('?') != -1); + } + + public static String[] tokenizeToStringArray(String str, String delimiters, + boolean trimTokens, boolean ignoreEmptyTokens) { + if (str == null) { + return null; + } + StringTokenizer st = new StringTokenizer(str, delimiters); + List tokens = new ArrayList(); + while (st.hasMoreTokens()) { + String token = st.nextToken(); + if (trimTokens) { + token = token.trim(); + } + if (!ignoreEmptyTokens || token.length() > 0) { + tokens.add(token); + } + } + return tokens.toArray(new String[tokens.size()]); + } + + public boolean match(String pattern, String str) { + if (str.startsWith("/") != pattern.startsWith("/")) { + return false; + } + + String[] patDirs = tokenizeToStringArray(pattern, "/", true, true); + String[] strDirs = tokenizeToStringArray(str, "/", true, true); + + int patIdxStart = 0; + int patIdxEnd = patDirs.length - 1; + int strIdxStart = 0; + int strIdxEnd = strDirs.length - 1; + + // Match all elements up to the first ** + while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { + String patDir = (String) patDirs[patIdxStart]; + if (patDir.equals("**")) { + break; + } + if (!matchStrings(patDir, (String) strDirs[strIdxStart])) { + return false; + } + patIdxStart++; + strIdxStart++; + } + + if (strIdxStart > strIdxEnd) { + // String is exhausted, only match if rest of pattern is **'s + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (!patDirs[i].equals("**")) { + return false; + } + } + return true; + } else { + if (patIdxStart > patIdxEnd) { + // String not exhausted, but pattern is. Failure. + return false; + } + } + + // up to last '**' + while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) { + String patDir = (String) patDirs[patIdxEnd]; + if (patDir.equals("**")) { + break; + } + if (!matchStrings(patDir, (String) strDirs[strIdxEnd])) { + return false; + } + patIdxEnd--; + strIdxEnd--; + } + if (strIdxStart > strIdxEnd) { + // String is exhausted + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (!patDirs[i].equals("**")) { + return false; + } + } + return true; + } + + while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) { + int patIdxTmp = -1; + for (int i = patIdxStart + 1; i <= patIdxEnd; i++) { + if (patDirs[i].equals("**")) { + patIdxTmp = i; + break; + } + } + if (patIdxTmp == patIdxStart + 1) { + // '**/**' situation, so skip one + patIdxStart++; + continue; + } + // Find the pattern between padIdxStart & padIdxTmp in str between + // strIdxStart & strIdxEnd + int patLength = (patIdxTmp - patIdxStart - 1); + int strLength = (strIdxEnd - strIdxStart + 1); + int foundIdx = -1; + strLoop: for (int i = 0; i <= strLength - patLength; i++) { + for (int j = 0; j < patLength; j++) { + String subPat = (String) patDirs[patIdxStart + j + 1]; + String subStr = (String) strDirs[strIdxStart + i + j]; + if (!matchStrings(subPat, subStr)) { + continue strLoop; + } + } + + foundIdx = strIdxStart + i; + break; + } + + if (foundIdx == -1) { + return false; + } + + patIdxStart = patIdxTmp; + strIdxStart = foundIdx + patLength; + } + + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (!patDirs[i].equals("**")) { + return false; + } + } + + return true; + } + + /** + * Tests whether or not a string matches against a pattern. The pattern may + * contain two special characters:
+ * '*' means zero or more characters
+ * '?' means one and only one character + * + * @param pattern + * pattern to match against. Must not be null. + * @param str + * string which must be matched against the pattern. Must not be + * null. + * @return true if the string matches against the pattern, or + * false otherwise. + */ + private boolean matchStrings(String pattern, String str) { + char[] patArr = pattern.toCharArray(); + char[] strArr = str.toCharArray(); + int patIdxStart = 0; + int patIdxEnd = patArr.length - 1; + int strIdxStart = 0; + int strIdxEnd = strArr.length - 1; + char ch; + + boolean containsStar = false; + for (int i = 0; i < patArr.length; i++) { + if (patArr[i] == '*') { + containsStar = true; + break; + } + } + + if (!containsStar) { + // No '*'s, so we make a shortcut + if (patIdxEnd != strIdxEnd) { + return false; // Pattern and string do not have the same size + } + for (int i = 0; i <= patIdxEnd; i++) { + ch = patArr[i]; + if (ch != '?') { + if (ch != strArr[i]) { + return false;// Character mismatch + } + } + } + return true; // String matches against pattern + } + + if (patIdxEnd == 0) { + return true; // Pattern contains only '*', which matches anything + } + + // Process characters before first star + while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) { + if (ch != '?') { + if (ch != strArr[strIdxStart]) { + return false;// Character mismatch + } + } + patIdxStart++; + strIdxStart++; + } + if (strIdxStart > strIdxEnd) { + // All characters in the string are used. Check if only '*'s are + // left in the pattern. If so, we succeeded. Otherwise failure. + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (patArr[i] != '*') { + return false; + } + } + return true; + } + + // Process characters after last star + while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) { + if (ch != '?') { + if (ch != strArr[strIdxEnd]) { + return false;// Character mismatch + } + } + patIdxEnd--; + strIdxEnd--; + } + if (strIdxStart > strIdxEnd) { + // All characters in the string are used. Check if only '*'s are + // left in the pattern. If so, we succeeded. Otherwise failure. + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (patArr[i] != '*') { + return false; + } + } + return true; + } + + // process pattern between stars. padIdxStart and patIdxEnd point + // always to a '*'. + while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) { + int patIdxTmp = -1; + for (int i = patIdxStart + 1; i <= patIdxEnd; i++) { + if (patArr[i] == '*') { + patIdxTmp = i; + break; + } + } + if (patIdxTmp == patIdxStart + 1) { + // Two stars next to each other, skip the first one. + patIdxStart++; + continue; + } + // Find the pattern between padIdxStart & padIdxTmp in str between + // strIdxStart & strIdxEnd + int patLength = (patIdxTmp - patIdxStart - 1); + int strLength = (strIdxEnd - strIdxStart + 1); + int foundIdx = -1; + strLoop: for (int i = 0; i <= strLength - patLength; i++) { + for (int j = 0; j < patLength; j++) { + ch = patArr[patIdxStart + j + 1]; + if (ch != '?') { + if (ch != strArr[strIdxStart + i + j]) { + continue strLoop; + } + } + } + + foundIdx = strIdxStart + i; + break; + } + + if (foundIdx == -1) { + return false; + } + + patIdxStart = patIdxTmp; + strIdxStart = foundIdx + patLength; + } + + // All characters in the string are used. Check if only '*'s are left + // in the pattern. If so, we succeeded. Otherwise failure. + for (int i = patIdxStart; i <= patIdxEnd; i++) { + if (patArr[i] != '*') { + return false; + } + } + + return true; + } + +} \ No newline at end of file diff --git a/extensions/jnigen/src/com/badlogic/gdx/jnigen/NativeCodeGenerator.java b/extensions/jnigen/src/com/badlogic/gdx/jnigen/NativeCodeGenerator.java index 496acab31..c838157f4 100644 --- a/extensions/jnigen/src/com/badlogic/gdx/jnigen/NativeCodeGenerator.java +++ b/extensions/jnigen/src/com/badlogic/gdx/jnigen/NativeCodeGenerator.java @@ -393,43 +393,4 @@ public class NativeCodeGenerator { + Arrays.toString(arguments) + "]"; } } - - private static String findMatchingLine(FileDescriptor srcDir, String message) { - String file = message.substring(0, message.indexOf(".cpp")); - String className = file.substring(file.lastIndexOf('.') + 1).replace('.', '/'); - FileDescriptor child = srcDir.child(className + ".java"); - String javaContent = child.readString(); - - - - return ""; - } - - public static void main(String[] args) throws Exception { - new NativeCodeGenerator().generate(args[0], args[1], args[2]); - -// Process process = Runtime.getRuntime().exec("ant.bat -f build-win32home.xml -v", null, new File("jni")); -// final InputStream stream = process.getInputStream(); -// Thread t = new Thread(new Runnable() { -// @Override -// public void run() { -// int c = 0; -// try { -// BufferedReader reader = new BufferedReader(new InputStreamReader(stream)); -// String line = reader.readLine(); -// while(line != null) { -// System.out.println(line); -// if(line.contains("error:")) { -// } -// line = reader.readLine(); -// } -// } catch (IOException e) { -// e.printStackTrace(); -// } -// } -// }); -// t.setDaemon(true); -// t.start(); -// process.waitFor(); - } } -- 2.11.0