/**
* Chooses files that match the specified pattern.
*
* @param file file filter
* @param content content filter
* @param root root directory
* @return sorted file paths
* @throws InterruptedException interruption
*/
String[] filter(final String file, final String content, final IOFile root)
throws InterruptedException {
final long id = ++filterId;
final TreeSet<String> results = new TreeSet<>();
final int[] search = new TokenParser(Token.lc(Token.token(content))).toArray();
// glob pattern
final ProjectCache pc = cache(root);
if (file.contains("*") || file.contains("?")) {
final Pattern pt = Pattern.compile(IOFile.regex(file));
for (final String path : pc) {
final int offset = offset(path, true);
if (pt.matcher(path.substring(offset)).matches() && filterContent(path, search)) {
results.add(path);
if (results.size() >= MAXHITS) break;
}
if (id != filterId) throw new InterruptedException();
}
} else {
// starts-with, contains, camel case
final String pttrn = file.toLowerCase(Locale.ENGLISH).replace('\\', '/');
final HashSet<String> exclude = new HashSet<>();
final boolean pathSearch = pttrn.indexOf('/') != -1;
for (int i = 0; i < (pathSearch ? 2 : 3); i++) {
filter(pttrn, search, i, results, exclude, pathSearch, pc, id);
}
}
return results.toArray(new String[results.size()]);
}
/**
* Chooses tokens from the file cache that match the specified pattern.
*
* @param pattern file pattern
* @param search search string
* @param mode search mode (0-2)
* @param results search result
* @param exclude exclude file from content search
* @param pathSearch path flag
* @param pc file cache
* @param id search id
* @throws InterruptedException interruption
*/
private void filter(
final String pattern,
final int[] search,
final int mode,
final TreeSet<String> results,
final HashSet<String> exclude,
final boolean pathSearch,
final ProjectCache pc,
final long id)
throws InterruptedException {
if (results.size() >= MAXHITS) return;
for (final String path : pc) {
// check if current file matches the pattern
final String lc = path.toLowerCase(Locale.ENGLISH).replace('\\', '/');
final int offset = offset(lc, pathSearch);
if (mode == 0
? lc.startsWith(pattern, offset)
: mode == 1 ? (lc.indexOf(pattern, offset) != -1) : matches(lc, pattern, offset)) {
if (!exclude.contains(path)) {
exclude.add(path);
if (filterContent(path, search)) {
results.add(path);
if (results.size() >= MAXHITS) return;
}
}
}
if (id != filterId) throw new InterruptedException();
}
}
public static void extract_consequent(PptMap ppts) {
// Retrieve Ppt objects in sorted order.
// Use a custom comparator for a specific ordering
Comparator<PptTopLevel> comparator = new Ppt.NameComparator();
TreeSet<PptTopLevel> ppts_sorted = new TreeSet<PptTopLevel>(comparator);
ppts_sorted.addAll(ppts.asCollection());
for (PptTopLevel ppt : ppts_sorted) {
extract_consequent_maybe(ppt, ppts);
}
PrintWriter pw = new PrintWriter(System.out, true);
// All conditions at a program point. A TreeSet to enable
// deterministic output.
TreeSet<String> allConds = new TreeSet<String>();
for (String pptname : pptname_to_conditions.keySet()) {
Map<String, Map<String, HashedConsequent>> cluster_to_conditions =
pptname_to_conditions.get(pptname);
for (Map.Entry</*@KeyFor("cluster_to_conditions")*/ String, Map<String, HashedConsequent>>
entry : cluster_to_conditions.entrySet()) {
String predicate = entry.getKey();
Map<String, HashedConsequent> conditions = entry.getValue();
StringBuffer conjunctionJava = new StringBuffer();
StringBuffer conjunctionDaikon = new StringBuffer();
StringBuffer conjunctionESC = new StringBuffer();
StringBuffer conjunctionSimplify = new StringBuffer("(AND ");
int count = 0;
for (Map.Entry</*@KeyFor("conditions")*/ String, HashedConsequent> entry2 :
conditions.entrySet()) {
count++;
String condIndex = entry2.getKey();
HashedConsequent cond = entry2.getValue();
if (cond.fakeFor != null) {
count--;
continue;
}
String javaStr = cond.inv.format_using(OutputFormat.JAVA);
String daikonStr = cond.inv.format_using(OutputFormat.DAIKON);
String escStr = cond.inv.format_using(OutputFormat.ESCJAVA);
String simplifyStr = cond.inv.format_using(OutputFormat.SIMPLIFY);
allConds.add(combineDummy(condIndex, "<dummy> " + daikonStr, escStr, simplifyStr));
// allConds.add(condIndex);
if (count > 0) {
conjunctionJava.append(" && ");
conjunctionDaikon.append(" and ");
conjunctionESC.append(" && ");
conjunctionSimplify.append(" ");
}
conjunctionJava.append(javaStr);
conjunctionDaikon.append(daikonStr);
conjunctionESC.append(escStr);
conjunctionSimplify.append(simplifyStr);
}
conjunctionSimplify.append(")");
String conj = conjunctionJava.toString();
// Avoid inserting self-contradictory conditions such as "x == 1 &&
// x == 2", or conjunctions of only a single condition.
if (count < 2
|| contradict_inv_pattern.matcher(conj).find()
|| useless_inv_pattern_1.matcher(conj).find()
|| useless_inv_pattern_2.matcher(conj).find()) {
// System.out.println("Suppressing: " + conj);
} else {
allConds.add(
combineDummy(
conjunctionJava.toString(),
conjunctionDaikon.toString(),
conjunctionESC.toString(),
conjunctionSimplify.toString()));
}
}
if (allConds.size() > 0) {
pw.println();
pw.println("PPT_NAME " + pptname);
for (String s : allConds) {
pw.println(s);
}
}
allConds.clear();
}
pw.flush();
}
