public String mainSyntaxModuleName() { return parsedDefinition.att().<String>getOptional(Att.syntaxModule()).get(); }
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 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; }
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 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); }