public ExpandMacros(Module mod, FileUtil files, KompileOptions kompileOptions, boolean reverse) { this.mod = mod; this.reverse = reverse; this.cover = kompileOptions.coverage; files.resolveKompiled(".").mkdirs(); macros = stream(mod.rules()).filter(r -> isMacro(r.att(), reverse)).sorted(Comparator.comparing(r -> r.att().contains("owise"))).collect(Collectors.groupingBy(r -> ((KApply)getLeft(r, reverse)).klabel())); if (cover) { try { FileOutputStream os = new FileOutputStream(files.resolveKompiled("coverage.txt"), true); channel = os.getChannel(); coverage = new PrintWriter(new BufferedWriter(new OutputStreamWriter(os))); } catch (IOException e) { throw KEMException.internalError("Could not write list of rules to coverage document.", e); } } else { channel = null; coverage = null; } }
KompileOptions options = glue.kompileOptions; List<Rule> rules = stream(spec.rules()).filter(r -> r.att().contains("specification")).collect(Collectors.toList());
public Module gen(Module mod) { this.mod = mod; predicateRules = stream(mod.rules()).filter(this::isPredicate).collect(Collectors.toSet()); return Module(mod.name(), mod.imports(), (Set<Sentence>) mod.localSentences().$bar(stream(mod.definedSorts()) .flatMap(this::gen).collect(Collections.toSet())), mod.att()); }
/** * Converts the org.kframework.Rules to backend Rules, also plugging in the automaton rule */ public void addKoreRules(Module module, GlobalContext global) { KOREtoBackendKIL transformer = new KOREtoBackendKIL(module, this, global, true); List<org.kframework.definition.Rule> koreRules = JavaConversions.setAsJavaSet(module.rules()).stream() .filter(r -> !r.att().contains(AUTOMATON)) .collect(Collectors.toList()); koreRules.forEach(r -> { if (r.att().contains(Att.topRule())) { reverseRuleTable.put(r.hashCode(), reverseRuleTable.size()); } }); koreRules.forEach(r -> { Rule convertedRule = transformer.convert(Optional.of(module), r); addRule(convertedRule); if (r.att().contains(Att.topRule())) { ruleTable.put(reverseRuleTable.get(r.hashCode()), convertedRule); } }); Optional<org.kframework.definition.Rule> koreAutomaton = JavaConversions.setAsJavaSet(module.localRules()).stream() .filter(r -> r.att().contains(AUTOMATON)) .collect(Collectors.collectingAndThen( Collectors.toList(), list -> list.size() == 1 ? Optional.of(list.get(0)) : Optional.empty() )); if (koreAutomaton.isPresent()) { automaton = transformer.convert(Optional.of(module), koreAutomaton.get()); } }
private void initializeConfigurationVariableDefaultSorts() { // searching for #SemanticCastTo<Sort>(Map:lookup(_, #token(<VarName>, KConfigVar))) Collections.stream(parsedDefinition.mainModule().rules()) .forEach(r -> { new VisitK() { @Override public void apply(KApply k) { if (k.klabel().name().contains("#SemanticCastTo") && k.items().size() == 1 && k.items().get(0) instanceof KApply) { KApply theMapLookup = (KApply) k.items().get(0); if (theMapLookup.klabel().name().startsWith("project:")) { theMapLookup = (KApply) theMapLookup.items().get(0); } if (KLabels.MAP_LOOKUP.equals(theMapLookup.klabel()) && theMapLookup.size() == 2 && theMapLookup.items().get(1) instanceof KToken) { KToken t = (KToken) theMapLookup.items().get(1); if (t.sort().equals(Sorts.KConfigVar())) { Sort sort = Outer.parseSort(k.klabel().name().replace("#SemanticCastTo", "")); configurationVariableDefaultSorts.put(t.s(), sort); } } } super.apply(k); } }.apply(r.body()); }); }
List<Rule> rules = stream(mod.rules()).filter(r -> r.att().contains("specification")).collect(Collectors.toList()); ProcessProofRules processProofRules = new ProcessProofRules(rules).invoke(rewritingContext, initCounterValue, module, definition); List<org.kframework.backend.java.kil.Rule> javaRules = processProofRules.getJavaRules();
for (Rule r : iterable(mainModule.rules())) { integers(r.body(), integerConstants); integers(r.requires(), integerConstants);
ListMultimap<KLabel, Rule> anywhereRules = ArrayListMultimap.create(); anywhereKLabels = new HashSet<>(); stream(mainModule.rules()).filter(r -> !r.att().contains(Attribute.MACRO_KEY) && !r.att().contains(Attribute.ALIAS_KEY)).forEach(r -> { K left = RewriteToTop.toLeft(r.body()); if (left instanceof KSequence) { List<Rule> unsortedRules = stream(mainModule.rules()).collect(Collectors.toList()); if (options.reverse) { Collections.reverse(unsortedRules);
stream(module.rules()).filter(r -> !r.att().contains(Attribute.MACRO_KEY) && !r.att().contains(Attribute.ALIAS_KEY)).forEach(r -> { K left = RewriteToTop.toLeft(r.body()); if (left instanceof KApply) {
collectAttributes(attributes, att); for (Rule r : iterable(module.rules())) { Att att = r.att(); collectAttributes(attributes, att); for (Rule rule : iterable(module.rules())) { K left = RewriteToTop.toLeft(rule.body()); if (left instanceof KApply) { for (Rule rule : iterable(module.rules())) { convertRule(rule, heatCoolEq, topCell, attributes, functionRules, false);