private static boolean assignableAndPrimitivableWithVarargs(
ParameterTypes paramTypes, IRubyObject... args) {
// bail out if this is not a varargs method
if (!paramTypes.isVarArgs()) return false;
Class[] types = paramTypes.getParameterTypes();
Class varArgArrayType = types[types.length - 1];
Class varArgType = varArgArrayType.getComponentType();
// if there's no args, we only match when there's just varargs
if (args.length == 0) {
return types.length <= 1;
}
// dig out as many trailing args as will fit, ensuring they match varargs type
int nonVarargs = types.length - 1;
for (int i = args.length - 1; i >= nonVarargs; i--) {
if (!(ASSIGNABLE.match(varArgType, args[i]) || PRIMITIVABLE.match(varArgType, args[i]))) {
return false;
}
}
// check remaining args
for (int i = 0; i < nonVarargs; i++) {
if (!(ASSIGNABLE.match(types[i], args[i]) || PRIMITIVABLE.match(types[i], args[i]))) {
return false;
}
}
return true;
}
private static boolean assignableOrDuckable(ParameterTypes paramTypes, IRubyObject... args) {
Class[] types = paramTypes.getParameterTypes();
if (args.length != types.length) return false;
for (int i = 0; i < types.length; i++) {
if (!(ASSIGNABLE.match(types[i], args[i]) || DUCKABLE.match(types[i], args[i]))) {
return false;
}
}
return true;
}
/**
* Looks for a list item that matches the given value and selects the one that is found.
*
* @param value the value to look for
* @param matcher the object used to match the given value with the list item values
*/
protected void setSelectedValue(String value, Matcher<String> matcher) {
// First, see if the given value is already selected.
if (getSelectedIndex() >= 0 && matcher.match(getValue(getSelectedIndex()), value)) {
return;
}
// Look for a matching value.
for (int i = getItemCount() - 1; i >= 0; i--) {
if (matcher.match(getValue(i), value)) {
setSelectedIndex(i);
return;
}
}
// No matching value found.
setSelectedIndex(-1);
}
private static List<ParameterTypes> findCallable(
ParameterTypes[] callables, IRubyObject... args) {
List<ParameterTypes> retainedCallables = new ArrayList<ParameterTypes>(callables.length);
List<ParameterTypes> incomingCallables =
new ArrayList<ParameterTypes>(Arrays.asList(callables));
for (int currentArg = 0; currentArg < args.length; currentArg++) {
retainedCallables.clear();
for (Matcher matcher : MATCH_SEQUENCE) {
for (Iterator<ParameterTypes> callableIter = incomingCallables.iterator();
callableIter.hasNext(); ) {
ParameterTypes callable = callableIter.next();
Class[] types = callable.getParameterTypes();
if (matcher.match(types[currentArg], args[currentArg])) {
callableIter.remove();
retainedCallables.add(callable);
}
}
}
incomingCallables.clear();
incomingCallables.addAll(retainedCallables);
}
return retainedCallables;
}
public boolean isMatchAt(
Playfield<E> haystack,
Playfield<E> needle,
Matcher<E, E> m,
IntegerElement x,
IntegerElement y) {
IntegerElement width = needle.getMaxX().subtract(needle.getMinX()).succ();
IntegerElement height = needle.getMaxY().subtract(needle.getMinY()).succ();
if (x.pred().add(width).compareTo(haystack.getMaxX()) > 0
|| y.pred().add(height).compareTo(haystack.getMaxY()) > 0) {
// exceeds the right or bottom edge, so, no
return false;
}
IntegerElement cx, cy, dx, dy;
for (cx = x, dx = needle.getMinX();
dx.compareTo(needle.getMaxX()) <= 0;
cx = cx.succ(), dx = dx.succ()) {
for (cy = y, dy = needle.getMinY();
dy.compareTo(needle.getMinY()) <= 0;
cy = cy.succ(), dy = dy.succ()) {
E soughtElem = needle.get(dx, dy);
E foundElem = haystack.get(cx, cy);
// System.out.printf("sought (%s,%s): '%s', found (%s,%s): '%s'\n",
// dx, dy, soughtElem.getName(),
// cx, cy, foundElem.getName());
if (m.match(soughtElem, foundElem)) {
// add something to the result-list
} else {
return false;
}
}
}
return true;
}
public void match(
final String expression, final Handler<Triple> handler, final TweetContext context)
throws MatcherException {
for (Matcher m : componentMatchers) {
m.match(expression, handler, context);
}
}
public void testMatch() {
Matcher matcher = new Matcher();
int[] expected = new int[] {10, 50, 30, 98};
int clipLimit = 100;
int delta = 5;
int[] actual = new int[] {12, 55, 25, 110};
assertTrue(matcher.match(expected, actual, clipLimit, delta));
actual = new int[] {10, 60, 30, 98};
assertTrue(!matcher.match(expected, actual, clipLimit, delta));
actual = new int[] {10, 50, 30};
assertTrue(!matcher.match(expected, actual, clipLimit, delta));
}
public String readLine() throws IOException {
StringBuffer sb = new StringBuffer();
boolean lineIsOnlyWhiteSpace = true;
boolean done = false;
int i = read();
while ((i != -1) && !done) {
switch (i) {
case 13: // '\r'
i = read();
if (i != 10) {
throw new IOException("Bad line terminator");
}
// fall through
case 10: // '\n'
if (lineIsOnlyWhiteSpace) {
sb.setLength(0);
}
mark(1);
i = read();
reset();
switch (i) {
case 9: // '\t'
case 32: // ' '
skip(1L);
break;
default:
if (!lineIsOnlyWhiteSpace) {
done = true;
continue;
}
skip(1L);
}
break;
case 9: // '\t'
case 32: // ' '
sb.append((char) i);
i = read();
break;
default:
sb.append((char) i);
if (matcher.match(sb)) {
return sb.toString().trim();
}
i = read();
lineIsOnlyWhiteSpace = false;
}
if (lineIsOnlyWhiteSpace) {
return null;
}
}
return sb.toString().trim();
}
@Override
public StorageResults fetch(Expression userQuery) {
Expression expression = userQuery.normalize();
Matcher matcher = expression.accept(new MatcherCreator());
List<DataRecord> matchRecords = new LinkedList<DataRecord>();
for (DataRecord dataRecord : storage) {
if (matcher.match(dataRecord)) {
matchRecords.add(dataRecord);
}
}
List<DataRecord> filteredRecords = expression.accept(new Filter(matchRecords));
return new InMemoryStorageResults(filteredRecords);
}
@Test
public void basicTest() throws GrammarException, IOException {
String[] rules = {
//
"<ROOT> = <a> <s> <b>", //
"<a> = 'a'", //
"<b> = 'b'", //
"<s> = /\\s++/", //
};
Grammar g = new Grammar(rules);
String s = "a\nb";
Matcher m = g.find(s);
assertNotNull("found joe", m.match());
}
public static void main(String[] args) {
String newSnapFile, oldSnapFile, targetClass;
boolean use_statics = false;
if (args.length < 5) {
System.out.println(
"Usage: main old_snapshot_dir1 old_snapshot_dir2 new_snapshot_dir classname fieldname");
System.exit(-1);
}
File old_dir1 = new File(args[0]);
File old_dir2 = new File(args[1]);
File new_dir = new File(args[2]);
FieldPath synthField = new FieldPath(args[4]);
if (args.length == 6)
if (args[5].equals("-static")) {
use_statics = true;
System.out.println("Using static fields.");
}
System.out.println("synthField = " + synthField);
targetClass = args[3];
File[] old_snapshots1 = old_dir1.listFiles();
File[] old_snapshots2 = old_dir2.listFiles();
File[] new_snapshots = new_dir.listFiles();
if (old_snapshots1.length != old_snapshots2.length
|| old_snapshots1.length != new_snapshots.length) {
System.out.println("Directories contain unequal numbers of snapshot files.");
System.exit(-1);
}
int num_snapshots = old_snapshots1.length;
assert (num_snapshots == new_snapshots.length);
System.out.println("Loading heap snapshots...");
LinkedList<HeapSnapshot> oldSnaps1 = new LinkedList<HeapSnapshot>();
LinkedList<HeapSnapshot> oldSnaps2 = new LinkedList<HeapSnapshot>();
LinkedList<HeapSnapshot> newSnaps = new LinkedList<HeapSnapshot>();
for (int i = 0; i < num_snapshots; i++) {
System.out.println("Loading old snapshot 1...");
HeapSnapshot snap = new HeapSnapshot(old_snapshots1[i]);
oldSnaps1.add(snap);
System.out.println("Loading old snapshot 2...");
snap = new HeapSnapshot(old_snapshots2[i]);
oldSnaps2.add(snap);
System.out.println("Loading new snapshot...");
snap = new HeapSnapshot(new_snapshots[i]);
newSnaps.add(snap);
}
Stats stats = new Stats(oldSnaps1, oldSnaps2, newSnaps, targetClass);
stats.printStats();
/* TODO: resurrect this code at some point
if(newSets.getFirst().getFields().contains(new FieldPath(synthField))) {
System.out.println("Field is present in examples.");
}
else {
System.out.println("Field is not present in examples.");
System.out.println("Field list:");
System.out.println(newSets.getFirst().getFields().toString());
System.exit(-1);
}
*/
long start = System.currentTimeMillis();
Matcher matcher = new Matcher(oldSnaps1, oldSnaps2, newSnaps, use_statics);
List<Example> exList = matcher.match(targetClass, true, synthField);
long match_time = System.currentTimeMillis() - start;
System.out.println("Synthesizing update for field: " + synthField);
SynthSwitch part = null;
System.out.println("Number of example pairs: " + exList.size());
Example.examplesToHTML(exList, "examples.html");
// Remove example pairs not containing the field.
System.out.println("Removing examples not containing field " + synthField);
Iterator<Example> iter = exList.iterator();
while (iter.hasNext()) {
Example ex = iter.next();
if (ex.getOld() == null
|| ex.getNew() == null
||
/* !ex.getOld().containsField(synthField) ||*/
!ex.getNew().containsField(synthField)) iter.remove();
}
System.out.println("Number of example pairs: " + exList.size());
start = System.currentTimeMillis();
int exNum = 0;
for (Example ex : exList) {
System.out.println("Example " + exNum++ + "\n");
if (part == null) part = SynthSwitch.getSynthFun(targetClass, synthField, ex);
else part.expand(ex);
}
System.out.print("Number of partitions: ");
if (part != null) {
System.out.println(part.numPartitions());
System.out.println("Synthesized function:");
System.out.println("type = " + part.getClass());
System.out.println(part);
} else System.out.println("Synthesis failed.");
long synth_time = System.currentTimeMillis() - start;
System.out.println("Match time: " + ((double) match_time) / 1000);
System.out.println("Synth time: " + ((double) synth_time) / 1000);
}
