public Rule compileRule(Definition compiledDef, Rule parsedRule) { return (Rule) UnaryOperator.<Sentence>identity() .andThen(new ResolveAnonVar()::resolve) .andThen(new ResolveSemanticCasts(kompileOptions.backend.equals(Backends.JAVA))::resolve) .andThen(s -> concretizeSentence(s, compiledDef)) .apply(parsedRule); }
private Context resolve(Context context) { resetCasts(); gatherCasts(context.body()); gatherCasts(context.requires()); return new Context( transform(context.body()), addSideCondition(transform(context.requires()), false), context.att()); }
public K resolve(K k) { resetCasts(); gatherCasts(k); return transform(k); }
@Override public K search(K initialConfiguration, Optional<Integer> depth, Optional<Integer> bound, Rule pattern, SearchType searchType) { rewritingContext.stateLog.open("search-" + Integer.toString(Math.abs(initialConfiguration.hashCode()))); TermContext termContext = TermContext.builder(rewritingContext).freshCounter(initCounterValue).build(); KOREtoBackendKIL converter = new KOREtoBackendKIL(module, definition, termContext.global(), false); ResolveSemanticCasts resolveCasts = new ResolveSemanticCasts(true); ExpandMacros macroExpander = new ExpandMacros(module, files, kompileOptions, false); termContext.setKOREtoBackendKILConverter(converter); Term javaTerm = converter.convert(macroExpander.expand(resolveCasts.resolve(initialConfiguration))).evaluate(termContext); org.kframework.backend.java.kil.Rule javaPattern = converter.convert(Optional.empty(), transformFunction(JavaBackend::convertKSeqToKApply, pattern)); SymbolicRewriter rewriter = new SymbolicRewriter(rewritingContext, transitions, converter); K result = rewriter.search(javaTerm, javaPattern, bound.orElse(NEGATIVE_VALUE), depth.orElse(NEGATIVE_VALUE), searchType, termContext); rewritingContext.stateLog.close(); return result; }
K addSideCondition(K requires, boolean macro) { if (skipSortPredicates || macro) return requires; else { Optional<KApply> sideCondition = casts.stream().map(k -> { return new TransformK() { @Override public K apply(KVariable k) { if (varToTypedVar.containsKey(k)) { return varToTypedVar.get(k); } return k; } }.apply(k); }).map(k -> KApply(KLabel("is" + getSortNameOfCast((KApply) k)), transform(k))).reduce(BooleanUtils::and); if (!sideCondition.isPresent()) { return requires; } else if (requires.equals(BooleanUtils.TRUE) && sideCondition.isPresent()) { return sideCondition.get(); } else { return BooleanUtils.and(sideCondition.get(), requires); } } }
private String wellformedAndGetSortNameOfCast(KList klist) { try { if (klist.size() == 3) { KApply k1 = (KApply) klist.items().get(0); KApply k3 = (KApply) klist.items().get(2); if (KLabels.NO_DOTS.equals(k1.klabel()) && k1.klist().size() == 0 && KLabels.DOTS.equals(k3.klabel()) && k3.klist().size() == 0) { KRewrite k2 = (KRewrite) klist.items().get(1); KApply k2l = (KApply) k2.left(); KApply k2r = (KApply) k2.right(); if (k2l.klabel().name().equals("ListItem") && k2l.klist().size() == 1 && k2r.klabel().name().equals(".List") && k2r.klist().size() == 0) { KApply k2li = (KApply) k2l.klist().items().get(0); if (k2li.klabel().name().startsWith("#SemanticCastTo") && k2li.klist().size() == 1 && k2li.klist().items().get(0) instanceof KVariable) { return ResolveSemanticCasts.getSortNameOfCast(k2li); // k2li.klabel().name().substring("#SemanticCastTo".length()); } } } } } catch (ClassCastException ignored) { } return ""; } }.apply(rule.body());
@Override public RewriterResult execute(K k, Optional<Integer> depth) { rewritingContext.stateLog.open("execute-" + Integer.toString(Math.abs(k.hashCode()))); TermContext termContext = TermContext.builder(rewritingContext).freshCounter(initCounterValue).build(); KOREtoBackendKIL converter = new KOREtoBackendKIL(module, definition, termContext.global(), false); ResolveSemanticCasts resolveCasts = new ResolveSemanticCasts(true); ExpandMacros macroExpander = new ExpandMacros(module, files, kompileOptions, false); termContext.setKOREtoBackendKILConverter(converter); Term backendKil = converter.convert(macroExpander.expand(resolveCasts.resolve(k))).evaluate(termContext); SymbolicRewriter rewriter = new SymbolicRewriter(rewritingContext, transitions, converter); RewriterResult result = rewriter.rewrite(new ConstrainedTerm(backendKil, termContext), depth.orElse(-1)); rewritingContext.stateLog.close(); return result; }
@Override public Function<Module, Module> specificationSteps(Definition def) { BiFunction<Module, K, K> convertCellCollections = (Module m, K k) -> new ConvertDataStructureToLookup(m, false).convert(k); return m -> ModuleTransformer.fromSentenceTransformer(new ResolveAnonVar()::resolve, "resolve anonymous varaibles") .andThen(ModuleTransformer.fromSentenceTransformer(s -> new ResolveSemanticCasts(kompileOptions.backend.equals(Backends.JAVA)).resolve(s), "resolve semantic casts")) .andThen(AddImplicitComputationCell::transformModule) .andThen(ConcretizeCells::transformModule) .andThen(ModuleTransformer.fromRuleBodyTransformer(RewriteToTop::bubbleRewriteToTopInsideCells, "bubble out rewrites below cells")) .andThen(AddBottomSortForListsWithIdenticalLabels.singleton()) .andThen(ModuleTransformer.fromSentenceTransformer((mod, s) -> new ExpandMacros(mod, files, kompileOptions, false).expand(s), "expand macros")) .andThen(ModuleTransformer.fromKTransformerWithModuleInfo(convertCellCollections::apply, "convert cell to the underlying collections")) .andThen(ModuleTransformer.fromRuleBodyTransformer(JavaBackend::ADTKVariableToSortedVariable, "ADT.KVariable to SortedVariable")) .andThen(ModuleTransformer.fromRuleBodyTransformer(JavaBackend::convertKSeqToKApply, "kseq to kapply")) .andThen(ModuleTransformer.fromRuleBodyTransformer(NormalizeKSeq.self(), "normalize kseq")) .andThen(mod -> JavaBackend.markRegularRules(def, mod)) .andThen(ModuleTransformer.fromSentenceTransformer(new AddConfigurationRecoveryFlags()::apply, "add refers_THIS_CONFIGURATION_marker")) .apply(m); }
private Rule resolve(Rule rule) { resetCasts(); gatherCasts(rule.body()); gatherCasts(rule.requires()); gatherCasts(rule.ensures()); return new Rule( transform(rule.body()), addSideCondition(transform(rule.requires()), rule.att().contains("macro") || rule.att().contains("alias")), transform(rule.ensures()), rule.att()); }
DefinitionTransformer resolveAnonVars = DefinitionTransformer.fromSentenceTransformer(new ResolveAnonVar()::resolve, "resolving \"_\" vars"); DefinitionTransformer resolveSemanticCasts = DefinitionTransformer.fromSentenceTransformer(new ResolveSemanticCasts(kompileOptions.backend.equals(Backends.JAVA))::resolve, "resolving semantic casts"); DefinitionTransformer resolveFun = DefinitionTransformer.from(new ResolveFun()::resolve, "resolving #fun"); DefinitionTransformer generateSortPredicateSyntax = DefinitionTransformer.from(new GenerateSortPredicateSyntax()::gen, "adding sort predicate productions");
@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); }
DefinitionTransformer resolveAnonVars = DefinitionTransformer.fromSentenceTransformer(new ResolveAnonVar()::resolve, "resolving \"_\" vars"); DefinitionTransformer resolveSemanticCasts = DefinitionTransformer.fromSentenceTransformer(new ResolveSemanticCasts(true)::resolve, "resolving semantic casts"); DefinitionTransformer resolveFun = DefinitionTransformer.from(new ResolveFun()::resolve, "resolving #fun"); DefinitionTransformer generateSortPredicateSyntax = DefinitionTransformer.from(new GenerateSortPredicateSyntax()::gen, "adding sort predicate productions");