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(')'); }
if (pi instanceof NonTerminal) { if (parameter.contains(idx)) { pis.set(j, NonTerminal(srt, ((NonTerminal) pi).name()));
private static Production resolve(Production prod) { if (prod.klabel().isDefined() && prod.klabel().get().equals(KLabels.GENERATED_TOP_CELL)) { List<Integer> cellPositions = new ArrayList<Integer>(); int i = 1; for (ProductionItem p: JavaConverters.seqAsJavaList(prod.items())) { if (p instanceof NonTerminal) { NonTerminal nt = (NonTerminal) p; if (! nt.sort().equals(Sorts.GeneratedCounterCell())) { cellPositions.add(i); } } i++; } StringBuilder format = new StringBuilder(); if (cellPositions.size() == 1) { format.append("%").append(cellPositions.get(0)); } else { format.append("%1%i"); int j; for (j = 0; j < cellPositions.size(); j++) { format.append("%n%").append(cellPositions.get(j)); } format.append("%d%n%").append(cellPositions.get(j - 1) + 1); } return Production(prod.klabel(), prod.sort(), prod.items(), prod.att().add("format", format.toString())); } return prod; }
if (prdItem instanceof org.kframework.definition.NonTerminal) { org.kframework.definition.NonTerminal srt = (org.kframework.definition.NonTerminal) prdItem; Grammar.NonTerminalState nts = grammar.new NonTerminalState(sort + " ::= " + srt.sort(), nt, grammar.get(srt.sort().toString())); previous.next.add(nts); previous = nts;
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); } } } } } }
private Set<Sort> sort(K k, Rule r) { if (k instanceof KVariable) { return Collections.singleton(k.att().get(Sort.class)); } else if (k instanceof KToken) { return Collections.singleton(((KToken)k).sort()); } else if (k instanceof KApply) { KApply kapp = (KApply)k; if (kapp.klabel() instanceof KVariable) { throw KEMException.compilerError("Cannot compute macros with klabel variables.", r); } Set<Production> prods = new HashSet<>(mutable(mod.productionsFor().apply(kapp.klabel()))); prods.removeIf(p -> p.arity() != kapp.items().size()); for (int i = 0; i < kapp.items().size(); i++) { final int idx = i; Set<Sort> sorts = sort(kapp.items().get(idx), r); prods.removeIf(p -> sorts.stream().noneMatch(s -> mod.subsorts().lessThanEq(s, p.nonterminal(idx).sort()))); } Set<Sort> candidates = prods.stream().map(Production::sort).collect(Collectors.toSet()); return candidates; } else { throw KEMException.compilerError("Cannot compute macros with sort check on terms that are not KApply, KToken, or KVariable.", r); } }
if (!subsorts.lessThanEq(sortIter.next(), ((NonTerminal) item).sort())) {
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."); } } } }
ul.childSort = ((NonTerminal) p.items().head()).sort(); ul.pList = p; } else if (p.items().size() == 1 && p.items().head() instanceof Terminal) {
ul.childSort = ((NonTerminal) p.items().head()).sort(); ul.pList = p; } else if (p.items().size() == 1 && p.items().head() instanceof Terminal) {
if (kompileOptions.strict()) { items.add(cast(production.nonterminal(j).sort(), KVariable("K" + j))); } else { items.add(KVariable("K" + j)); if (kompileOptions.strict()) { items.set(strictnessPosition, cast(production.nonterminal(strictnessPosition).sort(), KVariable("HOLE"))); } else { items.set(strictnessPosition, cast(Sorts.KItem(), KVariable("HOLE"))); if (kompileOptions.strict()) { items.add(cast(production.nonterminal(j).sort(), KVariable("K" + j))); } else { items.add(KVariable("K" + j));
continue; Sort expectedSort = ((NonTerminal) pi).sort(); ProductionReference child = (ProductionReference) items.next(); Sort childSort = getSort(child);
if (!mod.subsorts().lessThanEq(candidateProduction.nonterminal(i).sort(), possibleParentProduction.nonterminal(i).sort())) { 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));
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"); } }
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 Term apply(TermCons tc) { for (int i = 0, j = 0; i < tc.production().items().size(); i++) { if (tc.production().items().apply(i) instanceof NonTerminal) { if (tc.production().klabel().isDefined() && (tc.production().klabel().get().name().equals("#SyntacticCast") || tc.production().klabel().get().name().startsWith("#SemanticCastTo") || tc.production().klabel().get().name().equals("#InnerCast")) || (isFunctionRule(tc) && j == 0)) { Term t = tc.get(0); new CollectUndeclaredVariables2(getSortOfCast(tc)).apply(t); j++; } else { Term t = tc.get(j); new CollectUndeclaredVariables2(((NonTerminal) tc.production().items().apply(i)).sort()).apply(t); j++; } } } return super.apply(tc); }
conn = ""; for (NonTerminal nt : iterable(prod.nonterminals())) { Sort sort = nt.sort(); sb.append(conn); convert(sort, prod); if (!(prod.sort().equals(prod.nonterminal(0).sort()) && prod.sort().equals(prod.nonterminal(1).sort()))) { throw KEMException.compilerError("Found an associative production with ill formed sorts", prod); if (!(prod.nonterminal(0).sort().equals(prod.nonterminal(1).sort()))) { throw KEMException.compilerError("Found a commutative production with ill formed sorts", prod); Sort childSort = prod.nonterminal(0).sort(); sb.append(" axiom"); convertParams(prod.klabel(), true); if (!(prod.sort().equals(prod.nonterminal(0).sort()) && prod.sort().equals(prod.nonterminal(1).sort()))) { throw KEMException.compilerError("Found an associative production with ill formed sorts", prod); if (!(prod.sort().equals(prod.nonterminal(0).sort()) && prod.sort().equals(prod.nonterminal(1).sort()))) { throw KEMException.compilerError("Found an associative production with ill formed sorts", prod); sb.append(conn); sb.append("\\and{"); convert(prod.nonterminal(i).sort(), prod); sb.append("} (X").append(i).append(":"); convert(prod.nonterminal(i).sort(), prod); sb.append(", Y").append(i).append(":"); convert(prod.nonterminal(i).sort(), prod);
Sort expectedSort = prod.nonterminal(i).sort(); if (polyPositions.contains(i + 1)) { expectedSort = actualSort;
} else { Term t = tc.get(j); Sort s = ((NonTerminal) tc.production().items().apply(i)).sort(); Either<Set<ParseFailedException>, Term> rez = new ApplyTypeCheck2(s, false, false, inferSortChecks).apply(t); if (rez.isLeft())
public Tuple2<Either<java.util.Set<ParseFailedException>, Term>, java.util.Set<VarInfo>> apply(TermCons tc) { // TODO: (Radu) if this is cast, take the sort from annotations? Set<VarInfo> collector = Sets.newHashSet(); for (int i = 0, j = 0; i < tc.production().items().size(); i++) { if (tc.production().items().apply(i) instanceof NonTerminal) { if (tc.production().klabel().isDefined() && (tc.production().klabel().get().name().equals("#SyntacticCast") || tc.production().klabel().get().name().startsWith("#SemanticCastTo") || tc.production().klabel().get().name().equals("#InnerCast"))) { Term t = tc.get(0); collector = new CollectVariables2(getSortOfCast(tc), VarType.USER).apply(t)._2(); } else if (tc.production().klabel().isDefined() && isFunctionRule(tc) && j == 0) { Term t = tc.get(0); collector = new CollectVariables2(getSortOfCast(tc), VarType.CONTEXT).apply(t)._2(); j++; } else { Term t = tc.get(j); Set<VarInfo> vars = new CollectVariables2(((NonTerminal) tc.production().items().apply(i)).sort(), VarType.CONTEXT).apply(t)._2(); collector.addAll(vars); j++; } } } Tuple2<Either<java.util.Set<ParseFailedException>, Term>, java.util.Set<VarInfo>> rez = super.apply(tc); return new Tuple2<>(Right.apply(rez._1().right().get()), mergeWarnings(collector, rez._2())); }