public void apply(KLabel klabel) { if (klabel instanceof KVariable) { Att att = ((KVariable)klabel).att(); if (att.contains("klabelPredicate") && !rhs) { List<KLabel> klabelsForPredicate = klabelsForEachPredicate.get(att.get("klabelPredicate")); sb.append("("); Joiner.on("|").appendTo(sb, klabelsForPredicate.stream().map(kl -> (Object)encodeStringToIdentifier(kl))::iterator); sb.append(") as "); } apply((KVariable) klabel); } else { encodeStringToIdentifier(sb, klabel); } } }
public static String getSortOfVar(KVariable k, VarInfo vars) { if (vars.vars.containsKey(k)) { String varName = vars.vars.get(k).iterator().next(); if (vars.listVars.containsKey(varName)) { return vars.listVars.get(varName).name(); } } if (k.att().contains("cellSort")) { return Sorts.K().toString(); } return k.att().getOptional(Sort.class).orElse(Sorts.K()).toString(); }
@Override public void apply(KVariable k) { sb.append("Var"); convert(k.name()); sb.append(":"); convert(k.att().getOptional(Sort.class).orElse(Sorts.K()), false); }
public K apply(KVariable kvar) { return new SortedADT.SortedKVariable(kvar.name(), kvar.att()); } }.apply(ruleBody);
@Override public KVariable apply(KVariable k) { return KVariable(k.name(), k.att()); }
private void applyVarLhs(KVariable k, StringBuilder sb, VarInfo vars) { String varName = encodeStringToVariable(k.name()); vars.vars.put(k, varName); Sort s = k.att().getOptional(Sort.class).orElse(Sort("")); if (mainModule.sortAttributesFor().contains(s)) { String hook = mainModule.sortAttributesFor().apply(s).<String>getOptional("hook").orElse(""); if (sortVarHooks.containsKey(hook)) { sb.append("("); sb.append(sortVarHooks.get(hook).apply(s)); sb.append(" as ").append(varName).append(")"); return; } } sb.append(varName); }
@Override public K apply(KVariable k) { if (normalization.containsKey(k)) { return KVariable(normalization.get(k), k.att().add("denormal", k.name())); } return super.apply(k); } }.apply(denormal);
@Override public void apply(KVariable k) { if (context != null) { k = KVariable(k.name(), k.att().add(Sort.class, context)); } if (isRHS()) { if (!k.name().equals(KLabels.THIS_CONFIGURATION) && ((k.equals(ResolveAnonVar.ANON_VAR) && !isLHS()) || (!k.equals(ResolveAnonVar.ANON_VAR) && !(k.name().startsWith("?") || k.name().startsWith("!")) && !vars.contains(k)))) { reporter.accept(k); } } }
public K apply(KVariable var) { if (var.name(). equals("HOLE") && transitions.stream().noneMatch(att::contains)) { return KVariable(var.name(), var.att().add(Sort.class, Outer.parseSort(att.getOptional("result").orElse("KResult")))); } return super.apply(var); } }.apply(body);
this.rewriteThreadSet = Rule(new TransformK() { public K apply(KVariable var) { return KVariable(var.name(), var.att().remove(Sort.class)); } }.apply(this.rewriteThreadSet.body()), this.rewriteThreadSet.requires(), this.rewriteThreadSet.ensures());
private KLabel apply(KLabel klabel) { KVariable var = (KVariable) klabel; return KVariable(var.name(), var.att().add("klabelPredicate", predicates.get(var).klabel().name())); }
@Override public K apply(K k) { if (isRHS() && !isLHS()) { if (cache.containsKey(k)) { return cache.get(k); } } if (isLHS() && !isRHS()) { if (usedOnRhs.contains(k)) { return KAs(super.apply(k), cache.get(k), Att.empty().add(Sort.class, cache.get(k).att().get(Sort.class))); } } return super.apply(k); } }.apply(term);
@Override public K apply(KVariable k) { if (freshVars.contains(k)) { Optional<Sort> s = k.att().getOptional(Sort.class); if (!s.isPresent()) { throw KEMException.compilerError("Fresh constant used without a declared sort.", k); } Option<KLabel> lbl = m.freshFunctionFor().get(s.get()); if (!lbl.isDefined()) { throw KEMException.compilerError("No fresh generator defined for sort " + s, k); } return KApply(lbl.get(), KApply(KLabel("_+Int_"), FRESH, KToken(offsets.get(k).toString(), Sorts.Int()))); } return super.apply(k); } }.apply(term);
private Term convert1(KLabel klabel) { if (klabel instanceof KVariable) { return KVariable(klabel.name(), ((KVariable) klabel).att().add(org.kframework.kore.Sort.class, Sorts.KLabel())); } else { return KLabel(klabel); } }
private Production funProd(KLabel fun, K k) { List<ProductionItem> pis = new ArrayList<>(); K left = RewriteToTop.toLeft(k); K right = RewriteToTop.toRight(k); pis.add(Terminal(fun.name())); pis.add(Terminal("(")); pis.add(NonTerminal(sort(left))); for (KVariable var : closure(k)) { pis.add(Terminal(",")); pis.add(NonTerminal(var.att().getOptional(Sort.class).orElse(Sorts.K()))); } pis.add(Terminal(")")); return Production(fun, sort(right), immutable(pis), Att().add("function")); }
@Override public K apply(KAs k) { K res = apply(k.pattern()); KVariable var = (KVariable) k.alias(); if (!(res instanceof KSequence) && var.att().getOptional(Sort.class).orElse(Sorts.K()).equals(Sorts.K())) { res = KSequence(res); } return KAs(res, k.alias(), k.att()); } }.apply(term);