@SuppressLint("WorldReadableFiles")
@Override
protected FilterResults performFiltering(CharSequence constraint) {
// NOTE: this function is *always* called from a background thread, and
// not the UI thread.
ArrayList<ApplicationInfo> items = new ArrayList<ApplicationInfo>();
synchronized (this) {
items.addAll(appList);
}
SharedPreferences prefs = getSharedPreferences(Common.PREFS, Context.MODE_WORLD_READABLE);
FilterResults result = new FilterResults();
if (constraint != null && constraint.length() > 0) {
Pattern regexp =
Pattern.compile(constraint.toString(), Pattern.LITERAL | Pattern.CASE_INSENSITIVE);
for (Iterator<ApplicationInfo> i = items.iterator(); i.hasNext(); ) {
ApplicationInfo app = i.next();
if (!regexp.matcher(app.name == null ? "" : app.name).find()
&& !regexp.matcher(app.packageName).find()) {
i.remove();
}
}
}
for (Iterator<ApplicationInfo> i = items.iterator(); i.hasNext(); ) {
ApplicationInfo app = i.next();
if (filteredOut(prefs, app)) i.remove();
}
result.values = items;
result.count = items.size();
return result;
}
boolean isManaged(File file) {
log("isManaged() " + file);
if (file == null) {
return false;
}
String path = file.getAbsolutePath();
if (metadataPattern.matcher(path).matches()) {
return false;
}
if (lhTmpFilePattern.matcher(path).matches()) {
return false;
}
if (includeFiles != null) {
return includeFiles.matcher(path).matches();
}
if (excludeFiles != null) {
return !excludeFiles.matcher(path).matches();
}
return true;
}
private String cleanXSS(String paramString) {
if (paramString == null) {
return "";
}
String str = paramString.toLowerCase();
str = str.replaceAll("", "");
Pattern localPattern = Pattern.compile("<script>(.*?)</script>", 2);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\'(.*?)\\'", 42);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", 42);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("</script>", 2);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("<script(.*?)>", 42);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("eval\\((.*?)\\)", 42);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("expression\\((.*?)\\)", 42);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("javascript:", 2);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("vbscript:", 2);
str = localPattern.matcher(str).replaceAll("");
localPattern = Pattern.compile("onload(.*?)=", 42);
str = localPattern.matcher(str).replaceAll("");
str = str.replaceAll("\\(", "(").replaceAll("\\)", ")");
str = str.replaceAll("'", this.apostrophe);
str = str.replaceAll("<", "<").replaceAll(">", ">");
return str;
}
private List<String> findRelativeURLs(StringBuffer buf) {
List<String> uris = new ArrayList<String>();
if (buf.indexOf("<wsdl:") < 0) { // $NON-NLS-1$
Pattern pattern = Pattern.compile("(<import)(.*)( schemaLocation=\")([^\"]+)"); // $NON-NLS-1$
Matcher matcher = pattern.matcher(buf);
while (matcher.find()) {
String relativeURLString = matcher.group(4);
uris.add(relativeURLString);
}
pattern = Pattern.compile("(<import schemaLocation=\")([^\"]+)"); // $NON-NLS-1$
matcher = pattern.matcher(buf);
while (matcher.find()) {
String relativeURLString = matcher.group(2);
uris.add(relativeURLString);
}
} else {
Pattern pattern =
Pattern.compile("(<xsd:import)(.*)( schemaLocation=\")([^\"]+)"); // $NON-NLS-1$
Matcher matcher = pattern.matcher(buf);
while (matcher.find()) {
String relativeURLString = matcher.group(4);
uris.add(relativeURLString);
}
pattern = Pattern.compile("(<xsd:import schemaLocation=\")([^\"]+)"); // $NON-NLS-1$
matcher = pattern.matcher(buf);
while (matcher.find()) {
String relativeURLString = matcher.group(2);
uris.add(relativeURLString);
}
}
return uris;
}
private boolean isValidPort(String text) {
if (StringUtils.isBlank(text)) return false;
String[] ports = text.trim().split(",");
boolean ok = false;
// linux (and OSX?)
if (SystemUtils.IS_OS_LINUX || SystemUtils.IS_OS_MAC_OSX) {
// each will be /dev/tty* or /dev/cu*
for (String port : ports) {
if (StringUtils.isBlank(port)) continue;
if (portNamesRegexLinux.matcher(port.trim()).matches()) {
// must be at least one good
ok = true;
} else {
// doesnt match, its bad so outa here.
return false;
}
}
}
// windows
if (SystemUtils.IS_OS_WINDOWS) {
// each will be COM*
for (String port : ports) {
if (StringUtils.isBlank(port)) continue;
if (portNamesRegexWindows.matcher(port.trim()).matches()) {
// must be at least one good
ok = true;
} else {
// doesnt match, its bad so outa here.
return false;
}
}
}
return ok;
}
/**
* Returns the browser given by the specified browser string
*
* @param browser a browser string like "*firefox"
* @param sessionId the sessionId to launch
* @param queue
* @return the BrowserLauncher ready to launch
*/
public BrowserLauncher getBrowserLauncher(String browser, String sessionId, SeleneseQueue queue) {
if (browser == null) throw new IllegalArgumentException("browser may not be null");
for (Iterator iterator = supportedBrowsers.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry entry = (Map.Entry) iterator.next();
String name = (String) entry.getKey();
Class c = (Class) entry.getValue();
Pattern pat = Pattern.compile("^\\*" + name + "( .*)?$");
Matcher mat = pat.matcher(browser);
if (mat.find()) {
String browserStartCommand;
if (browser.equals("*" + name)) {
browserStartCommand = null;
} else {
browserStartCommand = mat.group(1).substring(1);
}
return createBrowserLauncher(c, browserStartCommand, sessionId, queue);
}
}
Matcher CustomMatcher = CUSTOM_PATTERN.matcher(browser);
if (CustomMatcher.find()) {
String browserStartCommand = CustomMatcher.group(1).substring(1);
return new DestroyableRuntimeExecutingBrowserLauncher(browserStartCommand, sessionId);
}
throw browserNotSupported(browser);
}
/**
* 把参数名转换为字段名，把中文转换为拼音，特殊字符转换为下划线
*
* @param string
* @return
*/
public static String pinyin(String string) {
Pattern pattern = Pattern.compile("[\\u4e00-\\u9fa5]");
Pattern pattern2 = Pattern.compile("^\\w+$");
char ch[] = string.toCharArray();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < ch.length; i++) {
String t = String.valueOf(ch[i]);
Matcher matcher = pattern.matcher(t);
Matcher matcher2 = pattern2.matcher(t);
if (matcher.find()) { // 匹配中文
String pinyin =
PinyinHelper.toHanyuPinyinStringArray(matcher.group().toCharArray()[0])[0]
.replaceAll("\\d+", "")
.replace("u:", "v");
sb.append(pinyin);
} else {
if (matcher2.find()) { // 匹配字母数字下划线
} else {
t = "_";
}
sb.append(t);
}
}
return sb.toString();
}
public static Boolean evaluate(String string, String regex, int flags, Navigator navigator) {
ThreadLocalCache<Map<String, Pattern>> threadLocalPatterns =
ThreadLocalCacheManager.getThreadLocalCache(
Lifecycle.ETERNAL, MatchesFunction.class.getName());
Map<String, Pattern> patterns = threadLocalPatterns.get(_THREAD_LOCAL_PATTERNS_KEY);
if (patterns == null) {
patterns = new HashMap<String, Pattern>();
}
Pattern pattern = patterns.get(regex);
if (pattern != null) {
Matcher matcher = pattern.matcher(string);
return matcher.find();
}
pattern = Pattern.compile(regex, flags);
patterns.put(regex, pattern);
threadLocalPatterns.put(_THREAD_LOCAL_PATTERNS_KEY, patterns);
Matcher matcher = pattern.matcher(string);
return matcher.find();
}
private String normalizeCountList(String str) {
ArrayList<String> chunkedtokens = new ArrayList<String>(Arrays.asList(str.split("\\s+")));
String countp = "one|two|three|four|five|six|seven|eight|nine|ten|more|fewer";
Pattern p = Pattern.compile("(\\b(?:" + countp + ") (?:or|to) (?:" + countp + ")\\b)");
Matcher m = p.matcher(str);
while (m.find()) {
int start = m.start(1);
int end = m.end(1);
String count = m.group(1);
String rcount = "{count~list~" + count.replaceAll(" ", "~") + "}";
// synchronise this.chunkedtokens
// split by single space to get an accurate count to elements that would be in chunkedtokens
int index =
(str.substring(0, start).trim() + " a").trim().split("\\s").length
- 1; // number of tokens before the count pattern
chunkedtokens.set(index, rcount);
int num = count.split("\\s+").length;
for (int i = index + 1; i < index + num; i++) {
chunkedtokens.set(i, "");
}
// resemble the str from chunkedtokens, counting all empty elements, so the str and
// chunkedtokens are in synch.
str = "";
for (String t : chunkedtokens) {
str += t + " ";
}
m = p.matcher(str);
}
return str.replaceAll("\\s+", " ").trim();
}
/**
* Handles DROP TABLE. Drop table suppresses comments so we instead add a fake table with the
* comment in the following form:
*
* <pre><code>
* DROP TABLE, TUNGSTEN_INFO.`comment text`, othertable1, othertable2,...
* </code></pre>
*
* This requires special handling to ensure we deal with multiple tables, comments in the DROP
* TABLE command, and extra syntax like IF EXISTS.
*
* @param statement DROP TABLE statement that requires a comment to be inserted.
* @param comment Comment string to be added.
*/
private String processDropTable(String statement, String comment) {
// Ensure we don't edit in the values twice. Look for the edit
// values and skip out if they are already there.
if (statement.contains(" TUNGSTEN_INFO.`")) return statement;
// Now process the edit, since it has not been done before.
Matcher m = ifExistsPattern.matcher(statement);
boolean foundIfExists = m.find();
if (foundIfExists) {
// This is the easy case. Split the DROP table and put our
// comment in between.
String before = m.group(1);
String after = m.group(2);
String newStatement = before + " TUNGSTEN_INFO.`" + comment + "`, " + after;
return newStatement;
} else {
// This is trickier. We need to split the statement before the
// first table name and add our comment preceded by IF EXISTS.
// Another regex to the rescue. This regex much split properly even
// there are comments embedded in the DROP TABLE or multiple
// tables.
Matcher m2 = dropTable.matcher(statement);
if (m2.find()) {
String before = m2.group(1);
String after = m2.group(2);
String newStatement = before + " IF EXISTS TUNGSTEN_INFO.`" + comment + "`, " + after;
return newStatement;
}
}
// We didn't succeed in matching. We'll hand back the original statement
// and hope for the best.
return statement;
}
public static Map<String, Long> decodeVersioningMap(String in) {
// Cleaning up
Map<String, Long> out = new HashMap<String, Long>();
if (in == null || in.isEmpty()) {
return null;
}
String inMod = in.trim();
inMod = leftTrimP.matcher(inMod).replaceFirst("");
inMod = rightTrimP.matcher(inMod).replaceFirst("");
// The value should look like this: <proj>=<ver>;<proj>=ver;...
for (String entry : inMod.split(";")) {
Matcher m = keyValP.matcher(entry);
while (m.find()) {
String key = m.group(1);
if (key == null || key.isEmpty()) {
continue;
}
String value = m.group(2);
if (value == null || value.isEmpty()) {
continue;
}
try {
Long lv = Long.parseLong(value);
// Trying to add this to the version map
out.put(key, lv);
} catch (NumberFormatException ex) {
continue;
}
}
}
return out;
}
/**
* Applies the exclude and include filters to the found annotations.
*
* @param allAnnotations all annotations
* @return the filtered annotations if there is a filter defined
*/
private List<FileAnnotation> applyFilters(final List<FileAnnotation> allAnnotations) {
List<FileAnnotation> includedAnnotations;
if (includePatterns.isEmpty()) {
includedAnnotations = allAnnotations;
} else {
includedAnnotations = new ArrayList<FileAnnotation>();
for (FileAnnotation annotation : allAnnotations) {
for (Pattern include : includePatterns) {
if (include.matcher(annotation.getFileName()).matches()) {
includedAnnotations.add(annotation);
}
}
}
}
if (excludePatterns.isEmpty()) {
return includedAnnotations;
} else {
List<FileAnnotation> excludedAnnotations = new ArrayList<FileAnnotation>(includedAnnotations);
for (FileAnnotation annotation : includedAnnotations) {
for (Pattern exclude : excludePatterns) {
if (exclude.matcher(annotation.getFileName()).matches()) {
excludedAnnotations.remove(annotation);
}
}
}
return excludedAnnotations;
}
}
/**
* This method is used to help in converting a complex object's data into a JSON string
*
* @param data The submitted data as a string
* @return The JSON equivalent of the submitted string
*/
private String applyRegEx(String data) {
// regular expresion for getting property names
String elementPart = "([\\w]*:)";
// regular expression for getting the values
String elValuePart = "(:)([\\w]*)";
// apply regular expressions to patterns
Pattern elPattern = Pattern.compile(elementPart);
Pattern valPattern = Pattern.compile(elValuePart);
// get matchers to use patterns to match the data/String
Matcher elMatcher = elPattern.matcher(data);
Matcher vMatcher = valPattern.matcher(data);
while (elMatcher.find()) // handles value part
{
String element = elMatcher.group();
data = StringUtils.replaceOnce(data, element, "\"" + element.replace(":", "\":"));
}
while (vMatcher.find()) // handles the value part
{
String value = vMatcher.group();
value = StringUtils.remove(value, ":");
if (!StringUtils.isNumeric(value)
&& // not a number
!StringUtils.equals(value, "true")
&& // not a boolean value
!StringUtils.equals(value, "false")) // not a boolean value
{
if (StringUtils.isEmpty(value)) data = data.replace(":,", ":null,");
else data = StringUtils.replaceOnce(data, value, "\"" + value + "\"");
}
}
return data;
}
private Multiplier multiplier(String expression, int offset) {
Matcher matcher = MULTIPLIER_PREFIX_PATTERN.matcher(expression);
if (!matcher.find()) {
return null;
}
if (matcher.start() > 0) {
fail(offset + matcher.start(), "illegal multiplier position");
}
Matcher digitMatcher = DIGIT_PATTERN.matcher(expression);
if (!digitMatcher.find()) {
return null;
}
String digitStr = expression.substring(0, digitMatcher.end());
int number = 0;
try {
number = Integer.parseInt(digitStr);
} catch (NumberFormatException e) {
fail(offset, e);
}
if (number <= 0) {
fail(offset, "illegal 0 multiplier");
}
String subexpression = expression.substring(matcher.end(), expression.length() - 1);
return new Multiplier(number, subexpression, matcher.end());
}
/**
* Analyze ping results. Compare number of tolerated lost packets to actual lost packets. Note
* that the analyzer does not use the expected number packets for analysis but for reporting only.
*/
public void analyze() {
String text = (String) testAgainst;
status = true;
if (text == null) {
title = "null testAgainst";
status = false;
return;
}
message = text;
// First check if the ping results are in Windows format
Pattern p =
Pattern.compile(
"Sent\\s*=\\s*(\\d+),\\s*Received\\s*=\\s*(\\d+),\\s*Lost\\s*=\\s*\\d+\\s*\\((\\d+)%.*Minimum\\s*=\\s*(\\d+).*Maximum\\s*=\\s*(\\d+).*Average\\s*=\\s*(\\d+)",
Pattern.DOTALL);
Matcher m = p.matcher(text);
if (!m.find()) {
// If not, check if the ping results are in Windows format
p =
Pattern.compile(
"---\\s*\\n(\\d*)\\s*packets transmitted,\\s*(\\d*)\\s*received,\\s*(\\d*)%");
m = p.matcher(text);
if (!m.find()) {
// If not Windows, nor Linux, give up
title = "Unknown ping output format";
status = false;
return;
}
}
// Retrieve raw data from ping results
sent = Integer.parseInt(m.group(1));
received = Integer.parseInt(m.group(2));
lost = Integer.parseInt(m.group(3));
min = Integer.parseInt(m.group(4));
max = Integer.parseInt(m.group(5));
average = Integer.parseInt(m.group(6));
/*
* Compare number of tolerated lost packets to actual lost packets.
*/
if (lost > expected) {
status = false;
}
title =
"Packets: Expected "
+ expected
+ "% lost. Sent = "
+ sent
+ ", Received = "
+ received
+ ", Lost = "
+ lost
+ "%"
+ ", Average = "
+ average;
}
public boolean matches(String extension) {
switch (matchType) {
case IS:
for (Pattern o : this.list) {
try {
if (o.matcher(extension).matches()) return true;
} catch (Throwable e) {
e.printStackTrace();
}
}
return false;
case IS_NOT:
for (Pattern o : this.list) {
try {
if (o.matcher(extension).matches()) return false;
} catch (Throwable e) {
e.printStackTrace();
}
}
return true;
}
return false;
}
private void extractUsedProperties(String text) {
Pattern p1 = Pattern.compile("\\$\\{([^@$}]*)\\}");
Matcher m1 = p1.matcher(text);
log(text, Project.MSG_DEBUG);
while (m1.find()) {
String group = m1.group(1);
if (!propertyList.contains(group)) {
propertyList.add(group);
}
log("property matches: " + group, Project.MSG_DEBUG);
}
Pattern p2 = Pattern.compile("\\$\\{([^\n]*\\})\\}");
Matcher m2 = p2.matcher(text);
log(text, Project.MSG_DEBUG);
while (m2.find()) {
String group = m2.group(1);
if (!propertyList.contains(group)) {
propertyList.add(group);
}
log("property matches: " + group, Project.MSG_DEBUG);
}
Pattern p3 = Pattern.compile("\\$\\{(\\@\\{[^\n]*)\\}");
Matcher m3 = p3.matcher(text);
log(text, Project.MSG_DEBUG);
while (m3.find()) {
String group = m3.group(1);
if (!propertyList.contains(group)) {
propertyList.add(group);
}
log("property matches: " + group, Project.MSG_DEBUG);
}
}
private String replaceEscapedLiterals(String resolvedMessage) {
resolvedMessage = LEFT_BRACE.matcher(resolvedMessage).replaceAll("{");
resolvedMessage = RIGHT_BRACE.matcher(resolvedMessage).replaceAll("}");
resolvedMessage = SLASH.matcher(resolvedMessage).replaceAll(Matcher.quoteReplacement("\\"));
resolvedMessage = DOLLAR.matcher(resolvedMessage).replaceAll(Matcher.quoteReplacement("$"));
return resolvedMessage;
}
protected Map<String, String> getAttributes() {
if (attributes != null) {
return attributes;
}
attributes = new HashMap<String, String>();
matcher = ADDITIONAL_ATTRIBUTES_PATTERN.matcher(firstLine);
if (matcher.find()) {
String s;
Matcher attributeMatcher;
s = matcher.group(2);
attributeMatcher = ADDITIONAL_ATTRIBUTE_PATTERN.matcher(s);
while (attributeMatcher.find()) {
String key;
String value;
key = attributeMatcher.group(1);
value = attributeMatcher.group(2);
attributes.put(key.toLowerCase(Locale.ENGLISH), value);
}
}
return attributes;
}
@Override
public TestCaseResult test(Project project, boolean autoGrade)
throws NotAutomatableException, NotGradableException {
RunningProject noInfo = RunningProjectUtils.runProject(project, 10, "ba");
String noInfoOutput = noInfo.await();
boolean hasMessage = false;
boolean askAgain = false;
if (noInfoOutput.toLowerCase().contains("not enough information")) hasMessage = true;
String[] splittedNoInfoOutput = noInfoOutput.split("\n");
int length = splittedNoInfoOutput.length;
Pattern genecrap = Pattern.compile(".*gene|seq|anoth.*");
if (genecrap.matcher(splittedNoInfoOutput[length - 1]).find()
|| genecrap.matcher(splittedNoInfoOutput[length - 2]).find()) askAgain = true;
if (askAgain && hasMessage) return pass();
if (!askAgain && !hasMessage)
return fail("did not print out notification correctly nor asked for gene input");
int numwrong = 0;
String graderMessage = "";
if (!hasMessage) {
graderMessage += "Did not print out the notification exactly as prompt states.";
numwrong++;
}
if (!askAgain) {
graderMessage += "Does not ask for another gene input";
numwrong++;
}
return partialPass(0.5, graderMessage);
}
@Override
public void output(int id, String line) {
// general check if line contains file
if (line.contains(fileName)) {
// try to match line exactly
try {
Matcher permissionMatcher = permissionPattern.matcher(line);
if (permissionMatcher.find()) {
permissions = convertPermissions(permissionMatcher.group(1));
Log.d(RootCommands.TAG, "Found permissions: " + permissions);
} else {
Log.d(RootCommands.TAG, "Permissions were not found in ls command!");
}
// try to parse for symlink
Matcher symlinkMatcher = symlinkPattern.matcher(line);
if (symlinkMatcher.find()) {
/*
* TODO: If symlink points to a file in the same directory the path is not
* absolute!!!
*/
symlink = symlinkMatcher.group(1);
Log.d(RootCommands.TAG, "Symlink found: " + symlink);
} else {
Log.d(RootCommands.TAG, "No symlink found!");
}
} catch (Exception e) {
Log.e(RootCommands.TAG, "Error with regex!", e);
}
}
}
/** @desc 初始化 */
public void initMethods() {
getMethods = new Hashtable<String, Method>();
setMethods = new Hashtable<String, Method>();
cls = obj.getClass();
Method[] methods = cls.getMethods();
// 定义正则表达式，从方法中过滤出getter / setter 函数.
String gs = "get(\\w+)";
Pattern getM = Pattern.compile(gs);
String ss = "set(\\w+)";
Pattern setM = Pattern.compile(ss);
// 把方法中的"set" 或者 "get" 去掉
String rapl = "$1";
String param;
for (int i = 0; i < methods.length; ++i) {
Method m = methods[i];
String methodName = m.getName();
if (Pattern.matches(gs, methodName)) {
param = getM.matcher(methodName).replaceAll(rapl).toLowerCase();
getMethods.put(param, m);
} else if (Pattern.matches(ss, methodName)) {
param = setM.matcher(methodName).replaceAll(rapl).toLowerCase();
setMethods.put(param, m);
} else {
// System.out.println(methodName + " 不是getter,setter方法！");
}
}
}
private String getTextNodeText(TextNode tn, boolean normalText) {
String input = normalText ? tn.text() : tn.getWholeText();
Node prev = tn.previousSibling();
Node next = tn.nextSibling();
boolean parentIsBlock = isBlock(tn.parent());
if (isBlock(prev)) {
input = ltrim(input);
} else if (prev == null && parentIsBlock) {
input = ltrim(input);
} else if (normalText && prev instanceof TextNode) {
TextNode tprev = (TextNode) prev;
if (EMPTY_MATCHER.matcher(tprev.text()).matches()) {
input = ltrim(input);
}
}
if (input.length() > 0) {
if (isBlock(next)) {
input = rtrim(input);
} else if (next == null && parentIsBlock) {
input = rtrim(input);
} else if (normalText && next instanceof TextNode) {
TextNode tnext = (TextNode) next;
if (EMPTY_MATCHER.matcher(tnext.text()).matches()) {
input = rtrim(input);
}
}
}
return input;
}
public Set<Integer> parseRanges(Collection<String> ranges) {
Set<Integer> result = new TreeSet<>();
for (String range : ranges) {
range = range.trim();
if (range.isEmpty()) {
continue;
}
Matcher matcher;
if (SINGLE_YEAR_PATTERN.matcher(range).matches()) {
result.add(Integer.parseInt(range));
} else if ((matcher = FULL_RANGE_YEAR_PATTERN.matcher(range)).matches()) {
result.addAll(
range(Integer.parseInt(matcher.group(1)), Integer.parseInt(matcher.group(2))));
} else if ((matcher = SHORTEN_RANGE_YEAR_PATTERN.matcher(range)).matches()) {
int start = Integer.parseInt(matcher.group(1));
int end = Integer.parseInt(matcher.group(1).substring(0, 2) + matcher.group(2));
result.addAll(range(start, end));
} else if ((matcher = LIST_YEAR_PATTERN.matcher(range)).matches()) { // 1989,1990,1991
String[] years = matcher.group(0).split(",");
for (String year : years) {
result.add(Integer.parseInt(year));
}
} else if ((matcher = FOUR_DIGIT_YEAR_PATTERN.matcher(range)).find()) {
int year = Integer.parseInt(matcher.group(0));
if (year == 9999) year = MAX_YEAR;
result.add(year);
} else {
// logger.warn("Range '{}' not matched", range);
}
}
return result;
}
@Override
public List<String> getCphNameList(boolean toLowerCase) {
Pattern pattern = Pattern.compile("ui:insert\\s*name=[\"'](.*?)[\"']");
Set<String> matches = new HashSet<String>();
Matcher m = pattern.matcher(head);
while (m.find()) {
String match = m.group(1);
if (!match.startsWith("_")) {
matches.add(m.group(1));
}
}
m = pattern.matcher(body);
while (m.find()) {
String match = m.group(1);
if (!match.startsWith("_")) {
matches.add(m.group(1));
}
}
List<String> cphNameList = new ArrayList<String>(matches);
if (toLowerCase) {
for (int i = 0, n = cphNameList.size(); i < n; i++) {
cphNameList.set(i, cphNameList.get(i).toLowerCase());
}
}
return cphNameList;
}
public boolean compare(BibtexEntry entry) {
// specification of fields to search is done in the search expression itself
String[] searchKeys = entry.getAllFields().toArray(new String[entry.getAllFields().size()]);
boolean noSuchField = true;
// this loop iterates over all regular keys, then over pseudo keys like "type"
for (int i = 0; i < searchKeys.length + 1; i++) {
String content;
if (i - searchKeys.length == 0) {
// PSEUDOFIELD_TYPE
if (!fieldPattern.matcher("entrytype").matches()) continue;
content = entry.getType().getName();
} else {
String searchKey = searchKeys[i];
if (!fieldPattern.matcher(searchKey).matches()) continue;
content = entry.getField(searchKey);
}
noSuchField = false;
if (content == null) continue; // paranoia
if (matchInField(content)) {
return true;
}
}
return noSuchField && operator == ComparisonOperator.DOES_NOT_CONTAIN;
}
private String decodeEntities(String s) {
StringBuffer buf = new StringBuffer();
Matcher m = P_ENTITY.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.decode(match).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
buf = new StringBuffer();
m = P_ENTITY_UNICODE.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.valueOf(match, 16).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
buf = new StringBuffer();
m = P_ENCODE.matcher(s);
while (m.find()) {
final String match = m.group(1);
final int decimal = Integer.valueOf(match, 16).intValue();
m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
}
m.appendTail(buf);
s = buf.toString();
s = validateEntities(s);
return s;
}
/**
* Converts an identifier to upper-underscore format. The identifier must start with a letter or
* underscore and must only contain letters, digits, and underscores (i.e. it must match the
* regular expression {@code [A-Za-z_][A-Za-z_0-9]*}).
*
* @param ident The identifer to convert.
* @return The identifier in upper-underscore format.
*/
public static String convertToUpperUnderscore(String ident) {
ident = LEADING_OR_TRAILING_UNDERSCORE_PATTERN.matcher(ident).replaceAll("");
ident = WORD_BOUNDARY_IN_IDENT_PATTERN.matcher(ident).replaceAll("_");
ident = CONSECUTIVE_UNDERSCORES_PATTERN.matcher(ident).replaceAll("_");
return ident.toUpperCase();
}
private void checkLoadedModForPermissionClass(File modFile) {
try {
Pattern p = Pattern.compile("permission", Pattern.CASE_INSENSITIVE);
if (modFile.isDirectory()) {
for (File file : modFile.listFiles()) {
checkLoadedModForPermissionClass(file);
}
} else if ((modFile.getName().endsWith(".zip")) || (modFile.getName().endsWith(".jar"))) {
ZipFile zip = new ZipFile(modFile);
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry zipentry = (ZipEntry) entries.nextElement();
if (zipentry != null
&& zipentry.getName().endsWith(".class")
&& p.matcher(zipentry.getName()).find()) {
checkLoadedClass(zip.getInputStream(zipentry));
}
}
zip.close();
} else if (modFile.getName().endsWith(".class") && p.matcher(modFile.getName()).find()) {
checkLoadedClass(new FileInputStream(modFile));
}
} catch (IOException e) {
}
}
@Override
protected String calculateId(String tokenName, int tokenType) {
if (PUNCTUATION.matcher(tokenName).matches()) {
return DefaultHighlightingConfiguration.DEFAULT_ID;
}
if ("'requirements'".equals(tokenName)
|| "'allEnvironments'".equals(tokenName)
|| "'source'".equals(tokenName)
|| "'configurePhase'".equals(tokenName)) {
return TargetPlatformHighlightingConfiguration.OPTION_ID;
}
if ("'version'".equals(tokenName) || "'='".equals(tokenName) || "';'".equals(tokenName)) {
return DefaultHighlightingConfiguration.DEFAULT_ID;
}
if (QUOTED.matcher(tokenName).matches()) {
return DefaultHighlightingConfiguration.KEYWORD_ID;
}
if ("RULE_STRING".equals(tokenName)) {
return DefaultHighlightingConfiguration.STRING_ID;
}
if ("RULE_ML_COMMENT".equals(tokenName) || "RULE_SL_COMMENT".equals(tokenName)) {
return DefaultHighlightingConfiguration.COMMENT_ID;
}
return DefaultHighlightingConfiguration.DEFAULT_ID;
}