/** * 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); }
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)