!7

srecord DollarVarPattern(S pat) {}

srecord Definition(O lhs, O rhs) {}

srecord PatternMatches(O pat, O s) {}

srecord Input(S s) {}

sS defs = [[

A cup of water = A cup with water inside

A cup of Peter = A cup that belongs to Peter

A cup of glass = A cup that consists of glass

A cup of style = A cup that has a lot of style

]];

static new LinkedHashSet objects;

p-exp {

  objects.add(Input("a cup of joe"));

  for (S s : tlft(defs)) {

    L<S> l = splitAtJavaToken(s, "=");

    objects.add(Definition(first(l), second(l)));

  }

  int initialObjects = l(objects);

  long startTime = now();

  int n = -1;

  while (l(objects) > n) {

    n = l(objects);

    L<Definition> defs = instancesOf(Definition, objects);

    for (Definition a : defs)

      for (Definition b : defs)

        if (a.lhs instanceof S && b.lhs instanceof S) {

          S pat = combineToDollarVarPattern((S) a.lhs, (S) b.lhs);

          if (containsDollarVars(pat))

            objects.add(DollarVarPattern(pat));

        }

    for (DollarVarPattern pat : instancesOf(DollarVarPattern, objects)) {

      for (Definition a : defs) if (a.lhs instanceof S) {

        SS match = matchDollarVarsIC(pat.pat, (S) a.lhs);

        if (match != null)

          generalizeDefinition(a, match);

      }

    }

    for (Input i : instancesOf(Input, objects))

      for (Definition a : defs) if (a.lhs instanceof DollarVarPattern) {

        SS match = matchDollarVarsIC(((DollarVarPattern) a.lhs).pat, i.s);

        if (match != null)

          specializeDefinition(a, match);

      }

  }

  long time = now()-startTime;

  pnlStruct(objects);

  print("\n" + n2(l(objects)-initialObjects, "rewrite") + " in " + (now()-startTime) + " ms");

  final Input in = firstInstanceOf(Input, objects);

  if (in != null) {

    L<Definition> definitions = [Definition d : instancesOf(Definition, objects) | eqic_gen(d.lhs, in.s)];

    print("Got " + n2(definitions, "definition") + " for input " + quote(in.s) + (empty(definitions) ? "." : ":"));

    printStructLinesIndent(definitions);

    assertEquals(4, l(definitions));

  }

}

svoid generalizeDefinition(Definition def, SS match) {

  SS rev = reverseCIMap(match);

  S lhs = transformEachTokenUsingMap((S) def.lhs, rev);

  S rhs = transformEachTokenUsingMap((S) def.rhs, rev);

  addIfNotNull(objects, Definition(DollarVarPattern(lhs), DollarVarPattern(rhs)));

}

svoid specializeDefinition(Definition def, SS match) {

  S lhs = transformEachTokenUsingMap(((DollarVarPattern) def.lhs).pat, match);

  S rhs = transformEachTokenUsingMap(((DollarVarPattern) def.rhs).pat, match);

  addIfNotNull(objects, Definition(lhs, rhs));

}