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 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()); }
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; }
/** * A module containing the compiled definition */ public Module executionModule() { return kompiledDefinition.mainModule(); }
private static Module getModule(String defModule, Map<String, Module> modules, Definition oldDef) { if (modules.containsKey(defModule)) return modules.get(defModule); Option<Module> mod = oldDef.getModule(defModule); if (mod.isDefined()) { return mod.get(); } throw KEMException.criticalError("Module " + defModule + " does not exist."); }
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; }
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())); }
private void checkDefinition(Definition parsedDef) { CheckRHSVariables checkRHSVariables = new CheckRHSVariables(errors); stream(parsedDef.modules()).forEach(m -> stream(m.localSentences()).forEach(checkRHSVariables::check)); stream(parsedDef.modules()).forEach(m -> stream(m.localSentences()).forEach(new CheckConfigurationCells(errors, m)::check)); stream(parsedDef.modules()).forEach(m -> stream(m.localSentences()).forEach(new CheckSortTopUniqueness(errors, m)::check)); stream(parsedDef.modules()).forEach(m -> stream(m.localSentences()).forEach(new CheckStreams(errors, m)::check)); stream(parsedDef.modules()).forEach(m -> stream(m.localSentences()).forEach(new CheckRewrite(errors, m)::check)); stream(parsedDef.modules()).forEach(new CheckImports(parsedDef.mainModule(), kem)::check); Set<String> moduleNames = new HashSet<>(); stream(parsedDef.modules()).forEach(m -> { if (moduleNames.contains(m.name())) { errors.add(KEMException.compilerError("Found multiple modules with name: " + m.name())); } moduleNames.add(m.name()); }); CheckKLabels checkKLabels = new CheckKLabels(errors); // only check imported modules because otherwise we might have false positives Consumer<Module> checkModuleKLabels = m -> stream(m.localSentences()).forEach(s -> checkKLabels.check(s, m)); stream(parsedDef.mainModule().importedModules()).forEach(checkModuleKLabels); checkModuleKLabels.accept(parsedDef.mainModule()); if (!errors.isEmpty()) { kem.addAllKException(errors.stream().map(e -> e.exception).collect(Collectors.toList())); throw KEMException.compilerError("Had " + errors.size() + " structural errors."); } }
/** * 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 org.kframework.definition.Definition loadDefinition( String mainModuleName, String syntaxModuleName, String definitionText, File source, File currentDirectory, List<File> lookupDirectories, boolean autoImportDomains, boolean kore) { return loadDefinition(mainModuleName, syntaxModuleName, definitionText, Source.apply(source.getAbsolutePath()), currentDirectory, lookupDirectories, autoImportDomains, kore); }
public java.util.Set<Module> parseModules(CompiledDefinition definition, String mainModule, File definitionFile) { Definition def = parser.loadDefinition( mainModule, mutable(definition.getParsedDefinition().modules()), "require " + StringUtil.enquoteCString(definitionFile.getPath()), Source.apply(definitionFile.getAbsolutePath()), return mutable(def.entryModules());
public String mainSyntaxModuleName() { return parsedDefinition.att().<String>getOptional(Att.syntaxModule()).get(); }
protected String getKompiledString(CompiledDefinition def) { return getKompiledString(def.kompiledDefinition.mainModule(), def.topCellInitializer, files, heatCoolEquations); }
private Module getStreamModule(String streamName) { // TODO(Daejun): fix hard-coded stream module naming convention String moduleName = streamName.toUpperCase() + "-STREAM"; Option<Module> module = definition.getModule(moduleName); if (module.isDefined()) { return module.get(); } else { throw KEMException.compilerError("no such module: " + moduleName); } }
KToken counterCellLabel = KToken("generatedCounter", Sort("#CellName")); KApply freshCell = KApply(KLabel("#configCell"), counterCellLabel, KApply(KLabel("#cellPropertyListTerminator")), KToken("0", Sorts.Int()), counterCellLabel); if (m.equals(def.mainModule()) && kore) { if (!m.definedKLabels().contains(KLabels.GENERATED_TOP_CELL)) { RuleGrammarGenerator gen = new RuleGrammarGenerator(def); return m; return new GenerateSortPredicateSyntax().gen(Module(m.name(), kore ? m.imports() : add(def.getModule("K-REFLECTION").get(), m.imports()), sentences, m.att()));
public org.kframework.definition.Definition loadDefinition( String mainModuleName, String syntaxModuleName, String definitionText, Source source, File currentDirectory, List<File> lookupDirectories, boolean autoImportDomains, boolean kore) { Set<Module> previousModules = new HashSet<>(); Set<File> requiredFiles = new HashSet<>(); if (autoImportDomains) previousModules.addAll(loadModules(new HashSet<>(), Kompile.REQUIRE_PRELUDE_K, source, currentDirectory, lookupDirectories, requiredFiles, kore)); Set<Module> modules = loadModules(previousModules, definitionText, source, currentDirectory, lookupDirectories, requiredFiles, kore); modules.addAll(previousModules); // add the previous modules, since load modules is not additive Module mainModule = getMainModule(mainModuleName, modules); Optional<Module> opt; opt = modules.stream().filter(m -> m.name().equals(syntaxModuleName)).findFirst(); Module syntaxModule; if (!opt.isPresent()) { kem.registerCompilerWarning("Could not find main syntax module with name " + syntaxModuleName + " in definition. Use --syntax-module to specify one. Using " + mainModuleName + " as default."); syntaxModule = mainModule; } else { syntaxModule = opt.get(); } return org.kframework.definition.Definition.apply(mainModule, immutable(modules), Att().add(Att.syntaxModule(), syntaxModule.name())); }
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); }
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); } }
private Module getStreamSyntaxModule(String streamName) { // TODO(Daejun): fix hard-coded stream module naming convention String moduleName = streamName.toUpperCase() + "-STREAM$SYNTAX"; Option<Module> module = definition.getModule(moduleName); if (module.isDefined()) { return module.get(); } else { throw KEMException.compilerError("no such module: " + moduleName); } }
@Test public void testFrom() throws Exception { org.kframework.definition.Definition actual = Definition.from("module X endmodule"); Module modSyntax = Module.apply("X$SYNTAX", Set()); Module mod = new Module("X", Set(modSyntax), Set(), Att()); assertEquals(org.kframework.definition.Definition.apply(mod, Set(mod, modSyntax), Att()), actual); } }