public static Sentence convertListItemToNonFunction(Module mod, Sentence sentence) { if (!(sentence instanceof Production)) { return sentence; } Production prod = (Production)sentence; if (prod.klabel().isDefined() && KLabels.ListItem.equals(prod.klabel().get())) { return Production(prod.sort(), prod.items(), prod.att().remove("function")); } return prod; }
private void applyPattern(Production prod, String varName) { convert(prod.klabel().get(), prod); sb.append("("); String conn = ""; for (int i = 0; i < prod.arity(); i++) { sb.append(conn); sb.append(varName).append(i).append(":"); convert(prod.nonterminal(i).sort(), prod); conn = ", "; } sb.append(')'); }
public WrapLabelRule(Production label) { assert label != null; this.label = label; this.isToken = label.att().contains("token"); this.needsLabel = label.klabel().isDefined() || !label.isSyntacticSubsort(); } protected Term apply(KList klist, MetaData metaData) {
public static Sort getSortOfCast(TermCons tc) { switch (tc.production().klabel().get().name()) { case "#ruleNoConditions": case "#ruleRequires": case "#ruleEnsures": case "#ruleRequiresEnsures": { ProductionReference child = (ProductionReference) tc.get(0); if (child.production().klabel().isDefined() && child.production().klabel().get().equals(KLabels.KREWRITE)) { child = (ProductionReference)((TermCons)child).get(0); } return child.production().sort(); } case "#SyntacticCast": case "#OuterCast": return tc.production().sort(); case "#InnerCast": return ((NonTerminal)tc.production().items().apply(1)).sort(); default: if (tc.production().klabel().get().name().startsWith("#SemanticCastTo")) { return tc.production().sort(); } throw new AssertionError("Unexpected cast type"); } }
private Production computePolyProd(Production prod) { if (!prod.att().contains("poly")) return prod.withAtt(prod.att().add("originalPrd", Production.class, prod)); List<Set<Integer>> poly = RuleGrammarGenerator.computePositions(prod); 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++) { Set<Integer> positions = poly.get(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));
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())); requires = sideCondition.get(); Rule r = Rule(KRewrite(KApply(KLabel("is" + sort.toString()), KApply(p.klabel().get(), KList(klist))), BooleanUtils.TRUE), requires, BooleanUtils.TRUE); res.add(r);
private void forEachKLabel(Consumer<Tuple2<KLabel, Long>> action) { for (KLabel label : iterable(mainModule.definedKLabels())) { if (ConvertDataStructureToLookup.isLookupKLabel(label) || label.name().equals("#KToken")) continue; stream(mainModule.productionsFor().apply(label)).map(p -> Tuple2.apply(p.klabel().get(), stream(p.items()).filter(pi -> pi instanceof NonTerminal).count())).distinct().forEach(action); } }
public static boolean isFunctionRule(TermCons tc) { if (tc.production().sort().name().equals("RuleContent")) { ProductionReference child = (ProductionReference) tc.get(0); if (child.production().klabel().isDefined() && child.production().klabel().get().equals(KLabels.KREWRITE)) { child = (ProductionReference)((TermCons)child).get(0); } return child.production().att().contains(Attribute.FUNCTION_KEY); } return false; }
if (p.isPrefixProduction()) { prods.addAll(mutable(p.recordProductions())); if (p.att().contains("poly")) { List<Set<Integer>> positions = computePositions(p); if (!p.isSyntacticSubsort()) { 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))); addRuleCells = mod.sentences().exists(p -> p instanceof Production && ((Production) p).att().contains("cell")); } else { addRuleCells = false; assert p.items().head() instanceof Terminal || p.items().head() instanceof RegexTerminal; assert p.items().last() instanceof Terminal || p.items().last() instanceof RegexTerminal; final ProductionItem body; if (cfgInfo.isLeafCell(p.sort())) { body = p.items().tail().head(); } else { body = NonTerminal(Sorts.Bag()); Seq<ProductionItem> pi = Seq(p.items().head(), optDots, body, optDots, p.items().last()); Production p1 = Production(p.klabel().get(), p.sort(), pi, p.att());
Att att = prod.att(); collectAttributes(attributes, att); att = att.remove(Attribute.HOOK_KEY); } else { Production concatProd = stream(module.productionsForSort().apply(sort)).filter(p -> p.att().contains("element")).findAny().get(); att = att.add("element", K.class, KApply(KLabel(concatProd.att().get("element")))); att = att.add("concat", K.class, KApply(concatProd.klabel().get())); att = att.add("unit", K.class, KApply(KLabel(concatProd.att().get("unit")))); sb.append("hooked-"); KApply kapp = (KApply) left; Production prod = production(kapp); if (prod.att().contains(Attribute.FUNCTION_KEY) || rule.att().contains(Attribute.ANYWHERE_KEY)) { functionRules.put(kapp.klabel(), rule); if (prod.klabel().isEmpty()) { continue; if (impurities.contains(prod.klabel().get())) { impureFunctions.add(prod.klabel().get().name()); if (isFunction(prod) && prod.att().contains(Attribute.HOOK_KEY) && !prod.att().get(Attribute.HOOK_KEY).startsWith("ARRAY.")) { sb.append("hooked-"); convert(prod.klabel().get(), true); String conn; sb.append("("); conn = "";
private void check(Production p) { if (p.att().contains(Attribute.CELL_KEY)) { for (ProductionItem i : mutable(p.items())) { if (i instanceof NonTerminal) { Sort sort = ((NonTerminal) i).sort(); if (sort.name().endsWith("Cell")) { if (cells.contains(sort)) { Production cell = new ConfigurationInfoFromModule(module).cellProductionsFor().get(sort).get().head(); errors.add(KEMException.compilerError("Cell " + cell.klabel().get() + " found twice in configuration.", p)); } cells.add(sort); } } } } } }
/** * Gather sort information from a module. * Populates the close operators only for sorts which only have a single associative production. */ public static SortInfo fromModule(Module module) { Multimap<Sort, KLabel> joinOps = HashMultimap.create(); Collections.stream(module.productionsFor()).forEach(x -> { if (Collections.stream(x._2()).anyMatch(p -> p.att().contains("assoc") && Collections.stream(p.items()).filter(i -> i instanceof NonTerminal).count() == 2)) { joinOps.put(x._2().head().sort(), x._1()); } }); SortInfo info = new SortInfo(); joinOps.asMap().forEach((sort, labels) -> { info.closeOperators.put(sort, Iterators.getNext(labels.iterator(), null)); }); return info; } }
EnumSet<Fixity> fixity = getFixity(inner, outer); EnumSet<Fixity> innerFixity = getFixity(inner); if (inner.production().klabel().equals(outer.production().klabel()) && inner.production().klabel().isDefined() && m.attributesFor().apply(inner.production().klabel().get()).contains(Attribute.ASSOCIATIVE_KEY)) return false; if (inner instanceof Constant) if (priority) return true; if (inner.production().isSyntacticSubsort()) return false; inversePriority = isPriorityWrong(inner, rightCapture, inner.production().items().size() - 1); EnumSet<Fixity> rightCaptureFixity = getFixity(rightCapture); if (!inversePriority && rightCaptureFixity.contains(Fixity.BARE_LEFT)) {
public Set<Sentence> resolve(Production production, boolean sequential) { long arity = stream(production.items()).filter(i -> i instanceof NonTerminal).count(); List<Integer> strictnessPositions = new ArrayList<>(); String attribute; if (sequential) { attribute = production.att().get(Attribute.SEQSTRICT_KEY); } else { attribute = production.att().get(Attribute.STRICT_KEY); items.add(cast(production.nonterminal(j).sort(), KVariable("K" + j))); } else { items.add(KVariable("K" + j)); items.set(strictnessPosition, cast(production.nonterminal(strictnessPosition).sort(), KVariable("HOLE"))); } else { items.set(strictnessPosition, cast(Sorts.KItem(), KVariable("HOLE"))); Context ctx = Context(KApply(production.klabel().get(), KList(items)), requires, production.att()); sentences.add(ctx); if (production.att().contains("hybrid")) { List<K> items = new ArrayList<>(); for (int j = 0; j < arity; j++) { if (kompileOptions.strict()) { items.add(cast(production.nonterminal(j).sort(), KVariable("K" + j))); } else { items.add(KVariable("K" + j)); K term = KApply(production.klabel().get(), KList(items));
private void check(Production p) { if (p.att().contains("cell") && p.att().contains("stream")) { ProductionItem i = mutable(p.items()).get(1); if (i instanceof NonTerminal) { Sort sort = ((NonTerminal) i).sort(); if (!module.subsorts().lessThanEq(sort, Sorts.List())) { errors.add(KEMException.compilerError("Wrong sort in streaming cell. Expected List, but found " + sort.toString() + ".", p)); } } else { throw KEMException.internalError("Illegal arguments for stream cell."); } } } }
private void check(Production p) { check(p.sort(), p); }