mirror of
https://github.com/GTNewHorizons/CraftTweaker.git
synced 2026-11-19 11:49:05 +00:00
Added projects and basic build scripts. Project for scripting engine, API, Main 1.7 version and one for each mod supported in 1.7.
This commit is contained in:
1 parent
219106f392
commit
38b78ce305
281 files changed
+25090
-49
No files matched your search
@@ -0,0 +1,574 @@
|
||||
/*
|
||||
* This file is subject to the license.txt file in the main folder
|
||||
* of this project.
|
||||
*/
|
||||
|
||||
package stanhebben.zenscript.parser;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Queue;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Stan Hebben
|
||||
*/
|
||||
public class NFA {
|
||||
public static final int NOFINAL = Integer.MIN_VALUE;
|
||||
public static final int EPSILON = Integer.MIN_VALUE + 1;
|
||||
|
||||
private final NFAState initial;
|
||||
|
||||
private HashMap<NodeSet, DFA.DFAState> converted;
|
||||
|
||||
/**
|
||||
* Creates a new NFA with the specified initial state.
|
||||
*
|
||||
* @param initial initial state
|
||||
*/
|
||||
public NFA(NFAState initial) {
|
||||
this.initial = initial;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new NFA from the specified regular expression.
|
||||
*
|
||||
* Note: the regular expression implementation is not complete. Shorthand
|
||||
* character classes (\s, \w, \d), hexadecimal and unicode escape sequences and
|
||||
* unicode properties are not implemented.
|
||||
*
|
||||
* Anchors, lazy plus operators, lookbehind and lookforward are not implemented
|
||||
* since they cannot be implemented in an NFA.
|
||||
*
|
||||
* @param regexp regular expression
|
||||
*/
|
||||
public NFA(String regexp) {
|
||||
Partial main = processRegExp(new CharStream(regexp));
|
||||
initial = new NFAState();
|
||||
initial.addTransition(main.tailLabel, main.tail);
|
||||
main.head.setFinal(1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts an array of regular expressions to an NFA. Each regular expression
|
||||
* can have its own final class. The length of both arrays must match.
|
||||
*
|
||||
* @param regexp regular expression array
|
||||
* @param finals final classes
|
||||
*/
|
||||
public NFA(String[] regexp, int[] finals) {
|
||||
initial = new NFAState();
|
||||
|
||||
Partial[] partials = new Partial[regexp.length];
|
||||
for (int i = 0; i < regexp.length; i++) {
|
||||
//System.out.println("Processing regexp " + i + ": " + regexp[i]);
|
||||
partials[i] = processRegExp(new CharStream(regexp[i]));
|
||||
partials[i].head.setFinal(finals[i]);
|
||||
initial.addTransition(partials[i].tailLabel, partials[i].tail);
|
||||
}
|
||||
|
||||
//System.out.println("NFA generated");
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts this NFA to a DFA. The resulting DFA is not optimal. If the
|
||||
* NFA is ambiguous, the token with lowest value will receive preference.
|
||||
*
|
||||
* @return this NFA as DFA
|
||||
*/
|
||||
public DFA toDFA() {
|
||||
converted = new HashMap<NodeSet, DFA.DFAState>();
|
||||
HashSet<NFAState> closure = new HashSet<NFAState>();
|
||||
this.initial.closure(closure);
|
||||
DFA.DFAState init = convert(new NodeSet(closure));
|
||||
|
||||
DFA dfs = new DFA(init);
|
||||
return dfs;
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// Private methods
|
||||
////////////////////
|
||||
|
||||
/* Converts a set of possible states to a DFA state. */
|
||||
private DFA.DFAState convert(NodeSet nodes) {
|
||||
if (!converted.containsKey(nodes)) {
|
||||
DFA.DFAState node = new DFA.DFAState();
|
||||
converted.put(nodes, node);
|
||||
|
||||
HashSet<Integer> edgeSet = new HashSet<Integer>();
|
||||
for (NFAState n : nodes.nodes) {
|
||||
n.alphabet(edgeSet);
|
||||
}
|
||||
for (int i : edgeSet) {
|
||||
HashSet<NFAState> edge = new HashSet<NFAState>();
|
||||
for (NFAState n : nodes.nodes) {
|
||||
n.edge(i, edge);
|
||||
}
|
||||
NodeSet set = new NodeSet(edge);
|
||||
node.addTransition(i, convert(set));
|
||||
}
|
||||
int finalCode = DFA.NOFINAL;
|
||||
for (NFAState n : nodes.nodes) {
|
||||
if (n.finalCode != NOFINAL) {
|
||||
if (finalCode != DFA.NOFINAL) {
|
||||
finalCode = Math.min(n.finalCode, finalCode);
|
||||
} else {
|
||||
finalCode = n.finalCode;
|
||||
}
|
||||
}
|
||||
}
|
||||
node.setFinal(finalCode);
|
||||
|
||||
return node;
|
||||
}
|
||||
return converted.get(nodes);
|
||||
}
|
||||
|
||||
/* Processes a regular expression */
|
||||
private Partial processRegExp(CharStream stream) {
|
||||
Partial partial = processRegExp0(stream);
|
||||
if (stream.optional('|')) {
|
||||
ArrayList<Partial> partials = new ArrayList<Partial>();
|
||||
partials.add(partial);
|
||||
partials.add(processRegExp0(stream));
|
||||
while (stream.optional('|')) {
|
||||
partials.add(processRegExp0(stream));
|
||||
}
|
||||
NFAState head = new NFAState();
|
||||
NFAState tail = new NFAState();
|
||||
for (Partial p : partials) {
|
||||
tail.addTransition(p.tailLabel, p.tail);
|
||||
p.head.addTransition(EPSILON, head);
|
||||
}
|
||||
return new Partial(EPSILON, tail, head);
|
||||
} else {
|
||||
return partial;
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes an element of an alternation clause */
|
||||
private Partial processRegExp0(CharStream stream) {
|
||||
Partial partial = processRegExp1(stream);
|
||||
while (!stream.peek(')') && !stream.peek('|') && stream.hasMore()) {
|
||||
Partial partial2 = processRegExp1(stream);
|
||||
partial.head.addTransition(partial2.tailLabel, partial2.tail);
|
||||
partial = new Partial(partial.tailLabel, partial.tail, partial2.head);
|
||||
}
|
||||
return partial;
|
||||
}
|
||||
|
||||
/* Processes a partial with optional repetition */
|
||||
private Partial processRegExp1(CharStream stream) {
|
||||
Partial partial = processPartial(stream);
|
||||
if (stream.optional('*')) {
|
||||
NFAState node = new NFAState();
|
||||
partial.head.addTransition(EPSILON, node);
|
||||
node.addTransition(partial.tailLabel, partial.tail);
|
||||
return new Partial(EPSILON, node, node);
|
||||
} else if (stream.optional('+')) {
|
||||
NFAState node = new NFAState();
|
||||
partial.head.addTransition(EPSILON, node);
|
||||
node.addTransition(partial.tailLabel, partial.tail);
|
||||
return new Partial(partial.tailLabel, partial.tail, node);
|
||||
} else if (stream.optional('?')) {
|
||||
NFAState node = new NFAState();
|
||||
node.addTransition(EPSILON, partial.head);
|
||||
node.addTransition(partial.tailLabel, partial.tail);
|
||||
return new Partial(EPSILON, node, partial.head);
|
||||
} else if (stream.optional('{')) {
|
||||
int amount = processInt(stream);
|
||||
if (amount < 0) throw new IllegalArgumentException("Repitition count expected");
|
||||
if (stream.optional(',')) {
|
||||
int amount2 = processInt(stream);
|
||||
stream.required('}');
|
||||
if (amount2 < 0) {
|
||||
// unbounded
|
||||
Partial[] duplicates = new Partial[amount];
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i] = partial.duplicate();
|
||||
}
|
||||
duplicates[amount - 1] = partial;
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
|
||||
}
|
||||
duplicates[amount - 1].head.addTransition(duplicates[amount - 1].tailLabel, duplicates[amount - 1].tail);
|
||||
return new Partial(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount - 1].head);
|
||||
} else {
|
||||
Partial[] duplicates = new Partial[amount2];
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i] = partial.duplicate();
|
||||
}
|
||||
duplicates[amount2 - 1] = partial;
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
|
||||
}
|
||||
for (int i = amount; i < amount2; i++) {
|
||||
if (i == 0) {
|
||||
/* insert additional node before the chain because minimal repeat is 0 */
|
||||
NFAState additional = new NFAState();
|
||||
additional.addTransition(duplicates[0].tailLabel, duplicates[0].tail);
|
||||
additional.addTransition(EPSILON, duplicates[amount2 - 1].head);
|
||||
duplicates[0].tailLabel = EPSILON;
|
||||
duplicates[0].tail = additional;
|
||||
} else {
|
||||
duplicates[i - 1].head.addTransition(EPSILON, duplicates[amount2 - 1].head);
|
||||
}
|
||||
}
|
||||
return new Partial(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount2 - 1].head);
|
||||
}
|
||||
} else {
|
||||
stream.required('}');
|
||||
|
||||
Partial[] duplicates = new Partial[amount];
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i] = partial.duplicate();
|
||||
}
|
||||
duplicates[amount - 1] = partial;
|
||||
for (int i = 0; i < duplicates.length - 1; i++) {
|
||||
duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
|
||||
}
|
||||
return new Partial(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount - 1].head);
|
||||
}
|
||||
} else {
|
||||
return partial;
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes a part of a regular expression, which can be a character,
|
||||
* expression between brackets, a dot or a character list */
|
||||
private Partial processPartial(CharStream stream) {
|
||||
if (stream.optional('(')) {
|
||||
Partial result = processRegExp(stream);
|
||||
stream.required(')');
|
||||
return result;
|
||||
} else if (stream.optional('[')) {
|
||||
NFAState head = new NFAState();
|
||||
NFAState tail = new NFAState();
|
||||
|
||||
IteratorI iter = processCharList(stream).iterator();
|
||||
while (iter.hasNext()) {
|
||||
tail.addTransition(iter.next(), head);
|
||||
}
|
||||
stream.required(']');
|
||||
return new Partial(EPSILON, tail, head);
|
||||
} else if (stream.optional('.')) {
|
||||
NFAState head = new NFAState();
|
||||
NFAState tail = new NFAState();
|
||||
|
||||
for (int i = 0; i <= 256; i++) {
|
||||
tail.addTransition(i, head);
|
||||
}
|
||||
return new Partial(EPSILON, tail, head);
|
||||
} else {
|
||||
NFAState node = new NFAState();
|
||||
return new Partial(processChar(stream), node, node);
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes a character list */
|
||||
private HashSetI processCharList(CharStream stream) {
|
||||
boolean invert = stream.optional('^');
|
||||
HashSetI base = new HashSetI();
|
||||
do {
|
||||
processCharPartial(base, stream);
|
||||
} while (!stream.peek(']'));
|
||||
if (invert) {
|
||||
HashSetI result = new HashSetI();
|
||||
for (int i = 0; i <= 256; i++) {
|
||||
if (!base.contains(i)) result.add(i);
|
||||
}
|
||||
return result;
|
||||
} else {
|
||||
return base;
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes a character partial, which can be a single character or a range
|
||||
* of characters. */
|
||||
private void processCharPartial(HashSetI out, CharStream stream) {
|
||||
if (stream.optional('.')) {
|
||||
for (int i = 0; i <= 256; i++) {
|
||||
out.add(i);
|
||||
}
|
||||
} else {
|
||||
char from = processChar(stream);
|
||||
if (stream.optional('-')) {
|
||||
char to = processChar(stream);
|
||||
for (int i = from; i <= to; i++) {
|
||||
out.add(i);
|
||||
}
|
||||
} else {
|
||||
out.add(from);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes a single character */
|
||||
private char processChar(CharStream stream) {
|
||||
if (stream.optional('\\')) {
|
||||
if (stream.optional('r')) return '\r';
|
||||
if (stream.optional('n')) return '\n';
|
||||
if (stream.optional('t')) return '\t';
|
||||
if (stream.optional('[')) return '[';
|
||||
if (stream.optional(']')) return ']';
|
||||
if (stream.optional('(')) return '(';
|
||||
if (stream.optional(')')) return ')';
|
||||
if (stream.optional('.')) return '.';
|
||||
if (stream.optional('+')) return '+';
|
||||
if (stream.optional('-')) return '-';
|
||||
if (stream.optional('\\')) return '\\';
|
||||
if (stream.optional('{')) return '{';
|
||||
if (stream.optional('}')) return '}';
|
||||
if (stream.optional('?')) return '?';
|
||||
if (stream.optional('*')) return '*';
|
||||
if (stream.optional('~')) return '~';
|
||||
if (stream.optional('|')) return '|';
|
||||
if (stream.optional('^')) return '^';
|
||||
throw new IllegalArgumentException("Invalid character: " + stream.next());
|
||||
} else {
|
||||
if (stream.peek('[')
|
||||
|| stream.peek(']')
|
||||
|| stream.peek('(')
|
||||
|| stream.peek(')')
|
||||
|| stream.peek('{')
|
||||
|| stream.peek('}')
|
||||
|| stream.peek('.')
|
||||
|| stream.peek('-')
|
||||
|| stream.peek('+')
|
||||
|| stream.peek('?')
|
||||
|| stream.peek('*')) {
|
||||
throw new IllegalArgumentException("Invalid character: " + stream.next());
|
||||
} else {
|
||||
return stream.next();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Processes an optional integer, returns -1 if the next character do not
|
||||
* represent an integer */
|
||||
private int processInt(CharStream stream) {
|
||||
int data = stream.optional('0', '9') - '0';
|
||||
if (data < 0) return -1;
|
||||
char ch = stream.optional('0', '9');
|
||||
while (ch != 0) {
|
||||
data = data * 10 + (ch - '0');
|
||||
ch = stream.optional('0', '9');
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
/////////////////////////
|
||||
// Public inner classes
|
||||
/////////////////////////
|
||||
|
||||
/**
|
||||
* Represents an NFA state.
|
||||
*/
|
||||
public static class NFAState {
|
||||
private static int counter = 1;
|
||||
|
||||
private ArrayList<Transition> transitions;
|
||||
private ArrayList<NFAState> closure;
|
||||
private int index;
|
||||
private int finalCode = NOFINAL;
|
||||
|
||||
/**
|
||||
* Creates a new state.
|
||||
*/
|
||||
public NFAState() {
|
||||
transitions = new ArrayList<Transition>();
|
||||
index = counter++;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a transition.
|
||||
*
|
||||
* @param label transition label
|
||||
* @param next next state
|
||||
*/
|
||||
public void addTransition(int label, NFAState next) {
|
||||
transitions.add(new Transition(label, next));
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the final state of this state.
|
||||
*
|
||||
* @param finalCode
|
||||
*/
|
||||
public void setFinal(int finalCode) {
|
||||
if (this.finalCode == finalCode) return;
|
||||
this.finalCode = finalCode;
|
||||
|
||||
for (Transition t : transitions) {
|
||||
if (t.label == EPSILON) {
|
||||
t.next.setFinal(finalCode);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// Private methods
|
||||
////////////////////
|
||||
|
||||
/**
|
||||
* Determines the (partial) closure of this state.
|
||||
*
|
||||
* @param output output to store the closure in
|
||||
*/
|
||||
private void closure(HashSet<NFAState> output) {
|
||||
for (NFAState node : closure()) output.add(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the (full) closure of this state.
|
||||
*
|
||||
* @return this state's closure
|
||||
*/
|
||||
private ArrayList<NFAState> closure() {
|
||||
if (closure == null) {
|
||||
HashSet<NFAState> tmp = new HashSet<NFAState>();
|
||||
tmp.add(this);
|
||||
for (Transition transition : transitions) {
|
||||
if (transition.label == EPSILON) {
|
||||
if (!tmp.contains(transition.next)) {
|
||||
tmp.add(transition.next);
|
||||
transition.next.closure(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
closure = new ArrayList<NFAState>();
|
||||
for (NFAState node : tmp) closure.add(node);
|
||||
}
|
||||
return closure;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the possible set of states after a transition with the
|
||||
* specified value
|
||||
*
|
||||
* @param label transition label
|
||||
* @param output possible set of states (out)
|
||||
*/
|
||||
private void edge(int label, HashSet<NFAState> output) {
|
||||
for (Transition transition : transitions) {
|
||||
if (transition.label == label) {
|
||||
if (!output.contains(transition.next)) {
|
||||
output.add(transition.next);
|
||||
transition.next.closure(output);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the alphabet of this state.
|
||||
*
|
||||
* @param output alphabet (out)
|
||||
*/
|
||||
private void alphabet(HashSet<Integer> output) {
|
||||
for (NFAState node : closure()) {
|
||||
for (Transition t : node.transitions) {
|
||||
if (t.label != EPSILON) {
|
||||
output.add(t.label);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
////////////////
|
||||
// Inner class
|
||||
////////////////
|
||||
|
||||
/* Represents a transition */
|
||||
private class Transition {
|
||||
private int label;
|
||||
private NFAState next;
|
||||
|
||||
public Transition(int input, NFAState next) {
|
||||
this.label = input;
|
||||
this.next = next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Hashable set of nodes */
|
||||
private class NodeSet {
|
||||
private NFAState[] nodes;
|
||||
|
||||
public NodeSet(HashSet<NFAState> nodes) {
|
||||
this.nodes = new NFAState[nodes.size()];
|
||||
int i = 0;
|
||||
for (NFAState node : nodes) this.nodes[i++] = node;
|
||||
Arrays.sort(this.nodes, new Comparator<NFAState>() {
|
||||
public int compare(NFAState o1, NFAState o2) {
|
||||
return o1.index - o2.index;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Arrays.hashCode(nodes);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object other) {
|
||||
if (other.getClass() != NodeSet.class) return false;
|
||||
return Arrays.equals(nodes, ((NodeSet)other).nodes);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Contains a partially parsed regular expression. Has a head and a tail.
|
||||
*
|
||||
* The tail is a transition and thus has a label and a next node. The head
|
||||
* is the 'final' state of the partial.
|
||||
*/
|
||||
private static class Partial {
|
||||
private int tailLabel;
|
||||
private NFAState tail;
|
||||
private NFAState head;
|
||||
|
||||
/**
|
||||
* Creates a new partial
|
||||
* @param tailLabel tail label
|
||||
* @param tail tail node
|
||||
* @param head head node
|
||||
*/
|
||||
public Partial(int tailLabel, NFAState tail, NFAState head) {
|
||||
this.tailLabel = tailLabel;
|
||||
this.tail = tail;
|
||||
this.head = head;
|
||||
}
|
||||
|
||||
/**
|
||||
* Duplicates the NFA of this partial.
|
||||
*
|
||||
* @return a duplicate of this partial
|
||||
*/
|
||||
public Partial duplicate() {
|
||||
HashMap<NFAState, NFAState> nodes = new HashMap<NFAState, NFAState>();
|
||||
|
||||
Queue<NFAState> todo = new LinkedList<NFAState>();
|
||||
todo.add(tail);
|
||||
nodes.put(tail, new NFAState());
|
||||
while (!todo.isEmpty()) {
|
||||
NFAState node = todo.poll();
|
||||
for (NFAState.Transition t : node.transitions) {
|
||||
if (!nodes.containsKey(t.next)) {
|
||||
nodes.put(t.next, new NFAState());
|
||||
todo.add(t.next);
|
||||
}
|
||||
nodes.get(node).addTransition(t.label, nodes.get(t.next));
|
||||
}
|
||||
}
|
||||
|
||||
return new Partial(tailLabel, nodes.get(tail), nodes.get(head));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user