@Override public Boolean apply(KVariable v) { return v.name().equals(KLabels.THIS_CONFIGURATION); } }.apply(r.body());
private boolean isHOLEVar(K k) { return k instanceof KVariable && ((KVariable) k).name().equals("HOLE"); } }.apply(body);
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); } } }
@Override public DefaultMutableTreeNode apply(KVariable k) { return new DefaultMutableTreeNode(k.name()); }
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) { if (!k.name().equals("HOLE")) { vars.put(k, k); finalHolePosition[0] = currentHolePosition[0]; } else { holeVar = k; currentHolePosition[0]++; } super.apply(k); }
private K addSideCondition(K requires) { Optional<KApply> sideCondition = freshVars.stream().map(k -> { Optional<Sort> s = k.att().getOptional(Sort.class); if (!s.isPresent()) { throw KEMException.compilerError("Fresh constant used without a declared sort.", k); } return KApply(KLabel("#match"), k, KApply(KLabel("#fresh"), KToken(StringUtil.enquoteKString(s.get().toString()), Sorts.String()))); }).reduce(BooleanUtils::and); if (!sideCondition.isPresent()) { return requires; } else if (requires.equals(BooleanUtils.TRUE) && sideCondition.isPresent()) { return sideCondition.get(); } else { // we order the lookup after the requires clause so that the fresh constant // matching side condition occurs last. This is necessary in order to // ensure that fresh constants in rule RHSs are consecutive return BooleanUtils.and(requires, sideCondition.get()); } }
@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 boolean isAnyVar() { return var.value().equals(ResolveAnonVar.ANON_VAR.name()); } }
@Override public void apply(KApply k) { if (k.klabel().name().equals("#cells")) { for (int i = 0; i < k.klist().size(); i++) { K item = k.klist().items().get(i); if (item instanceof KVariable) { KVariable var = (KVariable) item; if (var.att().contains(Sort.class)) { Sort sort = var.att().get(Sort.class); if (!cfg.cfg.isCell(sort)) { if (!cellFragmentVars.containsKey(var)) { cellFragmentVars.put(var, new HashSet<>()); } cellFragmentVars.get(var).add(k); } } else { if (!cellFragmentVars.containsKey(var)) { cellFragmentVars.put(var, new HashSet<>()); } cellFragmentVars.get(var).add(k); } } } } else { super.apply(k); } } }.apply(term);
@Override public void apply(KVariable k) { if (k.name().startsWith("!")) { freshVars.add(k); } super.apply(k); } }.apply(term);
if (topOfKCellLabel instanceof KVariable) { KVariable var = (KVariable) topOfKCellLabel; if (var.att().contains("klabelPredicate")) { Set<KLabel> klabelsThatCouldMatchThisVariable = new HashSet<>(klabelsForEachPredicate.get(var.att().get("klabelPredicate"))); if (klabelsThatCouldMatchThisVariable.contains(lbl)) { res.add(r);
private void check(K body, boolean isBody) { Set<KVariable> unbound = new HashSet<>(); new ComputeUnboundVariables(isBody, errors, vars, unbound::add).apply(body); for (KVariable k : unbound) { errors.add(KEMException.compilerError("Found variable " + k.name() + " on right hand side of rule, not bound on left hand side." + " Did you mean \"?" + k.name() + "\"?", k)); } }
@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);