@Override public boolean equals(Object obj) { if (obj == null) return false; if (obj == this) return true; if (!(obj instanceof NonTerminal)) return false; NonTerminal nt = (NonTerminal) obj; if (!sort.equals(nt.sort)) return false; return true; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; KToken kToken = (KToken) o; if (!s.equals(kToken.s)) return false; return sort.equals(kToken.sort); }
private boolean isPredicateFor(Rule r, Sort s) { Optional<Sort> sort = getPredicateSort(r); return sort.isPresent() && sort.get().equals(s); }
public Term apply(Constant c) { if (c.production().sort().equals(Sorts.KVariable()) && !declaredNames.contains(getVarKey(c))) { if (vars.isEmpty()) vars.add(HashMultimap.<VarKey, Sort>create()); for (Multimap<VarKey, Sort> vars2 : vars) vars2.put(getVarKey(c), sort); } return c; } }
@Override public boolean equals(Object obj) { if (obj == null) return false; if (obj == this) return true; if (!(obj instanceof UserList)) return false; UserList srt = (UserList) obj; if (!sort.equals(srt.getSort())) return false; if (!separator.equals(srt.getSeparator())) return false; return true; }
@Override public void apply(KToken k) { if (k.sort().equals(Sorts.KConfigVar())) { hasConfigVar = true; } }
@Override public void apply(KToken k) { if (k.sort().equals(Sorts.Int())) { accum.add(k.s()); } } }.apply(term);
private Optional<KLabel> klabelFromTerm(Term labelTerm) { if (labelTerm instanceof Constant) { Constant labelCon = (Constant) labelTerm; if (labelCon.production().sort().equals(Sorts.KLabel())) { String labelVal = labelCon.value(); if (labelVal.charAt(0) == '`') { return Optional.of(KLabel(labelVal.substring(1, labelVal.length() - 1))); } else { return Optional.of(KLabel(labelVal)); } } } return Optional.empty(); }
public K apply(KVariable kvar) { if (kvar instanceof SortedADT.SortedKVariable && ((SortedADT.SortedKVariable) kvar).sort().equals(Sorts.K()) && varCount.get(kvar) == 1 && !kvar.name().equals(KLabels.THIS_CONFIGURATION)) { return new SortedADT.SortedKVariable("THE_VARIABLE", Att.empty()); } else { return kvar; } } };
private Sort nthArgSort(KLabel klabel, int n) { java.util.Set<Tuple2<Seq<Sort>,Sort>> sigs = mutable(JavaConversions.mapAsJavaMap(module.signatureFor()).get(klabel)); if (sigs == null) { throw new IllegalArgumentException("Not found signature for label: " + klabel); } Sort sort = null; for (Tuple2<Seq<Sort>,Sort> sig : sigs) { List<Sort> sorts = JavaConversions.seqAsJavaList(sig._1()); if (n >= sorts.size()) continue; sort = sorts.get(n); if (!sort.equals(Sorts.K())) { return sort; } } return sort; } }
public Either<java.util.Set<ParseFailedException>, Term> apply(Constant c) { if (c.production().sort().equals(Sorts.KVariable())) { Sort declared = decl.get(getVarKey(c)); if (declared != null && !(declared.equals(Sorts.K()) && subsorts.lessThanEq(sort, Sorts.KList()))) { // if the declared/inferred sort is K, make sure it can fit in the context (ex. is not a KLabel) if ((!strictSortEquality && !subsorts.lessThanEq(declared, sort)) || (strictSortEquality && !declared.equals(sort))) { String msg = "Unexpected sort " + declared + " for term " + c.value() + ". Expected " + sort + "."; KException kex = new KException(KException.ExceptionType.ERROR, KException.KExceptionGroup.CRITICAL, msg, c.source().orElse(null), c.location().orElse(null)); return Left.apply(Sets.newHashSet(new VariableTypeClashException(kex))); } return wrapTermWithCast(c, declared); } } return Right.apply(c); }
public Tuple2<Either<java.util.Set<ParseFailedException>, Term>, java.util.Set<VarInfo>> apply(Constant c) { if (c.production().sort().equals(Sorts.KVariable())) { return new Tuple2<>(Right.apply(c), Sets.newHashSet(new VarInfo(c, this.sort, varType))); } return simpleResult(c); } }
private void check(Sort s, Sentence p) { if (!s.equals(Sorts.Cell()) && module.subsorts().lessThan(s, Sorts.KList()) && module.subsorts().lessThan(s, Sorts.Bag())) { errors.add(KEMException.compilerError("Multiple top sorts found for " + s.toString() + ": KList and Bag.", p)); } } }
@Override public K apply(KToken k) { if (k.sort().equals(Sorts.KConfigVar())) { if (sort == null || sort.equals(Sorts.K())) { return KApply(KLabel("Map:lookup"), INIT, k); } else { h.sentences = (Set<Sentence>) h.sentences.$bar(genProjection(sort, m)); return KApply(getProjectLbl(sort, m), KApply(KLabel("Map:lookup"), INIT, k)); } } return k; } }.apply(leafContents), h.sentences);
private Stream<? extends Sentence> genKore(Sort sort) { if (sort.equals(Sorts.K())) { return Stream.of(Rule(KRewrite(KApply(KLabel("is" + sort.toString()), KVariable("K")), BooleanUtils.TRUE), BooleanUtils.TRUE, BooleanUtils.TRUE)); } else { List<Sentence> res = new ArrayList<>(); res.add(Rule(KRewrite(KApply(KLabel("is" + sort.toString()), KVariable(sort.name(), Att().add(Sort.class, sort))), BooleanUtils.TRUE), BooleanUtils.TRUE, BooleanUtils.TRUE)); res.add(Rule(KRewrite(KApply(KLabel("is" + sort.toString()), KVariable("K")), BooleanUtils.FALSE), BooleanUtils.TRUE, BooleanUtils.TRUE, Att().add("owise"))); return res.stream(); } }
public Token KToken(String s, org.kframework.kore.Sort sort, Att att) { return !sort.equals(KORE.Sort("KBoolean")) ? Token.of(Sort(sort), s) : Token.of(Sort(Sorts.Bool()), s); }
private Either<Set<ParseFailedException>, Term> wrapTermWithCast(Constant c, Sort declared) { Production cast; if (addCast) { cast = productions.apply(KLabel("#SemanticCastTo" + declared.toString())).head(); } else if (inferCasts && !hasCastAlready && productions.contains(KLabel("#SyntacticCast"))) { cast = stream(productions.apply(KLabel("#SyntacticCast"))).filter(p -> p.sort().equals(declared)).findAny().get(); } else { cast = null; } if (cast == null) { return Right.apply(c); } else { return Right.apply(TermCons.apply(ConsPStack.singleton(c), cast, c.location(), c.source())); } }
@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);
private static Sentence markRegularRules(Definition d, ConfigurationInfoFromModule configInfo, Sentence s, String att) { if (s instanceof org.kframework.definition.Rule) { org.kframework.definition.Rule r = (org.kframework.definition.Rule) s; if (r.body() instanceof KApply) { KLabel klabel = ((KApply) r.body()).klabel(); if (d.mainModule().sortFor().contains(klabel) //is false for rules in specification modules not part of semantics && d.mainModule().sortFor().apply(klabel).equals(configInfo.topCell())) { return Rule.apply(r.body(), r.requires(), r.ensures(), r.att().add(att)); } } } return s; }