248 lines
8.2 KiB
Java
248 lines
8.2 KiB
Java
package net.minecraft.util.parsing.packrat;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public interface Term<S> {
|
|
boolean parse(ParseState<S> p_334989_, Scope p_334936_, Control p_335743_);
|
|
|
|
static <S, T> Term<S> marker(Atom<T> p_333477_, T p_335010_) {
|
|
return new Term.Marker<>(p_333477_, p_335010_);
|
|
}
|
|
|
|
@SafeVarargs
|
|
static <S> Term<S> sequence(Term<S>... p_331306_) {
|
|
return new Term.Sequence<>(p_331306_);
|
|
}
|
|
|
|
@SafeVarargs
|
|
static <S> Term<S> alternative(Term<S>... p_334441_) {
|
|
return new Term.Alternative<>(p_334441_);
|
|
}
|
|
|
|
static <S> Term<S> optional(Term<S> p_335256_) {
|
|
return new Term.Maybe<>(p_335256_);
|
|
}
|
|
|
|
static <S, T> Term<S> repeated(NamedRule<S, T> p_391997_, Atom<List<T>> p_395278_) {
|
|
return repeated(p_391997_, p_395278_, 0);
|
|
}
|
|
|
|
static <S, T> Term<S> repeated(NamedRule<S, T> p_394090_, Atom<List<T>> p_396235_, int p_397596_) {
|
|
return new Term.Repeated<>(p_394090_, p_396235_, p_397596_);
|
|
}
|
|
|
|
static <S, T> Term<S> repeatedWithTrailingSeparator(NamedRule<S, T> p_395582_, Atom<List<T>> p_391503_, Term<S> p_394717_) {
|
|
return repeatedWithTrailingSeparator(p_395582_, p_391503_, p_394717_, 0);
|
|
}
|
|
|
|
static <S, T> Term<S> repeatedWithTrailingSeparator(NamedRule<S, T> p_397489_, Atom<List<T>> p_392214_, Term<S> p_395301_, int p_391759_) {
|
|
return new Term.RepeatedWithSeparator<>(p_397489_, p_392214_, p_395301_, p_391759_, true);
|
|
}
|
|
|
|
static <S, T> Term<S> repeatedWithoutTrailingSeparator(NamedRule<S, T> p_392740_, Atom<List<T>> p_397250_, Term<S> p_393470_) {
|
|
return repeatedWithoutTrailingSeparator(p_392740_, p_397250_, p_393470_, 0);
|
|
}
|
|
|
|
static <S, T> Term<S> repeatedWithoutTrailingSeparator(NamedRule<S, T> p_393071_, Atom<List<T>> p_395445_, Term<S> p_395475_, int p_392015_) {
|
|
return new Term.RepeatedWithSeparator<>(p_393071_, p_395445_, p_395475_, p_392015_, false);
|
|
}
|
|
|
|
static <S> Term<S> positiveLookahead(Term<S> p_395551_) {
|
|
return new Term.LookAhead<>(p_395551_, true);
|
|
}
|
|
|
|
static <S> Term<S> negativeLookahead(Term<S> p_395059_) {
|
|
return new Term.LookAhead<>(p_395059_, false);
|
|
}
|
|
|
|
static <S> Term<S> cut() {
|
|
return new Term<S>() {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_333527_, Scope p_336097_, Control p_335047_) {
|
|
p_335047_.cut();
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "\u2191";
|
|
}
|
|
};
|
|
}
|
|
|
|
static <S> Term<S> empty() {
|
|
return new Term<S>() {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_328418_, Scope p_332040_, Control p_328784_) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "\u03b5";
|
|
}
|
|
};
|
|
}
|
|
|
|
static <S> Term<S> fail(final Object p_396725_) {
|
|
return new Term<S>() {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_394241_, Scope p_396858_, Control p_393969_) {
|
|
p_394241_.errorCollector().store(p_394241_.mark(), p_396725_);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "fail";
|
|
}
|
|
};
|
|
}
|
|
|
|
public record Alternative<S>(Term<S>[] elements) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_328094_, Scope p_331753_, Control p_334626_) {
|
|
Control control = p_328094_.acquireControl();
|
|
|
|
try {
|
|
int i = p_328094_.mark();
|
|
p_331753_.splitFrame();
|
|
|
|
for (Term<S> term : this.elements) {
|
|
if (term.parse(p_328094_, p_331753_, control)) {
|
|
p_331753_.mergeFrame();
|
|
return true;
|
|
}
|
|
|
|
p_331753_.clearFrameValues();
|
|
p_328094_.restore(i);
|
|
if (control.hasCut()) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
p_331753_.popFrame();
|
|
return false;
|
|
} finally {
|
|
p_328094_.releaseControl();
|
|
}
|
|
}
|
|
}
|
|
|
|
public record LookAhead<S>(Term<S> term, boolean positive) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_391493_, Scope p_395827_, Control p_391882_) {
|
|
int i = p_391493_.mark();
|
|
boolean flag = this.term.parse(p_391493_.silent(), p_395827_, p_391882_);
|
|
p_391493_.restore(i);
|
|
return this.positive == flag;
|
|
}
|
|
}
|
|
|
|
public record Marker<S, T>(Atom<T> name, T value) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_332878_, Scope p_331621_, Control p_334053_) {
|
|
p_331621_.put(this.name, this.value);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public record Maybe<S>(Term<S> term) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_332001_, Scope p_329861_, Control p_331352_) {
|
|
int i = p_332001_.mark();
|
|
if (!this.term.parse(p_332001_, p_329861_, p_331352_)) {
|
|
p_332001_.restore(i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public record Repeated<S, T>(NamedRule<S, T> element, Atom<List<T>> listName, int minRepetitions) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_393223_, Scope p_397132_, Control p_396901_) {
|
|
int i = p_393223_.mark();
|
|
List<T> list = new ArrayList<>(this.minRepetitions);
|
|
|
|
while (true) {
|
|
int j = p_393223_.mark();
|
|
T t = p_393223_.parse(this.element);
|
|
if (t == null) {
|
|
p_393223_.restore(j);
|
|
if (list.size() < this.minRepetitions) {
|
|
p_393223_.restore(i);
|
|
return false;
|
|
} else {
|
|
p_397132_.put(this.listName, list);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
list.add(t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public record RepeatedWithSeparator<S, T>(NamedRule<S, T> element, Atom<List<T>> listName, Term<S> separator, int minRepetitions, boolean allowTrailingSeparator)
|
|
implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_396935_, Scope p_392276_, Control p_393022_) {
|
|
int i = p_396935_.mark();
|
|
List<T> list = new ArrayList<>(this.minRepetitions);
|
|
boolean flag = true;
|
|
|
|
while (true) {
|
|
int j = p_396935_.mark();
|
|
if (!flag && !this.separator.parse(p_396935_, p_392276_, p_393022_)) {
|
|
p_396935_.restore(j);
|
|
break;
|
|
}
|
|
|
|
int k = p_396935_.mark();
|
|
T t = p_396935_.parse(this.element);
|
|
if (t == null) {
|
|
if (flag) {
|
|
p_396935_.restore(k);
|
|
} else {
|
|
if (!this.allowTrailingSeparator) {
|
|
p_396935_.restore(i);
|
|
return false;
|
|
}
|
|
|
|
p_396935_.restore(k);
|
|
}
|
|
break;
|
|
}
|
|
|
|
list.add(t);
|
|
flag = false;
|
|
}
|
|
|
|
if (list.size() < this.minRepetitions) {
|
|
p_396935_.restore(i);
|
|
return false;
|
|
} else {
|
|
p_392276_.put(this.listName, list);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public record Sequence<S>(Term<S>[] elements) implements Term<S> {
|
|
@Override
|
|
public boolean parse(ParseState<S> p_330195_, Scope p_336361_, Control p_328798_) {
|
|
int i = p_330195_.mark();
|
|
|
|
for (Term<S> term : this.elements) {
|
|
if (!term.parse(p_330195_, p_336361_, p_328798_)) {
|
|
p_330195_.restore(i);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} |