diff options
Diffstat (limited to 'src/main/com/jantuomi/borker')
72 files changed, 3094 insertions, 0 deletions
diff --git a/src/main/com/jantuomi/borker/Main.java b/src/main/com/jantuomi/borker/Main.java new file mode 100644 index 0000000..d7445a8 --- /dev/null +++ b/src/main/com/jantuomi/borker/Main.java @@ -0,0 +1,90 @@ +package com.jantuomi.borker; + +import com.jantuomi.borker.core.CommandLineArgumentContainer; +import com.jantuomi.borker.core.parser.ASTGenerator; +import com.jantuomi.borker.core.parser.Parser; +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.runtime.Interpreter; +import com.jantuomi.borker.core.tokenizer.Tokenizer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; +import org.kohsuke.args4j.CmdLineException; +import org.kohsuke.args4j.CmdLineParser; + +import java.util.Collections; +import java.util.List; +import java.util.Scanner; + +public class Main { + + public static void main(String[] args) throws Exception { + boolean parseSuccess = parseArguments(args); + if (!parseSuccess) { + return; + } + + if (CommandLineArgumentContainer.getInstance().isInteractive()) { + repl(); + } else { + String sourceFileContents = CommandLineArgumentContainer.getInstance().getSourceFileContents(); + run(sourceFileContents); + } + } + + public static void repl() { + Scanner scanner = new Scanner(System.in); + String input; + while (true) { + System.out.print(">> "); + input = scanner.nextLine(); + + try { + run(input); + } catch (InterpreterException e) { + e.printStackTrace(); + } + } + } + + public static void run(String input) throws InterpreterException { + Tokenizer tokenizer = Tokenizer.getInstance(); + List<Token> sequence = tokenizer.tokenize(input); + + Collections.reverse(sequence); + + List<Token> trees = Parser.getInstance().parse(sequence); + if (CommandLineArgumentContainer.getInstance().isDebugModeActive()) { + Parser.getInstance().printAllTrees(trees); + } + + List<ASTNode> nodes = ASTGenerator.getInstance().generate(trees); + if (CommandLineArgumentContainer.getInstance().isDebugModeActive()) { + ASTGenerator.getInstance().printAllTrees(nodes); + } + + String output = Interpreter.execute(nodes); + + if (output.trim().length() > 0) { + System.out.println(output); + } + } + + public static boolean parseArguments(String[] args) { + CommandLineArgumentContainer container = CommandLineArgumentContainer.getInstance(); + CmdLineParser parser = new CmdLineParser(container); + + + try { + if (args.length == 0) { + throw new CmdLineException("Please provide an argument."); + } + parser.parseArgument(args); + } catch (CmdLineException e) { + System.err.println(e.getMessage()); + parser.printUsage(System.err); + return false; + } + + return true; + } +} diff --git a/src/main/com/jantuomi/borker/core/CommandLineArgumentContainer.java b/src/main/com/jantuomi/borker/core/CommandLineArgumentContainer.java new file mode 100644 index 0000000..b89c88e --- /dev/null +++ b/src/main/com/jantuomi/borker/core/CommandLineArgumentContainer.java @@ -0,0 +1,73 @@ +package com.jantuomi.borker.core; + + +import org.kohsuke.args4j.Option; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; + +/** + * Created by jan on 10.6.2016. + */ + +public class CommandLineArgumentContainer { + + private CommandLineArgumentContainer() {} + + private static final CommandLineArgumentContainer instance = new CommandLineArgumentContainer(); + private File srcFile; + + + @Option(name="-f", usage="Execute script in file FILE.") + public void setFile(File file) { + this.srcFile = file; + } + + @Option(name="-i", usage="Run in interactive mode.") + public boolean interactiveModeActive = false; + + + @Option(name="-d", usage="Display verbose debug output.") + public boolean debugModeActive = false; + + public static CommandLineArgumentContainer getInstance() { + return instance; + } + + public boolean isInteractive() { + return interactiveModeActive; + } + + public boolean isDebugModeActive() { + return debugModeActive; + } + + public String getSourceFileContents() { + if (srcFile == null) { + return null; + } + + BufferedReader br; + String contents = null; + try { + br = new BufferedReader(new FileReader(srcFile)); + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + contents = sb.toString(); + } catch (IOException e) { + e.printStackTrace(); + return null; + } finally { + // Add a newline at the end for comment rows to terminate nicely + return contents + "\n"; + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ASTGenerator.java b/src/main/com/jantuomi/borker/core/parser/ASTGenerator.java new file mode 100644 index 0000000..4086929 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ASTGenerator.java @@ -0,0 +1,43 @@ +package com.jantuomi.borker.core.parser; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class ASTGenerator { + private static final ASTGenerator instance = new ASTGenerator(); + + private ASTGenerator() {} + + public static ASTGenerator getInstance() { + return instance; + } + + public List<ASTNode> generate(List<Token> trees) throws InterpreterException { + List<ASTNode> list = new ArrayList<>(); + + for (Token root : trees) { + list.add(root.generateNode()); + } + + return list; + } + + public void printTree(ASTNode root) { + System.out.println("### AST Tree begin ###"); + root.print(0); + System.out.println("### AST Tree end ###"); + } + + public void printAllTrees(List<ASTNode> trees) { + for (ASTNode tree : trees) { + printTree(tree); + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/Parser.java b/src/main/com/jantuomi/borker/core/parser/Parser.java new file mode 100644 index 0000000..99f81e9 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/Parser.java @@ -0,0 +1,108 @@ +package com.jantuomi.borker.core.parser; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +/** + * Created by jan on 11.6.2016. + */ +public class Parser { + private static final Parser instance = new Parser(); + + private List<Token> tokens; + private List<ASTNode> statementSequence; + + public static Parser getInstance() { + return instance; + } + + private Parser() { + + } + + private Stack<Token> stack; + + public List<Token> parse(List<Token> tokens) throws InterpreterException { + this.tokens = tokens; + this.stack = new Stack<>(); + + List<Token> args; + List<Token> output = new ArrayList<>(); + for (Token t : tokens) { + if (t.getTokenType() == Token.Type.NewlineToken) { +// if (stack.size() > 0) { +// output.add(stack.pop()); +// } + continue; + } + + args = new ArrayList<>(); + ArgumentInfo argumentInfo = t.getArgumentInfo(); + + /* + This branch is executed if the token has a variable list of arguments + */ + if (argumentInfo.getVarargs()) { + while (true) { + if (stack.size() > 0) { + Token arg = stack.pop(); + if (arg.getTokenType() != argumentInfo.getTerminator()) { + args.add(arg); + } + else { + args.add(arg); + break; + } + } + } + } + /* + If the token has an optional argument type (it is only an argument if + it is of certain type) + */ + else if (argumentInfo.getOptionalArgument() != null) { + if (stack.size() > 0 && stack.peek().getTokenType() == argumentInfo.getOptionalArgument()) { + args.add(stack.pop()); + } + } + /* Normal cases with a fixed list of arguments */ + else { + for (int i = 0; i < argumentInfo.getCount(); i++) { + if (stack.size() > 0) { + args.add(stack.pop()); + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.ArgumentError, t.getLine(), + t.toString(), Integer.toString(argumentInfo.getCount())); + return null; + } + } + } + + Token result = t.setArguments(args); + stack.push(result); + } + while (stack.size() > 0) { + output.add(stack.pop()); + } + return output; + } + + public void printTree(Token e) { + System.out.println("### Token Tree begin ###"); + e.print(0); + System.out.println("### Token Tree end ###"); + } + + public void printAllTrees(List<Token> trees) { + for (Token tree : trees) { + printTree(tree); + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/ASTNode.java b/src/main/com/jantuomi/borker/core/parser/ast/ASTNode.java new file mode 100644 index 0000000..3967edb --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/ASTNode.java @@ -0,0 +1,40 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.List; + +/** + * Created by jan on 11.6.2016. + */ +abstract public class ASTNode { + + public abstract DataContainer evaluate() throws InterpreterException; + + protected Token source; + + public ASTNode(Token token) { + this.source = token; + } + + public Token.Type tokenType() { + return source.getTokenType(); + } + + abstract List<ASTNode> getChildren(); + + public void print(int indent) { + for (int i = 0; i < indent; i++) { + System.out.print("\t"); + } + + System.out.println(source.toString()); + for (ASTNode node : getChildren()) { + if (node != null) { + node.print(indent + 1); + } + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/AdditionNode.java b/src/main/com/jantuomi/borker/core/parser/ast/AdditionNode.java new file mode 100644 index 0000000..ba99a54 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/AdditionNode.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class AdditionNode extends BinaryOperatorNode { + + public AdditionNode(Token token, ASTNode lhs, ASTNode rhs) { + super(token, lhs, rhs); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer operand1 = lhs.evaluate(); + DataContainer operand2 = rhs.evaluate(); + + DataContainer result = operand1.add(operand2); + if (result != null) { + return result; + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(), + operand1.getType().toString(), operand2.getType().toString()); + return null; + } + + } + @Override + List<ASTNode> getChildren() { + return Arrays.asList(lhs, rhs); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/AssignmentNode.java b/src/main/com/jantuomi/borker/core/parser/ast/AssignmentNode.java new file mode 100644 index 0000000..94013c2 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/AssignmentNode.java @@ -0,0 +1,34 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.runtime.State; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class AssignmentNode extends BinaryOperatorNode { + public AssignmentNode(Token token, SymbolNode lhs, ASTNode rhs) { + super(token, lhs, rhs); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + SymbolNode symbol = (SymbolNode) lhs; + DataContainer rValue = rhs.evaluate(); + State.getInstance().setSymbolValueToScope( + symbol.getName(), + rValue + ); + return rValue; + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(lhs, rhs); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/BinaryOperatorNode.java b/src/main/com/jantuomi/borker/core/parser/ast/BinaryOperatorNode.java new file mode 100644 index 0000000..a8f473f --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/BinaryOperatorNode.java @@ -0,0 +1,17 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.tokenizer.token.Token; + +/** + * Created by jan on 16.6.2016. + */ +abstract public class BinaryOperatorNode extends ASTNode { + protected ASTNode lhs; + protected ASTNode rhs; + + public BinaryOperatorNode(Token token, ASTNode lhs, ASTNode rhs) { + super(token); + this.lhs = lhs; + this.rhs = rhs; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/BlockBodyNode.java b/src/main/com/jantuomi/borker/core/parser/ast/BlockBodyNode.java new file mode 100644 index 0000000..dd0582c --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/BlockBodyNode.java @@ -0,0 +1,26 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.VoidDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 17.6.2016. + */ +public class BlockBodyNode extends VarargOperatorNode { + public BlockBodyNode(Token token) { + super(token); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer returnValue = new VoidDataContainer(); + + for (ASTNode node : args) { + returnValue = node.evaluate(); + } + + return returnValue; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/BooleanLiteralNode.java b/src/main/com/jantuomi/borker/core/parser/ast/BooleanLiteralNode.java new file mode 100644 index 0000000..b5818a9 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/BooleanLiteralNode.java @@ -0,0 +1,30 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.BooleanDataContainer; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class BooleanLiteralNode extends ASTNode { + private BooleanDataContainer value; + + public BooleanLiteralNode(Token token) { + super(token); + value = new BooleanDataContainer(Boolean.parseBoolean(token.getText())); + } + + @Override + public DataContainer evaluate() { + return value; + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/BranchNode.java b/src/main/com/jantuomi/borker/core/parser/ast/BranchNode.java new file mode 100644 index 0000000..12f304c --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/BranchNode.java @@ -0,0 +1,42 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.BooleanDataContainer; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 17.6.2016. + */ +public class BranchNode extends ASTNode { + + private ASTNode expression; + private BlockBodyNode branch; + + public BranchNode(Token token, ASTNode expression, BlockBodyNode branch) { + super(token); + this.expression = expression; + this.branch = branch; + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer ev = expression.evaluate(); + boolean returnValue = false; + if (ev instanceof BooleanDataContainer) { + returnValue = ((BooleanDataContainer) ev).getData(); + if (returnValue) { + branch.evaluate(); + } + } + return new BooleanDataContainer(returnValue); + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(expression, branch); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/DivisionNode.java b/src/main/com/jantuomi/borker/core/parser/ast/DivisionNode.java new file mode 100644 index 0000000..04af834 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/DivisionNode.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class DivisionNode extends BinaryOperatorNode { + + public DivisionNode(Token token, ASTNode lhs, ASTNode rhs) { + super(token, lhs, rhs); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer operand1 = lhs.evaluate(); + DataContainer operand2 = rhs.evaluate(); + + DataContainer result = operand1.divide(operand2); + if (result != null) { + return result; + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(), + operand1.getType().toString(), operand2.getType().toString()); + return null; + } + + } + @Override + List<ASTNode> getChildren() { + return Arrays.asList(lhs, rhs); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/DoubleLiteralNode.java b/src/main/com/jantuomi/borker/core/parser/ast/DoubleLiteralNode.java new file mode 100644 index 0000000..084218b --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/DoubleLiteralNode.java @@ -0,0 +1,30 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.DoubleDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class DoubleLiteralNode extends ASTNode { + private DoubleDataContainer value; + + public DoubleLiteralNode(Token token) { + super(token); + value = new DoubleDataContainer(Double.parseDouble(token.getText())); + } + + @Override + public DataContainer evaluate() { + return value; + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/EmptyNode.java b/src/main/com/jantuomi/borker/core/parser/ast/EmptyNode.java new file mode 100644 index 0000000..cd97f44 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/EmptyNode.java @@ -0,0 +1,27 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.VoidDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 17.6.2016. + */ +public class EmptyNode extends ASTNode { + public EmptyNode(Token source) { + super(source); + } + + @Override + public DataContainer evaluate() { + return new VoidDataContainer(); + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/FunctionDefineNode.java b/src/main/com/jantuomi/borker/core/parser/ast/FunctionDefineNode.java new file mode 100644 index 0000000..2365511 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/FunctionDefineNode.java @@ -0,0 +1,73 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.runtime.Function; +import com.jantuomi.borker.core.runtime.State; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 17.6.2016. + */ +public class FunctionDefineNode extends VarargOperatorNode { + + private String name; + + public void setBody(ASTNode body) { + this.body = body; + } + + public void setName(String name) { + this.name = name; + } + + private ASTNode body; + + public FunctionDefineNode(Token token) { + super(token); + } + + @Override + public DataContainer evaluate() { + List<String> argumentNames = new ArrayList<>(); + for (ASTNode arg : args) { + SymbolNode argSym = (SymbolNode) arg; + argumentNames.add(argSym.getName()); + } + Function function = new Function(argumentNames, (BlockBodyNode) body); + function.setName(name); + State.getInstance().addFunctionToScope(name, function); + + return new StringDataContainer("function " + name); + } + + @Override + public void print(int indent) { + + for (int i = 0; i < indent; i++) { + System.out.print("\t"); + } + + System.out.println(String.format("Function %s", name)); + + for (int i = 0; i < indent + 1; i++) { + System.out.print("\t"); + } + + System.out.println(String.format("Arguments: ")); + + for (ASTNode node : args) { + node.print(indent + 2); + } + + for (int i = 0; i < indent + 1; i++) { + System.out.print("\t"); + } + + System.out.println(String.format("Body statements: ")); + body.print(indent + 2); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/IntegerLiteralNode.java b/src/main/com/jantuomi/borker/core/parser/ast/IntegerLiteralNode.java new file mode 100644 index 0000000..573d491 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/IntegerLiteralNode.java @@ -0,0 +1,30 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.IntegerDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class IntegerLiteralNode extends ASTNode { + private IntegerDataContainer value; + + public IntegerLiteralNode(Token token) { + super(token); + value = new IntegerDataContainer(Integer.parseInt(token.getText())); + } + + @Override + public DataContainer evaluate() { + return value; + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/MultiplicationNode.java b/src/main/com/jantuomi/borker/core/parser/ast/MultiplicationNode.java new file mode 100644 index 0000000..53bf8ee --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/MultiplicationNode.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class MultiplicationNode extends BinaryOperatorNode { + + public MultiplicationNode(Token token, ASTNode lhs, ASTNode rhs) { + super(token, lhs, rhs); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer operand1 = lhs.evaluate(); + DataContainer operand2 = rhs.evaluate(); + + DataContainer result = operand1.multiply(operand2); + if (result != null) { + return result; + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(), + operand1.getType().toString(), operand2.getType().toString()); + return null; + } + + } + @Override + List<ASTNode> getChildren() { + return Arrays.asList(lhs, rhs); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/NegationNode.java b/src/main/com/jantuomi/borker/core/parser/ast/NegationNode.java new file mode 100644 index 0000000..2617198 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/NegationNode.java @@ -0,0 +1,34 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.BooleanDataContainer; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.IntegerDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 21.6.2016. + */ +public class NegationNode extends UnaryOperatorNode { + public NegationNode(Token token, ASTNode operand) { + super(token, operand); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer d = getOperand().evaluate(); + + if (d instanceof BooleanDataContainer) { + return new BooleanDataContainer(!((BooleanDataContainer) d).getData()); + } + else if (d instanceof IntegerDataContainer) { + return new BooleanDataContainer( + ((IntegerDataContainer) d).getData() != 0 + ); + } + ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(), "not", d.toString()); + return null; + + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/ParameterListNode.java b/src/main/com/jantuomi/borker/core/parser/ast/ParameterListNode.java new file mode 100644 index 0000000..2d76694 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/ParameterListNode.java @@ -0,0 +1,38 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 19.6.2016. + */ +public class ParameterListNode extends ASTNode { + + private List<ASTNode> parameters = new ArrayList<>(); + + public void addParameter(ASTNode param) { + parameters.add(param); + } + + public List<ASTNode> getParameters() { + return parameters; + } + + public ParameterListNode(Token token) { + super(token); + } + + @Override + public DataContainer evaluate() { + // TODO use State to evaluate function + return null; + } + + @Override + List<ASTNode> getChildren() { + return parameters; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/StringLiteralNode.java b/src/main/com/jantuomi/borker/core/parser/ast/StringLiteralNode.java new file mode 100644 index 0000000..214316a --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/StringLiteralNode.java @@ -0,0 +1,27 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class StringLiteralNode extends ASTNode { + @Override + public DataContainer evaluate() { + return new StringDataContainer(source.getText()); + } + + public StringLiteralNode(Token source) { + super(source); + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/SubtractionNode.java b/src/main/com/jantuomi/borker/core/parser/ast/SubtractionNode.java new file mode 100644 index 0000000..6f0b3fb --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/SubtractionNode.java @@ -0,0 +1,38 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class SubtractionNode extends BinaryOperatorNode { + public SubtractionNode(Token token, ASTNode lhs, ASTNode rhs) { + super(token, lhs, rhs); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + DataContainer operand1 = lhs.evaluate(); + DataContainer operand2 = rhs.evaluate(); + + DataContainer result = operand1.subtract(operand2); + if (result != null) { + return result; + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.TypeError, source.getLine(), + operand1.getType().toString(), operand2.getType().toString()); + return null; + } + + } + @Override + List<ASTNode> getChildren() { + return Arrays.asList(lhs, rhs); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/SymbolNode.java b/src/main/com/jantuomi/borker/core/parser/ast/SymbolNode.java new file mode 100644 index 0000000..f473989 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/SymbolNode.java @@ -0,0 +1,70 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.runtime.State; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +/** + * Created by jan on 17.6.2016. + */ +public class SymbolNode extends ASTNode { + + public ParameterListNode getParameterListNode() { + return parameterListNode; + } + + public void setParameterListNode(ParameterListNode parameterListNode) { + this.parameterListNode = parameterListNode; + } + + private ParameterListNode parameterListNode; + + public void setName(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + private String name; + + public SymbolNode(Token token) { + super(token); + } + + @Override + public DataContainer evaluate() throws InterpreterException { + List<DataContainer> paramValues = new ArrayList<>(); + if (parameterListNode != null) { + for (ASTNode param : parameterListNode.getChildren()) { + paramValues.add(param.evaluate()); + } + } + DataContainer returnValue = State.getInstance().getSymbolValue(name, paramValues); + if (returnValue != null) { + return returnValue; + } else { + ExceptionManager.raise(InterpreterException.ExceptionType.UndeclaredSymbolError, source.getLine(), name, + StringUtils.join(paramValues.stream().map(dataContainer -> dataContainer.toString()).collect(Collectors.toList()), ",")); + return null; + } + } + + @Override + List<ASTNode> getChildren() { + if (parameterListNode == null) { + return Arrays.asList(); + } else { + return Arrays.asList(parameterListNode); + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/UnaryOperatorNode.java b/src/main/com/jantuomi/borker/core/parser/ast/UnaryOperatorNode.java new file mode 100644 index 0000000..2636bfe --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/UnaryOperatorNode.java @@ -0,0 +1,31 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +abstract public class UnaryOperatorNode extends ASTNode { + public UnaryOperatorNode(Token token, ASTNode operand) { + super(token); + this.operand = operand; + } + + public ASTNode getOperand() { + return operand; + } + + public void setOperand(ASTNode operand) { + this.operand = operand; + } + + private ASTNode operand; + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(operand); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/VarargOperatorNode.java b/src/main/com/jantuomi/borker/core/parser/ast/VarargOperatorNode.java new file mode 100644 index 0000000..007bdf6 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/VarargOperatorNode.java @@ -0,0 +1,26 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.List; + +/** + * Created by jan on 17.6.2016. + */ +public abstract class VarargOperatorNode extends ASTNode { + + protected List<ASTNode> args; + + public VarargOperatorNode(Token token) { + super(token); + } + + @Override + public List<ASTNode> getChildren() { + return args; + } + + public void setArgs(List<ASTNode> args) { + this.args = args; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/ast/VariableDeclareNode.java b/src/main/com/jantuomi/borker/core/parser/ast/VariableDeclareNode.java new file mode 100644 index 0000000..e37b17f --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/ast/VariableDeclareNode.java @@ -0,0 +1,32 @@ +package com.jantuomi.borker.core.parser.ast; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.runtime.State; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 20.6.2016. + */ +public class VariableDeclareNode extends ASTNode { + private SymbolNode variable; + + public VariableDeclareNode(Token source, SymbolNode variable) { + super(source); + this.variable = variable; + } + + @Override + public DataContainer evaluate() { + State.getInstance().addSymbolToScope(variable.getName()); + return new StringDataContainer(variable.getName()); + } + + @Override + List<ASTNode> getChildren() { + return Arrays.asList(); + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/BooleanDataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/BooleanDataContainer.java new file mode 100644 index 0000000..14f4a80 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/BooleanDataContainer.java @@ -0,0 +1,44 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 16.6.2016. + */ +public class BooleanDataContainer extends DataContainer<Boolean> { + + + public BooleanDataContainer(boolean value) { + setData(value); + } + + @Override + public Type getType() { + return Type.Boolean; + } + + @Override + public String toString() { + return Boolean.toString(getData()); + } + + @Override + public DataContainer<Boolean> add(DataContainer<Boolean> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<Boolean> subtract(DataContainer<Boolean> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<Boolean> multiply(DataContainer<Boolean> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<Boolean> divide(DataContainer<Boolean> other) throws InterpreterException { + return null; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/DataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/DataContainer.java new file mode 100644 index 0000000..cdb202d --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/DataContainer.java @@ -0,0 +1,37 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 11.6.2016. + */ +abstract public class DataContainer<T> { + + public enum Type { + Integer, + Double, + String, + Boolean, + Void + } + + abstract public Type getType(); + + private T data; + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } + + @Override + abstract public String toString(); + + abstract public DataContainer<T> add(DataContainer<T> other) throws InterpreterException; + public abstract DataContainer<T> subtract(DataContainer<T> other) throws InterpreterException; + public abstract DataContainer<T> multiply(DataContainer<T> other) throws InterpreterException; + public abstract DataContainer<T> divide(DataContainer<T> other) throws InterpreterException; +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/DoubleDataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/DoubleDataContainer.java new file mode 100644 index 0000000..e7fea19 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/DoubleDataContainer.java @@ -0,0 +1,86 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 22.6.2016. + */ +public class DoubleDataContainer extends DataContainer<Double> { + public DoubleDataContainer(double value) { + setData(value); + } + + @Override + public Type getType() { + return Type.Double; + } + + @Override + public String toString() { + return getData().toString(); + } + + @Override + public DataContainer add(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Double: + return new DoubleDataContainer( + getData() + ((DoubleDataContainer) other).getData() + ); + case Integer: + return new DoubleDataContainer( + getData() + ((IntegerDataContainer) other).getData() + ); + default: + return null; + } + } + + @Override + public DataContainer subtract(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Double: + return new DoubleDataContainer( + getData() - ((DoubleDataContainer) other).getData() + ); + case Integer: + return new DoubleDataContainer( + getData() - ((IntegerDataContainer) other).getData() + ); + default: + return null; + } + } + + @Override + public DataContainer multiply(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Double: + return new DoubleDataContainer( + getData() * ((DoubleDataContainer) other).getData() + ); + case Integer: + return new DoubleDataContainer( + getData() * ((IntegerDataContainer) other).getData() + ); + default: + return null; + } + } + + @Override + public DataContainer divide(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Double: + return new DoubleDataContainer( + getData() / ((DoubleDataContainer) other).getData() + ); + case Integer: + return new DoubleDataContainer( + getData() / ((IntegerDataContainer) other).getData() + ); + default: + return null; + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/IntegerDataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/IntegerDataContainer.java new file mode 100644 index 0000000..a0e42f6 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/IntegerDataContainer.java @@ -0,0 +1,91 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 16.6.2016. + */ +public class IntegerDataContainer extends DataContainer<Integer> { + + public IntegerDataContainer(int value) { + setData(value); + } + + @Override + public Type getType() { + return Type.Integer; + } + + @Override + public String toString() { + return Integer.toString(getData()); + } + + @Override + public DataContainer add(DataContainer other) { + switch (other.getType()) { + case Integer: + return new IntegerDataContainer( + this.getData() + ((IntegerDataContainer) other).getData() + ); + case Double: + return new DoubleDataContainer( + (double) getData() + ((DoubleDataContainer) other).getData() + ); + default: + return null; + + } + } + + @Override + public DataContainer subtract(DataContainer other) { + switch (other.getType()) { + case Integer: + return new IntegerDataContainer( + this.getData() - ((IntegerDataContainer) other).getData() + ); + case Double: + return new DoubleDataContainer( + (double) getData() - ((DoubleDataContainer) other).getData() + ); + default: + return null; + + } + } + + @Override + public DataContainer multiply(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Integer: + return new IntegerDataContainer( + this.getData() * ((IntegerDataContainer) other).getData() + ); + case Double: + return new DoubleDataContainer( + (double) getData() * ((DoubleDataContainer) other).getData() + ); + default: + return null; + + } + } + + @Override + public DataContainer divide(DataContainer other) throws InterpreterException { + switch (other.getType()) { + case Integer: + return new IntegerDataContainer( + this.getData() / ((IntegerDataContainer) other).getData() + ); + case Double: + return new DoubleDataContainer( + (double) getData() / ((DoubleDataContainer) other).getData() + ); + default: + return null; + + } + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/StringDataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/StringDataContainer.java new file mode 100644 index 0000000..6984642 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/StringDataContainer.java @@ -0,0 +1,46 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 16.6.2016. + */ +public class StringDataContainer extends DataContainer<String> { + + + public StringDataContainer(String text) { + setData(text); + } + + @Override + public Type getType() { + return Type.String; + } + + @Override + public String toString() { + return getData(); + } + + @Override + public DataContainer<String> add(DataContainer<String> other) { + return new StringDataContainer( + getData() + other.getData() + ); + } + + @Override + public DataContainer<String> subtract(DataContainer<String> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<String> multiply(DataContainer<String> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<String> divide(DataContainer<String> other) throws InterpreterException { + return null; + } +} diff --git a/src/main/com/jantuomi/borker/core/parser/datatype/VoidDataContainer.java b/src/main/com/jantuomi/borker/core/parser/datatype/VoidDataContainer.java new file mode 100644 index 0000000..4b7be6c --- /dev/null +++ b/src/main/com/jantuomi/borker/core/parser/datatype/VoidDataContainer.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.parser.datatype; + +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 17.6.2016. + */ +public class VoidDataContainer extends DataContainer<Integer> { + + @Override + public Type getType() { + return Type.Void; + } + + @Override + public String toString() { + return ""; + } + + @Override + public DataContainer<Integer> add(DataContainer<Integer> other) { + return null; + } + + @Override + public DataContainer<Integer> subtract(DataContainer<Integer> other) { + return null; + } + + @Override + public DataContainer<Integer> multiply(DataContainer<Integer> other) throws InterpreterException { + return null; + } + + @Override + public DataContainer<Integer> divide(DataContainer<Integer> other) throws InterpreterException { + return null; + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/Function.java b/src/main/com/jantuomi/borker/core/runtime/Function.java new file mode 100644 index 0000000..714dcea --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/Function.java @@ -0,0 +1,52 @@ +package com.jantuomi.borker.core.runtime; + +import com.jantuomi.borker.core.parser.ast.BlockBodyNode; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.List; + +/** + * Created by jan on 20.6.2016. + */ +public class Function { + + private List<String> argumentNames; + + private BlockBodyNode body; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + private String name; + + public Function(List<String> argumentNames, BlockBodyNode body) { + this.argumentNames = argumentNames; + this.body = body; + } + + public DataContainer evaluate(List<DataContainer> params) throws InterpreterException { + State.getInstance().createScope(); + + if (params.size() != argumentNames.size()) { + return null; + } + + for (int i = 0; i < argumentNames.size(); i++) { + State.getInstance().addSymbolToScope(argumentNames.get(i)); + State.getInstance().setSymbolValueToScope(argumentNames.get(i), params.get(i)); + } + + DataContainer returnValue = body.evaluate(); + + State.getInstance().popScope(); + + return returnValue; + } + +} diff --git a/src/main/com/jantuomi/borker/core/runtime/Interpreter.java b/src/main/com/jantuomi/borker/core/runtime/Interpreter.java new file mode 100644 index 0000000..2a7bbbf --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/Interpreter.java @@ -0,0 +1,35 @@ +package com.jantuomi.borker.core.runtime; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.List; + +/** + * Created by jan on 14.6.2016. + */ +public class Interpreter { + private static final Interpreter instance = new Interpreter(); + + public static Interpreter getInstance() { + return instance; + } + + private Interpreter() { + + } + public static String execute(List<ASTNode> sequence) throws InterpreterException { + String output = ""; + for (ASTNode node : sequence) { + DataContainer data = node.evaluate(); + + if (data != null) { + output = data.toString(); + } else { + break; + } + } + return output; + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/Scope.java b/src/main/com/jantuomi/borker/core/runtime/Scope.java new file mode 100644 index 0000000..90c1578 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/Scope.java @@ -0,0 +1,50 @@ +package com.jantuomi.borker.core.runtime; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Created by jan on 20.6.2016. + */ +public class Scope { + private Scope parent = null; + + private Map<String, DataContainer> variables = new HashMap<>(); + private Map<String, Function> functions = new HashMap<>(); + + public void addVariable(String symbol) { + variables.put(symbol, null); + } + + public void setVariableValue(String symbol, DataContainer value) { + variables.replace(symbol, value); + } + + public DataContainer resolveSymbol(String symbol, List<DataContainer> params) throws InterpreterException { + if (functions.containsKey(symbol)) { + DataContainer r = functions.get(symbol).evaluate(params); + return r; + } + if (variables.containsKey(symbol)) { + return variables.get(symbol); + } + else if (parent != null) { + return parent.resolveSymbol(symbol, params); + } + else { + return null; + } + } + + public void setParent(Scope parent) { + this.parent = parent; + } + + public void addFunction(String symbol, Function func) { + functions.put(symbol, func); + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/State.java b/src/main/com/jantuomi/borker/core/runtime/State.java new file mode 100644 index 0000000..1ad09e7 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/State.java @@ -0,0 +1,74 @@ +package com.jantuomi.borker.core.runtime; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.runtime.builtins.BuiltinManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; +import java.util.Stack; + +/** + * Created by jan on 11.6.2016. + */ +public class State { + private static final State instance = new State(); + + public static State getInstance() { + return instance; + } + + private Stack<Scope> scopes = new Stack<>(); + + private State() { + /* Push global scope onto the stack */ + Scope globalScope = new Scope(); + + for (Function builtin : BuiltinManager.getInstance().getBuiltins()) { + globalScope.addFunction(builtin.getName(), builtin); + } + + scopes.push(globalScope); + + } + + private DataContainer resolveSymbol(String symbol) throws InterpreterException { + return scopes.peek().resolveSymbol(symbol, Arrays.asList()); + } + + public DataContainer getSymbolValue(String symbol) throws InterpreterException { + DataContainer d = resolveSymbol(symbol); + return d; + } + + public DataContainer getSymbolValue(String symbol, List<DataContainer> parameters) throws InterpreterException { + return scopes.peek().resolveSymbol(symbol, parameters); + } + + public Scope createScope() { + Scope scope = new Scope(); + if (scopes.size() > 0) { + scope.setParent(scopes.peek()); + } else { + scope.setParent(null); + } + scopes.push(scope); + return scope; + } + + public void addSymbolToScope(String symbol) { + scopes.peek().addVariable(symbol); + } + + public void addFunctionToScope(String symbol, Function func) { + scopes.peek().addFunction(symbol, func); + } + + public void setSymbolValueToScope(String symbol, DataContainer value) { + scopes.peek().setVariableValue(symbol, value); + } + + public Scope popScope() { + return scopes.pop(); + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/builtins/AsIntBuiltinFunction.java b/src/main/com/jantuomi/borker/core/runtime/builtins/AsIntBuiltinFunction.java new file mode 100644 index 0000000..e1f2a93 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/builtins/AsIntBuiltinFunction.java @@ -0,0 +1,52 @@ +package com.jantuomi.borker.core.runtime.builtins; + +import com.jantuomi.borker.core.parser.datatype.BooleanDataContainer; +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.IntegerDataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.runtime.Function; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class AsIntBuiltinFunction extends Function { + public AsIntBuiltinFunction() { + super( + Arrays.asList("expression"), + null + ); + } + + @Override + public String getName() { + return "as_int"; + } + + @Override + public DataContainer evaluate(List<DataContainer> params) throws InterpreterException { + if (params.size() != 1) { + return null; + } + DataContainer param = params.get(0); + int i = 0; + if (param instanceof StringDataContainer) { + try { + i = Integer.parseInt(((StringDataContainer) param).getData()); + } + catch (NumberFormatException ex) { + return null; + } + } + else if (param instanceof IntegerDataContainer) { + i = ((IntegerDataContainer) param).getData(); + } + else if (param instanceof BooleanDataContainer) { + i = ((BooleanDataContainer) param).getData() ? 1 : 0; + } + return new IntegerDataContainer(i); + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/builtins/BuiltinManager.java b/src/main/com/jantuomi/borker/core/runtime/builtins/BuiltinManager.java new file mode 100644 index 0000000..18f49a9 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/builtins/BuiltinManager.java @@ -0,0 +1,30 @@ +package com.jantuomi.borker.core.runtime.builtins; + +import com.jantuomi.borker.core.runtime.Function; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class BuiltinManager { + private static BuiltinManager instance = new BuiltinManager(); + + public static BuiltinManager getInstance() { + return instance; + } + + private List<Function> builtins = new ArrayList<>(); + + private BuiltinManager() { + builtins.add(new OutBuiltinFunction()); + builtins.add(new InBuiltinFunction()); + builtins.add(new ConcatBuiltinFunction()); + builtins.add(new AsIntBuiltinFunction()); + } + + public List<Function> getBuiltins() { + return builtins; + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/builtins/ConcatBuiltinFunction.java b/src/main/com/jantuomi/borker/core/runtime/builtins/ConcatBuiltinFunction.java new file mode 100644 index 0000000..293b918 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/builtins/ConcatBuiltinFunction.java @@ -0,0 +1,38 @@ +package com.jantuomi.borker.core.runtime.builtins; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.runtime.Function; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class ConcatBuiltinFunction extends Function { + public ConcatBuiltinFunction() { + super( + Arrays.asList("strings"), + null + ); + } + + @Override + public String getName() { + return "concat"; + } + + @Override + public DataContainer evaluate(List<DataContainer> params) throws InterpreterException { + StringBuilder sb = new StringBuilder(); + for (DataContainer d : params) { + sb.append(d.getData()); + } + + return new StringDataContainer( + sb.toString() + ); + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/builtins/InBuiltinFunction.java b/src/main/com/jantuomi/borker/core/runtime/builtins/InBuiltinFunction.java new file mode 100644 index 0000000..8d9184f --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/builtins/InBuiltinFunction.java @@ -0,0 +1,38 @@ +package com.jantuomi.borker.core.runtime.builtins; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.parser.datatype.StringDataContainer; +import com.jantuomi.borker.core.runtime.Function; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; +import java.util.Scanner; + +/** + * Created by jan on 21.6.2016. + */ +public class InBuiltinFunction extends Function { + public InBuiltinFunction() { + super( + Arrays.asList("expression"), + null + ); + } + + @Override + public String getName() { + return "in"; + } + + @Override + public DataContainer evaluate(List<DataContainer> params) throws InterpreterException { + if (params.size() > 0) { + DataContainer param = params.get(0); + System.out.print(param.getData().toString()); + } + Scanner in = new Scanner(System.in); + String userInput = in.nextLine(); + return new StringDataContainer(userInput); + } +} diff --git a/src/main/com/jantuomi/borker/core/runtime/builtins/OutBuiltinFunction.java b/src/main/com/jantuomi/borker/core/runtime/builtins/OutBuiltinFunction.java new file mode 100644 index 0000000..4e977c8 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/runtime/builtins/OutBuiltinFunction.java @@ -0,0 +1,32 @@ +package com.jantuomi.borker.core.runtime.builtins; + +import com.jantuomi.borker.core.parser.datatype.DataContainer; +import com.jantuomi.borker.core.runtime.Function; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class OutBuiltinFunction extends Function { + public OutBuiltinFunction() { + super( + Arrays.asList("expression"), + null + ); + } + + @Override + public String getName() { + return "out"; + } + + @Override + public DataContainer evaluate(List<DataContainer> params) throws InterpreterException { + DataContainer param = params.get(0); + System.out.println(param.getData().toString()); + return param; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/Tokenizer.java b/src/main/com/jantuomi/borker/core/tokenizer/Tokenizer.java new file mode 100644 index 0000000..d7d8870 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/Tokenizer.java @@ -0,0 +1,119 @@ +package com.jantuomi.borker.core.tokenizer; + + +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * Created by jan on 10.6.2016. + */ +public class Tokenizer { + private String sourceString; + + public List<Token> getTokens() { + return tokens; + } + + private List<Token> tokens = new ArrayList<>(); + + private static Map<Token.Type, String> tokenRegexes = new LinkedHashMap<>(); + private static final List<Token.Type> discardedTokenTypes = new ArrayList<>(); + private static final List<Token.Type> erroneousTokenTypes = new ArrayList<>(); + + private static final Tokenizer instance = new Tokenizer(); + + public static final Tokenizer getInstance() { + return instance; + } + + private Tokenizer() { + tokenRegexes.put(Token.Type.CommentToken, "^\\/\\*(.*?)\\*\\/"); + + tokenRegexes.put(Token.Type.DoubleLiteralToken, "^([-+]?[0-9]*\\.?[0-9]+)f\\b"); + tokenRegexes.put(Token.Type.IntegerLiteralToken, "^([-+]?\\d+)\\b"); + tokenRegexes.put(Token.Type.BooleanLiteralToken, "^(true|false)\\b"); + tokenRegexes.put(Token.Type.StringLiteralToken, "^\"(.*?)\""); + + tokenRegexes.put(Token.Type.WhitespaceToken, "^( |\t)"); + tokenRegexes.put(Token.Type.NewlineToken, "^(\n|\r\n)"); + tokenRegexes.put(Token.Type.AdditionToken, "^(\\+)"); + tokenRegexes.put(Token.Type.SubtractionToken, "^(\\-)"); + tokenRegexes.put(Token.Type.DivisionToken, "^(\\/)"); + tokenRegexes.put(Token.Type.MultiplicationToken, "^(\\*)"); + tokenRegexes.put(Token.Type.AssignmentToken, "^(set)\\b"); + tokenRegexes.put(Token.Type.LessThanToken, "^(\\<)"); + tokenRegexes.put(Token.Type.GreaterThanToken, "^(\\>)"); + tokenRegexes.put(Token.Type.LessOrEqualThanToken, "^(\\<\\=)"); + tokenRegexes.put(Token.Type.GreaterOrEqualThanToken, "^(\\>\\=)"); + tokenRegexes.put(Token.Type.EqualsToken, "^(\\=\\=)"); + tokenRegexes.put(Token.Type.NotEqualsToken, "^(\\!\\=)"); + tokenRegexes.put(Token.Type.OpenParenToken, "^(\\()"); + tokenRegexes.put(Token.Type.ClosedParenToken, "^(\\))"); + tokenRegexes.put(Token.Type.FunctionDefineToken, "^(func)\\b"); + tokenRegexes.put(Token.Type.FunctionBodyToken, "^(as)\\b"); + tokenRegexes.put(Token.Type.BranchBodyToken, "^(then)\\b"); + tokenRegexes.put(Token.Type.EndBlockToken, "^(end)\\b"); + tokenRegexes.put(Token.Type.NegationToken, "^(not)\\b"); + tokenRegexes.put(Token.Type.DeclarationToken, "^(decl)\\b"); + tokenRegexes.put(Token.Type.BranchToken, "^(if)\\b"); + + tokenRegexes.put(Token.Type.SymbolToken, "^([a-zA-Z]+\\w*)"); + + discardedTokenTypes.add(Token.Type.WhitespaceToken); + discardedTokenTypes.add(Token.Type.CommentToken); + + erroneousTokenTypes.add(Token.Type.NotAToken); + } + + public List<Token> tokenize(String string) throws InterpreterException { + sourceString = string; + tokens.clear(); + int line = 1; + for (int i = 0; i < string.length();) { + + Token token = Token.makeToken(string.substring(i), tokenRegexes, line); + + if (token == null) { + i++; + continue; + } + + if (token.getTokenType() == Token.Type.NewlineToken) { + line++; + } + + if (!discardedTokenTypes.contains(token.getTokenType())) { + tokens.add(token); + } + + if (erroneousTokenTypes.contains(token.getTokenType())) { + ExceptionManager.raise(InterpreterException.ExceptionType.IllegalTokenError, line, token.getText()); + } + + String tokenRawText = token.getRawText(); + if (tokenRawText == null) { + tokenRawText = token.getText(); + } + if (tokenRawText != null) { + i += tokenRawText.length(); + } else { + i++; + } + } + return tokens; + } + + public static void printTokens(List<Token> tokens) { + System.out.println("### Tokens: ###"); + for (Token token : tokens) { + System.out.println(String.format("%-40s %s", token.getTokenType(), token.getText())); + } + System.out.println("### End ###"); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/ArgumentInfo.java b/src/main/com/jantuomi/borker/core/tokenizer/token/ArgumentInfo.java new file mode 100644 index 0000000..967b341 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/ArgumentInfo.java @@ -0,0 +1,49 @@ +package com.jantuomi.borker.core.tokenizer.token; + +/** + * Created by jan on 15.6.2016. + */ +public class ArgumentInfo { + private int count = 0; + private boolean isVarargs = false; + + public Token.Type getOptionalArgument() { + return optionalArgument; + } + + public void setOptionalArgument(Token.Type optionalArgument) { + this.optionalArgument = optionalArgument; + } + + private Token.Type optionalArgument = null; + + public Token.Type getTerminator() { + return terminator; + } + + public void setTerminator(Token.Type terminator) { + this.terminator = terminator; + } + + private Token.Type terminator; + + public ArgumentInfo(int count) { + this.count = count; + } + + public ArgumentInfo() { + + } + + public void setVariable(boolean value) { + this.isVarargs = value; + } + + public boolean getVarargs() { + return isVarargs; + } + + public int getCount() { + return count; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/Token.java b/src/main/com/jantuomi/borker/core/tokenizer/token/Token.java new file mode 100644 index 0000000..b43755d --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/Token.java @@ -0,0 +1,212 @@ +package com.jantuomi.borker.core.tokenizer.token; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; +import org.apache.commons.lang3.builder.EqualsBuilder; +import org.apache.commons.lang3.builder.HashCodeBuilder; + +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + + +/** + * Created by jan on 10.6.2016. + */ +abstract public class Token { + + public void print(int indent) { + for (int i = 0; i < indent; i++) { + System.out.print("\t"); + } + System.out.println(toString()); + for (Token child : getChildren()) { + child.print(indent + 1); + } + } + + abstract public ASTNode generateNode() throws InterpreterException; + + /* Token types, ordered by precedence */ + public enum Type { + CommentToken, + + AdditionToken, + SubtractionToken, + DivisionToken, + MultiplicationToken, + + AssignmentToken, + + LessThanToken, + GreaterThanToken, + LessOrEqualThanToken, + GreaterOrEqualThanToken, + EqualsToken, + NotEqualsToken, + + OpenParenToken, + ClosedParenToken, + + FunctionDefineToken, + DeclarationToken, + + StringLiteralToken, + IntegerLiteralToken, + BooleanLiteralToken, + DoubleLiteralToken, + + WhitespaceToken, + NewlineToken, + + BranchToken, + SymbolToken, + EndBlockToken, + FunctionBodyToken, + BranchBodyToken, + NegationToken, + + NotAToken + } + + abstract public Token setArguments(List<Token> args); + + abstract public List<Token> getChildren(); + + public boolean is(Type type) { + return getTokenType() == type; + } + + public int getLine() { + return line; + } + + public void setLine(int line) { + this.line = line; + } + + private int line; + private String rawText; + private String text; + private Type type; + + public String getText() { + return text; + } + + public Type getTokenType() { + return this.type; + } + + public String getRawText() { + return rawText; + } + + public boolean isHigherPrecedenceThan(Token other) { + return getTokenType().ordinal() <= other.getTokenType().ordinal(); + } + + public Token(Type type, String text, String rawText) { + initialize(type, text, rawText); + } + + public Token(Type type, String text) { + initialize(type, text); + } + + public Token(Type type) { + initialize(type, null); + } + + private void initialize(Type type, String text, String rawText) { + this.type = type; + this.text = text; + this.rawText = rawText; + } + + private void initialize(Type type, String text) { + initialize(type, text, text); + } + + public static Token makeToken(String string, Map<Type, String> regexes, int line) throws InterpreterException { + Type type = Type.NotAToken; + String text = Character.toString(string.charAt(0)); + + for (Type t : regexes.keySet()) { + String regex = regexes.get(t); + Token found = matchToken(string, t, regex, line); + if (found != null) { + found.setLine(line); + return found; + } + } + + // TODO raise error + return null; + } + + public static Token matchToken(String string, Type type, String regex, int line) throws InterpreterException { + Pattern pattern = Pattern.compile(regex, Pattern.DOTALL); + Matcher matcher = pattern.matcher(string); + + if (matcher.find()) { + String lexeme = matcher.group(1); + String rawText = matcher.group(0); + + Token token = TokenFactory.create(type, lexeme, rawText); + if (token != null) { + token.setLine(line); + } + else { + ExceptionManager.raise(InterpreterException.ExceptionType.IllegalTokenError, line, + type.toString() + ); + } + + return token; + } + return null; + } + + abstract public ArgumentInfo getArgumentInfo(); + + @Override + public int hashCode() { + return new HashCodeBuilder(17, 37) + .append(text) + .append(getTokenType()) + .toHashCode(); + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Token)) return false; + if (o == this) return true; + + Token rhs = (Token) o; + return new EqualsBuilder() + .append(getTokenType(), rhs.getTokenType()) + .append(text, rhs.text) + .isEquals(); + } + + @Override + public String toString() { + return String.format(String.format( + "%s%s", + getTokenType().toString().replace("Token", ""), + getText() == null ? "" : " " + getText() + )); + } + + public String toFormattedString() { + String textRepr = text; + return String.format("%-40s %s", getTokenType(), textRepr); + } + + public boolean isSameType(Token other) { + return type == other.type; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/TokenFactory.java b/src/main/com/jantuomi/borker/core/tokenizer/token/TokenFactory.java new file mode 100644 index 0000000..5fa9473 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/TokenFactory.java @@ -0,0 +1,71 @@ +package com.jantuomi.borker.core.tokenizer.token; + +import com.jantuomi.borker.core.tokenizer.token.types.*; + +/** + * Created by jan on 28.6.2016. + */ +public class TokenFactory { + private static TokenFactory instance = new TokenFactory(); + + public static TokenFactory getInstance() { + return instance; + } + + private TokenFactory() { + } + + public static Token create(Token.Type type, String text, String rawText) { + switch (type) { + case WhitespaceToken: + return new WhitespaceToken(); + case CommentToken: + return new CommentToken(text, rawText); + + // TODO placeholder whitespace instead of newline + case NewlineToken: + return new WhitespaceToken(); + + case IntegerLiteralToken: + return new IntegerLiteralToken(text); + case StringLiteralToken: + return new StringLiteralToken(text, rawText); + case BooleanLiteralToken: + return new BooleanLiteralToken(text); + case DoubleLiteralToken: + return new DoubleLiteralToken(text, rawText); + case AdditionToken: + return new AdditionToken(); + case SubtractionToken: + return new SubtractionToken(); + case MultiplicationToken: + return new MultiplicationToken(); + case DivisionToken: + return new DivisionToken(); + case FunctionDefineToken: + return new FunctionDefineToken(); + case EndBlockToken: + return new EndBlockToken(); + case FunctionBodyToken: + return new BlockBodyToken("as"); + case BranchBodyToken: + return new BlockBodyToken("then"); + case DeclarationToken: + return new VariableDeclareToken(); + case AssignmentToken: + return new AssignmentToken(); + case SymbolToken: + return new SymbolToken(text); + case OpenParenToken: + return new OpenParenToken(); + case ClosedParenToken: + return new ClosedParenToken(); + case BranchToken: + return new BranchToken(); + case NegationToken: + return new NegationToken(); + default: + return null; + } + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/AdditionToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/AdditionToken.java new file mode 100644 index 0000000..ee49846 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/AdditionToken.java @@ -0,0 +1,22 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.AdditionNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 15.6.2016. + */ +public class AdditionToken extends BinaryOperatorToken { + public AdditionToken() { + super(Type.AdditionToken); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new AdditionNode(this, + lhs.generateNode(), + rhs.generateNode() + ); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/AssignmentToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/AssignmentToken.java new file mode 100644 index 0000000..8d8903e --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/AssignmentToken.java @@ -0,0 +1,36 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.AssignmentNode; +import com.jantuomi.borker.core.parser.ast.SymbolNode; +import com.jantuomi.borker.exception.ExceptionManager; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 20.6.2016. + */ +public class AssignmentToken extends BinaryOperatorToken { + + public AssignmentToken() { + super(Type.AssignmentToken, "set"); + } + + // TODO this and the node + + @Override + public ASTNode generateNode() throws InterpreterException { + ASTNode lhsNode = lhs.generateNode(); + + if (!(lhsNode instanceof SymbolNode)) { + ExceptionManager.raise(InterpreterException.ExceptionType.SyntaxError, getLine(), "non-symbol " + toString()); + return null; + } + + AssignmentNode node = new AssignmentNode(this, + (SymbolNode) lhsNode, + rhs.generateNode() + ); + + return node; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/BinaryOperatorToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BinaryOperatorToken.java new file mode 100644 index 0000000..207820a --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BinaryOperatorToken.java @@ -0,0 +1,40 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 15.6.2016. + */ +abstract public class BinaryOperatorToken extends Token { + protected Token lhs; + protected Token rhs; + + public BinaryOperatorToken(Type type) { + super(type); + } + + public BinaryOperatorToken(Type type, String text) { + super(type, text); + } + + @Override + public Token setArguments(List<Token> args) { + lhs = args.get(0); + rhs = args.get(1); + return this; + } + + @Override + public List<Token> getChildren() { + return Arrays.asList(lhs, rhs); + } + + @Override + public ArgumentInfo getArgumentInfo() { + return new ArgumentInfo(2); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/BlockBodyToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BlockBodyToken.java new file mode 100644 index 0000000..c6a251d --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BlockBodyToken.java @@ -0,0 +1,35 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.BlockBodyNode; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class BlockBodyToken extends VarargOperatorToken { + public BlockBodyToken(String keyword) { + super(Type.FunctionBodyToken, keyword); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + BlockBodyNode node = new BlockBodyNode(this); + List<ASTNode> statements = new ArrayList<>(); + for (int i = 0; i < args.size() - 1; i++) { + Token arg = args.get(i); + statements.add(arg.generateNode()); + } + node.setArgs(statements); + return node; + } + + @Override + public Type getTerminatorTokenType() { + return Type.EndBlockToken; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/BooleanLiteralToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BooleanLiteralToken.java new file mode 100644 index 0000000..4e8510c --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BooleanLiteralToken.java @@ -0,0 +1,18 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.BooleanLiteralNode; + +/** + * Created by jan on 15.6.2016. + */ +public class BooleanLiteralToken extends TerminalToken{ + public BooleanLiteralToken(String text) { + super(Type.BooleanLiteralToken, text); + } + + @Override + public ASTNode generateNode() { + return new BooleanLiteralNode(this); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/BranchToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BranchToken.java new file mode 100644 index 0000000..dd74c50 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/BranchToken.java @@ -0,0 +1,48 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.BlockBodyNode; +import com.jantuomi.borker.core.parser.ast.BranchNode; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 21.6.2016. + */ +public class BranchToken extends VarargOperatorToken { + + private Token expression; + private BlockBodyToken branch; + + public BranchToken() { + super(Type.BranchToken, "if"); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new BranchNode(this, + expression.generateNode(), + (BlockBodyNode) branch.generateNode() + ); + } + + @Override + public Token setArguments(List<Token> args) { + expression = args.get(0); + branch = (BlockBodyToken) args.get(1); + return this; + } + + @Override + public List<Token> getChildren() { + return Arrays.asList(expression, branch); + } + + @Override + public Type getTerminatorTokenType() { + return Type.BranchBodyToken; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/ClosedParenToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/ClosedParenToken.java new file mode 100644 index 0000000..3071aaf --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/ClosedParenToken.java @@ -0,0 +1,18 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; + +/** + * Created by jan on 19.6.2016. + */ +public class ClosedParenToken extends TerminalToken { + public ClosedParenToken() { + super(Type.ClosedParenToken); + } + + @Override + public ASTNode generateNode() { + return null; + } + +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/CommentToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/CommentToken.java new file mode 100644 index 0000000..4908116 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/CommentToken.java @@ -0,0 +1,18 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.EmptyNode; + +/** + * Created by jan on 19.6.2016. + */ +public class CommentToken extends TerminalToken { + public CommentToken(String text, String rawText) { + super(Type.CommentToken, text, rawText); + } + + @Override + public ASTNode generateNode() { + return new EmptyNode(this); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/DivisionToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/DivisionToken.java new file mode 100644 index 0000000..2b9892e --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/DivisionToken.java @@ -0,0 +1,23 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.DivisionNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 15.6.2016. + */ +public class DivisionToken extends BinaryOperatorToken { + public DivisionToken() { + super(Type.DivisionToken); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new DivisionNode(this, + lhs.generateNode(), + rhs.generateNode() + ); + + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/DoubleLiteralToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/DoubleLiteralToken.java new file mode 100644 index 0000000..71da848 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/DoubleLiteralToken.java @@ -0,0 +1,18 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.DoubleLiteralNode; + +/** + * Created by jan on 15.6.2016. + */ +public class DoubleLiteralToken extends TerminalToken { + public DoubleLiteralToken(String text, String rawText) { + super(Type.DoubleLiteralToken, text, rawText); + } + + @Override + public ASTNode generateNode() { + return new DoubleLiteralNode(this); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/EndBlockToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/EndBlockToken.java new file mode 100644 index 0000000..3a07432 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/EndBlockToken.java @@ -0,0 +1,17 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; + +/** + * Created by jan on 16.6.2016. + */ +public class EndBlockToken extends TerminalToken { + public EndBlockToken() { + super(Type.EndBlockToken, "end"); + } + + @Override + public ASTNode generateNode() { + return null; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/FunctionDefineToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/FunctionDefineToken.java new file mode 100644 index 0000000..dab0e3a --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/FunctionDefineToken.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.BlockBodyNode; +import com.jantuomi.borker.core.parser.ast.FunctionDefineNode; +import com.jantuomi.borker.exception.InterpreterException; + +import java.util.ArrayList; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class FunctionDefineToken extends VarargOperatorToken { + public FunctionDefineToken() { + super(Type.FunctionDefineToken, "func"); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + FunctionDefineNode node = new FunctionDefineNode(this); + node.setName(args.get(0).getText()); + + List<ASTNode> funcArgs = new ArrayList<>(); + for (int i = 1; i < args.size() - 1; i++) { + funcArgs.add(args.get(i).generateNode()); + } + node.setArgs(funcArgs); + + BlockBodyNode bodyNode = (BlockBodyNode) args.get(args.size() - 1).generateNode(); + node.setBody(bodyNode); + return node; + } + + @Override + public Type getTerminatorTokenType() { + return Type.FunctionBodyToken; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/IntegerLiteralToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/IntegerLiteralToken.java new file mode 100644 index 0000000..1b18373 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/IntegerLiteralToken.java @@ -0,0 +1,18 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.IntegerLiteralNode; + +/** + * Created by jan on 15.6.2016. + */ +public class IntegerLiteralToken extends TerminalToken { + public IntegerLiteralToken(String text) { + super(Type.IntegerLiteralToken, text); + } + + @Override + public ASTNode generateNode() { + return new IntegerLiteralNode(this); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/MultiplicationToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/MultiplicationToken.java new file mode 100644 index 0000000..fc55e7a --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/MultiplicationToken.java @@ -0,0 +1,23 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.MultiplicationNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 15.6.2016. + */ +public class MultiplicationToken extends BinaryOperatorToken { + public MultiplicationToken() { + super(Type.MultiplicationToken); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new MultiplicationNode(this, + lhs.generateNode(), + rhs.generateNode() + ); + + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/NegationToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/NegationToken.java new file mode 100644 index 0000000..fbe0787 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/NegationToken.java @@ -0,0 +1,20 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.NegationNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 21.6.2016. + */ +public class NegationToken extends UnaryOperatorToken { + + public NegationToken() { + super(Type.NegationToken, "not"); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new NegationNode(this, operand.generateNode()); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/OpenParenToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/OpenParenToken.java new file mode 100644 index 0000000..37a1df0 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/OpenParenToken.java @@ -0,0 +1,34 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.ParameterListNode; +import com.jantuomi.borker.core.tokenizer.token.Token; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 19.6.2016. + */ +public class OpenParenToken extends VarargOperatorToken { + public OpenParenToken() { + super(Type.OpenParenToken); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + ParameterListNode node = new ParameterListNode(this); + + for (Token token : args) { + if (token.getTokenType() == Type.ClosedParenToken) { + continue; + } + + node.addParameter(token.generateNode()); + } + return node; + } + + @Override + public Type getTerminatorTokenType() { + return Type.ClosedParenToken; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/OptionalArgumentToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/OptionalArgumentToken.java new file mode 100644 index 0000000..8cf41af --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/OptionalArgumentToken.java @@ -0,0 +1,48 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 28.6.2016. + */ +public abstract class OptionalArgumentToken extends Token { + public OptionalArgumentToken(Type type, String text) { + super(type, text); + } + + protected Token optionalArgument; + + public void setOptionalArgument(OpenParenToken optionalArgument) { + this.optionalArgument = optionalArgument; + } + + abstract public Token.Type getOptionalArgumentType(); + + @Override + public ArgumentInfo getArgumentInfo() { + ArgumentInfo ai = new ArgumentInfo(); + ai.setOptionalArgument(getOptionalArgumentType()); + return ai; + } + + @Override + public Token setArguments(List<Token> args) { + if (args.size() > 0) { + setOptionalArgument((OpenParenToken) args.get(0)); + } + return this; + } + + @Override + public List<Token> getChildren() { + if (optionalArgument == null) { + return Arrays.asList(); + } else { + return Arrays.asList(optionalArgument); + } + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/StringLiteralToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/StringLiteralToken.java new file mode 100644 index 0000000..7370444 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/StringLiteralToken.java @@ -0,0 +1,19 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.StringLiteralNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 21.6.2016. + */ +public class StringLiteralToken extends TerminalToken { + public StringLiteralToken(String text, String rawText) { + super(Type.StringLiteralToken, text, rawText); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new StringLiteralNode(this); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/SubtractionToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/SubtractionToken.java new file mode 100644 index 0000000..9e9d2cb --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/SubtractionToken.java @@ -0,0 +1,22 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.SubtractionNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 16.6.2016. + */ +public class SubtractionToken extends BinaryOperatorToken { + public SubtractionToken() { + super(Type.SubtractionToken); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + return new SubtractionNode(this, + lhs.generateNode(), + rhs.generateNode() + ); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/SymbolToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/SymbolToken.java new file mode 100644 index 0000000..76dbad2 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/SymbolToken.java @@ -0,0 +1,31 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.ParameterListNode; +import com.jantuomi.borker.core.parser.ast.SymbolNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 16.6.2016. + */ +public class SymbolToken extends OptionalArgumentToken { + + public SymbolToken(String name) { + super(Type.SymbolToken, name); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + SymbolNode node = new SymbolNode(this); + node.setName(this.getText()); + if (optionalArgument != null) { + node.setParameterListNode((ParameterListNode) optionalArgument.generateNode()); + } + return node; + } + + @Override + public Type getOptionalArgumentType() { + return Type.OpenParenToken; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/TerminalToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/TerminalToken.java new file mode 100644 index 0000000..fb943fe --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/TerminalToken.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 28.6.2016. + */ +abstract public class TerminalToken extends Token { + public TerminalToken(Type type, String text, String rawText) { + super(type, text, rawText); + } + + public TerminalToken(Type type, String text) { + super(type, text); + } + + public TerminalToken(Type type) { + super(type); + } + + @Override + public Token setArguments(List<Token> args) { + return this; + } + + @Override + public List<Token> getChildren() { + return Arrays.asList(); + } + + @Override + public ArgumentInfo getArgumentInfo() { + return new ArgumentInfo(0); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/UnaryOperatorToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/UnaryOperatorToken.java new file mode 100644 index 0000000..7c13ad0 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/UnaryOperatorToken.java @@ -0,0 +1,39 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 28.6.2016. + */ +abstract public class UnaryOperatorToken extends Token { + public UnaryOperatorToken(Type type, String text) { + super(type, text); + } + + public UnaryOperatorToken(Type type) { + super(type); + } + + protected Token operand; + + + @Override + public ArgumentInfo getArgumentInfo() { + return new ArgumentInfo(1); + } + + @Override + public Token setArguments(List<Token> args) { + operand = args.get(0); + return this; + } + + @Override + public List<Token> getChildren() { + return Arrays.asList(operand); + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/VarargOperatorToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/VarargOperatorToken.java new file mode 100644 index 0000000..fe82a43 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/VarargOperatorToken.java @@ -0,0 +1,45 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +abstract public class VarargOperatorToken extends Token { + + protected List<Token> args; + + public VarargOperatorToken(Type type, String text) { + super(type, text); + } + + public VarargOperatorToken(Type type) { + super(type); + } + + @Override + public Token setArguments(List<Token> args) { + this.args = args; + return this; + } + + @Override + public List<Token> getChildren() { + return args; + } + + abstract public Token.Type getTerminatorTokenType(); + + @Override + public ArgumentInfo getArgumentInfo() { + ArgumentInfo ai = new ArgumentInfo(); + ai.setVariable(true); + ai.setTerminator(getTerminatorTokenType()); + return ai; + + } + +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/VariableDeclareToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/VariableDeclareToken.java new file mode 100644 index 0000000..c999452 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/VariableDeclareToken.java @@ -0,0 +1,25 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.parser.ast.SymbolNode; +import com.jantuomi.borker.core.parser.ast.VariableDeclareNode; +import com.jantuomi.borker.exception.InterpreterException; + +/** + * Created by jan on 20.6.2016. + */ +public class VariableDeclareToken extends UnaryOperatorToken { + + + public VariableDeclareToken() { + super(Type.DeclarationToken, "decl"); + } + + @Override + public ASTNode generateNode() throws InterpreterException { + SymbolToken st = (SymbolToken) operand; + VariableDeclareNode node = new VariableDeclareNode(this, + (SymbolNode) st.generateNode()); + return node; + } +} diff --git a/src/main/com/jantuomi/borker/core/tokenizer/token/types/WhitespaceToken.java b/src/main/com/jantuomi/borker/core/tokenizer/token/types/WhitespaceToken.java new file mode 100644 index 0000000..7b15e01 --- /dev/null +++ b/src/main/com/jantuomi/borker/core/tokenizer/token/types/WhitespaceToken.java @@ -0,0 +1,37 @@ +package com.jantuomi.borker.core.tokenizer.token.types; + +import com.jantuomi.borker.core.parser.ast.ASTNode; +import com.jantuomi.borker.core.tokenizer.token.ArgumentInfo; +import com.jantuomi.borker.core.tokenizer.token.Token; + +import java.util.Arrays; +import java.util.List; + +/** + * Created by jan on 16.6.2016. + */ +public class WhitespaceToken extends Token { + public WhitespaceToken() { + super(Type.WhitespaceToken); + } + + @Override + public ASTNode generateNode() { + return null; + } + + @Override + public Token setArguments(List<Token> args) { + return this; + } + + @Override + public List<Token> getChildren() { + return Arrays.asList(); + } + + @Override + public ArgumentInfo getArgumentInfo() { + return new ArgumentInfo(0); + } +} diff --git a/src/main/com/jantuomi/borker/exception/ExceptionManager.java b/src/main/com/jantuomi/borker/exception/ExceptionManager.java new file mode 100644 index 0000000..b9b302b --- /dev/null +++ b/src/main/com/jantuomi/borker/exception/ExceptionManager.java @@ -0,0 +1,21 @@ +package com.jantuomi.borker.exception; + +/** + * Created by jan on 10.6.2016. + */ +public class ExceptionManager { + + private static final ExceptionManager instance = new ExceptionManager(); + + private ExceptionManager() { + } + + public static ExceptionManager getInstance() { + return instance; + } + + public static void raise(InterpreterException.ExceptionType ex, int line, String... args) throws InterpreterException { + InterpreterException e = new InterpreterException(ex, line, args); + throw e; + } +} diff --git a/src/main/com/jantuomi/borker/exception/InterpreterException.java b/src/main/com/jantuomi/borker/exception/InterpreterException.java new file mode 100644 index 0000000..153da0a --- /dev/null +++ b/src/main/com/jantuomi/borker/exception/InterpreterException.java @@ -0,0 +1,53 @@ +package com.jantuomi.borker.exception; + + +import java.util.HashMap; +import java.util.Map; + +/** + * Created by jan on 12.6.2016. + */ +public class InterpreterException extends Exception { + + public enum ExceptionType { + IllegalTokenError, + SyntaxError, + TypeError, + ArgumentError, + UndeclaredSymbolError + } + + public static Map<ExceptionType, String> errorTexts = new HashMap<>(); + + static { + errorTexts.put(ExceptionType.IllegalTokenError, "Unknown or illegal token %s found."); + errorTexts.put(ExceptionType.SyntaxError, "Unexpected %s."); + errorTexts.put(ExceptionType.TypeError, "Incompatible types %s and %s."); + errorTexts.put(ExceptionType.ArgumentError, "The parameter list given to function %s is either of wrong length or the parameters are of wrong type. Actual: %s"); + errorTexts.put(ExceptionType.UndeclaredSymbolError, "No symbol %s defined, parameters: [%s]."); + } + + private ExceptionType exceptionType; + private String completeMessage; + + public InterpreterException(ExceptionType exceptionType, int line, String... args) { + super(exceptionType.toString(), null, false, false); + this.exceptionType = exceptionType; + this.completeMessage = formatMessage(exceptionType.toString() + ": " + what(exceptionType), line, args); + } + + private static String formatMessage(String message, int line, String... args) { + + message = String.format(message, args); + return String.format("\nline %d: ", line) + message; + } + + public static String what(ExceptionType type) { + return errorTexts.get(type); + } + + @Override + public void printStackTrace() { + System.err.println(completeMessage); + } +} diff --git a/src/main/com/jantuomi/borker/utils/Utilities.java b/src/main/com/jantuomi/borker/utils/Utilities.java new file mode 100644 index 0000000..60e221d --- /dev/null +++ b/src/main/com/jantuomi/borker/utils/Utilities.java @@ -0,0 +1,17 @@ +package com.jantuomi.borker.utils; + +import java.nio.file.Path; +import java.nio.file.Paths; + +/** + * Created by jan on 10.6.2016. + */ +public class Utilities { + private Utilities() {} + + public static String getBasePath() { + Path currentRelativePath = Paths.get(""); + String s = currentRelativePath.toAbsolutePath().toString(); + return s; + } +} |