Basic string operators

7 files changed, 78 insertions, 10 deletions

diff --git a/dice-lang/src/bjc/dicelang/DiceLangEngine.java b/dice-lang/src/bjc/dicelang/DiceLangEngine.java
index cd613b5..c34ecac 100644
--- a/dice-lang/src/bjc/dicelang/DiceLangEngine.java
+++ b/dice-lang/src/bjc/dicelang/DiceLangEngine.java
@@ -124,6 +124,8 @@ public class DiceLangEngine {
 		opExpander.addDelimiter(":=");
 		opExpander.addDelimiter("=>");
 		opExpander.addDelimiter("//");
+		opExpander.addDelimiter(".+.");
+		opExpander.addDelimiter(".*.");
 		opExpander.addDelimiter("+");
 		opExpander.addDelimiter("-");
 		opExpander.addDelimiter("*");
diff --git a/dice-lang/src/bjc/dicelang/Errors.java b/dice-lang/src/bjc/dicelang/Errors.java
index c4ecfc4..e066292 100644
--- a/dice-lang/src/bjc/dicelang/Errors.java
+++ b/dice-lang/src/bjc/dicelang/Errors.java
@@ -61,6 +61,10 @@ public class Errors {
 		EK_EVAL_INVDICE,
 		// Mismatched types to math operator
 		EK_EVAL_MISMATH,
+		// Incorrect type to string operator
+		EK_EVAL_INVSTRING,
+		// Unknown string operator
+		EK_EVAL_UNSTRING,
 
 		// Parser Error
 		// Group closing where there couldn't be an opener
@@ -181,7 +185,7 @@ public class Errors {
 			System.out.printf("\tERROR: Unknown node in evaluator: %s\n", args[0]);
 			break;
 		case EK_EVAL_INVBIN:
-			System.out.printf("\tERROR: Binary operators take 2 operand, not %s\n"
+			System.out.printf("\tERROR: Binary operators take 2 operands, not %s\n"
 					+ "\tProblem node is %s\n", args[0], args[1]);
 			break;
 		case EK_EVAL_UNBIN:
@@ -219,6 +223,12 @@ public class Errors {
 		case EK_EVAL_MISMATH:
 			System.out.printf("\tERROR: Math operators expect two operands of the same type\n");
 			break;
+		case EK_EVAL_INVSTRING:
+			System.out.printf("\tERROR: Incorrect type %s to string operator\n", args[0]);
+			break;
+		case EK_EVAL_UNSTRING:
+			System.out.printf("\tERROR: Unknown string operator %s\n", args[0]);
+			break;
 		case EK_PARSE_NOCLOSE:
 			System.out.printf("\tERROR: Group closing with no possible group opener\n");
 			break;
diff --git a/dice-lang/src/bjc/dicelang/Evaluator.java b/dice-lang/src/bjc/dicelang/Evaluator.java
index 87980d4..551325a 100644
--- a/dice-lang/src/bjc/dicelang/Evaluator.java
+++ b/dice-lang/src/bjc/dicelang/Evaluator.java
@@ -119,6 +119,9 @@ public class Evaluator {
 		}
 
 		switch(ast.getHead().operatorType) {
+		/*
+		 * @TODO move coercing to its own class
+		 */
 		case COERCE:
 			ITree<Node> toCoerce = ast.getChild(0);
 			ITree<Node> retVal   = new Tree<>(toCoerce.getHead());
@@ -221,12 +224,53 @@ public class Evaluator {
 			return evaluateDiceBinary(binOp,
 					left.getHead().resultVal, right.getHead().resultVal,
 					ctx);
+		case STRCAT:
+		case STRREP:
+			return evaluateStringBinary(binOp,
+					left.getHead().resultVal, right.getHead().resultVal,
+					ctx);
 		default:
 			Errors.inst.printError(EK_EVAL_UNBIN, binOp.toString());
 			return new Tree<>(FAIL(ast));
 		}
 	}
 
+	private ITree<Node> evaluateStringBinary(Token.Type op,
+			EvaluatorResult left, EvaluatorResult right, Context ctx) {
+		if(left.type != STRING) {
+			Errors.inst.printError(EK_EVAL_INVSTRING, left.type.toString());
+			return new Tree<>(FAIL(left));
+		}
+
+		String strang = left.stringVal;
+
+		switch(op) {
+		case STRCAT:
+			if(right.type != STRING) {
+				Errors.inst.printError(EK_EVAL_UNSTRING, right.type.toString());
+				return new Tree<>(FAIL(right));
+			} else {
+				String strung = right.stringVal;
+				return new Tree<>(new Node(Node.Type.RESULT, new EvaluatorResult(STRING, strang + strung)));
+			}
+		case STRREP:
+			if(right.type != INT) {
+				Errors.inst.printError(EK_EVAL_INVSTRING, right.type.toString());
+				return new Tree<>(FAIL(right));
+			} else {
+				String res = strang;
+				long count = right.intVal;
+				for(long i = 1; i < count; i++) {
+					res += strang;
+				}
+				return new Tree<>(new Node(Node.Type.RESULT, new EvaluatorResult(STRING, res)));
+			}
+		default:
+			Errors.inst.printError(EK_EVAL_UNSTRING, op.toString());
+			return new Tree<>(FAIL());
+		}
+	}
+
 	private ITree<Node> evaluateDiceBinary(Token.Type op,
 			EvaluatorResult left, EvaluatorResult right, Context ctx) {
 		EvaluatorResult res = null;
@@ -434,7 +478,7 @@ public class Evaluator {
 			res = new EvaluatorResult(DICE, tk.diceValue);
 			break;
 		case STRING_LIT:
-			res = new EvaluatorResult(STRING, eng.stringLits.get((int)(tk.intValue)));
+			res = new EvaluatorResult(STRING, eng.stringLiterals.get((int)(tk.intValue)));
 			break;
 		default:
 			Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString());
diff --git a/dice-lang/src/bjc/dicelang/Parser.java b/dice-lang/src/bjc/dicelang/Parser.java
index db050c4..5f8d552 100644
--- a/dice-lang/src/bjc/dicelang/Parser.java
+++ b/dice-lang/src/bjc/dicelang/Parser.java
@@ -31,6 +31,14 @@ public class Parser {
 					boolean sc = parseClosingGrouper(working, tk);
 					if(!sc)      return false;
 					break;
+				case MULTIPLY:
+				case DIVIDE:
+				case IDIVIDE:
+				case DICEGROUP:
+				case DICECONCAT:
+				case DICELIST:
+				case STRCAT:
+				case STRREP:
 				case LET:
 				case BIND:
 					if(working.size() < 2) {
@@ -42,17 +50,14 @@ public class Parser {
 
 						ITree<Node> opNode = new Tree<>(new Node(BINOP, tk.type));
 						
+						opNode.addChild(left);
+						opNode.addChild(right);
+
 						working.push(opNode);
 					}
 					break;
 				case ADD:
 				case SUBTRACT:
-				case MULTIPLY:
-				case DIVIDE:
-				case IDIVIDE:
-				case DICEGROUP:
-				case DICECONCAT:
-				case DICELIST:
 					if(working.size() == 0) {
 						Errors.inst.printError(EK_PARSE_UNOPERAND, tk.toString());
 						return false;
diff --git a/dice-lang/src/bjc/dicelang/Shunter.java b/dice-lang/src/bjc/dicelang/Shunter.java
index 38f49be..28ae117 100644
--- a/dice-lang/src/bjc/dicelang/Shunter.java
+++ b/dice-lang/src/bjc/dicelang/Shunter.java
@@ -30,8 +30,9 @@ public class Shunter {
 	// applied to operator tokens and yield data tokens
 	private Set<Token.Type> unaryGerunds;
 
-	private final int MATH_PREC	 = 20;
-	private final int DICE_PREC	 = 10;
+	private final int MATH_PREC	 = 30;
+	private final int DICE_PREC	 = 20;
+	private final int STR_PREC       = 10;
 	private final int EXPR_PREC	 = 0;
 
 	public Shunter() {
@@ -56,6 +57,9 @@ public class Shunter {
 
 		ops.put(DICELIST,   2 + DICE_PREC);
 
+		ops.put(STRCAT,     0 + STR_PREC);
+		
+		ops.put(STRREP,     1 + STR_PREC);
 		ops.put(LET,        0 + EXPR_PREC);
 		ops.put(BIND,       1 + EXPR_PREC);
 	}
diff --git a/dice-lang/src/bjc/dicelang/Token.java b/dice-lang/src/bjc/dicelang/Token.java
index 62755d2..4cc3f16 100644
--- a/dice-lang/src/bjc/dicelang/Token.java
+++ b/dice-lang/src/bjc/dicelang/Token.java
@@ -23,6 +23,7 @@ public class Token {
 		DICE_LIT,  DICESCALAR, DICEFUDGE,
 		DICEGROUP, DICECONCAT, DICELIST,
 		LET,       BIND,      COERCE,
+		STRCAT,    STRREP,
 		OPAREN,    CPAREN,
 		OBRACKET,  CBRACKET,
 		OBRACE,    CBRACE,
diff --git a/dice-lang/src/bjc/dicelang/Tokenizer.java b/dice-lang/src/bjc/dicelang/Tokenizer.java
index 6bb4f86..688a632 100644
--- a/dice-lang/src/bjc/dicelang/Tokenizer.java
+++ b/dice-lang/src/bjc/dicelang/Tokenizer.java
@@ -38,6 +38,8 @@ public class Tokenizer {
 		litTokens.put("dl",  DICELIST);

 		litTokens.put("=>",  LET);

 		litTokens.put(":=",  BIND);

+		litTokens.put(".+.", STRCAT);

+		litTokens.put(".*.", STRREP);

 		litTokens.put(",",   GROUPSEP);

 		litTokens.put("crc", COERCE);

 	}