public static String rollShowResults(String diceExpression) {
LinkedHashMap<Dice, OperatorType> dice = parseMany(diceExpression);
StringCompiler sb = new StringCompiler();
Iterator<Map.Entry<Dice, OperatorType>> it = dice.entrySet().iterator();
OperatorType op = null;
Integer res = 0, roll = 0;
sb.append("{");
while (it.hasNext()) {
Map.Entry<Dice, OperatorType> current = it.next();
if (op != null) {
roll = current.getKey().roll();
res = op.doOperation(res, roll);
} else {
// First roll
res = current.getKey().roll();
}
op = current.getValue();
sb.append("[").append(roll).append(":").append(res).append("]");
if (op != null) {
sb.append(op.toString());
}
}
sb.append("} = ").append(res);
return sb.toString();
}
public static LinkedHashMap<Dice, OperatorType> parseMany(String dts) {
LinkedHashMap<Dice, OperatorType> ret = new LinkedHashMap<Dice, OperatorType>();
ArrayList<String> parts = Utils.splitEncolosed(dts, OPENED_DICE, CLOSED_DICE);
Dice dt = null;
OperatorType ot = null;
for (int i = 0; (i + 1) <= parts.size(); i += 2) {
String part1 = parts.get(i);
String part2 = (i + 1) < parts.size() ? parts.get(i + 1) : "";
if (isDice(part1)) {
if (dt == null) {
dt = Dice.parse(part1);
} else {
ret.put(dt, OperatorType.Addition);
dt = Dice.parse(part1);
ot = null;
}
}
if (isDice(part2)) {
ret.put(dt, OperatorType.Addition);
dt = Dice.parse(part2);
} else {
if (OperatorType.isOperator(part2)) {
ot = OperatorType.getOperator(part2);
}
ret.put(dt, ot);
dt = null;
}
ot = null;
}
return ret;
}
public static Integer rollSum(LinkedHashMap<Dice, OperatorType> dice) {
Integer ret = 0;
Iterator<Map.Entry<Dice, OperatorType>> it = dice.entrySet().iterator();
OperatorType op = null;
while (it.hasNext()) {
Map.Entry<Dice, OperatorType> current = it.next();
if (op != null) {
ret = op.doOperation(ret, current.getKey().roll());
} else {
// First roll
ret = current.getKey().roll();
}
op = current.getValue();
}
return ret;
}
private void parseBuffer(int startOffset, int startColumn) {
if (buffer.length() == 0) {
return;
}
final String value = buffer.toString();
buffer.setLength(0);
if (OperatorType.getExactMatch(value) != null) {
addToken(TokenType.OPERATOR, value, startOffset, line, startColumn);
return;
}
if ("=".equals(value)) {
addToken(TokenType.EQUALS, "=", scanner.offset() - 1, line, startColumn);
return;
}
boolean isOnlyDigits = true;
for (int i = 0, len = value.length(); i < len; i++) {
if (!Character.isDigit(value.charAt(i))) {
isOnlyDigits = false;
break;
}
}
if (isOnlyDigits) {
addToken(TokenType.DIGITS, value, startOffset, line, startColumn);
return;
}
addToken(TokenType.TEXT, value, startOffset, line, startColumn);
}
/** Creates an operator symbol. */
private Symbol makeOperator(
Name name, List<OperatorType> formals, OperatorType res, int... opcodes) {
MethodType opType =
new MethodType(
formals.stream().map(o -> o.asType(syms)).collect(List.collector()),
res.asType(syms),
List.nil(),
syms.methodClass);
return new OperatorSymbol(name, opType, mergeOpcodes(opcodes), syms.noSymbol);
}
public static Dice parse(String dt) {
Dice ret = null;
try {
dt = dt.toUpperCase();
String[] diceparts = dt.split(DICE_TOKEN_S);
if (diceparts.length == 2) {
int nThrows = Integer.valueOf(diceparts[0]), nFaces = 0, modifier = 0;
String nFacesBld = "";
OperatorType opType = null;
char[] faceParts = diceparts[1].toCharArray();
for (char c : faceParts) {
String current = String.valueOf(c);
if (Utils.isInteger(current)) {
nFacesBld = nFacesBld.concat(current);
} else if ((opType = OperatorType.parseOperator(c)) != null) {
break;
} else {
break;
}
}
nFaces = Integer.valueOf(nFacesBld);
if (opType != null) {
String[] bonusParts = diceparts[1].split(opType.toEscapedString());
if ((bonusParts.length == 2) && Utils.isInteger(bonusParts[1])) {
modifier = Integer.valueOf(bonusParts[1]);
}
ret = new Dice(nThrows, nFaces, opType, modifier);
} else {
ret = new Dice(nThrows, nFaces);
}
}
} catch (NumberFormatException e) {
e.printStackTrace();
ret = null;
}
return ret;
}
@Test
public void shouldReturnTrueForEqOperator() throws Exception {
assertThat(OperatorType.contains("$eq")).isTrue();
}
@Test(expected = IllegalArgumentException.class)
public void shouldThrowExceptionOnIncorrectNameForOperatorType() throws Exception {
OperatorType.fromString("foo");
}
@Test
public void shouldReturnOperatorTypeForEqualOperator() throws Exception {
assertThat(OperatorType.EQUAL).isEqualTo(OperatorType.fromString("$eq"));
}
@Test
public void shouldReturnFalseForUnknownOperator() throws Exception {
assertThat(OperatorType.contains("$foo")).isFalse();
}
private void parseTokens() {
if (!tokens.isEmpty()) {
return;
}
int startOffset = scanner.offset();
int startColumn = column;
buffer.setLength(0);
while (!scanner.eof() && isWhitespace(scanner.peek())) {
final char c = scanner.next();
column++;
if (!ignoreWhitespace) {
buffer.append(c);
}
}
if (buffer.length() > 0) {
addToken(TokenType.WHITESPACE, buffer.toString(), startOffset, line, startColumn);
return;
}
startOffset = scanner.offset();
outer:
while (!scanner.eof()) {
final char c = scanner.next();
if (isWhitespace(c)) {
scanner.pushBack();
break;
}
column++;
if (c == '-') {
parseBuffer(startOffset, startColumn);
addToken(TokenType.OPERATOR, c, scanner.offset() - 1, line, column);
break outer;
}
if (OperatorType.mayBeOperator(buffer.toString() + c)) {
buffer.append(c);
continue;
} else if (OperatorType.getExactMatch(buffer.toString()) != null) {
addToken(TokenType.OPERATOR, buffer.toString(), startOffset, line, startColumn);
buffer.setLength(0);
scanner.pushBack();
column--;
break;
} else if (OperatorType.mayBeOperator(c)) {
scanner.pushBack();
column--;
break;
}
switch (c) {
case '(':
parseBuffer(startOffset, startColumn);
addToken(TokenType.PARENS_OPEN, c, scanner.offset() - 1, line, column);
break outer;
case ')':
parseBuffer(startOffset, startColumn);
addToken(TokenType.PARENS_CLOSE, c, scanner.offset() - 1, line, column);
break outer;
case '=':
parseBuffer(startOffset, startColumn);
addToken(TokenType.EQUALS, c, scanner.offset() - 1, line, column);
break outer;
case ';':
parseBuffer(startOffset, startColumn);
addToken(TokenType.SEMICOLON, c, scanner.offset() - 1, line, column);
break outer;
case '\'':
parseBuffer(startOffset, startColumn);
addToken(TokenType.SINGLE_QUOTE, c, scanner.offset() - 1, line, column);
break outer;
case '"':
parseBuffer(startOffset, startColumn);
addToken(TokenType.DOUBLE_QUOTE, c, scanner.offset() - 1, line, column);
break outer;
case '.':
parseBuffer(startOffset, startColumn);
addToken(TokenType.DOT, c, scanner.offset() - 1, line, column);
break outer;
case '#':
parseBuffer(startOffset, startColumn);
addToken(TokenType.HASH, c, scanner.offset() - 1, line, column);
break outer;
case ',':
parseBuffer(startOffset, startColumn);
addToken(TokenType.COMMA, c, scanner.offset() - 1, line, column);
break outer;
case '\n':
parseBuffer(startOffset, startColumn);
addToken(TokenType.EOL, c, scanner.offset() - 1, line, column);
break outer;
case ':':
parseBuffer(startOffset, startColumn);
addToken(TokenType.COLON, ':', scanner.offset() - 1, line, column);
break outer;
case '\r':
parseBuffer(startOffset, startColumn);
if (!scanner.eof() && scanner.peek() == '\n') {
scanner.next();
addToken(TokenType.EOL, "\r\n", scanner.offset() - 2, line, column);
column++;
} else {
addToken(TokenType.EOL, "\r", scanner.offset() - 1, line, column);
}
line++;
column = 0;
break outer;
default:
buffer.append(c);
}
}
parseBuffer(startOffset, startColumn);
if (scanner.eof()) {
addToken(TokenType.EOF, "", scanner.offset(), line, column);
}
}
