add stop on node

[ci skip]

.travis.yml

@@ -0,0 +1 @@
+language: java

README.md

@@ -1,2 +1,26 @@
 # abacus
+[![Build Status](https://travis-ci.org/DanilaFe/abacus.svg?branch=master)](https://travis-ci.org/DanilaFe/abacus)
+
 Summer project for NWAPW.
+Created by Arthur Drobot, Danila Fedorin and Riley Jones.
+
+## Project Description
+Abacus is a calculator built with extensibility and usability in mind. It provides a plugin interface, via Java, as Lua provides too difficult to link up to the Java core. The description of the internals of the project can be found on the wiki page.
+
+## Current State
+Abacus is being built for the Northwest Advanced Programming Workshop, a 3 week program in which students work in treams to complete a single project, following principles of agile development. Because of its short timeframe, Abacus is not even close to completed state. Below is a list of the current features and problems.
+- [x] Basic number class
+- [x] Implementation of basic functions 
+- [x] Implementation of `exp`, `ln`, `sqrt` using the basic functions and Taylor Series
+- [x] Plugin loading from JAR files
+- [x] Regular expression pattern construction and matching
+- [x] Infix and postfix operators
+- [ ] __Correct__ handling of postfix operators (`12+!3` parses to `12!+3`, which is wrong)
+- [ ] User-defined precision
+ 
+## Project Proposal
+>There is currently no calculator that is up to par with a sophisticated programmer's needs. The standard system ones are awful, not respecting the order of operations and having only a few basic functions programmed into them. The web ones are tied to the Internet and don't function offline. Physical ones like the TI-84 come close in terms of functionality, but they make the user have to switch between the computer and the device. 
+>
+>My proposal is a more ergonomic calculator for advanced users. Of course, for a calculator, being able to do the actual math is a requirement. However, in this project I also would like to include other features that would make it much more pleasant to use. The first of these features is a wide collection of built in functions, designed with usefulness and consistency in mind. The second is scripting capabilities - most simply using Lua and its provided library. By allowing the users to script in a standardized language that isn't TI-BASIC, the calculator could simplify a variety of tasks and not have to clutter up the default provided functions with overly specific things. Lastly, it's important for the calculator to have a good design that doesn't get in the way of its use, on the two major desktop platforms (macOS and Windows). 
+>
+>With these features I believe that this is a calculator that I would use (and frequently find myself wanting to use). It also seems to have a diverse array of tasks, such as UI design, implementing the math functions to be fast and optimized (fast inverse square root, anyone?), parsing code, and working with Lua integration.

build.gradle

@@ -1,14 +1,6 @@
 apply plugin: 'java'
 apply plugin: 'application'
 
-sourceSets {
-  main {
-    java {
-      srcDirs = ['src']
-    }
-  }
-}
-
 repositories {
   mavenCentral()
 }

src/main/java/org/nwapw/abacus/Abacus.java

@@ -1,15 +1,15 @@
 package org.nwapw.abacus;
 
 import org.nwapw.abacus.config.ConfigurationObject;
-import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.parsing.LexerTokenizer;
+import org.nwapw.abacus.parsing.ShuntingYardParser;
+import org.nwapw.abacus.parsing.TreeBuilder;
 import org.nwapw.abacus.plugin.ClassFinder;
-import org.nwapw.abacus.plugin.PluginListener;
 import org.nwapw.abacus.plugin.PluginManager;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.NumberReducer;
-import org.nwapw.abacus.tree.TreeBuilder;
 import org.nwapw.abacus.tree.TreeNode;
 import org.nwapw.abacus.window.Window;
 
@@ -23,7 +23,7 @@ import java.lang.reflect.InvocationTargetException;
  * for piecing together all of the components, allowing
  * their interaction with each other.
  */
-public class Abacus implements PluginListener {
+public class Abacus {
 
     /**
      * The default implementation to use for the number representation.
@@ -34,21 +34,12 @@ public class Abacus implements PluginListener {
      */
     public static final File CONFIG_FILE = new File("config.toml");
 
-    /**
-     * The main Abacus UI.
-     */
-    private Window mainUi;
     /**
      * The plugin manager responsible for
      * loading and unloading plugins,
      * and getting functions from them.
      */
     private PluginManager pluginManager;
-    /**
-     * Tree builder built from plugin manager,
-     * used to construct parse trees.
-     */
-    private TreeBuilder treeBuilder;
     /**
      * The reducer used to evaluate the tree.
      */
@@ -57,18 +48,29 @@ public class Abacus implements PluginListener {
      * The configuration loaded from a file.
      */
     private ConfigurationObject configuration;
-
+    /**
+     * The tree builder used to construct a tree
+     * from a string.
+     */
+    private TreeBuilder treeBuilder;
+    private Window window;
+    public boolean getStop(){
+        return window.getStop();
+    }
     /**
      * Creates a new instance of the Abacus calculator.
      */
-    public Abacus(){
-        pluginManager = new PluginManager(this);
-        mainUi = new Window(this);
+    public Abacus() {
+        pluginManager = new PluginManager();
         numberReducer = new NumberReducer(this);
         configuration = new ConfigurationObject(CONFIG_FILE);
         configuration.save(CONFIG_FILE);
+        LexerTokenizer lexerTokenizer = new LexerTokenizer();
+        ShuntingYardParser shuntingYardParser = new ShuntingYardParser(this);
+        treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
 
-        pluginManager.addListener(this);
+        pluginManager.addListener(lexerTokenizer);
+        pluginManager.addListener(shuntingYardParser);
         pluginManager.addInstantiated(new StandardPlugin(pluginManager));
         try {
             ClassFinder.loadJars("plugins")
@@ -77,12 +79,21 @@ public class Abacus implements PluginListener {
             e.printStackTrace();
         }
         pluginManager.load();
+    }
 
-        mainUi.setVisible(true);
+    public static void main(String[] args) {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        new Window(new Abacus()).setVisible(true);
     }
 
     /**
      * Gets the current tree builder.
+     *
      * @return the main tree builder in this abacus instance.
      */
     public TreeBuilder getTreeBuilder() {
@@ -91,23 +102,17 @@ public class Abacus implements PluginListener {
 
     /**
      * Gets the current plugin manager,
+     *
      * @return the plugin manager in this abacus instance.
      */
     public PluginManager getPluginManager() {
         return pluginManager;
     }
 
-    /**
-     * Gets the current UI.
-     * @return the UI window in this abacus instance.
-     */
-    public Window getMainUi() {
-        return mainUi;
-    }
-
     /**
      * Get the reducer that is responsible for transforming
      * an expression into a number.
+     *
      * @return the number reducer in this abacus instance.
      */
     public NumberReducer getNumberReducer() {
@@ -116,6 +121,7 @@ public class Abacus implements PluginListener {
 
     /**
      * Gets the configuration object associated with this instance.
+     *
      * @return the configuration object.
      */
     public ConfigurationObject getConfiguration() {
@@ -125,28 +131,35 @@ public class Abacus implements PluginListener {
     /**
      * Parses a string into a tree structure using the main
      * tree builder.
+     *
      * @param input the input string to parse
      * @return the resulting tree, null if the tree builder or the produced tree are null.
      */
-    public TreeNode parseString(String input){
-        if(treeBuilder == null) return null;
-        return treeBuilder.fromString(input);
+    public TreeNode parseString(String input) {
+        return treeBuilder.fromString(input,this);
     }
 
     /**
      * Evaluates the given tree using the main
      * number reducer.
+     *
      * @param tree the tree to reduce, must not be null.
      * @return the resulting number, or null of the reduction failed.
      */
-    public NumberInterface evaluateTree(TreeNode tree){
+    public NumberInterface evaluateTree(TreeNode tree) {
         return tree.reduce(numberReducer);
     }
 
-    public NumberInterface numberFromString(String numberString){
+    /**
+     * Creates a number from a string.
+     *
+     * @param numberString the string to create the number from.
+     * @return the resulting number.
+     */
+    public NumberInterface numberFromString(String numberString) {
         Class<? extends NumberInterface> toInstantiate =
                 pluginManager.numberFor(configuration.getNumberImplementation());
-        if(toInstantiate == null) toInstantiate = DEFAULT_NUMBER;
+        if (toInstantiate == null) toInstantiate = DEFAULT_NUMBER;
 
         try {
             return toInstantiate.getConstructor(String.class).newInstance(numberString);
@@ -156,33 +169,7 @@ public class Abacus implements PluginListener {
         return null;
     }
 
-    @Override
-    public void onLoad(PluginManager manager) {
-        treeBuilder = new TreeBuilder(this);
-        for(String function : manager.getAllFunctions()){
-            treeBuilder.registerFunction(function);
-        }
-        for(String operator : manager.getAllOperators()){
-            Operator operatorObject = manager.operatorFor(operator);
-            treeBuilder.registerOperator(operator,
-                    operatorObject.getAssociativity(),
-                    operatorObject.getType(),
-                    operatorObject.getPrecedence());
-        }
-    }
-
-    @Override
-    public void onUnload(PluginManager manager) {
-        treeBuilder = null;
-    }
-
-    public static void main(String[] args){
-        try {
-            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-        new Abacus();
+    public void setWindow(Window window) {
+        this.window = window;
     }
 }

src/main/java/org/nwapw/abacus/config/ConfigurationObject.java

@@ -23,56 +23,12 @@ public class ConfigurationObject {
      */
     private Configuration configuration;
 
-    /**
-     * Sets up the ConfigurationObject.
-     * different constructors do different things,
-     * but they all lead here.
-     * @param configuration the configuration to set up with.
-     */
-    private void setup(Configuration configuration){
-        this.configuration = configuration;
-    }
-
-    /**
-     * Creates a default configuration.
-     * @return the newly created default configuration.
-     */
-    private Configuration getDefaultConfig(){
-        configuration = new Configuration();
-        configuration.numberType = "naive";
-        return configuration;
-    }
-
-    /**
-     * Returns the implementation the user has requested to
-     * represent their numbers.
-     * @return the implementation name.
-     */
-    public String getNumberImplementation() {
-        return configuration.numberType;
-    }
-
-    /**
-     * Saves the ConfigurationObject to the given file.
-     * @param toFile the file to save ot.
-     * @return true if the save succeed, false if otherwise.
-     */
-    public boolean save(File toFile){
-        if(toFile.getParentFile() != null) toFile.getParentFile().mkdirs();
-        try {
-            TOML_WRITER.write(configuration, toFile);
-            return true;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
     /**
      * Creates a new configuration object with the given config.
+     *
      * @param config the config to use.
      */
-    public ConfigurationObject(Configuration config){
+    public ConfigurationObject(Configuration config) {
         setup(config);
     }
 
@@ -80,11 +36,12 @@ public class ConfigurationObject {
      * Create a configuration object by attempting to
      * load a config from the given path, using the
      * default configuration otherwise.
+     *
      * @param path the path to attempt to load.
      */
-    public ConfigurationObject(File path){
+    public ConfigurationObject(File path) {
         Configuration config;
-        if(!path.exists()) {
+        if (!path.exists()) {
             config = getDefaultConfig();
         } else {
             Toml parse = new Toml();
@@ -98,8 +55,57 @@ public class ConfigurationObject {
      * Creates a new configuration object with the
      * default configuration.
      */
-    public ConfigurationObject(){
+    public ConfigurationObject() {
         setup(getDefaultConfig());
     }
 
+    /**
+     * Sets up the ConfigurationObject.
+     * different constructors do different things,
+     * but they all lead here.
+     *
+     * @param configuration the configuration to set up with.
+     */
+    private void setup(Configuration configuration) {
+        this.configuration = configuration;
+    }
+
+    /**
+     * Creates a default configuration.
+     *
+     * @return the newly created default configuration.
+     */
+    private Configuration getDefaultConfig() {
+        configuration = new Configuration();
+        configuration.numberType = "naive";
+        return configuration;
+    }
+
+    /**
+     * Returns the implementation the user has requested to
+     * represent their numbers.
+     *
+     * @return the implementation name.
+     */
+    public String getNumberImplementation() {
+        return configuration.numberType;
+    }
+
+    /**
+     * Saves the ConfigurationObject to the given file.
+     *
+     * @param toFile the file to save ot.
+     * @return true if the save succeed, false if otherwise.
+     */
+    public boolean save(File toFile) {
+        if (toFile.getParentFile() != null) toFile.getParentFile().mkdirs();
+        try {
+            TOML_WRITER.write(configuration, toFile);
+            return true;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
 }

src/main/java/org/nwapw/abacus/function/Function.java

@@ -23,6 +23,7 @@ public abstract class Function {
 
     /**
      * Checks whether the given params will work for the given function.
+     *
      * @param params the given params
      * @return true if the params can be used with this function.
      */
@@ -31,6 +32,7 @@ public abstract class Function {
     /**
      * Internal apply implementation, which already receives appropriately promoted
      * parameters that have bee run through matchesParams
+     *
      * @param params the promoted parameters.
      * @return the return value of the function.
      */
@@ -38,11 +40,12 @@ public abstract class Function {
 
     /**
      * Function to check, promote arguments and run the function.
+     *
      * @param params the raw input parameters.
      * @return the return value of the function, or null if an error occurred.
      */
-    public NumberInterface apply(NumberInterface...params) {
-        if(!matchesParams(params)) return null;
+    public NumberInterface apply(NumberInterface... params) {
+        if (!matchesParams(params)) return null;
         return applyInternal(params);
     }
 

src/main/java/org/nwapw/abacus/function/Operator.java

@@ -24,11 +24,12 @@ public class Operator {
 
     /**
      * Creates a new operator with the given parameters.
+     *
      * @param associativity the associativity of the operator.
      * @param precedence    the precedence of the operator.
      * @param function      the function that the operator calls.
      */
-    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function){
+    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function) {
         this.associativity = associativity;
         this.type = operatorType;
         this.precedence = precedence;
@@ -37,6 +38,7 @@ public class Operator {
 
     /**
      * Gets the operator's associativity.
+     *
      * @return the associativity.
      */
     public OperatorAssociativity getAssociativity() {
@@ -45,6 +47,7 @@ public class Operator {
 
     /**
      * Gets the operator's type.
+     *
      * @return the type.
      */
     public OperatorType getType() {
@@ -53,6 +56,7 @@ public class Operator {
 
     /**
      * Gets the operator's precedence.
+     *
      * @return the precedence.
      */
     public int getPrecedence() {
@@ -61,6 +65,7 @@ public class Operator {
 
     /**
      * Gets the operator's function.
+     *
      * @return the function.
      */
     public Function getFunction() {

src/main/java/org/nwapw/abacus/lexing/Lexer.java

@@ -10,15 +10,111 @@ import java.util.*;
 /**
  * A lexer that can generate tokens of a given type given a list of regular expressions
  * to operate on.
+ *
  * @param <T> the type used to identify which match belongs to which pattern.
  */
 public class Lexer<T> {
 
+    /**
+     * The registered patterns.
+     */
+    private Map<PatternEntry<T>, Pattern<T>> patterns;
+
+    /**
+     * Creates a new lexer with no registered patterns.
+     */
+    public Lexer() {
+        patterns = new HashMap<>();
+    }
+
+    /**
+     * Registers a single pattern.
+     *
+     * @param pattern the pattern regex
+     * @param id      the ID by which to identify the pattern.
+     */
+    public void register(String pattern, T id) {
+        Pattern<T> compiledPattern = new Pattern<>(pattern, id);
+        if (compiledPattern.getHead() != null) patterns.put(new PatternEntry<>(pattern, id), compiledPattern);
+    }
+
+    /**
+     * Unregisters a pattern.
+     *
+     * @param pattern the pattern to unregister
+     * @param id      the ID by which to identify the pattern.
+     */
+    public void unregister(String pattern, T id) {
+        patterns.remove(new PatternEntry<>(pattern, id));
+    }
+
+    /**
+     * Reads one token from the given string.
+     *
+     * @param from    the string to read from
+     * @param startAt the index to start at
+     * @param compare the comparator used to sort tokens by their ID.
+     * @return the best match.
+     */
+    public Match<T> lexOne(String from, int startAt, Comparator<T> compare) {
+        ArrayList<Match<T>> matches = new ArrayList<>();
+        HashSet<PatternNode<T>> currentSet = new HashSet<>();
+        HashSet<PatternNode<T>> futureSet = new HashSet<>();
+        int index = startAt;
+        for (Pattern<T> pattern : patterns.values()) {
+            pattern.getHead().addInto(currentSet);
+        }
+        while (!currentSet.isEmpty()) {
+            for (PatternNode<T> node : currentSet) {
+                if (index < from.length() && node.matches(from.charAt(index))) {
+                    node.addOutputsInto(futureSet);
+                } else if (node instanceof EndNode) {
+                    matches.add(new Match<>(from.substring(startAt, index), ((EndNode<T>) node).getPatternId()));
+                }
+            }
+
+            HashSet<PatternNode<T>> tmp = currentSet;
+            currentSet = futureSet;
+            futureSet = tmp;
+            futureSet.clear();
+
+            index++;
+        }
+        matches.sort((a, b) -> compare.compare(a.getType(), b.getType()));
+        if (compare != null) {
+            matches.sort(Comparator.comparingInt(a -> a.getContent().length()));
+        }
+        return matches.isEmpty() ? null : matches.get(matches.size() - 1);
+    }
+
+    /**
+     * Reads all tokens from a string.
+     *
+     * @param from    the string to start from.
+     * @param startAt the index to start at.
+     * @param compare the comparator used to sort matches by their IDs.
+     * @return the resulting list of matches, in order, or null on error.
+     */
+    public List<Match<T>> lexAll(String from, int startAt, Comparator<T> compare) {
+        int index = startAt;
+        ArrayList<Match<T>> matches = new ArrayList<>();
+        Match<T> lastMatch = null;
+        while (index < from.length() && (lastMatch = lexOne(from, index, compare)) != null) {
+            int length = lastMatch.getContent().length();
+            if (length == 0) return null;
+            matches.add(lastMatch);
+            index += length;
+        }
+        if (lastMatch == null) return null;
+        return matches;
+    }
+
     /**
      * An entry that represents a pattern that has been registered with the lexer.
+     *
      * @param <T> the type used to identify the pattern.
      */
-    private static class PatternEntry<T>{
+    private static class PatternEntry<T> {
         /**
          * The name of the entry.
          */
@@ -30,10 +126,11 @@ public class Lexer<T> {
 
         /**
          * Creates a new pattern entry with the given name and id.
+         *
          * @param name the name of the pattern entry.
          * @param id   the id of the pattern entry.
          */
-        public PatternEntry(String name, T id){
+        public PatternEntry(String name, T id) {
             this.name = name;
             this.id = id;
         }
@@ -51,93 +148,4 @@ public class Lexer<T> {
         }
     }
 
-    /**
-     * The registered patterns.
-     */
-    private Map<PatternEntry<T>, Pattern<T>> patterns;
-
-    /**
-     * Creates a new lexer with no registered patterns.
-     */
-    public Lexer(){
-        patterns = new HashMap<>();
-    }
-
-    /**
-     * Registers a single pattern.
-     * @param pattern the pattern regex
-     * @param id the ID by which to identify the pattern.
-     */
-    public void register(String pattern, T id){
-        Pattern<T> compiledPattern = new Pattern<>(pattern, id);
-        if(compiledPattern.getHead() != null) patterns.put(new PatternEntry<>(pattern, id), compiledPattern);
-    }
-
-    /**
-     * Unregisters a pattern.
-     * @param pattern the pattern to unregister
-     * @param id the ID by which to identify the pattern.
-     */
-    public void unregister(String pattern, T id){
-        patterns.remove(new PatternEntry<>(pattern, id));
-    }
-
-    /**
-     * Reads one token from the given string.
-     * @param from the string to read from
-     * @param startAt the index to start at
-     * @param compare the comparator used to sort tokens by their ID.
-     * @return the best match.
-     */
-    public Match<T> lexOne(String from, int startAt, Comparator<T> compare){
-        ArrayList<Match<T>> matches = new ArrayList<>();
-        HashSet<PatternNode<T>> currentSet = new HashSet<>();
-        HashSet<PatternNode<T>> futureSet = new HashSet<>();
-        int index = startAt;
-        for(Pattern<T> pattern : patterns.values()){
-            pattern.getHead().addInto(currentSet);
-        }
-        while(!currentSet.isEmpty()){
-            for(PatternNode<T> node : currentSet){
-                if(index < from.length() && node.matches(from.charAt(index))) {
-                    node.addOutputsInto(futureSet);
-                } else if(node instanceof EndNode){
-                    matches.add(new Match<>(startAt, index, ((EndNode<T>) node).getPatternId()));
-                }
-            }
-
-            HashSet<PatternNode<T>> tmp = currentSet;
-            currentSet = futureSet;
-            futureSet = tmp;
-            futureSet.clear();
-
-            index++;
-        }
-        matches.sort((a, b) -> compare.compare(a.getType(), b.getType()));
-        if(compare != null) {
-            matches.sort(Comparator.comparingInt(a -> a.getTo() - a.getFrom()));
-        }
-        return matches.isEmpty() ? null : matches.get(matches.size() - 1);
-    }
-
-    /**
-     * Reads all tokens from a string.
-     * @param from the string to start from.
-     * @param startAt the index to start at.
-     * @param compare the comparator used to sort matches by their IDs.
-     * @return the resulting list of matches, in order, or null on error.
-     */
-    public List<Match<T>> lexAll(String from, int startAt, Comparator<T> compare){
-        int index = startAt;
-        ArrayList<Match<T>> matches = new ArrayList<>();
-        Match<T> lastMatch = null;
-        while(index < from.length() && (lastMatch = lexOne(from, index, compare)) != null){
-            if(lastMatch.getTo() == lastMatch.getFrom()) return null;
-            matches.add(lastMatch);
-            index += lastMatch.getTo() - lastMatch.getFrom();
-        }
-        if(lastMatch == null) return null;
-        return matches;
-    }
-
 }

src/main/java/org/nwapw/abacus/lexing/pattern/AnyNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A pattern node that matches any character.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class AnyNode<T> extends PatternNode<T> {

src/main/java/org/nwapw/abacus/lexing/pattern/EndNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that represents a successful match.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class EndNode<T> extends PatternNode<T> {
@@ -13,17 +14,19 @@ public class EndNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new end node with the given ID.
+     *
      * @param patternId the pattern ID.
      */
-    public EndNode(T patternId){
+    public EndNode(T patternId) {
         this.patternId = patternId;
     }
 
     /**
      * Gets the pattern ID.
+     *
      * @return the pattern ID.
      */
-    public T getPatternId(){
+    public T getPatternId() {
         return patternId;
     }
 

src/main/java/org/nwapw/abacus/lexing/pattern/LinkNode.java

@@ -1,17 +1,17 @@
 package org.nwapw.abacus.lexing.pattern;
 
-import java.util.ArrayList;
 import java.util.Collection;
 
 /**
  * A node that is used as structural glue in pattern compilation.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class LinkNode<T> extends PatternNode<T> {
 
     @Override
     public void addInto(Collection<PatternNode<T>> into) {
-        if(!into.contains(this)) {
+        if (!into.contains(this)) {
             into.add(this);
             addOutputsInto(into);
         }

src/main/java/org/nwapw/abacus/lexing/pattern/Match.java

@@ -0,0 +1,47 @@
+package org.nwapw.abacus.lexing.pattern;
+
+/**
+ * A match that has been generated by the lexer.
+ *
+ * @param <T> the type used to represent the ID of the pattern this match belongs to.
+ */
+public class Match<T> {
+
+    /**
+     * The content of this match.
+     */
+    private String content;
+    /**
+     * The pattern type this match matched.
+     */
+    private T type;
+
+    /**
+     * Creates a new match with the given parameters.
+     *
+     * @param content the content of this match.
+     * @param type    the type of the match.
+     */
+    public Match(String content, T type) {
+        this.content = content;
+        this.type = type;
+    }
+
+    /**
+     * Gets the content of this match.
+     *
+     * @return the content.
+     */
+    public String getContent() {
+        return content;
+    }
+
+    /**
+     * Gets the pattern type of the node.
+     *
+     * @return the ID of the pattern that this match matched.
+     */
+    public T getType() {
+        return type;
+    }
+}

src/main/java/org/nwapw/abacus/lexing/pattern/Pattern.java

@@ -8,6 +8,7 @@ import java.util.function.Function;
 
 /**
  * A pattern that can be compiled from a string and used in lexing.
+ *
  * @param <T> the type that is used to identify and sort this pattern.
  */
 public class Pattern<T> {
@@ -40,13 +41,53 @@ public class Pattern<T> {
                 put('?', Pattern.this::transformQuestion);
             }};
 
+    /**
+     * Creates / compiles a new pattern with the given id from the given string.
+     *
+     * @param from the string to compile a pattern from.
+     * @param id   the ID to use.
+     */
+    public Pattern(String from, T id) {
+        this.id = id;
+        index = 0;
+        source = from;
+
+        PatternChain<T> chain = parseSegment(false);
+        if (chain == null) {
+            head = null;
+        } else {
+            chain.append(new EndNode<>(id));
+            head = chain.head;
+        }
+    }
+
+    /**
+     * Removes all characters that are considered "special" from
+     * the given string.
+     *
+     * @param from the string to sanitize.
+     * @return the resulting string.
+     */
+    public static String sanitize(String from) {
+        Pattern<Integer> pattern = new Pattern<>("", 0);
+        from = from.replace(".", "\\.");
+        from = from.replace("|", "\\|");
+        from = from.replace("(", "\\(");
+        from = from.replace(")", "\\)");
+        for (Character key : pattern.operations.keySet()) {
+            from = from.replace("" + key, "\\" + key);
+        }
+        return from;
+    }
+
     /**
      * A regex operator function that turns the chain
      * into a one-or-more chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformPlus(PatternChain<T> chain){
+    private PatternChain<T> transformPlus(PatternChain<T> chain) {
         chain.tail.outputStates.add(chain.head);
         return chain;
     }
@@ -54,10 +95,11 @@ public class Pattern<T> {
     /**
      * A regex operator function that turns the chain
      * into a zero-or-more chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformStar(PatternChain<T> chain){
+    private PatternChain<T> transformStar(PatternChain<T> chain) {
         LinkNode<T> newTail = new LinkNode<>();
         LinkNode<T> newHead = new LinkNode<>();
         newHead.outputStates.add(chain.head);
@@ -72,10 +114,11 @@ public class Pattern<T> {
     /**
      * A regex operator function that turns the chain
      * into a zero-or-one chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformQuestion(PatternChain<T> chain){
+    private PatternChain<T> transformQuestion(PatternChain<T> chain) {
         LinkNode<T> newTail = new LinkNode<>();
         LinkNode<T> newHead = new LinkNode<>();
         newHead.outputStates.add(chain.head);
@@ -88,14 +131,15 @@ public class Pattern<T> {
 
     /**
      * Combines a collection of chains into one OR chain.
+     *
      * @param collection the collection of chains to combine.
      * @return the resulting OR chain.
      */
-    private PatternChain<T> combineChains(Collection<PatternChain<T>> collection){
+    private PatternChain<T> combineChains(Collection<PatternChain<T>> collection) {
         LinkNode<T> head = new LinkNode<>();
         LinkNode<T> tail = new LinkNode<>();
         PatternChain<T> newChain = new PatternChain<>(head, tail);
-        for(PatternChain<T> chain : collection){
+        for (PatternChain<T> chain : collection) {
             head.outputStates.add(chain.head);
             chain.tail.outputStates.add(tail);
         }
@@ -104,105 +148,108 @@ public class Pattern<T> {
 
     /**
      * Parses a single value from the input into a chain.
+     *
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseValue(){
-        if(index >= source.length()) return null;
-        if(source.charAt(index) == '\\'){
-            if(++index >= source.length()) return null;
+    private PatternChain<T> parseValue() {
+        if (index >= source.length()) return null;
+        if (source.charAt(index) == '\\') {
+            if (++index >= source.length()) return null;
         }
         return new PatternChain<>(new ValueNode<>(source.charAt(index++)));
     }
 
     /**
      * Parses a [] range from the input into a chain.
+     *
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseOr(){
+    private PatternChain<T> parseOr() {
         Stack<PatternChain<T>> orStack = new Stack<>();
         index++;
-        while(index < source.length() && source.charAt(index) != ']'){
-            if(source.charAt(index) == '-'){
+        while (index < source.length() && source.charAt(index) != ']') {
+            if (source.charAt(index) == '-') {
                 index++;
-                if(orStack.empty() || orStack.peek().tail.range() == '\0') return null;
+                if (orStack.empty() || orStack.peek().tail.range() == '\0') return null;
                 PatternChain<T> bottomRange = orStack.pop();
                 PatternChain<T> topRange = parseValue();
-                if(topRange == null || topRange.tail.range() == '\0') return null;
+                if (topRange == null || topRange.tail.range() == '\0') return null;
 
                 orStack.push(new PatternChain<>(new RangeNode<>(bottomRange.tail.range(), topRange.tail.range())));
             } else {
                 PatternChain<T> newChain = parseValue();
-                if(newChain == null) return null;
+                if (newChain == null) return null;
                 orStack.push(newChain);
             }
         }
-        if(index++ >= source.length()) return null;
+        if (index++ >= source.length()) return null;
         return (orStack.size() == 1) ? orStack.pop() : combineChains(orStack);
     }
 
     /**
      * Parses a repeatable segment from the input into a chain
+     *
      * @param isSubsegment whether the segment is a sub-expression "()", and therefore
      *                     whether to expect a closing brace.
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseSegment(boolean isSubsegment){
-        if(index >= source.length() || ((source.charAt(index) != '(') && isSubsegment)) return null;
-        if(isSubsegment) index++;
+    private PatternChain<T> parseSegment(boolean isSubsegment) {
+        if (index >= source.length() || ((source.charAt(index) != '(') && isSubsegment)) return null;
+        if (isSubsegment) index++;
 
         Stack<PatternChain<T>> orChain = new Stack<>();
         PatternChain<T> fullChain = new PatternChain<>();
         PatternChain<T> currentChain = null;
-        while (index < source.length() && source.charAt(index) != ')'){
+        while (index < source.length() && source.charAt(index) != ')') {
             char currentChar = source.charAt(index);
-            if(operations.containsKey(currentChar)){
-                if(currentChain == null) return null;
+            if (operations.containsKey(currentChar)) {
+                if (currentChain == null) return null;
 
                 currentChain = operations.get(currentChar).apply(currentChain);
                 fullChain.append(currentChain);
                 currentChain = null;
                 index++;
-            } else if(currentChar == '|'){
-                if(currentChain == null) return null;
+            } else if (currentChar == '|') {
+                if (currentChain == null) return null;
 
                 fullChain.append(currentChain);
                 orChain.push(fullChain);
                 currentChain = null;
                 fullChain = new PatternChain<>();
-                if(++index >= source.length()) return null;
-            } else if(currentChar == '('){
-                if(currentChain != null) {
+                if (++index >= source.length()) return null;
+            } else if (currentChar == '(') {
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
 
                 currentChain = parseSegment(true);
-                if(currentChain == null) return null;
-            } else if(currentChar == '['){
-                if(currentChain != null){
+                if (currentChain == null) return null;
+            } else if (currentChar == '[') {
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = parseOr();
-                if(currentChain == null) return null;
-            } else if(currentChar == '.'){
-                if(currentChain != null){
+                if (currentChain == null) return null;
+            } else if (currentChar == '.') {
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = new PatternChain<>(new AnyNode<>());
                 index++;
             } else {
-                if(currentChain != null){
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = parseValue();
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
             }
         }
 
-        if(!(!isSubsegment || (index < source.length() && source.charAt(index) == ')'))) return null;
-        if(isSubsegment) index++;
+        if (!(!isSubsegment || (index < source.length() && source.charAt(index) == ')'))) return null;
+        if (isSubsegment) index++;
 
-        if(currentChain != null) fullChain.append(currentChain);
-        if(!orChain.empty()){
+        if (currentChain != null) fullChain.append(currentChain);
+        if (!orChain.empty()) {
             orChain.push(fullChain);
             fullChain = combineChains(orChain);
         }
@@ -210,48 +257,12 @@ public class Pattern<T> {
         return fullChain;
     }
 
-    /**
-     * Creates / compiles a new pattern with the given id from the given string.
-     * @param from the string to compile a pattern from.
-     * @param id the ID to use.
-     */
-    public Pattern(String from, T id){
-        this.id = id;
-        index = 0;
-        source = from;
-
-        PatternChain<T> chain = parseSegment(false);
-        if(chain == null) {
-            head = null;
-        } else {
-            chain.append(new EndNode<>(id));
-            head = chain.head;
-        }
-    }
-
     /**
      * Gets the head PatternNode, for use in matching
+     *
      * @return the pattern node.
      */
     public PatternNode<T> getHead() {
         return head;
     }
-
-    /**
-     * Removes all characters that are considered "special" from
-     * the given string.
-     * @param from the string to sanitize.
-     * @return the resulting string.
-     */
-    public static String sanitize(String from){
-        Pattern<Integer> pattern = new Pattern<>("", 0);
-        from = from.replace(".", "\\.");
-        from = from.replace("|", "\\|");
-        from = from.replace("(", "\\(");
-        from = from.replace(")", "\\)");
-        for(Character key : pattern.operations.keySet()){
-            from = from.replace("" + key, "\\" + key);
-        }
-        return from;
-    }
 }

src/main/java/org/nwapw/abacus/lexing/pattern/PatternChain.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.lexing.pattern;
 /**
  * A chain of nodes that can be treated as a single unit.
  * Used during pattern compilation.
+ *
  * @param <T> the type used to identify which pattern has been matched.
  */
 public class PatternChain<T> {
@@ -18,26 +19,28 @@ public class PatternChain<T> {
 
     /**
      * Creates a new chain with the given start and end.
+     *
      * @param head the start of the chain.
      * @param tail the end of the chain.
      */
-    public PatternChain(PatternNode<T> head, PatternNode<T> tail){
+    public PatternChain(PatternNode<T> head, PatternNode<T> tail) {
         this.head = head;
         this.tail = tail;
     }
 
     /**
      * Creates a chain that starts and ends with the same node.
+     *
      * @param node the node to use.
      */
-    public PatternChain(PatternNode<T> node){
+    public PatternChain(PatternNode<T> node) {
         this(node, node);
     }
 
     /**
      * Creates an empty chain.
      */
-    public PatternChain(){
+    public PatternChain() {
         this(null);
     }
 
@@ -45,10 +48,11 @@ public class PatternChain<T> {
      * Appends the other chain to this one. This modifies
      * the nodes, as well.
      * If this chain is empty, it is set to the other.
+     *
      * @param other the other chain to append.
      */
-    public void append(PatternChain<T> other){
-        if(other.head == null || tail == null) {
+    public void append(PatternChain<T> other) {
+        if (other.head == null || tail == null) {
             this.head = other.head;
             this.tail = other.tail;
         } else {
@@ -61,10 +65,11 @@ public class PatternChain<T> {
      * Appends a single node to this chain. This modifies
      * the nodes, as well.
      * If this chain is empty, it is set to the node.
+     *
      * @param node the node to append to this chain.
      */
-    public void append(PatternNode<T> node){
-        if(tail == null){
+    public void append(PatternNode<T> node) {
+        if (tail == null) {
             head = tail = node;
         } else {
             tail.outputStates.add(node);

src/main/java/org/nwapw/abacus/lexing/pattern/PatternNode.java

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.lexing.pattern;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
@@ -9,6 +8,7 @@ import java.util.Set;
  * A base class for a pattern node. Provides all functions
  * necessary for matching, and is constructed by a Pattern instance
  * from a string.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class PatternNode<T> {
@@ -22,42 +22,46 @@ public class PatternNode<T> {
     /**
      * Creates a new pattern node.
      */
-    public PatternNode(){
+    public PatternNode() {
         outputStates = new HashSet<>();
     }
 
     /**
      * Determines whether the current input character can
      * be matched by this node.
+     *
      * @param other the character being matched.
      * @return true if the character can be matched, false otherwise.
      */
-    public boolean matches(char other){
+    public boolean matches(char other) {
         return false;
     }
 
     /**
      * If this node can be used as part of a range, returns that value.
+     *
      * @return a NULL terminator if this character cannot be converted
      * into a range bound, or the appropriate range bound if it can.
      */
-    public char range(){
+    public char range() {
         return '\0';
     }
 
     /**
      * Adds this node in a collection of other nodes.
+     *
      * @param into the collection to add into.
      */
-    public void addInto(Collection<PatternNode<T>> into){
+    public void addInto(Collection<PatternNode<T>> into) {
         into.add(this);
     }
 
     /**
      * Adds the node's children into a collection of other nodes.
+     *
      * @param into the collection to add into.
      */
-    public void addOutputsInto(Collection<PatternNode<T>> into){
+    public void addOutputsInto(Collection<PatternNode<T>> into) {
         outputStates.forEach(e -> e.addInto(into));
     }
 

src/main/java/org/nwapw/abacus/lexing/pattern/RangeNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that matches a range of characters.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class RangeNode<T> extends PatternNode<T> {
@@ -17,10 +18,11 @@ public class RangeNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new range node from the given range.
+     *
      * @param from the bottom bound of the range.
      * @param to   the top bound of hte range.
      */
-    public RangeNode(char from, char to){
+    public RangeNode(char from, char to) {
         this.from = from;
         this.to = to;
     }

src/main/java/org/nwapw/abacus/lexing/pattern/ValueNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that matches a single value.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class ValueNode<T> extends PatternNode<T> {
@@ -13,9 +14,10 @@ public class ValueNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new node that matches the given character.
+     *
      * @param value
      */
-    public ValueNode(char value){
+    public ValueNode(char value) {
         this.value = value;
     }
 

src/main/java/org/nwapw/abacus/number/NaiveNumber.java

@@ -5,26 +5,6 @@ package org.nwapw.abacus.number;
  */
 public class NaiveNumber implements NumberInterface {
 
-    /**
-     * The value of this number.
-     */
-    private double value;
-
-    /**
-     * Creates a new NaiveNumber with the given string.
-     * @param value the value, which will be parsed as a double.
-     */
-    public NaiveNumber(String value) {
-        this(Double.parseDouble(value));
-    }
-    /**
-     * Creates a new NaiveNumber with the given value.
-     * @param value the value to use.
-     */
-    public NaiveNumber(double value) {
-        this.value = value;
-    }
-
     /**
      * The number zero.
      */
@@ -33,6 +13,27 @@ public class NaiveNumber implements NumberInterface {
      * The number one.
      */
     public static final NaiveNumber ONE = new NaiveNumber(1);
+    /**
+     * The value of this number.
+     */
+    private double value;
+
+    /**
+     * Creates a new NaiveNumber with the given string.
+     *
+     * @param value the value, which will be parsed as a double.
+     */
+    public NaiveNumber(String value) {
+        this(Double.parseDouble(value));
+    }
+    /**
+     * Creates a new NaiveNumber with the given value.
+     *
+     * @param value the value to use.
+     */
+    public NaiveNumber(double value) {
+        this.value = value;
+    }
 
     @Override
     public int getMaxPrecision() {
@@ -41,22 +42,22 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface multiply(NumberInterface multiplier) {
-        return new NaiveNumber(value * ((NaiveNumber)multiplier).value);
+        return new NaiveNumber(value * ((NaiveNumber) multiplier).value);
     }
 
     @Override
     public NumberInterface divide(NumberInterface divisor) {
-        return new NaiveNumber(value / ((NaiveNumber)divisor).value);
+        return new NaiveNumber(value / ((NaiveNumber) divisor).value);
     }
 
     @Override
     public NumberInterface add(NumberInterface summand) {
-        return new NaiveNumber(value + ((NaiveNumber)summand).value);
+        return new NaiveNumber(value + ((NaiveNumber) summand).value);
     }
 
     @Override
     public NumberInterface subtract(NumberInterface subtrahend) {
-        return new NaiveNumber(value - ((NaiveNumber)subtrahend).value);
+        return new NaiveNumber(value - ((NaiveNumber) subtrahend).value);
     }
 
     @Override
@@ -66,16 +67,16 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface intPow(int exponent) {
-        if(exponent == 0){
+        if (exponent == 0) {
             return NaiveNumber.ONE;
         }
         boolean takeReciprocal = exponent < 0;
         exponent = Math.abs(exponent);
         NumberInterface power = this;
-        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
             power = power.multiply(this);
         }
-        if(takeReciprocal){
+        if (takeReciprocal) {
             power = NaiveNumber.ONE.divide(power);
         }
         return power;
@@ -94,14 +95,14 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        if(toClass == this.getClass()) return this;
-        else if(toClass == PreciseNumber.class){
+        if (toClass == this.getClass()) return this;
+        else if (toClass == PreciseNumber.class) {
             return new PreciseNumber(Double.toString(value));
         }
         return null;
     }
 
-    public String toString(){
+    public String toString() {
         double shiftBy = Math.pow(10, 10);
         return Double.toString(Math.round(value * shiftBy) / shiftBy);
     }

src/main/java/org/nwapw/abacus/number/NumberInterface.java

@@ -7,6 +7,7 @@ public interface NumberInterface {
 
     /**
      * The maximum precision to which this number operates.
+     *
      * @return the precision.
      */
     int getMaxPrecision();
@@ -14,27 +15,34 @@ public interface NumberInterface {
     /**
      * Multiplies this number by another, returning
      * a new number instance.
+     *
      * @param multiplier the multiplier
      * @return the result of the multiplication.
      */
     NumberInterface multiply(NumberInterface multiplier);
+
     /**
      * Divides this number by another, returning
      * a new number instance.
+     *
      * @param divisor the divisor
      * @return the result of the division.
      */
     NumberInterface divide(NumberInterface divisor);
+
     /**
      * Adds this number to another, returning
      * a new number instance.
+     *
      * @param summand the summand
      * @return the result of the summation.
      */
     NumberInterface add(NumberInterface summand);
+
     /**
      * Subtracts another number from this number,
      * a new number instance.
+     *
      * @param subtrahend the subtrahend.
      * @return the result of the subtraction.
      */
@@ -43,12 +51,14 @@ public interface NumberInterface {
     /**
      * Returns a new instance of this number with
      * the sign flipped.
+     *
      * @return the new instance.
      */
     NumberInterface negate();
 
     /**
      * Raises this number to an integer power.
+     *
      * @param exponent the exponent to which to take the number.
      * @return the resulting value.
      */
@@ -56,6 +66,7 @@ public interface NumberInterface {
 
     /**
      * Compares this number to another.
+     *
      * @param number the number to compare to.
      * @return same as Integer.compare();
      */
@@ -63,12 +74,14 @@ public interface NumberInterface {
 
     /**
      * Same as Math.signum().
+     *
      * @return 1 if this number is positive, -1 if this number is negative, 0 if this number is 0.
      */
     int signum();
 
     /**
      * Promotes this class to another number class.
+     *
      * @param toClass the class to promote to.
      * @return the resulting new instance.
      */

src/main/java/org/nwapw/abacus/number/PreciseNumber.java

@@ -3,7 +3,7 @@ package org.nwapw.abacus.number;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
-public class PreciseNumber implements NumberInterface{
+public class PreciseNumber implements NumberInterface {
 
     /**
      * The number one.
@@ -25,18 +25,20 @@ public class PreciseNumber implements NumberInterface{
 
     /**
      * Constructs a precise number from the given string.
+     *
      * @param string a string representation of the number meeting the same conditions
      *               as the BidDecimal(String) constructor.
      */
-    public PreciseNumber(String string){
+    public PreciseNumber(String string) {
         value = new BigDecimal(string);
     }
 
     /**
      * Constructs a precise number from the given BigDecimal.
+     *
      * @param value a BigDecimal object representing the value of the number.
      */
-    public PreciseNumber(BigDecimal value){
+    public PreciseNumber(BigDecimal value) {
         this.value = value;
     }
 
@@ -67,16 +69,16 @@ public class PreciseNumber implements NumberInterface{
 
     @Override
     public NumberInterface intPow(int exponent) {
-        if(exponent == 0){
+        if (exponent == 0) {
             return PreciseNumber.ONE;
         }
         boolean takeReciprocal = exponent < 0;
         exponent = Math.abs(exponent);
         NumberInterface power = this;
-        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
             power = power.multiply(this);
         }
-        if(takeReciprocal){
+        if (takeReciprocal) {
             power = PreciseNumber.ONE.divide(power);
         }
         return power;
@@ -93,13 +95,13 @@ public class PreciseNumber implements NumberInterface{
     }
 
     @Override
-    public NumberInterface negate(){
+    public NumberInterface negate() {
         return new PreciseNumber(value.negate());
     }
 
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        if(toClass == this.getClass()){
+        if (toClass == this.getClass()) {
             return this;
         }
         return null;

src/main/java/org/nwapw/abacus/parsing/LexerTokenizer.java

@@ -0,0 +1,67 @@
+package org.nwapw.abacus.parsing;
+
+import org.nwapw.abacus.lexing.Lexer;
+import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.lexing.pattern.Pattern;
+import org.nwapw.abacus.plugin.PluginListener;
+import org.nwapw.abacus.plugin.PluginManager;
+import org.nwapw.abacus.tree.TokenType;
+
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * A tokenzier that uses the lexer class and registered function and operator
+ * names to turn input into tokens in O(n) time.
+ */
+public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListener {
+
+    /**
+     * Comparator used to sort the tokens produced by the lexer.
+     */
+    protected static final Comparator<TokenType> TOKEN_SORTER = Comparator.comparingInt(e -> e.priority);
+
+    /**
+     * The lexer instance used to turn strings into matches.
+     */
+    private Lexer<TokenType> lexer;
+
+    /**
+     * Creates a new lexer tokenizer.
+     */
+    public LexerTokenizer() {
+        lexer = new Lexer<TokenType>() {{
+            register(" ", TokenType.WHITESPACE);
+            register(",", TokenType.COMMA);
+            register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
+            register("\\(", TokenType.OPEN_PARENTH);
+            register("\\)", TokenType.CLOSE_PARENTH);
+        }};
+    }
+
+    @Override
+    public List<Match<TokenType>> tokenizeString(String string) {
+        return lexer.lexAll(string, 0, TOKEN_SORTER);
+    }
+
+    @Override
+    public void onLoad(PluginManager manager) {
+        for (String operator : manager.getAllOperators()) {
+            lexer.register(Pattern.sanitize(operator), TokenType.OP);
+        }
+        for (String function : manager.getAllFunctions()) {
+            lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
+        }
+    }
+
+    @Override
+    public void onUnload(PluginManager manager) {
+        for (String operator : manager.getAllOperators()) {
+            lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
+        }
+        for (String function : manager.getAllFunctions()) {
+            lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
+        }
+    }
+
+}

src/main/java/org/nwapw/abacus/parsing/Parser.java

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.parsing;
+
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.tree.TreeNode;
+
+import java.util.List;
+
+/**
+ * An itnerface that provides the ability to convert a list of tokens
+ * into a parse tree.
+ *
+ * @param <T> the type of tokens accepted by this parser.
+ */
+public interface Parser<T> {
+
+    /**
+     * Constructs a tree out of the given tokens.
+     *
+     * @param tokens the tokens to construct a tree from.
+     * @return the constructed tree, or null on error.
+     */
+    public TreeNode constructTree(List<T> tokens,Abacus trace);
+}

src/main/java/org/nwapw/abacus/parsing/ShuntingYardParser.java

@@ -0,0 +1,179 @@
+package org.nwapw.abacus.parsing;
+
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.plugin.PluginListener;
+import org.nwapw.abacus.plugin.PluginManager;
+import org.nwapw.abacus.tree.*;
+
+import java.util.*;
+
+/**
+ * A parser that uses shunting yard to rearranged matches into postfix
+ * and then convert them into a parse tree.
+ */
+public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListener {
+
+    /**
+     * The Abacus instance used to create number instances.
+     */
+    private Abacus abacus;
+    /**
+     * Map of operator precedences, loaded from the plugin operators.
+     */
+    private Map<String, Integer> precedenceMap;
+    /**
+     * Map of operator associativity, loaded from the plugin operators.
+     */
+    private Map<String, OperatorAssociativity> associativityMap;
+    /**
+     * Map of operator types, loaded from plugin operators.
+     */
+    private Map<String, OperatorType> typeMap;
+
+    //private Abacus trace;
+
+    /**
+     * Creates a new Shunting Yard parser with the given Abacus instance.
+     *
+     * @param abacus the abacus instance.
+     */
+    public ShuntingYardParser(Abacus abacus) {
+        this.abacus = abacus;
+        precedenceMap = new HashMap<>();
+        associativityMap = new HashMap<>();
+        typeMap = new HashMap<>();
+    }
+
+    /**
+     * Rearranges tokens into a postfix list, using Shunting Yard.
+     *
+     * @param from the tokens to be rearranged.
+     * @return the resulting list of rearranged tokens.
+     */
+    public List<Match<TokenType>> intoPostfix(List<Match<TokenType>> from) {
+        ArrayList<Match<TokenType>> output = new ArrayList<>();
+        Stack<Match<TokenType>> tokenStack = new Stack<>();
+        while (!from.isEmpty()) {
+            Match<TokenType> match = from.remove(0);
+            TokenType matchType = match.getType();
+            if (matchType == TokenType.NUM) {
+                output.add(match);
+            } else if (matchType == TokenType.FUNCTION) {
+                output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
+                tokenStack.push(match);
+            } else if (matchType == TokenType.OP) {
+                String tokenString = match.getContent();
+                OperatorType type = typeMap.get(tokenString);
+                int precedence = precedenceMap.get(tokenString);
+                OperatorAssociativity associativity = associativityMap.get(tokenString);
+
+                if (type == OperatorType.UNARY_POSTFIX) {
+                    output.add(match);
+                    continue;
+                }
+
+                while (!tokenStack.empty()) {
+                    Match<TokenType> otherMatch = tokenStack.peek();
+                    TokenType otherMatchType = otherMatch.getType();
+                    if (!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
+
+                    if (otherMatchType == TokenType.OP) {
+                        int otherPrecedence = precedenceMap.get(match.getContent());
+                        if (otherPrecedence < precedence ||
+                                (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
+                            break;
+                        }
+                    }
+                    output.add(tokenStack.pop());
+                }
+                tokenStack.push(match);
+            } else if (matchType == TokenType.OPEN_PARENTH) {
+                tokenStack.push(match);
+            } else if (matchType == TokenType.CLOSE_PARENTH || matchType == TokenType.COMMA) {
+                while (!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH) {
+                    output.add(tokenStack.pop());
+                }
+                if (tokenStack.empty()) return null;
+                if (matchType == TokenType.CLOSE_PARENTH) {
+                    tokenStack.pop();
+                }
+            }
+        }
+        while (!tokenStack.empty()) {
+            Match<TokenType> match = tokenStack.peek();
+            TokenType matchType = match.getType();
+            if (!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
+            output.add(tokenStack.pop());
+        }
+        return output;
+    }
+
+    /**
+     * Constructs a tree recursively from a list of tokens.
+     *
+     * @param matches the list of tokens from the source string.
+     * @return the construct tree expression.
+     */
+    public TreeNode constructRecursive(List<Match<TokenType>> matches,Abacus trace) {
+        //this.trace = trace;
+        if (matches.size() == 0) return null;
+        Match<TokenType> match = matches.remove(0);
+        TokenType matchType = match.getType();
+        if (matchType == TokenType.OP) {
+            String operator = match.getContent();
+            OperatorType type = typeMap.get(operator);
+            if (type == OperatorType.BINARY_INFIX) {
+                TreeNode right = constructRecursive(matches,trace);
+                TreeNode left = constructRecursive(matches,trace);
+                if (left == null || right == null) return null;
+                else return new BinaryInfixNode(operator, left, right,trace);
+            } else {
+                TreeNode applyTo = constructRecursive(matches,trace);
+                if (applyTo == null) return null;
+                else return new UnaryPrefixNode(operator, applyTo,trace);
+            }
+        } else if (matchType == TokenType.NUM) {
+            return new NumberNode(abacus.numberFromString(match.getContent()));
+        } else if (matchType == TokenType.FUNCTION) {
+            String functionName = match.getContent();
+            FunctionNode node = new FunctionNode(functionName,trace);
+            while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
+                TreeNode argument = constructRecursive(matches,trace);
+                if (argument == null) return null;
+                node.prependChild(argument);
+            }
+            if (matches.isEmpty()) return null;
+            matches.remove(0);
+            return node;
+        }
+        return null;
+    }
+
+    @Override
+    public TreeNode constructTree(List<Match<TokenType>> tokens,Abacus trace) {
+        tokens = intoPostfix(new ArrayList<>(tokens));
+        Collections.reverse(tokens);
+        return constructRecursive(tokens,trace);
+    }
+
+    @Override
+    public void onLoad(PluginManager manager) {
+        for (String operator : manager.getAllOperators()) {
+            Operator operatorInstance = manager.operatorFor(operator);
+            precedenceMap.put(operator, operatorInstance.getPrecedence());
+            associativityMap.put(operator, operatorInstance.getAssociativity());
+            typeMap.put(operator, operatorInstance.getType());
+        }
+    }
+
+    @Override
+    public void onUnload(PluginManager manager) {
+        precedenceMap.clear();
+        associativityMap.clear();
+        typeMap.clear();
+    }
+}

src/main/java/org/nwapw/abacus/parsing/Tokenizer.java

@@ -0,0 +1,20 @@
+package org.nwapw.abacus.parsing;
+
+import java.util.List;
+
+/**
+ * Interface that provides the ability to convert a string into a list of tokens.
+ *
+ * @param <T> the type of the tokens produced.
+ */
+public interface Tokenizer<T> {
+
+    /**
+     * Converts a string into tokens.
+     *
+     * @param string the string to convert.
+     * @return the list of tokens, or null on error.
+     */
+    public List<T> tokenizeString(String string);
+
+}

src/main/java/org/nwapw/abacus/parsing/TreeBuilder.java

@@ -0,0 +1,51 @@
+package org.nwapw.abacus.parsing;
+
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.tree.TreeNode;
+
+import java.util.List;
+
+/**
+ * TreeBuilder class used to piece together a Tokenizer and
+ * Parser of the same kind. This is used to essentially avoid
+ * working with any parameters at all, and the generics
+ * in this class are used only to ensure the tokenizer and parser
+ * are of the same type.
+ *
+ * @param <T> the type of tokens created by the tokenizer and used by the parser.
+ */
+public class TreeBuilder<T> {
+
+    /**
+     * The tokenizer used to convert a string into tokens.
+     */
+    private Tokenizer<T> tokenizer;
+    /**
+     * The parser used to parse a list of tokens into a tree.
+     */
+    private Parser<T> parser;
+
+    /**
+     * Create a new Tree Builder with the given tokenizer and parser
+     *
+     * @param tokenizer the tokenizer to turn strings into tokens
+     * @param parser    the parser to turn tokens into a tree
+     */
+    public TreeBuilder(Tokenizer<T> tokenizer, Parser<T> parser) {
+        this.tokenizer = tokenizer;
+        this.parser = parser;
+    }
+
+    /**
+     * Parse the given string into a tree.
+     *
+     * @param input the string to parse into a tree.
+     * @return the resulting tree.
+     */
+    public TreeNode fromString(String input,Abacus trace) {
+        List<T> tokens = tokenizer.tokenizeString(input);
+        if (tokens == null) return null;
+        return parser.constructTree(tokens,trace);
+    }
+
+}

src/main/java/org/nwapw/abacus/plugin/ClassFinder.java

@@ -20,6 +20,7 @@ public class ClassFinder {
 
     /**
      * Loads all the plugin classes from the given plugin folder.
+     *
      * @param filePath the path for the plugin folder.
      * @return the list of all loaded classes.
      * @throws IOException            thrown if an error occurred scanning the plugin folder.
@@ -31,6 +32,7 @@ public class ClassFinder {
 
     /**
      * Loads all the plugin classes from the given plugin folder.
+     *
      * @param pluginFolderPath the folder in which to look for plugins.
      * @return the list of all loaded classes.
      * @throws IOException            thrown if an error occurred scanning the plugin folder.
@@ -38,12 +40,12 @@ public class ClassFinder {
      */
     public static List<Class<?>> loadJars(File pluginFolderPath) throws IOException, ClassNotFoundException {
         ArrayList<Class<?>> toReturn = new ArrayList<>();
-        if(!pluginFolderPath.exists()) return toReturn;
+        if (!pluginFolderPath.exists()) return toReturn;
         ArrayList<File> files = Files.walk(pluginFolderPath.toPath())
                 .map(Path::toFile)
                 .filter(f -> f.getName().endsWith(".jar"))
                 .collect(Collectors.toCollection(ArrayList::new));
-        for (File file : files){
+        for (File file : files) {
             toReturn.addAll(loadJar(file));
         }
         return toReturn;
@@ -51,6 +53,7 @@ public class ClassFinder {
 
     /**
      * Loads the classes from a single path, given by the file.
+     *
      * @param jarLocation the location of the jar to load.
      * @return the list of loaded classes loaded from the jar.
      * @throws IOException            thrown if there was an error reading the file

src/main/java/org/nwapw/abacus/plugin/Plugin.java

@@ -39,10 +39,12 @@ public abstract class Plugin {
      */
     private boolean enabled;
 
-    private Plugin(){ }
+    private Plugin() {
+    }
 
     /**
      * Creates a new plugin with the given PluginManager.
+     *
      * @param manager the manager controlling this plugin.
      */
     public Plugin(PluginManager manager) {
@@ -55,30 +57,34 @@ public abstract class Plugin {
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
-    public final Set<String> providedFunctions(){
+    public final Set<String> providedFunctions() {
         return functions.keySet();
     }
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
-    public final Set<String> providedOperators(){
+    public final Set<String> providedOperators() {
         return operators.keySet();
     }
 
     /**
      * Gets the list of all numbers provided by this plugin.
+     *
      * @return the list of registered numbers.
      */
-    public final Set<String> providedNumbers(){
+    public final Set<String> providedNumbers() {
         return numbers.keySet();
     }
 
     /**
      * Gets a function under the given function name.
+     *
      * @param functionName the name of the function to get
      * @return the function, or null if this plugin doesn't provide it.
      */
@@ -88,6 +94,7 @@ public abstract class Plugin {
 
     /**
      * Gets an operator under the given operator name.
+     *
      * @param operatorName the name of the operator to get.
      * @return the operator, or null if this plugin doesn't provide it.
      */
@@ -97,10 +104,11 @@ public abstract class Plugin {
 
     /**
      * Gets the class under the given name.
+     *
      * @param numberName the name of the class.
      * @return the class, or null if the plugin doesn't provide it.
      */
-    public final Class<? extends NumberInterface> getNumber(String numberName){
+    public final Class<? extends NumberInterface> getNumber(String numberName) {
         return numbers.get(numberName);
     }
 
@@ -108,8 +116,8 @@ public abstract class Plugin {
      * Enables the function, loading the necessary instances
      * of functions.
      */
-    public final void enable(){
-        if(enabled) return;
+    public final void enable() {
+        if (enabled) return;
         onEnable();
         enabled = true;
     }
@@ -118,8 +126,8 @@ public abstract class Plugin {
      * Disables the plugin, clearing loaded data store by default
      * and calling its disable() method.
      */
-    public final void disable(){
-        if(!enabled) return;
+    public final void disable() {
+        if (!enabled) return;
         onDisable();
         functions.clear();
         operators.clear();
@@ -129,6 +137,7 @@ public abstract class Plugin {
     /**
      * To be used in load(). Registers a function abstract class with the
      * plugin internally, which makes it accessible to the plugin manager.
+     *
      * @param name       the name to register by.
      * @param toRegister the function implementation.
      */
@@ -140,6 +149,7 @@ public abstract class Plugin {
      * To be used in load(). Registers an operator abstract class
      * with the plugin internally, which makes it accessible to
      * the plugin manager.
+     *
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
@@ -152,10 +162,11 @@ public abstract class Plugin {
      * with the plugin internally, which makes it possible
      * for the user to select it as an "implementation" for the
      * number that they would like to use.
+     *
      * @param name       the name to register it under.
      * @param toRegister the class to register.
      */
-    protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister){
+    protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister) {
         numbers.put(name, toRegister);
     }
 
@@ -163,6 +174,7 @@ public abstract class Plugin {
      * Searches the PluginManager for the given function name.
      * This can be used by the plugins internally in order to call functions
      * they do not provide.
+     *
      * @param name the name for which to search
      * @return the resulting function, or null if none was found for that name.
      */
@@ -174,6 +186,7 @@ public abstract class Plugin {
      * Searches the PluginManager for the given operator name.
      * This can be used by the plugins internally in order to call
      * operations they do not provide.
+     *
      * @param name the name for which to search
      * @return the resulting operator, or null if none was found for that name.
      */

src/main/java/org/nwapw/abacus/plugin/PluginListener.java

@@ -7,12 +7,14 @@ public interface PluginListener {
 
     /**
      * Called when the PluginManager loads plugins.
+     *
      * @param manager the manager that fired the event.
      */
     public void onLoad(PluginManager manager);
 
     /**
      * Called when the PluginManager unloads all its plugins.
+     *
      * @param manager the manager that fired the event.
      */
     public void onUnload(PluginManager manager);

src/main/java/org/nwapw/abacus/plugin/PluginManager.java

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.plugin;
 
-import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.number.NumberInterface;
@@ -53,17 +52,11 @@ public class PluginManager {
      * The list of plugin listeners attached to this instance.
      */
     private Set<PluginListener> listeners;
-    /**
-     * The instance of Abacus that is used to interact with its other
-     * components.
-     */
-    private Abacus abacus;
 
     /**
      * Creates a new plugin manager.
      */
-    public PluginManager(Abacus abacus){
-        this.abacus = abacus;
+    public PluginManager() {
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
         cachedFunctions = new HashMap<>();
@@ -80,6 +73,7 @@ public class PluginManager {
      * list of items of the type using the setFunction and getting the value
      * of it is available via getFunction. If the value is contained
      * in the cache, it returns the cached value instead.
+     *
      * @param plugins     the plugin list to search.
      * @param cache       the cache to use
      * @param setFunction the function to retrieve a set of available T's from the plugin
@@ -91,12 +85,12 @@ public class PluginManager {
     private static <T> T searchCached(Collection<Plugin> plugins, Map<String, T> cache,
                                       java.util.function.Function<Plugin, Set<String>> setFunction,
                                       java.util.function.BiFunction<Plugin, String, T> getFunction,
-                                      String name){
-        if(cache.containsKey(name)) return cache.get(name);
+                                      String name) {
+        if (cache.containsKey(name)) return cache.get(name);
 
         T loadedValue = null;
-        for(Plugin plugin : plugins){
-            if(setFunction.apply(plugin).contains(name)){
+        for (Plugin plugin : plugins) {
+            if (setFunction.apply(plugin).contains(name)) {
                 loadedValue = getFunction.apply(plugin, name);
                 break;
             }
@@ -105,39 +99,44 @@ public class PluginManager {
         cache.put(name, loadedValue);
         return loadedValue;
     }
+
     /**
      * Gets a function under the given name.
+     *
      * @param name the name of the function
      * @return the function under the given name.
      */
-    public Function functionFor(String name){
+    public Function functionFor(String name) {
         return searchCached(plugins, cachedFunctions, Plugin::providedFunctions, Plugin::getFunction, name);
     }
 
     /**
      * Gets an operator under the given name.
+     *
      * @param name the name of the operator.
      * @return the operator under the given name.
      */
-    public Operator operatorFor(String name){
+    public Operator operatorFor(String name) {
         return searchCached(plugins, cachedOperators, Plugin::providedOperators, Plugin::getOperator, name);
     }
 
     /**
      * Gets a numer implementation under the given name.
+     *
      * @param name the name of the implementation.
      * @return the implementation class
      */
-    public Class<? extends NumberInterface> numberFor(String name){
+    public Class<? extends NumberInterface> numberFor(String name) {
         return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, name);
     }
 
     /**
      * Adds an instance of Plugin that already has been instantiated.
+     *
      * @param plugin the plugin to add.
      */
-    public void addInstantiated(Plugin plugin){
-        if(loadedPluginClasses.contains(plugin.getClass())) return;
+    public void addInstantiated(Plugin plugin) {
+        if (loadedPluginClasses.contains(plugin.getClass())) return;
         plugins.add(plugin);
         loadedPluginClasses.add(plugin.getClass());
     }
@@ -145,10 +144,11 @@ public class PluginManager {
     /**
      * Instantiates a class of plugin, and adds it to this
      * plugin manager.
+     *
      * @param newClass the new class to instantiate.
      */
-    public void addClass(Class<?> newClass){
-        if(!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
+    public void addClass(Class<?> newClass) {
+        if (!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
         try {
             addInstantiated((Plugin) newClass.getConstructor(PluginManager.class).newInstance(this));
         } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
@@ -159,9 +159,9 @@ public class PluginManager {
     /**
      * Loads all the plugins in the PluginManager.
      */
-    public void load(){
-        for(Plugin plugin : plugins) plugin.enable();
-        for(Plugin plugin : plugins){
+    public void load() {
+        for (Plugin plugin : plugins) plugin.enable();
+        for (Plugin plugin : plugins) {
             allFunctions.addAll(plugin.providedFunctions());
             allOperators.addAll(plugin.providedOperators());
             allNumbers.addAll(plugin.providedNumbers());
@@ -172,8 +172,8 @@ public class PluginManager {
     /**
      * Unloads all the plugins in the PluginManager.
      */
-    public void unload(){
-        for(Plugin plugin : plugins) plugin.disable();
+    public void unload() {
+        for (Plugin plugin : plugins) plugin.disable();
         allFunctions.clear();
         allOperators.clear();
         allNumbers.clear();
@@ -183,13 +183,14 @@ public class PluginManager {
     /**
      * Reloads all the plugins in the PluginManager.
      */
-    public void reload(){
+    public void reload() {
         unload();
         reload();
     }
 
     /**
      * Gets all the functions loaded by the Plugin Manager.
+     *
      * @return the set of all functions that were loaded.
      */
     public Set<String> getAllFunctions() {
@@ -198,6 +199,7 @@ public class PluginManager {
 
     /**
      * Gets all the operators loaded by the Plugin Manager.
+     *
      * @return the set of all operators that were loaded.
      */
     public Set<String> getAllOperators() {
@@ -206,6 +208,7 @@ public class PluginManager {
 
     /**
      * Gets all the number implementations loaded by the Plugin Manager
+     *
      * @return the set of all implementations that were loaded
      */
     public Set<String> getAllNumbers() {
@@ -214,17 +217,19 @@ public class PluginManager {
 
     /**
      * Adds a plugin change listener to this plugin manager.
+     *
      * @param listener the listener to add.
      */
-    public void addListener(PluginListener listener){
+    public void addListener(PluginListener listener) {
         listeners.add(listener);
     }
 
     /**
      * Remove the plugin change listener from this plugin manager.
+     *
      * @param listener the listener to remove.
      */
-    public void removeListener(PluginListener listener){
+    public void removeListener(PluginListener listener) {
         listeners.remove(listener);
     }
 

src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java

@@ -0,0 +1,342 @@
+package org.nwapw.abacus.plugin;
+
+import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.number.NaiveNumber;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.PreciseNumber;
+
+import java.util.function.BiFunction;
+
+/**
+ * The plugin providing standard functions such as addition and subtraction to
+ * the calculator.
+ */
+public class StandardPlugin extends Plugin {
+
+    /**
+     * The addition operator, +
+     */
+    public static final Operator OP_ADD = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length >= 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface sum = params[0];
+            for (int i = 1; i < params.length; i++) {
+                sum = sum.add(params[i]);
+            }
+            return sum;
+        }
+    });
+    /**
+     * The subtraction operator, -
+     */
+    public static final Operator OP_SUBTRACT = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].subtract(params[1]);
+        }
+    });
+    /**
+     * The multiplication operator, *
+     */
+    public static final Operator OP_MULTIPLY = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length >= 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface product = params[0];
+            for (int i = 1; i < params.length; i++) {
+                product = product.multiply(params[i]);
+            }
+            return product;
+        }
+    });
+    /**
+     * The division operator, /
+     */
+    public static final Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length >= 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface product = params[0];
+            for (int i = 1; i < params.length; i++) {
+                product = product.multiply(params[i]);
+            }
+            return product;
+        }
+    });
+    /**
+     * The factorial operator, !
+     */
+    public static final Operator OP_FACTORIAL = new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
+        //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            if (params[0].signum() == 0) {
+                return (new NaiveNumber(1)).promoteTo(params[0].getClass());
+            }
+            NumberInterface factorial = params[0];
+            NumberInterface multiplier = params[0];
+            //It is necessary to later prevent calls of factorial on anything but non-negative integers.
+            while ((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1) {
+                factorial = factorial.multiply(multiplier);
+            }
+            return factorial;
+                /*if(!storedList.containsKey(params[0].getClass())){
+                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                }*/
+        }
+    });
+    /**
+     * The caret / pow operator, ^
+     */
+    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0]).multiply(params[1]));
+        }
+    });
+    /**
+     * The absolute value function, abs(-3) = 3
+     */
+    public static final Function FUNCTION_ABS = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
+        }
+    };
+    /**
+     * The exponential function, exp(1) = e^1 = 2.71...
+     */
+    public static final Function FUNCTION_EXP = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            boolean takeReciprocal = params[0].signum() == -1;
+            params[0] = FUNCTION_ABS.apply(params[0]);
+            NumberInterface sum = sumSeries(params[0], StandardPlugin::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
+            if (takeReciprocal) {
+                sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
+            }
+            return sum;
+        }
+    };
+    /**
+     * The natural log function, ln(exp(1)) = 1
+     */
+    public static final Function FUNCTION_LN = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface param = params[0];
+            int powersOf2 = 0;
+            while (FUNCTION_ABS.apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0) {
+                if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
+                    param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
+                    powersOf2++;
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                        break;
+                        //No infinite loop for you.
+                    }
+                } else {
+                    param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
+                    powersOf2--;
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                        break;
+                        //No infinite loop for you.
+                    }
+                }
+            }
+            return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+        }
+
+        /**
+         * Returns the partial sum of the Taylor series for logx (around x=1).
+         * Automatically determines the number of terms needed based on the precision of x.
+         * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
+         * @return the partial sum.
+         */
+        private NumberInterface getLogPartialSum(NumberInterface x) {
+            NumberInterface maxError = getMaxError(x);
+            x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
+            NumberInterface currentNumerator = x, currentTerm = x, sum = x;
+            int n = 1;
+            while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
+                n++;
+                currentNumerator = currentNumerator.multiply(x).negate();
+                currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClass()));
+                sum = sum.add(currentTerm);
+            }
+            return sum;
+        }
+
+        /**
+         * Returns natural log of 2 to the required precision of the class of number.
+         * @param number a number of the same type as the return type. (Used for precision.)
+         * @return the value of log(2) with the appropriate precision.
+         */
+        private NumberInterface getLog2(NumberInterface number) {
+            NumberInterface maxError = getMaxError(number);
+            //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
+            //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
+            //In the following, a=1/3^n, b=1/4^n, c = 1/n.
+            //a is also an error bound.
+            NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
+            NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
+            int n = 0;
+            while (a.compareTo(maxError) >= 1) {
+                n++;
+                a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
+                b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
+                c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
+                sum = sum.add(a.add(b).multiply(c));
+            }
+            return sum;
+        }
+    };
+    /**
+     * The square root function, sqrt(4) = 2
+     */
+    public static final Function FUNCTION_SQRT = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
+        }
+    };
+
+    public StandardPlugin(PluginManager manager) {
+        super(manager);
+    }
+
+    /**
+     * Returns the nth term of the Taylor series (centered at 0) of e^x
+     *
+     * @param n the term required (n >= 0).
+     * @param x the real number at which the series is evaluated.
+     * @return the nth term of the series.
+     */
+    private static NumberInterface getExpSeriesTerm(int n, NumberInterface x) {
+        return x.intPow(n).divide(OP_FACTORIAL.getFunction().apply((new NaiveNumber(n)).promoteTo(x.getClass())));
+    }
+
+    /**
+     * Returns the number of terms needed to evaluate the exponential function (at x)
+     * such that the error is at most maxError.
+     *
+     * @param maxError Maximum error permissible (This should probably be positive.)
+     * @param x        where the function is evaluated.
+     * @return the number of terms needed to evaluate the exponential function.
+     */
+    private static int getNTermsExp(NumberInterface maxError, NumberInterface x) {
+        //We need n such that |x^(n+1)| <= (n+1)! * maxError
+        //The variables LHS and RHS refer to the above inequality.
+        int n = 0;
+        x = FUNCTION_ABS.apply(x);
+        NumberInterface LHS = x, RHS = maxError;
+        while (LHS.compareTo(RHS) > 0) {
+            n++;
+            LHS = LHS.multiply(x);
+            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
+        }
+        return n;
+    }
+
+    /**
+     * Returns a partial sum of a series whose terms are given by the nthTermFunction, evaluated at x.
+     *
+     * @param x               the value at which the series is evaluated.
+     * @param nthTermFunction the function that returns the nth term of the series, in the format term(x, n).
+     * @param n               the number of terms in the partial sum.
+     * @return the value of the partial sum that has the same class as x.
+     */
+    private static NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n) {
+        NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClass());
+        for (int i = 0; i <= n; i++) {
+            sum = sum.add(nthTermFunction.apply(i, x));
+        }
+        return sum;
+    }
+
+    /**
+     * Returns the maximum error based on the precision of the class of number.
+     *
+     * @param number Any instance of the NumberInterface in question (should return an appropriate precision).
+     * @return the maximum error.
+     */
+    private static NumberInterface getMaxError(NumberInterface number) {
+        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
+    }
+
+    @Override
+    public void onEnable() {
+        registerNumber("naive", NaiveNumber.class);
+        registerNumber("precise", PreciseNumber.class);
+
+        registerOperator("+", OP_ADD);
+        registerOperator("-", OP_SUBTRACT);
+        registerOperator("*", OP_MULTIPLY);
+        registerOperator("/", OP_DIVIDE);
+        registerOperator("^", OP_CARET);
+        registerOperator("!", OP_FACTORIAL);
+
+        registerFunction("abs", FUNCTION_ABS);
+        registerFunction("exp", FUNCTION_EXP);
+        registerFunction("ln", FUNCTION_LN);
+        registerFunction("sqrt", FUNCTION_SQRT);
+    }
+
+    @Override
+    public void onDisable() {
+
+    }
+
+}

src/main/java/org/nwapw/abacus/tree/BinaryInfixNode.java

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 /**
  * A tree node that represents an operation being applied to two operands.
  */
@@ -17,33 +19,39 @@ public class BinaryInfixNode extends TreeNode {
      * The right node of the operation.
      */
     private TreeNode right;
+    private Abacus trace;
 
-    private BinaryInfixNode() {}
+    private BinaryInfixNode() {
+    }
 
     /**
      * Creates a new operation node with the given operation
      * and no child nodes.
+     *
      * @param operation the operation.
      */
-    public BinaryInfixNode(String operation){
-        this(operation, null, null);
+    public BinaryInfixNode(String operation,Abacus trace) {
+        this(operation, null, null,trace);
     }
 
     /**
      * Creates a new operation node with the given operation
      * and child nodes.
+     *
      * @param operation the operation.
      * @param left      the left node of the expression.
      * @param right     the right node of the expression.
      */
-    public BinaryInfixNode(String operation, TreeNode left, TreeNode right){
+    public BinaryInfixNode(String operation, TreeNode left, TreeNode right,Abacus trace) {
         this.operation = operation;
         this.left = left;
         this.right = right;
+        this.trace = trace;
     }
 
     /**
      * Gets the operation in this node.
+     *
      * @return the operation in this node.
      */
     public String getOperation() {
@@ -52,6 +60,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the left sub-expression of this node.
+     *
      * @return the left node.
      */
     public TreeNode getLeft() {
@@ -60,6 +69,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Sets the left sub-expression of this node.
+     *
      * @param left the sub-expression to apply.
      */
     public void setLeft(TreeNode left) {
@@ -68,6 +78,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the right sub-expression of this node.
+     *
      * @return the right node.
      */
     public TreeNode getRight() {
@@ -76,6 +87,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Sets the right sub-expression of this node.
+     *
      * @param right the sub-expression to apply.
      */
     public void setRight(TreeNode right) {
@@ -84,11 +96,16 @@ public class BinaryInfixNode extends TreeNode {
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(!trace.getStop()) {
             T leftReduce = left.reduce(reducer);
+
             T rightReduce = right.reduce(reducer);
-        if(leftReduce == null || rightReduce == null) return null;
+            if (leftReduce == null || rightReduce == null) return null;
             return reducer.reduceNode(this, leftReduce, rightReduce);
         }
+        return null;
+
+    }
 
     @Override
     public String toString() {

src/main/java/org/nwapw/abacus/tree/FunctionNode.java

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -16,23 +18,28 @@ public class FunctionNode extends TreeNode {
      * The list of arguments to the function.
      */
     private List<TreeNode> children;
+    private Abacus trace;
 
     /**
      * Creates a function node with no function.
      */
-    private FunctionNode() { }
+    private FunctionNode() {
+    }
 
     /**
      * Creates a new function node with the given function name.
+     *
      * @param function the function name.
      */
-    public FunctionNode(String function){
+    public FunctionNode(String function,Abacus trace) {
         this.function = function;
         children = new ArrayList<>();
+        this.trace = trace;
     }
 
     /**
      * Gets the function name for this node.
+     *
      * @return the function name.
      */
     public String getFunction() {
@@ -41,14 +48,16 @@ public class FunctionNode extends TreeNode {
 
     /**
      * Adds a child to the end of this node's child list.
+     *
      * @param node the child to add.
      */
-    public void appendChild(TreeNode node){
+    public void appendChild(TreeNode node) {
         children.add(node);
     }
 
     /**
      * Adds a new child to the beginning of this node's child list.
+     *
      * @param node the node to add.
      */
     public void prependChild(TreeNode node) {
@@ -58,9 +67,9 @@ public class FunctionNode extends TreeNode {
     @Override
     public <T> T reduce(Reducer<T> reducer) {
         Object[] reducedChildren = new Object[children.size()];
-        for(int i = 0; i < reducedChildren.length; i++){
+        for (int i = 0; i < reducedChildren.length; i++) {
             reducedChildren[i] = children.get(i).reduce(reducer);
-            if(reducedChildren[i] == null) return null;
+            if (reducedChildren[i] == null) return null;
         }
         return reducer.reduceNode(this, reducedChildren);
     }
@@ -70,7 +79,7 @@ public class FunctionNode extends TreeNode {
         StringBuilder buffer = new StringBuilder();
         buffer.append(function);
         buffer.append("(");
-        for(int i = 0; i < children.size(); i++){
+        for (int i = 0; i < children.size(); i++) {
             buffer.append(children.get(i));
             buffer.append(i == children.size() - 1 ? "" : ", ");
         }

src/main/java/org/nwapw/abacus/tree/NumberNode.java

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.tree;
 
-import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 
 /**
@@ -16,20 +15,22 @@ public class NumberNode extends TreeNode {
     /**
      * Creates a number node with no number.
      */
-    public NumberNode(){
+    public NumberNode() {
         number = null;
     }
 
     /**
      * Creates a new number node with the given double value.
+     *
      * @param newNumber the number for which to create a number node.
      */
-    public NumberNode(NumberInterface newNumber){
+    public NumberNode(NumberInterface newNumber) {
         this.number = newNumber;
     }
 
     /**
      * Gets the number value of this node.
+     *
      * @return the number value of this node.
      */
     public NumberInterface getNumber() {

src/main/java/org/nwapw/abacus/tree/NumberReducer.java

@@ -17,34 +17,35 @@ public class NumberReducer implements Reducer<NumberInterface> {
 
     /**
      * Creates a new number reducer.
+     *
      * @param abacus the calculator instance.
      */
-    public NumberReducer(Abacus abacus){
+    public NumberReducer(Abacus abacus) {
         this.abacus = abacus;
     }
 
     @Override
     public NumberInterface reduceNode(TreeNode node, Object... children) {
-        if(node instanceof NumberNode) {
+        if (node instanceof NumberNode) {
             return ((NumberNode) node).getNumber();
-        } else if(node instanceof BinaryInfixNode){
+        } else if (node instanceof BinaryInfixNode) {
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
             Function function = abacus.getPluginManager().operatorFor(((BinaryInfixNode) node).getOperation()).getFunction();
-            if(function == null) return null;
+            if (function == null) return null;
             return function.apply(left, right);
-        } else if(node instanceof UnaryPrefixNode) {
+        } else if (node instanceof UnaryPrefixNode) {
             NumberInterface child = (NumberInterface) children[0];
             Function functionn = abacus.getPluginManager().operatorFor(((UnaryPrefixNode) node).getOperation()).getFunction();
-            if(functionn == null) return null;
+            if (functionn == null) return null;
             return functionn.apply(child);
-        } else if(node instanceof FunctionNode){
+        } else if (node instanceof FunctionNode) {
             NumberInterface[] convertedChildren = new NumberInterface[children.length];
-            for(int i = 0; i < convertedChildren.length; i++){
+            for (int i = 0; i < convertedChildren.length; i++) {
                 convertedChildren[i] = (NumberInterface) children[i];
             }
             Function function = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
-            if(function == null) return null;
+            if (function == null) return null;
             return function.apply(convertedChildren);
         }
         return null;

src/main/java/org/nwapw/abacus/tree/Reducer.java

@@ -2,16 +2,18 @@ package org.nwapw.abacus.tree;
 
 /**
  * Interface used to reduce a tree into a single value.
+ *
  * @param <T> the value to reduce into.
  */
 public interface Reducer<T> {
 
     /**
      * Reduces the given tree into a single value of type T.
+     *
      * @param node     the node being passed in to be reduced.
      * @param children the already-reduced children of this node.
      * @return the resulting value from the reduce.
      */
-    public T reduceNode(TreeNode node, Object...children);
+    public T reduceNode(TreeNode node, Object... children);
 
 }

src/main/java/org/nwapw/abacus/tree/TokenType.java

@@ -16,9 +16,10 @@ public enum TokenType {
 
     /**
      * Creates a new token type with the given priority.
+     *
      * @param priority the priority of this token type.
      */
-    TokenType(int priority){
+    TokenType(int priority) {
         this.priority = priority;
     }
 

src/main/java/org/nwapw/abacus/tree/TreeNode.java

@@ -1,11 +1,5 @@
 package org.nwapw.abacus.tree;
 
-import org.nwapw.abacus.function.OperatorAssociativity;
-import org.nwapw.abacus.lexing.Lexer;
-import org.nwapw.abacus.lexing.pattern.Match;
-
-import java.util.*;
-
 /**
  * An abstract class that represents an expression tree node.
  */
@@ -13,6 +7,7 @@ public abstract class TreeNode {
 
     /**
      * The function that reduces a tree to a single vale.
+     *
      * @param reducer the reducer used to reduce the tree.
      * @param <T>     the type the reducer produces.
      * @return the result of the reduction, or null on error.

src/main/java/org/nwapw/abacus/tree/UnaryPrefixNode.java

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 public class UnaryPrefixNode extends TreeNode {
 
     /**
@@ -10,34 +12,42 @@ public class UnaryPrefixNode extends TreeNode {
      * The tree node to apply the operation to.
      */
     private TreeNode applyTo;
+    private Abacus trace;
 
     /**
      * Creates a new node with the given operation and no child.
+     *
      * @param operation the operation for this node.
      */
-    public UnaryPrefixNode(String operation){
-        this(operation, null);
+    public UnaryPrefixNode(String operation,Abacus trace) {
+        this(operation, null,trace);
     }
 
     /**
      * Creates a new node with the given operation and child.
+     *
      * @param operation the operation for this node.
      * @param applyTo   the node to apply the function to.
      */
-    public UnaryPrefixNode(String operation, TreeNode applyTo){
+    public UnaryPrefixNode(String operation, TreeNode applyTo,Abacus trace) {
         this.operation = operation;
         this.applyTo = applyTo;
+        this.trace = trace;
     }
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(!trace.getStop()) {
             Object reducedChild = applyTo.reduce(reducer);
-        if(reducedChild == null) return null;
+            if (reducedChild == null) return null;
             return reducer.reduceNode(this, reducedChild);
         }
+        return null;
+    }
 
     /**
      * Gets the operation of this node.
+     *
      * @return the operation this node performs.
      */
     public String getOperation() {
@@ -46,6 +56,7 @@ public class UnaryPrefixNode extends TreeNode {
 
     /**
      * Gets the node to which this node's operation applies.
+     *
      * @return the tree node to which the operation will be applied.
      */
     public TreeNode getApplyTo() {

src/main/java/org/nwapw/abacus/window/HistoryTableModel.java

@@ -2,9 +2,7 @@ package org.nwapw.abacus.window;
 
 import org.nwapw.abacus.tree.TreeNode;
 
-import javax.swing.event.TableModelListener;
 import javax.swing.table.AbstractTableModel;
-import javax.swing.table.TableModel;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -31,30 +29,6 @@ public class HistoryTableModel extends AbstractTableModel {
             TreeNode.class,
             String.class
     };
-
-    /**
-     * Class used specifically to hold data about
-     * the previous entries into the calculator.
-     */
-    public static class HistoryEntry {
-        public String input;
-        public TreeNode parsedInput;
-        public String output;
-
-        public HistoryEntry(String input, TreeNode parsedInput, String output){
-            this.input = input;
-            this.parsedInput = parsedInput;
-            this.output = output;
-        }
-
-        Object nthValue(int n){
-            if(n == 0) return input;
-            if(n == 1) return parsedInput;
-            if(n == 2) return output;
-            return null;
-        }
-    }
-
     /**
      * The list of entries.
      */
@@ -69,9 +43,10 @@ public class HistoryTableModel extends AbstractTableModel {
 
     /**
      * Adds an entry to the model.
+     *
      * @param entry the entry to add.
      */
-    public void addEntry(HistoryEntry entry){
+    public void addEntry(HistoryEntry entry) {
         entries.add(entry);
     }
 
@@ -105,4 +80,27 @@ public class HistoryTableModel extends AbstractTableModel {
         return entries.get(rowIndex).nthValue(columnIndex);
     }
 
+    /**
+     * Class used specifically to hold data about
+     * the previous entries into the calculator.
+     */
+    public static class HistoryEntry {
+        public String input;
+        public TreeNode parsedInput;
+        public String output;
+
+        public HistoryEntry(String input, TreeNode parsedInput, String output) {
+            this.input = input;
+            this.parsedInput = parsedInput;
+            this.output = output;
+        }
+
+        Object nthValue(int n) {
+            if (n == 0) return input;
+            if (n == 1) return parsedInput;
+            if (n == 2) return output;
+            return null;
+        }
+    }
+
 }

src/main/java/org/nwapw/abacus/window/Window.java

@@ -16,12 +16,13 @@ import java.awt.event.MouseEvent;
  */
 public class Window extends JFrame {
     
+
     private static final String CALC_STRING = "Calculate";
     private static final String SYNTAX_ERR_STRING = "Syntax Error";
     private static final String EVAL_ERR_STRING = "Evaluation Error";
     private static final String NUMBER_SYSTEM_LABEL = "Number Type:";
     private static final String FUNCTION_LABEL = "Functions:";
-
+    private static final String STOP_STRING = "Stop";
     /**
      * Array of Strings to which the "calculate" button's text
      * changes. For instance, in the graph tab, the name will
@@ -90,7 +91,10 @@ public class Window extends JFrame {
      * The "submit" button.
      */
     private JButton inputEnterButton;
-
+    /**
+     * The stop calculations button.
+     */
+    private JButton inputStopButton;
     /**
      * The side panel for separate configuration.
      */
@@ -113,26 +117,80 @@ public class Window extends JFrame {
      * The list of functions available to the user.
      */
     private JComboBox<String> functionList;
+    /**
+     * Thread used for calculations
+     */
+    private Thread calculateThread;
+    /**
+     * Check if currently calculating.
+     */
+    private boolean calculating;
+    /**
+     * Checks if thread should stop calculating.
+     */
+    private boolean stopCalculating;
+    /**
+     * Test variable to check number of threads running in the calculator.
+     */
+    private int count;
+    /**
+     * ActionListener that stops calculations.
+     */
+    private ActionListener stopListener = (event) -> {
+        //System.out.println(count++);  //Shows about how many calculation threads are running with the calculating=false command
+        //calculating = false;          //Ignores result of calculation and allows for the start of a new calculation
+        stopCalculating = true;         //Stops calculation at the next node check
+        //calculateThread.stop();         //Stops thread no matter what, Unsafe
+    };
 
     /**
-     * Action listener that causes the input to be evaluated.
+     * Node check to get whether nodes should continue calculating.
+     * @return boolean stop calculations if true.
+     */
+    public boolean getStop(){
+        return stopCalculating;
+    }
+
+    /**
+     * ActionListener that runs all calculations.
      */
     private ActionListener evaluateListener = (event) -> {
-        TreeNode parsedExpression = abacus.parseString(inputField.getText());
-        if(parsedExpression == null){
+        Runnable calculate = new Runnable() {
+            public void run() {
+                boolean skip = false;
+                calculating = true;
+                TreeNode parsedExpression = null;
+                parsedExpression = abacus.parseString(inputField.getText());
+                if (parsedExpression == null) {
                     lastOutputArea.setText(SYNTAX_ERR_STRING);
-            return;
+                    skip = true;
                 }
+                if(!skip){
                     NumberInterface numberInterface = abacus.evaluateTree(parsedExpression);
-        if(numberInterface == null) {
+                    if (numberInterface == null) {
                         lastOutputArea.setText(EVAL_ERR_STRING);
+                        calculating = false;
+                        stopCalculating = false;
+
                         return;
                     }
+                    if(calculateThread.equals(Thread.currentThread())) {
                         lastOutput = numberInterface.toString();
                         historyModel.addEntry(new HistoryTableModel.HistoryEntry(inputField.getText(), parsedExpression, lastOutput));
                         historyTable.invalidate();
                         lastOutputArea.setText(lastOutput);
                         inputField.setText("");
+                        calculating = false;
+                        stopCalculating = false;
+                    }
+                }
+            }
+        };
+        if(!calculating) {
+            calculateThread = new Thread(calculate);
+            calculateThread.setName("a-"+System.currentTimeMillis());
+            calculateThread.start();
+        }
     };
 
     /**
@@ -143,14 +201,24 @@ public class Window extends JFrame {
             evaluateListener,
             null
     };
+    /**
+     * Array of listeners that tell the stop button how to behave
+     * at a given input tab.
+     */
+    private ActionListener[] stopListeners = {
+            stopListener,
+            null
+    };
 
     /**
      * Creates a new window with the given manager.
+     *
      * @param abacus the calculator instance to interact with other components.
      */
-    public Window(Abacus abacus){
+    public Window(Abacus abacus) {
         this();
         this.abacus = abacus;
+        abacus.setWindow(this);
     }
 
     /**
@@ -159,25 +227,36 @@ public class Window extends JFrame {
     private Window() {
         super();
 
+        //variables related to when calculations occur
+        stopCalculating = false;
+        calculating = true;
+
         lastOutput = "";
 
+        //default window properties
         setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
         setSize(320, 480);
 
+        //initiates input objects
         inputField = new JTextField();
         inputEnterButton = new JButton(CALC_STRING);
+        inputStopButton = new JButton(STOP_STRING);
 
+        //adds input objects into Panel
         inputPanel = new JPanel();
         inputPanel.setLayout(new BorderLayout());
-        inputPanel.add(inputField, BorderLayout.CENTER);
-        inputPanel.add(inputEnterButton, BorderLayout.SOUTH);
+        inputPanel.add(inputStopButton, BorderLayout.SOUTH);
+        inputPanel.add(inputField, BorderLayout.NORTH);
+        inputPanel.add(inputEnterButton, BorderLayout.CENTER);
 
+        //initiates output objects in calculator tab
         historyModel = new HistoryTableModel();
         historyTable = new JTable(historyModel);
         historyScroll = new JScrollPane(historyTable);
         lastOutputArea = new JTextArea(lastOutput);
         lastOutputArea.setEditable(false);
 
+        //adds output objects into Panel
         calculationPanel = new JPanel();
         calculationPanel.setLayout(new BorderLayout());
         calculationPanel.add(historyScroll, BorderLayout.CENTER);
@@ -207,6 +286,8 @@ public class Window extends JFrame {
         settingsPanel.add(numberSystemPanel);
         settingsPanel.add(functionSelectPanel);
 
+        calculating = false;
+
         pane = new JTabbedPane();
         pane.add("Calculator", calculationPanel);
         pane.add("Settings", settingsPanel);
@@ -214,17 +295,23 @@ public class Window extends JFrame {
             int selectionIndex = pane.getSelectedIndex();
             boolean enabled = INPUT_ENABLED[selectionIndex];
             ActionListener listener = listeners[selectionIndex];
+            ActionListener stopUsed = stopListeners[selectionIndex];
             inputEnterButton.setText(BUTTON_NAMES[selectionIndex]);
             inputField.setEnabled(enabled);
             inputEnterButton.setEnabled(enabled);
+            inputStopButton.setEnabled(enabled);
 
-            for(ActionListener removingListener : inputEnterButton.getActionListeners()){
+            for (ActionListener removingListener : inputEnterButton.getActionListeners()) {
                 inputEnterButton.removeActionListener(removingListener);
                 inputField.removeActionListener(removingListener);
             }
-            if(listener != null){
+            for(ActionListener removingListener : inputStopButton.getActionListeners()){
+                inputStopButton.removeActionListener(removingListener);
+            }
+            if (listener != null) {
                 inputEnterButton.addActionListener(listener);
                 inputField.addActionListener(listener);
+                inputStopButton.addActionListener(stopUsed);
             }
         });
         add(pane, BorderLayout.CENTER);
@@ -232,11 +319,12 @@ public class Window extends JFrame {
 
         inputEnterButton.addActionListener(evaluateListener);
         inputField.addActionListener(evaluateListener);
+        inputStopButton.addActionListener(stopListener);
         historyTable.addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 Point clickPoint = e.getPoint();
-                if(e.getClickCount() == 2){
+                if (e.getClickCount() == 2) {
                     int row = historyTable.rowAtPoint(clickPoint);
                     int column = historyTable.columnAtPoint(clickPoint);
                     String toCopy = historyTable.getValueAt(row, column).toString();
@@ -246,4 +334,9 @@ public class Window extends JFrame {
         });
     }
 
+    @Override
+    public void setVisible(boolean b) {
+        super.setVisible(b);
+        if(b) inputField.requestFocusInWindow();
+    }
 }

src/org/nwapw/abacus/lexing/pattern/Match.java

@@ -1,57 +0,0 @@
-package org.nwapw.abacus.lexing.pattern;
-
-/**
- * A match that has been generated by the lexer.
- * @param <T> the type used to represent the ID of the pattern this match belongs to.
- */
-public class Match<T> {
-
-    /**
-     * The bottom range of the string, inclusive.
-     */
-    private int from;
-    /**
-     * The top range of the string, exclusive.
-     */
-    private int to;
-    /**
-     * The pattern type this match matched.
-     */
-    private T type;
-
-    /**
-     * Creates a new match with the given parameters.
-     * @param from the bottom range of the string.
-     * @param to the top range of the string.
-     * @param type the type of the match.
-     */
-    public Match(int from, int to, T type){
-        this.from = from;
-        this.to = to;
-        this.type = type;
-    }
-
-    /**
-     * Gets the bottom range bound of the string.
-     * @return the bottom range bound of the string.
-     */
-    public int getFrom() {
-        return from;
-    }
-
-    /**
-     * Gets the top range bound of the string.
-     * @return the top range bound of the string.
-     */
-    public int getTo() {
-        return to;
-    }
-
-    /**
-     * Gets the pattern type of the node.
-     * @return the ID of the pattern that this match matched.
-     */
-    public T getType() {
-        return type;
-    }
-}

src/org/nwapw/abacus/plugin/StandardPlugin.java

@@ -1,302 +0,0 @@
-package org.nwapw.abacus.plugin;
-
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
-import org.nwapw.abacus.function.OperatorAssociativity;
-import org.nwapw.abacus.function.OperatorType;
-import org.nwapw.abacus.number.NaiveNumber;
-import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.number.PreciseNumber;
-
-import java.util.function.BiFunction;
-
-/**
- * The plugin providing standard functions such as addition and subtraction to
- * the calculator.
- */
-public class StandardPlugin extends Plugin {
-
-    public StandardPlugin(PluginManager manager) {
-        super(manager);
-    }
-
-    @Override
-    public void onEnable() {
-        registerNumber("naive", NaiveNumber.class);
-        registerNumber("precise", PreciseNumber.class);
-
-        registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length >= 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface sum = params[0];
-                for(int i = 1; i < params.length; i++){
-                    sum = sum.add(params[i]);
-                }
-                return sum;
-            }
-        }));
-
-        registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 2;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].subtract(params[1]);
-            }
-        }));
-
-        registerOperator("*", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length >= 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface product = params[0];
-                for(int i = 1; i < params.length; i++){
-                    product = product.multiply(params[i]);
-                }
-                return product;
-            }
-        }));
-
-        registerOperator("/", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 2;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].divide(params[1]);
-            }
-        }));
-
-        registerOperator("^", new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 2;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return StandardPlugin.this.getFunction("exp").apply(StandardPlugin.this.getFunction("ln").apply(params[0]).multiply(params[1]));
-            }
-        }));
-
-        registerOperator("!", new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
-            //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                if(params[0].signum() == 0){
-                    return (new NaiveNumber(1)).promoteTo(params[0].getClass());
-                }
-                NumberInterface factorial = params[0];
-                NumberInterface multiplier = params[0];
-                //It is necessary to later prevent calls of factorial on anything but non-negative integers.
-                while((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1){
-                    factorial = factorial.multiply(multiplier);
-                }
-                return factorial;
-                /*if(!storedList.containsKey(params[0].getClass())){
-                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
-                }*/
-            }
-        }));
-
-        registerFunction("abs", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
-            }
-        });
-
-        registerFunction("exp", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                boolean takeReciprocal = params[0].signum() == -1;
-                params[0] = StandardPlugin.this.getFunction("abs").apply(params[0]);
-                NumberInterface sum = sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
-                if(takeReciprocal){
-                    sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
-                }
-                return sum;
-            }
-        });
-
-        registerFunction("ln", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface param = params[0];
-                int powersOf2 = 0;
-                while(StandardPlugin.this.getFunction("abs").apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0){
-                    if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
-                        param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
-                        powersOf2++;
-                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
-                            break;
-                            //No infinite loop for you.
-                        }
-                    }
-                    else {
-                        param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
-                        powersOf2--;
-                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
-                            break;
-                            //No infinite loop for you.
-                        }
-                    }
-                }
-                return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
-            }
-
-            /**
-             * Returns the partial sum of the Taylor series for logx (around x=1).
-             * Automatically determines the number of terms needed based on the precision of x.
-             * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
-             * @return the partial sum.
-             */
-            private NumberInterface getLogPartialSum(NumberInterface x){
-                NumberInterface maxError = StandardPlugin.this.getMaxError(x);
-                x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
-                NumberInterface currentTerm = x, sum = x;
-                int n = 1;
-                while(StandardPlugin.this.getFunction("abs").apply(currentTerm).compareTo(maxError) > 0){
-                    n++;
-                    currentTerm = currentTerm.multiply(x).multiply((new NaiveNumber(n-1)).promoteTo(x.getClass())).divide((new NaiveNumber(n)).promoteTo(x.getClass())).negate();
-                    sum = sum.add(currentTerm);
-                }
-                return sum;
-            }
-
-            /**
-             * Returns natural log of 2 to the required precision of the class of number.
-             * @param number a number of the same type as the return type. (Used for precision.)
-             * @return the value of log(2) with the appropriate precision.
-             */
-            private NumberInterface getLog2(NumberInterface number){
-                NumberInterface maxError = StandardPlugin.this.getMaxError(number);
-                //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
-                //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
-                //In the following, a=1/3^n, b=1/4^n, c = 1/n.
-                //a is also an error bound.
-                NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
-                NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
-                int n = 0;
-                while(a.compareTo(maxError) >= 1){
-                    n++;
-                    a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
-                    b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
-                    c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
-                    sum = sum.add(a.add(b).multiply(c));
-                }
-                return sum;
-            }
-        });
-
-        registerFunction("sqrt", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return StandardPlugin.this.getOperator("^").getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
-            }
-        });
-    }
-
-    @Override
-    public void onDisable() {
-
-    }
-
-    /**
-     * Returns the nth term of the Taylor series (centered at 0) of e^x
-     * @param n the term required (n >= 0).
-     * @param x the real number at which the series is evaluated.
-     * @return the nth term of the series.
-     */
-    private NumberInterface getExpSeriesTerm(int n, NumberInterface x){
-        return x.intPow(n).divide(this.getOperator("!").getFunction().apply((new NaiveNumber(n)).promoteTo(x.getClass())));
-    }
-
-    /**
-     * Returns the number of terms needed to evaluate the exponential function (at x)
-     * such that the error is at most maxError.
-     * @param maxError Maximum error permissible (This should probably be positive.)
-     * @param x where the function is evaluated.
-     * @return the number of terms needed to evaluated the exponential function.
-     */
-    private int getNTermsExp(NumberInterface maxError, NumberInterface x) {
-        //We need n such that |x^(n+1)| <= (n+1)! * maxError
-        //The variables LHS and RHS refer to the above inequality.
-        int n = 0;
-        x = this.getFunction("abs").apply(x);
-        NumberInterface LHS = x, RHS = maxError;
-        while (LHS.compareTo(RHS) > 0) {
-            n++;
-            LHS = LHS.multiply(x);
-            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
-        }
-        return n;
-    }
-
-
-    /**
-     * Returns a partial sum of a series whose terms are given by the nthTermFunction, evaluated at x.
-     * @param x the value at which the series is evaluated.
-     * @param nthTermFunction the function that returns the nth term of the series, in the format term(x, n).
-     * @param n the number of terms in the partial sum.
-     * @return the value of the partial sum that has the same class as x.
-     */
-    private NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n){
-        NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClass());
-        for(int i = 0; i <= n; i++){
-            sum = sum.add(nthTermFunction.apply(i, x));
-        }
-        return sum;
-    }
-
-    /**
-     * Returns the maximum error based on the precision of the class of number.
-     * @param number Any instance of the NumberInterface in question (should return an appropriate precision).
-     * @return the maximum error.
-     */
-    private NumberInterface getMaxError(NumberInterface number){
-        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
-    }
-
-}

src/org/nwapw/abacus/tree/TreeBuilder.java

@@ -1,212 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.OperatorAssociativity;
-import org.nwapw.abacus.function.OperatorType;
-import org.nwapw.abacus.lexing.Lexer;
-import org.nwapw.abacus.lexing.pattern.Match;
-import org.nwapw.abacus.lexing.pattern.Pattern;
-
-import java.util.*;
-
-/**
- * The builder responsible for turning strings into trees.
- */
-public class TreeBuilder {
-
-    /**
-     * The lexer used to get the input tokens.
-     */
-    private Lexer<TokenType> lexer;
-    /**
-     * The map of operator precedences.
-     */
-    private Map<String, Integer> precedenceMap;
-    /**
-     * The map of operator associativity.
-     */
-    private Map<String, OperatorAssociativity> associativityMap;
-    /**
-     * The map of operator types.
-     */
-    private Map<String, OperatorType> typeMap;
-    /**
-     * The abacus instance required to interact with
-     * other components of the calculator.
-     */
-    private Abacus abacus;
-
-    /**
-     * Comparator used to sort token types.
-     */
-    protected static Comparator<TokenType> tokenSorter = Comparator.comparingInt(e -> e.priority);
-
-    /**
-     * Creates a new TreeBuilder.
-     */
-    public TreeBuilder(Abacus abacus){
-        this.abacus = abacus;
-        lexer = new Lexer<TokenType>(){{
-            register(" ", TokenType.WHITESPACE);
-            register(",", TokenType.COMMA);
-            register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
-            register("\\(", TokenType.OPEN_PARENTH);
-            register("\\)", TokenType.CLOSE_PARENTH);
-        }};
-        precedenceMap = new HashMap<>();
-        associativityMap = new HashMap<>();
-        typeMap = new HashMap<>();
-    }
-
-    /**
-     * Registers a function with the TreeBuilder.
-     * @param function the function to register.
-     */
-    public void registerFunction(String function){
-        lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
-    }
-
-    /**
-     * Registers an operator with the TreeBuilder.
-     * @param operator the operator to register.
-     * @param precedence the precedence of the operator.
-     * @param associativity the associativity of the operator.
-     */
-    public void registerOperator(String operator, OperatorAssociativity associativity,
-                                 OperatorType operatorType, int precedence){
-        lexer.register(Pattern.sanitize(operator), TokenType.OP);
-        precedenceMap.put(operator, precedence);
-        associativityMap.put(operator, associativity);
-        typeMap.put(operator, operatorType);
-    }
-
-    /**
-     * Tokenizes a string, converting it into matches
-     * @param string the string to tokenize.
-     * @return the list of tokens produced.
-     */
-    public List<Match<TokenType>> tokenize(String string){
-        return lexer.lexAll(string, 0, tokenSorter);
-    }
-
-    /**
-     * Rearranges tokens into a postfix list, using Shunting Yard.
-     * @param source the source string.
-     * @param from the tokens to be rearranged.
-     * @return the resulting list of rearranged tokens.
-     */
-    public List<Match<TokenType>> intoPostfix(String source, List<Match<TokenType>> from){
-        ArrayList<Match<TokenType>> output = new ArrayList<>();
-        Stack<Match<TokenType>> tokenStack = new Stack<>();
-        while(!from.isEmpty()){
-            Match<TokenType> match = from.remove(0);
-            TokenType matchType = match.getType();
-            if(matchType == TokenType.NUM) {
-                output.add(match);
-            } else if(matchType == TokenType.FUNCTION) {
-                output.add(new Match<>(0, 0, TokenType.INTERNAL_FUNCTION_END));
-                tokenStack.push(match);
-            } else if(matchType == TokenType.OP){
-                String tokenString = source.substring(match.getFrom(), match.getTo());
-                OperatorType type = typeMap.get(tokenString);
-                int precedence = precedenceMap.get(tokenString);
-                OperatorAssociativity associativity = associativityMap.get(tokenString);
-
-                if(type == OperatorType.UNARY_POSTFIX){
-                    output.add(match);
-                    continue;
-                }
-
-                while(!tokenStack.empty()) {
-                    Match<TokenType> otherMatch = tokenStack.peek();
-                    TokenType otherMatchType = otherMatch.getType();
-                    if(!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
-
-                    if(otherMatchType == TokenType.OP){
-                        int otherPrecedence = precedenceMap.get(source.substring(otherMatch.getFrom(), otherMatch.getTo()));
-                        if(otherPrecedence < precedence ||
-                                (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
-                            break;
-                        }
-                    }
-                    output.add(tokenStack.pop());
-                }
-                tokenStack.push(match);
-            } else if(matchType == TokenType.OPEN_PARENTH){
-                tokenStack.push(match);
-            } else if(matchType == TokenType.CLOSE_PARENTH || matchType == TokenType.COMMA){
-                while(!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH){
-                    output.add(tokenStack.pop());
-                }
-                if(tokenStack.empty()) return null;
-                if(matchType == TokenType.CLOSE_PARENTH){
-                    tokenStack.pop();
-                }
-            }
-        }
-        while(!tokenStack.empty()){
-            Match<TokenType> match = tokenStack.peek();
-            TokenType matchType = match.getType();
-            if(!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
-            output.add(tokenStack.pop());
-        }
-        return output;
-    }
-
-    /**
-     * Constructs a tree recursively from a list of tokens.
-     * @param source the source string.
-     * @param matches the list of tokens from the source string.
-     * @return the construct tree expression.
-     */
-    public TreeNode fromStringRecursive(String source, List<Match<TokenType>> matches){
-        if(matches.size() == 0) return null;
-        Match<TokenType> match = matches.remove(0);
-        TokenType matchType = match.getType();
-        if(matchType == TokenType.OP){
-            String operator = source.substring(match.getFrom(), match.getTo());
-            OperatorType type = typeMap.get(operator);
-            if(type == OperatorType.BINARY_INFIX){
-                TreeNode right = fromStringRecursive(source, matches);
-                TreeNode left = fromStringRecursive(source, matches);
-                if(left == null || right == null) return null;
-                else return new BinaryInfixNode(operator, left, right);
-            } else {
-                TreeNode applyTo = fromStringRecursive(source, matches);
-                if(applyTo == null) return null;
-                else return new UnaryPrefixNode(operator, applyTo);
-            }
-        } else if(matchType == TokenType.NUM){
-            return new NumberNode(abacus.numberFromString(source.substring(match.getFrom(), match.getTo())));
-        } else if(matchType == TokenType.FUNCTION){
-            String functionName = source.substring(match.getFrom(), match.getTo());
-            FunctionNode node = new FunctionNode(functionName);
-            while(!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END){
-                TreeNode argument = fromStringRecursive(source, matches);
-                if(argument == null) return null;
-                node.prependChild(argument);
-            }
-            if(matches.isEmpty()) return null;
-            matches.remove(0);
-            return node;
-        }
-        return null;
-    }
-
-    /**
-     * Creates a tree node from a string.
-     * @param string the string to create a node from.
-     * @return the resulting tree.
-     */
-    public TreeNode fromString(String string){
-        List<Match<TokenType>> matches = tokenize(string);
-        if(matches == null) return null;
-        matches.removeIf(m -> m.getType() == TokenType.WHITESPACE);
-        matches = intoPostfix(string, matches);
-        if(matches == null) return null;
-
-        Collections.reverse(matches);
-        return fromStringRecursive(string, matches);
-    }
-
-}

src/test/java/org/nwapw/abacus/tests/LexerTests.java

@@ -0,0 +1,133 @@
+package org.nwapw.abacus.tests;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.nwapw.abacus.lexing.Lexer;
+import org.nwapw.abacus.lexing.pattern.Match;
+
+import java.util.List;
+
+public class LexerTests {
+
+    @Test
+    public void testBasicSuccess() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("abc", 0);
+        lexer.register("def", 1);
+        List<Match<Integer>> matchedIntegers = lexer.lexAll("abcdefabc", 0, Integer::compare);
+        Assert.assertNotNull(matchedIntegers);
+        Assert.assertEquals(matchedIntegers.get(0).getType(), Integer.valueOf(0));
+        Assert.assertEquals(matchedIntegers.get(1).getType(), Integer.valueOf(1));
+        Assert.assertEquals(matchedIntegers.get(2).getType(), Integer.valueOf(0));
+    }
+
+    @Test
+    public void testBasicFailure() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("abc", 0);
+        lexer.register("def", 1);
+        Assert.assertNull(lexer.lexAll("abcdefabcz", 0, Integer::compare));
+    }
+
+    @Test
+    public void testNoPatterns() {
+        Lexer<Integer> lexer = new Lexer<>();
+        Assert.assertNull(lexer.lexAll("abcdefabc", 0, Integer::compare));
+    }
+
+    @Test
+    public void testEmptyMatches() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a?", 0);
+        Assert.assertNull(lexer.lexAll("", 0, Integer::compare));
+    }
+
+    @Test
+    public void testOneOrMore() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a+", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    public void testZeroOrMore() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a*", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    public void testZeroOrOne() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a?", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 4);
+    }
+
+    @Test
+    public void testGreedyMatching() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a*a", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    public void testAnyCharacter() {
+        String testString = "abcdef";
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register(".", 0);
+        List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), testString.length());
+        for (int i = 0; i < tokens.size(); i++) {
+            Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
+        }
+    }
+
+    @Test
+    public void testBasicGroup() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("(abc)", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("abc", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+        Assert.assertEquals(tokens.get(0).getContent(), "abc");
+    }
+
+    @Test
+    public void testBasicRangeSuccess() {
+        String testString = "abcdef";
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("[a-f]", 0);
+        List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(testString.length(), tokens.size());
+        for (int i = 0; i < tokens.size(); i++) {
+            Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
+        }
+    }
+
+    @Test
+    public void testBasicRangeFailure() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("[a-f]", 0);
+        Assert.assertNull(lexer.lexAll("g", 0, Integer::compare));
+    }
+
+    @Test
+    public void testGroupAndOperator() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("(abc)+", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("abcabc", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+}

src/test/java/org/nwapw/abacus/tests/TokenizerTests.java

@@ -0,0 +1,124 @@
+package org.nwapw.abacus.tests;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.parsing.LexerTokenizer;
+import org.nwapw.abacus.plugin.Plugin;
+import org.nwapw.abacus.tree.TokenType;
+
+import java.util.List;
+
+public class TokenizerTests {
+
+    private static Abacus abacus = new Abacus();
+    private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
+    private static Function subtractFunction = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].subtract(params[1]);
+        }
+    };
+    private static Plugin testPlugin = new Plugin(abacus.getPluginManager()) {
+        @Override
+        public void onEnable() {
+            registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0, subtractFunction));
+            registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0, subtractFunction));
+            registerFunction("subtract", subtractFunction);
+        }
+
+        @Override
+        public void onDisable() {
+
+        }
+    };
+
+    private static void assertTokensMatch(List<Match<TokenType>> tokenList, TokenType[] expectedTypes) {
+        Assert.assertNotNull(tokenList);
+        Assert.assertEquals(tokenList.size(), expectedTypes.length);
+        for (int i = 0; i < expectedTypes.length; i++) {
+            Assert.assertEquals(expectedTypes[i], tokenList.get(i).getType());
+        }
+    }
+
+    @BeforeClass
+    public static void prepareTests() {
+        abacus.getPluginManager().addListener(lexerTokenizer);
+        abacus.getPluginManager().addInstantiated(testPlugin);
+        abacus.getPluginManager().load();
+    }
+
+    @Test
+    public void testInteger() {
+        assertTokensMatch(lexerTokenizer.tokenizeString("11"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testLeadingZeroDecimal() {
+        assertTokensMatch(lexerTokenizer.tokenizeString("0.1"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testNonLeadingDecimal() {
+        assertTokensMatch(lexerTokenizer.tokenizeString(".1"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testSimpleChars() {
+        TokenType[] types = {
+                TokenType.OPEN_PARENTH,
+                TokenType.WHITESPACE,
+                TokenType.COMMA,
+                TokenType.CLOSE_PARENTH
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("( ,)"), types);
+    }
+
+    @Test
+    public void testFunctionParsing() {
+        TokenType[] types = {
+                TokenType.FUNCTION,
+                TokenType.OPEN_PARENTH,
+                TokenType.NUM,
+                TokenType.COMMA,
+                TokenType.NUM,
+                TokenType.CLOSE_PARENTH
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("subtract(1,2)"), types);
+    }
+
+    @Test
+    public void testOperatorParsing() {
+        TokenType[] types = {
+                TokenType.NUM,
+                TokenType.OP,
+                TokenType.NUM
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("1-1"), types);
+    }
+
+    @Test
+    public void testSanitizedOperators() {
+        TokenType[] types = {
+                TokenType.NUM,
+                TokenType.OP,
+                TokenType.NUM
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("1+1"), types);
+    }
+
+}