no more trove dep

Parser/src/main/java/org/openzen/zenscript/lexer/CompiledDFA.java

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.map.hash.TIntIntHashMap;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Represents a compiled DFA. A compiled DFA has a compact representation and
 		return new NFA<>(regexps, tokens, tokenClass).compile();
 	}
 	
-    public TIntIntHashMap[] transitions;
+    public Map<Integer, Integer>[] transitions;
     public T[] finals;
 
     /**
      * @param transitions transitions graph
      * @param finals finals
      */
-    public CompiledDFA(TIntIntHashMap[] transitions, T[] finals)
+    public CompiledDFA(Map<Integer, Integer>[] transitions, T[] finals)
 	{
         this.transitions = transitions;
         this.finals = finals;
 	{
         StringBuilder result = new StringBuilder();
         for (int i = 0; i < transitions.length; i++) {
-            TIntIntHashMap map = transitions[i];
+            Map<Integer, Integer> map = transitions[i];
 
-            TIntIterator it = map.keySet().iterator();
+            Iterator<Integer> it = map.keySet().iterator();
             while (it.hasNext()) {
                 int v = it.next();
                 result.append("edge(");

Parser/src/main/java/org/openzen/zenscript/lexer/DFA.java

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.map.hash.TIntIntHashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-import gnu.trove.set.hash.TIntHashSet;
+
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Queue;
+import java.util.Set;
 
 /**
  * Implements a DFA. Used as intermediate form when compiling an NFA to a
 
         while (!todo.isEmpty()) {
             DFAState<T> current = todo.poll();
-
-            TIntIterator it = current.transitions.keySet().iterator();
+    
+            Iterator<Integer> it = current.transitions.keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 DFAState<T> next = current.transitions.get(k);
         }
 
         /* Compile */
-        TIntIntHashMap[] transitions = new TIntIntHashMap[counter];
+        Map<Integer, Integer>[] transitions = new HashMap[counter];
 		@SuppressWarnings("unchecked")
         T[] finals2 = (T[]) Array.newInstance(tokenClass, counter);
 		
         for (DFAState<T> node : nodeList) {
             int index = nodes.get(node);
             finals2[index] = node.finalCode;
-
-            transitions[index] = new TIntIntHashMap();
-            TIntIterator it = node.transitions.keySet().iterator();
+    
+            transitions[index] = new HashMap<>();
+            Iterator<Integer> it = node.transitions.keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 DFAState<T> next = node.transitions.get(k);
     public DFA<T> optimize()
 	{
         CompiledDFA<T> compiled = compile();
-        TIntIntHashMap[] transitions = compiled.transitions;
+        Map<Integer, Integer>[] transitions = compiled.transitions;
         int size = transitions.length;
 
         /* Collect all edges and determine alphabet */
-        TIntHashSet alphabet = new TIntHashSet();
+        Set<Integer> alphabet = new HashSet<>();
         for (int i = 0; i < size; i++) {
-            TIntIterator it = transitions[i].keySet().iterator();
+            Iterator<Integer> it = transitions[i].keySet().iterator();
             while (it.hasNext()) {
                 int k = it.next();
                 alphabet.add(k);
         boolean changed;
         do {
             changed = false;
-            TIntIterator ita = alphabet.iterator();
+            Iterator<Integer> ita = alphabet.iterator();
             while (ita.hasNext()) {
                 int x = ita.next();
                 for (int i = 0; i < size; i++) {
         } while (changed);
 
         /* Group nodes */
-        TIntObjectHashMap<DFAState<T>> nodeMap = new TIntObjectHashMap<>();
+        Map<Integer, DFAState<T>> nodeMap = new HashMap<>();
         outer: for (int i = 0; i < size; i++) {
             for (int j = 0; j < size; j++) {
                 if (!distinguishable[i][j] && nodeMap.containsKey(j)) {
         }
 
         for (int i = 0; i < compiled.transitions.length; i++) {
-            TIntIterator iter = transitions[i].keySet().iterator();
+            Iterator<Integer> iter = transitions[i].keySet().iterator();
             while (iter.hasNext()) {
                 int k = iter.next();
 
         StringBuilder result = new StringBuilder();
         CompiledDFA<T> dfs = compile();
         for (int i = 0; i < dfs.transitions.length; i++) {
-            TIntIntHashMap map = dfs.transitions[i];
-            
-            TIntIterator it = map.keySet().iterator();
+            Map<Integer, Integer> map = dfs.transitions[i];
+    
+            Iterator<Integer> it = map.keySet().iterator();
             while (it.hasNext()) {
                 int v = it.next();
                 result.append("edge(");
      */
     public static class DFAState<T>
 	{
-        private TIntObjectHashMap<DFAState<T>> transitions;
+        
+        private Map<Integer, DFAState<T>> transitions;
         private T finalCode = null;
 
         /**
          * Creates a new DFA state.
          */
         public DFAState() {
-            transitions = new TIntObjectHashMap<>();
+            transitions = new HashMap<>();
         }
 
         /**

Parser/src/main/java/org/openzen/zenscript/lexer/NFA.java

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import gnu.trove.iterator.TIntIterator;
-import gnu.trove.set.hash.TIntHashSet;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
+import java.util.Set;
 
 /**
  * Represents an NFA. NFAs can be compiled from a list of regular expressions.
             NFAState<T> head = new NFAState<>();
             NFAState<T> tail = new NFAState<>();
 
-            TIntIterator iter = processCharList(stream).iterator();
+            Iterator<Integer> iter = processCharList(stream).iterator();
             while (iter.hasNext()) {
                 tail.addTransition(iter.next(), head);
             }
     }
 
     /* Processes a character list */
-    private TIntHashSet processCharList(CharStream stream)
+    private Set<Integer> processCharList(CharStream stream)
 	{
         boolean invert = stream.optional('^');
-        TIntHashSet base = new TIntHashSet();
+        Set<Integer>base = new HashSet();
         do {
             processCharPartial(base, stream);
         } while (!stream.peek(']'));
         if (invert) {
-            TIntHashSet result = new TIntHashSet();
+            Set<Integer>result = new HashSet();
             for (int i = 0; i <= 256; i++) {
                 if (!base.contains(i)) result.add(i);
             }
 
     /* Processes a character partial, which can be a single character or a range
      * of characters. */
-    private void processCharPartial(TIntHashSet out, CharStream stream)
+    private void processCharPartial(Set<Integer>out, CharStream stream)
 	{
         if (stream.optional('.')) {
             for (int i = 0; i <= 256; i++) {

Parser/src/main/java/org/openzen/zenscript/lexer/TokenParser.java

 /* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
 package org.openzen.zenscript.lexer;
 
-import java.io.IOException;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 
+import java.io.IOException;
+
 /**
  * Represents a token stream. A token stream reads characters from a reader and
  * presents it as a series of tokens. Can be used to implement LL(*) parsers.
             while (dfa.transitions[state].containsKey(reader.peek())) {
 				char c = (char) reader.next();
                 value.append(c);
-                state = dfa.transitions[state].get(c);
+                state = dfa.transitions[state].get((int)c);
             }
 			
             if (dfa.finals[state] != null) {

common.gradle

 }
 
 dependencies {
-	compile 'net.sf.trove4j:trove4j:3.0.3'
 }
 
 String mavenArtifactId = name