/** * A module containing the compiled definition */ public Module executionModule() { return kompiledDefinition.mainModule(); }
protected String getKompiledString(CompiledDefinition def) { return getKompiledString(def.kompiledDefinition.mainModule(), def.topCellInitializer, files, heatCoolEquations); }
private Sentence concretizeSentence(Sentence s, Definition input) { ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(input.mainModule()); LabelInfo labelInfo = new LabelInfoFromModule(input.mainModule()); SortInfo sortInfo = SortInfo.fromModule(input.mainModule()); return new ConcretizeCells(configInfo, labelInfo, sortInfo, input.mainModule()).concretize(s); } }
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); }
public Definition resolve(Definition d) { klabels = new HashSet<>(); Module transformedMainModule = resolve(d.mainModule()); return Definition.apply(transformedMainModule, add(transformedMainModule, minus(d.mainModule(), d.entryModules())), d.att()); }
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); }
private Rule getExitCodeRule(Definition parsedDefinition) { Module mainMod = parsedDefinition.mainModule(); Set<Production> exitProds = stream(mainMod.productions()).filter(p -> p.att().contains("exit")).collect(Collectors.toSet()); if (exitProds.size() == 0) { return null; } else if (exitProds.size() > 1) { throw KEMException.compilerError("Found more than one or zero productions with 'exit' attribute. Exactly one production, a cell, must have this attribute, designating the exit code of krun. Found:\n" + exitProds); } Production exitProd = exitProds.iterator().next(); return Rule(IncompleteCellUtils.make(exitProd.klabel().get(), false, KApply(KLabel("#SemanticCastToInt"), KVariable("_")), false), BooleanUtils.TRUE, BooleanUtils.TRUE); }
public static Function1<Definition, Definition> excludeModulesByTag(Set<String> excludedModuleTags) { DefinitionTransformer dt = DefinitionTransformer.from(mod -> excludeModulesByTag(excludedModuleTags, mod), "remove modules based on attributes"); return dt.andThen(d -> Definition(d.mainModule(), immutable(stream(d.entryModules()).filter(mod -> excludedModuleTags.stream().noneMatch(tag -> mod.att().contains(tag))).collect(Collectors.toSet())), d.att())); }
public Definition parseDefinitionAndResolveBubbles(File definitionFile, String mainModuleName, String mainProgramsModule, java.util.Set<String> excludedModuleTags) { Definition parsedDefinition = parseDefinition(definitionFile, mainModuleName, mainProgramsModule); Stream<Module> modules = Stream.of(parsedDefinition.mainModule()); modules = Stream.concat(modules, stream(parsedDefinition.mainModule().importedModules())); Option<Module> syntaxModule = parsedDefinition.getModule(mainProgramsModule); if (syntaxModule.isDefined()) { modules = Stream.concat(modules, Stream.of(syntaxModule.get())); modules = Stream.concat(modules, stream(syntaxModule.get().importedModules())); } modules = Stream.concat(modules, Stream.of(parsedDefinition.getModule("K-REFLECTION").get())); modules = Stream.concat(modules, Stream.of(parsedDefinition.getModule("STDIN-STREAM").get())); modules = Stream.concat(modules, Stream.of(parsedDefinition.getModule("STDOUT-STREAM").get())); modules = Stream.concat(modules, stream(parsedDefinition.entryModules()).filter(m -> !stream(m.sentences()).anyMatch(s -> s instanceof Bubble))); Definition trimmed = Definition(parsedDefinition.mainModule(), modules.collect(Collections.toSet()), parsedDefinition.att()); trimmed = Kompile.excludeModulesByTag(excludedModuleTags).apply(trimmed); Definition afterResolvingConfigBubbles = resolveConfigBubbles(trimmed, parsedDefinition.getModule("DEFAULT-CONFIGURATION").get()); RuleGrammarGenerator gen = new RuleGrammarGenerator(afterResolvingConfigBubbles); Definition afterResolvingAllOtherBubbles = resolveNonConfigBubbles(afterResolvingConfigBubbles, gen); saveCachesAndReportParsingErrors(); return afterResolvingAllOtherBubbles; }
public int run( CompiledDefinition commonDef, CompiledDefinition def1, CompiledDefinition def2, KEqOptions keqOptions, Backend backend, Function<Module, Rewriter> commonGen, Function<Module, Rewriter> gen1, Function<Module, Rewriter> gen2) { Rewriter commonRewriter = commonGen.apply(commonDef.executionModule()); Tuple2<Definition, Module> compiled1 = KProve.getProofDefinition(files.resolveWorkingDirectory(keqOptions.spec1), keqOptions.defModule1, keqOptions.specModule1, def1, backend, files, kem, sw); Rewriter rewriter1 = gen1.apply(compiled1._1().mainModule()); Module spec1 = compiled1._2(); Tuple2<Definition, Module> compiled2 = KProve.getProofDefinition(files.resolveWorkingDirectory(keqOptions.spec2), keqOptions.defModule2, keqOptions.specModule2, def2, backend, files, kem, sw); Rewriter rewriter2 = gen2.apply(compiled2._1().mainModule()); Module spec2 = compiled2._2(); boolean isEquivalent = commonRewriter.equivalence(rewriter1, rewriter2, spec1, spec2); System.out.println(isEquivalent ? "#True" : "#False"); return isEquivalent ? 0 : 1; } }
private void checkConfigVars(Set<KToken> inputConfigVars, CompiledDefinition compiledDef) { Set<KToken> defConfigVars = mutable(new ConfigurationInfoFromModule(compiledDef.kompiledDefinition.mainModule()).configVars()); for (KToken defConfigVar : defConfigVars) { if (!inputConfigVars.contains(defConfigVar)) { throw KEMException.compilerError("Configuration variable missing: " + defConfigVar.s()); } } for (KToken inputConfigVar : inputConfigVars) { if (!defConfigVars.contains(inputConfigVar)) { if (!inputConfigVar.s().equals("$STDIN") && !inputConfigVar.s().equals("$IO")) { kem.registerCompilerWarning("User specified configuration variable " + inputConfigVar.s() + " which does not exist."); } } } }
private static Module markRegularRules(Definition d, Module mod) { ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(d.mainModule()); return ModuleTransformer.fromSentenceTransformer(s -> markRegularRules(d, configInfo, s, "specification"), "mark regular rules").apply(mod); }
public static Definition addSemanticsModule(Definition d) { java.util.Set<Module> allModules = mutable(d.modules()); Module languageParsingModule = Constructors.Module("LANGUAGE-PARSING", Set(d.mainModule(), d.getModule(d.att().get(Att.syntaxModule())).get(), d.getModule("K-TERM").get(), d.getModule(RuleGrammarGenerator.ID_PROGRAM_PARSING).get()), Set(), Att()); allModules.add(languageParsingModule); return Constructors.Definition(d.mainModule(), immutable(allModules), d.att()); }
/** * 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); }
/** * Executes the Kompile tool. This tool accesses a * * @param definitionFile * @param mainModuleName * @param mainProgramsModuleName * @param programStartSymbol * @return */ public CompiledDefinition run(File definitionFile, String mainModuleName, String mainProgramsModuleName, Function<Definition, Definition> pipeline, Set<String> excludedModuleTags) { Definition parsedDef = parseDefinition(definitionFile, mainModuleName, mainProgramsModuleName, excludedModuleTags); sw.printIntermediate("Parse definition [" + definitionParsing.parsedBubbles.get() + "/" + (definitionParsing.parsedBubbles.get() + definitionParsing.cachedBubbles.get()) + " rules]"); checkDefinition(parsedDef); Definition kompiledDefinition = pipeline.apply(parsedDef); files.saveToKompiled("compiled.txt", kompiledDefinition.toString()); sw.printIntermediate("Apply compile pipeline"); ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(kompiledDefinition.mainModule()); return new CompiledDefinition(kompileOptions, parsedDef, kompiledDefinition, files, kem, configInfo.getDefaultCell(configInfo.topCell()).klabel()); }
public static Tuple2<Definition, Module> getProofDefinition(File proofFile, String defModuleName, String specModuleName, CompiledDefinition compiledDefinition, Backend backend, FileUtil files, KExceptionManager kem, Stopwatch sw) { Kompile kompile = new Kompile(compiledDefinition.kompileOptions, files, kem, sw, true); if (defModuleName == null) { defModuleName = compiledDefinition.kompiledDefinition.mainModule().name(); } if (specModuleName == null) { specModuleName = FilenameUtils.getBaseName(proofFile.getName()).toUpperCase(); } java.util.Set<Module> modules = kompile.parseModules(compiledDefinition, defModuleName, files.resolveWorkingDirectory(proofFile).getAbsoluteFile()); Map<String, Module> modulesMap = new HashMap<>(); modules.forEach(m -> modulesMap.put(m.name(), m)); Module defModule = getModule(defModuleName, modulesMap, compiledDefinition.getParsedDefinition()); Module specModule = getModule(specModuleName, modulesMap, compiledDefinition.getParsedDefinition()); specModule = backend.specificationSteps(compiledDefinition.kompiledDefinition).apply(specModule); specModule = spliceModule(specModule, compiledDefinition.kompiledDefinition); Definition combinedDef = Definition.apply(defModule, compiledDefinition.getParsedDefinition().entryModules(), compiledDefinition.getParsedDefinition().att()); Definition compiled = compileDefinition(backend, combinedDef); return Tuple2.apply(compiled, specModule); }
public int run(KProveOptions options, CompiledDefinition compiledDefinition, Backend backend, Function<Module, Rewriter> rewriterGenerator) { Tuple2<Definition, Module> compiled = getProofDefinition(options.specFile(files), options.defModule, options.specModule, compiledDefinition, backend, files, kem, sw); Rewriter rewriter = rewriterGenerator.apply(compiled._1().mainModule()); Module specModule = compiled._2(); K results = rewriter.prove(specModule); int exit; if (results instanceof KApply) { KApply kapp = (KApply) results; exit = kapp.klabel().name().equals("#True") ? 0 : 1; } else { exit = 1; } kprint.prettyPrint(compiled._1(), compiled._1().getModule("LANGUAGE-PARSING").get(), s -> kprint.outputFile(s), results); return exit; }
private static Sentence markRegularRules(Definition d, ConfigurationInfoFromModule configInfo, Sentence s, String att) { if (s instanceof org.kframework.definition.Rule) { org.kframework.definition.Rule r = (org.kframework.definition.Rule) s; if (r.body() instanceof KApply) { KLabel klabel = ((KApply) r.body()).klabel(); if (d.mainModule().sortFor().contains(klabel) //is false for rules in specification modules not part of semantics && d.mainModule().sortFor().apply(klabel).equals(configInfo.topCell())) { return Rule.apply(r.body(), r.requires(), r.ensures(), r.att().add(att)); } } } return s; }
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); } }
@Override public Function<Module, Module> specificationSteps(Definition def) { Module mod = def.mainModule(); ConfigurationInfoFromModule configInfo = new ConfigurationInfoFromModule(mod); LabelInfo labelInfo = new LabelInfoFromModule(mod); SortInfo sortInfo = SortInfo.fromModule(mod); ModuleTransformer resolveAnonVars = ModuleTransformer.fromSentenceTransformer( new ResolveAnonVar()::resolve, "resolving \"_\" vars"); ModuleTransformer resolveSemanticCasts = ModuleTransformer.fromSentenceTransformer( new ResolveSemanticCasts(true)::resolve, "resolving semantic casts"); ModuleTransformer subsortKItem = ModuleTransformer.from(Kompile::subsortKItem, "subsort all sorts to KItem"); ModuleTransformer addImplicitComputationCell = ModuleTransformer.fromSentenceTransformer( new AddImplicitComputationCell(configInfo, labelInfo), "concretizing configuration"); Function1<Module, Module> resolveFreshConstants = d -> ModuleTransformer.from(new ResolveFreshConstants(def, true)::resolve, "resolving !Var variables").apply(d); ModuleTransformer concretizeCells = ModuleTransformer.fromSentenceTransformer( new ConcretizeCells(configInfo, labelInfo, sortInfo, mod)::concretize, "concretizing configuration"); return m -> resolveAnonVars .andThen(resolveSemanticCasts) .andThen(addImplicitComputationCell) .andThen(resolveFreshConstants) .andThen(concretizeCells) .andThen(subsortKItem) .apply(m); }