@Override public Set<K> unit() { return Collections.<K>Set(); }
private KLabel getUniqueLambdaLabel(String nameHint1, String nameHint2) { if (klabels.isEmpty()) { klabels.addAll(mutable(module.definedKLabels())); } int counter = 0; KLabel freezer; do { freezer = KLabel("#lambda" + nameHint1 + "_" + nameHint2 + "_" + (counter++ == 0 ? "" : counter)); } while (klabels.contains(freezer)); klabels.add(freezer); return freezer; }
public Module resolve(Module m) { module = m; funProds.clear(); funRules.clear(); Set<Sentence> newSentences = stream(m.localSentences()).map(this::resolve).collect(Collectors.toSet()); newSentences.addAll(funProds); newSentences.addAll(funRules); return Module(m.name(), m.imports(), immutable(newSentences), m.att()); } }
public Module resolve(Module input) { Set<Sentence> rulesToAdd = stream(input.sentences()) .filter(s -> s instanceof Context) .map(s -> (Context) s) .flatMap(c -> this.resolve(c, input)).collect(Collectors.toCollection(HashSet::new)); if (!rulesToAdd.isEmpty()) { rulesToAdd.add(SyntaxSort(Sorts.K())); } return Module(input.name(), input.imports(), (scala.collection.Set<Sentence>) stream(input.localSentences()).filter(s -> !(s instanceof Context)).collect(Collections.toSet()).$bar(immutable(rulesToAdd)), input.att()); }
for (Sort srt : iterable(mod.definedSorts())) { if (!isParserSort(srt)) { for (Production p : iterable(mod.productions())) { if (p.isPrefixProduction()) { prods.addAll(mutable(p.recordProductions())); for (Production p : iterable(mod.productions())) { if (p.att().contains("poly")) { List<Set<Integer>> positions = computePositions(p); Sort returnSort = p.sort(); List<ProductionItem> pis = new ArrayList<>(); pis.addAll(mutable(p.items())); for (int i = 0; i < positions.size(); i++) { Set<Integer> parameter = positions.get(i); prods.add(Production(p.klabel(), returnSort, immutable(pis), p.att().add(Constants.ORIGINAL_PRD, Production.class, p))); if (addRuleCells) { ConfigurationInfo cfgInfo = new ConfigurationInfoFromModule(mod); parseProds = Stream.concat(prods.stream(), stream(mod.sentences())).flatMap(s -> { if (s instanceof Production && s.att().contains("cellCollection")) { return Stream.empty(); Seq<ProductionItem> pi = Seq(p.items().head(), optDots, body, optDots, p.items().last()); Production p1 = Production(p.klabel().get(), p.sort(), pi, p.att()); Production p2 = Production(Sorts.Cell(), Seq(NonTerminal(p.sort()))); return Stream.of(p1, p2);
public ProductionReference addBrackets(ProductionReference inner, TermCons outer, ProductionReference leftCapture, ProductionReference rightCapture) { if (requiresBracketWithSimpleAlgorithm(outer, leftCapture, rightCapture, inner)) { int position = getPosition(inner, outer); Sort outerSort = ((NonTerminal)outer.production().items().apply(position)).sort(); Sort innerSort = inner.production().sort(); for (Tuple2<Sort, scala.collection.immutable.List<Production>> sort : iterable(m.bracketProductionsFor())) { boolean isCorrectOuterSort = m.subsorts().lessThanEq(sort._1(), outerSort); if (isCorrectOuterSort) { for (Production p : mutable(sort._2())) { boolean isCorrectInnerSort = stream(p.items()) .filter(i -> i instanceof NonTerminal) .map(i -> (NonTerminal) i) .map(NonTerminal::sort) .filter(s -> m.subsorts().lessThanEq(innerSort, s)) .findAny().isPresent(); if (isCorrectInnerSort) { return TermCons.apply(ConsPStack.singleton(inner), p); } } } } return TermCons.apply(ConsPStack.singleton(inner), Production(Sorts.KBott(), Seq(NonTerminal(Sorts.K())))); } return inner; }
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 static Module subsortKItem(Module module) { java.util.Set<Sentence> prods = new HashSet<>(); for (Sort srt : iterable(module.definedSorts())) { if (!RuleGrammarGenerator.isParserSort(srt)) { // KItem ::= Sort Production prod = Production(Sorts.KItem(), Seq(NonTerminal(srt)), Att()); if (!module.sentences().contains(prod)) { prods.add(prod); } } } if (prods.isEmpty()) { return module; } else { return Module(module.name(), module.imports(), Stream.concat(stream(module.localSentences()), prods.stream()) .collect(org.kframework.Collections.toSet()), module.att()); } }
public Module apply(Module inputModule) { if (stream(inputModule.localSentences()) .filter(s -> s instanceof Bubble) .map(b -> (Bubble) b) Set<Sentence> importedConfigurationSortsSubsortedToCell = stream(inputModule.productions()) .filter(p -> p.att().contains("cell")) .map(p -> Production(Sorts.Cell(), Seq(NonTerminal(p.sort())))).collect(Collections.toSet()); Set<Sentence> configDeclProductions = stream(module.localSentences()) .parallel() .filter(s -> s instanceof Bubble) configDecl -> stream(GenerateSentencesFromConfigDecl.gen(configDecl.body(), configDecl.ensures(), configDecl.att(), parser.getExtensionModule(), kore))) .collect(Collections.toSet()); Set<Sentence> configDeclSyntax = stream(configDeclProductions).filter(Sentence::isSyntax).collect(Collections.toSet()); Set<Sentence> configDeclRules = stream(configDeclProductions).filter(Sentence::isNonSyntax).collect(Collections.toSet()); throw KEMException.compilerError("Module Map must be visible at the configuration declaration, in module " + module.name()); return Module(module.name(), (Set<Module>) module.imports().$bar(Set(mapModule)), (Set<Sentence>) module.localSentences().$bar(configDeclSyntax), module.att()); return Module(module.name(), (Set<Module>) module.imports().$bar(Set(mapModule)), (Set<Sentence>) module.localSentences().$bar(configDeclRules), module.att());
polyKLabels.put(prod.klabel().get().name(), poly); List<Sort> params = new ArrayList<>(); List<NonTerminal> children = new ArrayList<>(mutable(prod.nonterminals())); Sort returnSort = prod.sort(); for (int i = 0; i < poly.size(); i++) { for (ProductionItem item : iterable(prod.items())) { if (item instanceof NonTerminal) { items.add(children.get(i)); return Production(KLabel(prod.klabel().get().name(), immutable(params)), returnSort, immutable(items), prod.att().add("originalPrd", Production.class, prod));
public Module gen(Module mod) { Set<Sentence> res = new HashSet<>(); for (Sort sort : iterable(mod.definedSorts())) { Production prod = Production(KLabel("is" + sort.toString()), Sorts.Bool(), Seq(Terminal("is" + sort.toString()), Terminal("("), NonTerminal(Sorts.K()), Terminal(")")), Att().add(Attribute.FUNCTION_KEY).add(Attribute.PREDICATE_KEY, Sort.class, sort)); if (!mod.productions().contains(prod)) res.add(prod); } if (!res.isEmpty()) { res.add(SyntaxSort(Sorts.K())); } return Module(mod.name(), mod.imports(), (scala.collection.Set<Sentence>) mod.localSentences().$bar(immutable(res)), mod.att()); } }
Option<Set<Production>> initializerProduction = m.productionsFor().get(KLabel(getInitLabel(sort))); if (initializerProduction.isDefined()) { Set<Production> realProds = stream(initializerProduction.get()).filter(p -> !p.att().contains("recordPrd", Production.class)).collect(Collections.toSet()); if (realProds.size() == 1) { // should be only a single initializer if (realProds.head().items().size() == 1) { return Tuple4.apply(Set(), Lists.newArrayList(sort), KApply(KLabel(getInitLabel(sort))), true); } else if (realProds.head().items().size() == 4) { return Tuple4.apply(Set(), Lists.newArrayList(sort), KApply(KLabel(getInitLabel(sort)), INIT), true); Set<Sentence> accumSentences = Set(); List<Sort> sorts = Lists.newArrayList(); List<K> initializers = Lists.newArrayList(); initializers.add(childResult._3()); return Tuple4.apply(accumSentences, sorts, KApply(KLabels.CELLS, immutable(initializers)), false);
private void collectAttributes(Map<String, Boolean> attributes, Att att) { for (Tuple2<Tuple2<String, Class<?>>, ?> attribute : iterable(att.att())) { String name = attribute._1._1; Class<?> cls = attribute._1._2; Object val = attribute._2; String strVal = val.toString(); if (strVal.equals("")) { if (!attributes.containsKey(name)) { attributes.put(name, false); } } else { attributes.put(name, true); } } }
Seq(Terminal("is" + sort.toString()), Terminal("("), NonTerminal(Sorts.K()), Terminal(")")), Att().add(Attribute.FUNCTION_KEY).add(Attribute.PREDICATE_KEY, Sort.class, sort)); res.add(prod); stream(mod.definedSorts()).filter(s -> mod.subsorts().lessThanEq(s, sort)).forEach(subsort -> { MutableBoolean isProtecting = new MutableBoolean(true); stream(mod.definedSorts()).filter(s -> mod.subsorts().lessThanEq(s, subsort)).forEach(candidateSort -> { if (predicateRules.stream().filter(r -> isPredicateFor(r, candidateSort)).findAny().isPresent()) { stream(mod.productions()).filter(p -> p.sort().equals(candidateSort) && p.klabel().isDefined()).forEach(candidateProduction -> { if (!stream(mod.productionsFor().apply(candidateProduction.klabel().get())).filter(p -> p.sort().equals(sort) && p.arity() == candidateProduction.arity()).anyMatch(possibleParentProduction -> { for (int i = 0; i < candidateProduction.arity(); i++) { if (!mod.subsorts().lessThanEq(candidateProduction.nonterminal(i).sort(), possibleParentProduction.nonterminal(i).sort())) { stream(mod.productions()).filter(p -> mod.subsorts().lessThanEq(p.sort(), sort)).filter(p -> nonProtectingSubsorts.contains(p.sort())).distinct().forEach(p -> { if (p.klabel().isDefined() && !p.att().contains(Attribute.FUNCTION_KEY)) { List<K> klist = new ArrayList<>(); List<K> side = new ArrayList<>(); int i = 0; List<NonTerminal> nts = stream(p.items()).filter(pi -> pi instanceof NonTerminal).map(pi -> (NonTerminal) pi).collect(Collectors.toList()); for (NonTerminal nt : nts) { KVariable v = KVariable("K" + i++, Att().add(Sort.class, nt.sort())); klist.add(v); if (!mutable(mod.sortAttributesFor()).getOrDefault(sort, Att()).contains("flatPredicate")) { side.add(KApply(KLabel("is" + nt.sort().toString()), v)); stream(mod.definedSorts()).filter(s -> mod.subsorts().lessThanEq(s, sort)).distinct().forEach(s -> { res.add(Rule(KRewrite(KApply(KLabel("is" + sort.toString()), KApply(KLabel("#KToken"), KToken(s.toString(), Sorts.KString()), KVariable("_"))), BooleanUtils.TRUE),
} else { Module newMod = ModuleTransformer.from(oldMod -> { Set<Module> imports = stream(oldMod.imports()).map(_import -> { if (_import.name().equals(ID)) { return baseK.getModule(ID_PROGRAM_PARSING).get(); return Module.apply(oldMod.name(), immutable(imports), oldMod.localSentences(), oldMod.att()); }, "apply program parsing modules").apply(mod); return Module.apply(mod.name() + POSTFIX, immutable(modules), Set(), Att());
@Test public void testSingleTop() { Production prod = Production(KLabel(".Opt"), Sort("OptCellContent"), Seq(Terminal(""))); Production prod2 = Production(KLabel("#SemanticCastToKItem"), Sort("KItem"), Seq(NonTerminal(Sort("KItem")))); K configuration = cell("threads", Collections.emptyMap(), cell("thread", Collections.singletonMap("multiplicity", "*"), cell("opt", Collections.singletonMap("multiplicity", "?"), KApply(KLabel(".Opt"), KList(), Att.empty().add(Production.class, prod)))))); Module m1 = Module("CONFIG", Set(def.getModule("KSEQ").get()), Set(prod), Att()); RuleGrammarGenerator parserGen = new RuleGrammarGenerator(def); Module m = RuleGrammarGenerator.getCombinedGrammar(parserGen.getConfigGrammar(m1), true).getExtensionModule(); Att initializerAtts = Att().add("initializer"); Att productionAtts = initializerAtts.add("function").add("noThread"); Set<Sentence> reference = Set(Production(KLabel("<threads>"), Sort("ThreadsCell"), Seq(Terminal("<threads>"), NonTerminal(Sort("ThreadCellBag")), Terminal("</threads>")), Att().add("cell").add("cellName", "threads").add("topcell").add("format", "%1%i%n%2%d%n%3")), SyntaxSort(Sort("ThreadCellBag"), Att().add("hook", "BAG.Bag")), Production(KLabel("_ThreadCellBag_"), Sort("ThreadCellBag"), Seq(NonTerminal(Sort("ThreadCellBag")), NonTerminal(Sort("ThreadCellBag"))), Att().add("assoc","").add("comm","").add("unit",".ThreadCellBag") .add("element","ThreadCellBagItem").add("wrapElement","<thread>") .add("function").add("avoid").add("bag").add("cellCollection").add("hook","BAG.concat")), Production(KLabel(".ThreadCellBag"), Sort("ThreadCellBag"), Seq(Terminal(".ThreadCellBag")), Att().add("function").add("hook","BAG.unit")), Production(Sort("ThreadCellBag"), Seq(NonTerminal(Sort("ThreadCell")))), Production(KLabel("ThreadCellBagItem"), Sort("ThreadCellBag"),
Production cellProduction = Production(KLabel(klabel), sort, immutable(items), att); sentences.add(cellProduction); Rule initializerRule; if (hasConfigurationOrRegularVariable || isStream) { initializer = Production(KLabel(initLabel), sort, Seq(Terminal(initLabel), Terminal("("), NonTerminal(Sorts.Map()), Terminal(")")), Att().add("initializer").add("function").add("noThread")); initializerRule = Rule(KRewrite(KApply(KLabel(initLabel), INIT), IncompleteCellUtils.make(KLabel("<" + cellName + ">"), false, childInitializer, false)), BooleanUtils.TRUE, ensures == null ? BooleanUtils.TRUE : ensures, Att().add("initializer")); } else { initializer = Production(KLabel(initLabel), sort, Seq(Terminal(initLabel)), Att().add("initializer").add("function").add("noThread")); initializerRule = Rule(KRewrite(KApply(KLabel(initLabel)), IncompleteCellUtils.make(KLabel("<" + cellName + ">"), false, childInitializer, false)), BooleanUtils.TRUE, ensures == null ? BooleanUtils.TRUE : ensures, Att().add("initializer")); sentences.add(Production(childOptSort, List(NonTerminal(childSort)))); if (!m.definedKLabels().contains(KLabel("no"+childSort.toString()))) { sentences.add(Production(KLabel("no"+childSort.toString()), childOptSort, List(Terminal("no"+childSort.toString())), Att().add(Attribute.CELL_OPT_ABSENT_KEY,Sort.class,childSort))); sentences.add(Production(KLabel("<" + cellName + ">-fragment"), fragmentSort, immutable(fragmentItems), Att().add(Attribute.CELL_FRAGMENT_KEY, Sort.class, Sort(sortName)))); Sentence bagSubsort = Production(bagSort, Seq(NonTerminal(sort))); Sentence bagElement; if (type.equals("Map")) { bagElement = Production(KLabel(bagSort.name() + "Item"), bagSort, Seq( Terminal(bagSort.name() + "Item"), Terminal("("), Terminal(")")), Att().add(Attribute.HOOK_KEY, elementHook).add(Attribute.FUNCTION_KEY)); } else {
private static Set<Sentence> genProjection(Sort sort, Module m) { KLabel lbl = getProjectLbl(sort, m); KVariable var = KVariable("K", Att.empty().add(Sort.class, sort)); Rule r = Rule(KRewrite(KApply(lbl, var), var), BooleanUtils.TRUE, BooleanUtils.TRUE, Att().add("projection")); if (m.definedKLabels().contains(lbl)) { return Set(r); } return Set(Production(lbl, sort, Seq(Terminal(lbl.name()), Terminal("("), NonTerminal(Sorts.K()), Terminal(")")), Att().add("function").add("projection")), r); }