How to use

apply

method

in

org.kframework.definition.DefinitionTransformer

/**
 * Generates the definition containing the modules appropriate for generating rule parsers.
 */
public static Definition toRuleParser(Definition d) {
  RuleGrammarGenerator rgg = new RuleGrammarGenerator(d);
  return DefinitionTransformer.from(rgg::getRuleGrammar, "toRuleParser").apply(d);
}

/**
 * Generates the module appropriate for generating the parser of a partial configuration,
 * with the exact cell labels not known apriori.
 */
public static Definition toGenericAbstractConfigurationParser(Definition d) {
  RuleGrammarGenerator rgg = new RuleGrammarGenerator(d);
  return DefinitionTransformer.from(rgg::getConfigGrammar, "toGenericAbstractConfigurationParser").apply(d);
}

public static Definition resolveFreshConstants(Definition input) {
  return DefinitionTransformer.from(new ResolveFreshConstants(input, false)::resolve, "resolving !Var variables")
      .apply(input);
}

  /**
   * Put a marker on the "regular" (i.e. non function/macro/etc.) rules that we can use later.
   */
private static Definition markRegularRules(Definition d) {
  ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(d.mainModule());
  return DefinitionTransformer.fromSentenceTransformer((mod, s) -> markRegularRules(d, configInfo, s, Att.topRule()), "mark regular rules").apply(d);
}

  }, "adding default configuration").apply(definition);
} else {
  definitionWithConfigBubble = definition;
  Definition defWithConfig = DefinitionTransformer.from(resolveConfig::apply, "parsing configurations").apply(definitionWithConfigBubble);
  return defWithConfig;
} catch (KEMException e) {

public static Definition transformDefinition(Definition input) {
  ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(input.mainModule());
  LabelInfo labelInfo = new LabelInfoFromModule(input.mainModule());
  return DefinitionTransformer.fromSentenceTransformer(
      new AddImplicitComputationCell(configInfo, labelInfo),
      "concretizing configuration").apply(input);
}

  def = DefinitionTransformer.from(resolveConfig::apply, "parse config bubbles").apply(def);
} catch (KEMException e) {
  errors.add(e);

public Definition resolveNonConfigBubbles(Definition defWithConfig, RuleGrammarGenerator gen) {
  Module ruleParserModule = gen.getRuleGrammar(defWithConfig.mainModule());
  ParseCache cache = loadCache(ruleParserModule);
  ParseInModule parser = RuleGrammarGenerator.getCombinedGrammar(cache.getModule(), isStrict);
  try (Scanner scanner = parser.getScanner()) {
    return DefinitionTransformer.from(m -> this.resolveNonConfigBubbles(m, scanner, gen), "parsing rules").apply(defWithConfig);
  }
}

public static Definition transformDefinition(Definition input) {
  ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(input.mainModule());
  LabelInfo labelInfo = new LabelInfoFromModule(input.mainModule());
  SortInfo sortInfo = SortInfo.fromModule(input.mainModule());
  return DefinitionTransformer.fromSentenceTransformer(
      new ConcretizeCells(configInfo, labelInfo, sortInfo, input.mainModule())::concretize,
      "concretizing configuration"
  ).apply(input);
}

DefinitionTransformer subsortKItem = DefinitionTransformer.from(Kompile::subsortKItem, "subsort all sorts to KItem");
DefinitionTransformer expandMacros = DefinitionTransformer.fromSentenceTransformer((m, s) -> new ExpandMacros(m, files, kompileOptions, false).expand(s), "expand macros");
Function1<Definition, Definition> resolveFreshConstants = d -> DefinitionTransformer.from(new ResolveFreshConstants(d, true)::resolve, "resolving !Var variables").apply(d);
DefinitionTransformer generatedTopFormat = DefinitionTransformer.from(GeneratedTopFormat::resolve, "setting generatedTop format attribute");
Function1<Definition, Definition> resolveIO = (d -> Kompile.resolveIOStreams(kem, d));
    .andThen(generatedTopFormat)
    .andThen(new Strategy(kompileOptions.experimental.heatCoolStrategies).addStrategyCellToRulesTransformer())
    .andThen(d -> Strategy.addStrategyRuleToMainModule(def.mainModule().name()).apply(d))
    .andThen(ConcretizeCells::transformDefinition)
    .andThen(subsortKItem)