Add the parse flag to the ccalc command (#215)

haykam821 · web-flow · commit 639834de4056 · 2021-03-21T11:15:31.000Z
diff --git a/src/main/java/net/earthcomputer/clientcommands/command/CalcCommand.java b/src/main/java/net/earthcomputer/clientcommands/command/CalcCommand.java
@@ -1,11 +1,12 @@
 package net.earthcomputer.clientcommands.command;
 
 import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+
 import net.earthcomputer.clientcommands.TempRules;
 import net.earthcomputer.clientcommands.command.arguments.ExpressionArgumentType;
 import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.text.LiteralText;
-import net.minecraft.text.MutableText;
+import net.minecraft.text.*;
 import net.minecraft.util.Formatting;
 
 import static net.earthcomputer.clientcommands.command.ClientCommandManager.*;
@@ -14,15 +15,24 @@
 
 public class CalcCommand {
 
+    private static final int FLAG_PARSE = 1;
+
     public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
         addClientSideCommand("ccalc");
 
+        LiteralCommandNode<ServerCommandSource> ccalc = dispatcher.register(literal("ccalc"));
         dispatcher.register(literal("ccalc")
+            .then(literal("--parse")
+                .redirect(ccalc, ctx -> withFlags(ctx.getSource(), FLAG_PARSE, true)))
             .then(argument("expr", expression())
                 .executes(ctx -> evaluateExpression(ctx.getSource(), getExpression(ctx, "expr")))));
     }
 
     private static int evaluateExpression(ServerCommandSource source, ExpressionArgumentType.Expression expression) {
+        if (getFlag(source, FLAG_PARSE)) {
+            sendFeedback(new TranslatableText("commands.ccalc.parse", expression.getParsedTree()));
+        }
+
         double result = expression.eval();
         TempRules.calcAnswer = result;
         int iresult = 0;
diff --git a/src/main/java/net/earthcomputer/clientcommands/command/arguments/ExpressionArgumentType.java b/src/main/java/net/earthcomputer/clientcommands/command/arguments/ExpressionArgumentType.java
@@ -12,7 +12,7 @@
 import net.earthcomputer.clientcommands.TempRules;
 import net.minecraft.command.CommandSource;
 import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.text.TranslatableText;
+import net.minecraft.text.*;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -89,14 +89,14 @@ private Expression parseExpression1() throws CommandSyntaxException {
                     reader.skip();
                     reader.skipWhitespace();
                     Expression right = parseExpression1();
-                    return new BinaryOpExpression(left, right, Double::sum);
+                    return new BinaryOpExpression(left, right, Double::sum, "addition");
                 }
 
                 if (reader.peek() == '-') {
                     reader.skip();
                     reader.skipWhitespace();
                     Expression right = parseExpression1();
-                    return new BinaryOpExpression(left, right, (l, r) -> l - r);
+                    return new BinaryOpExpression(left, right, (l, r) -> l - r, "subtraction");
                 }
             }
 
@@ -112,28 +112,28 @@ private Expression parseExpression2() throws CommandSyntaxException {
                     reader.skip();
                     reader.skipWhitespace();
                     Expression right = parseExpression2();
-                    return new BinaryOpExpression(left, right, (l, r) -> l * r);
+                    return new BinaryOpExpression(left, right, (l, r) -> l * r, "multiplication");
                 }
 
                 if (reader.peek() == '/') {
                     reader.skip();
                     reader.skipWhitespace();
                     Expression right = parseExpression2();
-                    return new BinaryOpExpression(left, right, (l, r) -> l / r);
+                    return new BinaryOpExpression(left, right, (l, r) -> l / r, "division");
                 }
 
                 if (reader.peek() == '%') {
                     reader.skip();
                     reader.skipWhitespace();
                     Expression right = parseExpression2();
-                    return new BinaryOpExpression(left, right, (l, r) -> l % r);
+                    return new BinaryOpExpression(left, right, (l, r) -> l % r, "modulo");
                 }
 
                 if (!StringReader.isAllowedNumber(reader.peek())) {
                     int cursor = reader.getCursor();
                     try {
                         Expression right = parseExpression5();
-                        return new BinaryOpExpression(left, right, (l, r) -> l * r);
+                        return new BinaryOpExpression(left, right, (l, r) -> l * r, "multiplication");
                     } catch (CommandSyntaxException e) {
                         reader.setCursor(cursor);
                     }
@@ -161,7 +161,7 @@ private Expression parseExpression3() throws CommandSyntaxException {
                 Expression right = subExpressions.get(subExpressions.size() - 1);
                 for (int i = subExpressions.size() - 2; i >= 0; i--) {
                     Expression left = subExpressions.get(i);
-                    right = new BinaryOpExpression(left, right, Math::pow);
+                    right = new BinaryOpExpression(left, right, Math::pow, "exponentiation");
                 }
                 return right;
             }
@@ -196,7 +196,7 @@ private Expression parseExpression5() throws CommandSyntaxException {
 
             if (ConstantExpression.CONSTANTS.containsKey(word)) {
                 suggestor = null;
-                return new ConstantExpression(ConstantExpression.CONSTANTS.get(word));
+                return new ConstantExpression(word, ConstantExpression.CONSTANTS.get(word));
             }
 
             if (FunctionExpression.FUNCTIONS.containsKey(word)) {
@@ -230,7 +230,7 @@ private Expression parseExpression5() throws CommandSyntaxException {
                     throw INVALID_ARGUMENT_COUNT.createWithContext(reader, word, arguments.size());
                 }
 
-                return new FunctionExpression(function, arguments.toArray(new Expression[0]));
+                return new FunctionExpression(word, function, arguments.toArray(new Expression[0]));
             }
 
             reader.setCursor(cursor);
@@ -280,24 +280,32 @@ private static boolean isAllowedNumber(char c) {
     public static abstract class Expression {
         public String strVal;
         public abstract double eval();
+        public abstract Text getParsedTree();
     }
 
     private static class BinaryOpExpression extends Expression {
 
         private Expression left;
         private Expression right;
         private DoubleBinaryOperator operator;
+        private String type;
 
-        public BinaryOpExpression(Expression left, Expression right, DoubleBinaryOperator operator) {
+        public BinaryOpExpression(Expression left, Expression right, DoubleBinaryOperator operator, String type) {
             this.left = left;
             this.right = right;
             this.operator = operator;
+            this.type = type;
         }
 
         @Override
         public double eval() {
             return operator.applyAsDouble(left.eval(), right.eval());
         }
+
+        @Override
+        public Text getParsedTree() {
+            return new TranslatableText("commands.ccalc.parse.binaryOperator." + type, left.getParsedTree(), right.getParsedTree());
+        }
     }
 
     private static class NegateExpression extends Expression {
@@ -311,6 +319,11 @@ public NegateExpression(Expression right) {
         public double eval() {
             return -right.eval();
         }
+
+        @Override
+        public Text getParsedTree() {
+            return new TranslatableText("commands.ccalc.parse.negate", this.right.getParsedTree());
+        }
     }
 
     private static class ConstantExpression extends Expression {
@@ -321,16 +334,23 @@ private static class ConstantExpression extends Expression {
                 "ans", () -> TempRules.calcAnswer
         );
 
+        private String type;
         private DoubleSupplier constant;
 
-        public ConstantExpression(DoubleSupplier constant) {
+        public ConstantExpression(String type, DoubleSupplier constant) {
+            this.type = type;
             this.constant = constant;
         }
 
         @Override
         public double eval() {
             return constant.getAsDouble();
         }
+
+        @Override
+        public Text getParsedTree() {
+            return new TranslatableText("commands.ccalc.parse.constant", this.type);
+        }
     }
 
     public static class FunctionExpression extends Expression {
@@ -403,10 +423,12 @@ public boolean isAcceptableInputCount(int count) {
                 .put("not", (UnaryFunction) val -> (double)(~((int)val)))
         .build();
 
+        private String type;
         private IFunction function;
         private Expression[] arguments;
 
-        public FunctionExpression(IFunction function, Expression... arguments) {
+        public FunctionExpression(String type, IFunction function, Expression... arguments) {
+            this.type = type;
             this.function = function;
             this.arguments = arguments;
         }
@@ -419,6 +441,23 @@ public double eval() {
             return function.eval(args);
         }
 
+        @Override
+        public Text getParsedTree() {
+            MutableText argumentsText = new LiteralText("");
+            boolean first = true;
+            for (Expression argument : this.arguments) {
+                if (first) {
+                    first = false;
+                } else {
+                    argumentsText.append(", ");
+                }
+
+                argumentsText.append(argument.getParsedTree());
+            }
+
+            return new TranslatableText("commands.ccalc.parse.function", this.type, argumentsText);
+        }
+
         private static interface IFunction {
             double eval(double... inputs);
             boolean isAcceptableInputCount(int count);
@@ -475,6 +514,11 @@ public LiteralExpression(double val) {
         public double eval() {
             return val;
         }
+
+        @Override
+        public Text getParsedTree() {
+            return new TranslatableText("commands.ccalc.parse.literal", this.val);
+        }
     }
 
 }
diff --git a/src/main/resources/assets/clientcommands/lang/en_us.json b/src/main/resources/assets/clientcommands/lang/en_us.json
@@ -4,6 +4,17 @@
 
   "commands.ccalc.expected": "Expected %s",
   "commands.ccalc.invalidArgumentCount": "Function \"%s\" cannot take %d arguments",
+  "commands.ccalc.parse": "Parsed expression: %s",
+  "commands.ccalc.parse.binaryOperator.addition": "(%s + %s)",
+  "commands.ccalc.parse.binaryOperator.division": "(%s / %s)",
+  "commands.ccalc.parse.binaryOperator.exponentiation": "(%s ^ %s)",
+  "commands.ccalc.parse.binaryOperator.modulo": "(%s % %s)",
+  "commands.ccalc.parse.binaryOperator.multiplication": "(%s * %s)",
+  "commands.ccalc.parse.binaryOperator.subtraction": "(%s - %s)",
+  "commands.ccalc.parse.constant": "(constant '%s')",
+  "commands.ccalc.parse.function": "(function '%s' with arguments: %s)",
+  "commands.ccalc.parse.literal": "(literal: %s)",
+  "commands.ccalc.parse.negate": "(negated: %s)",
 
   "commands.ccalcstack.success": "%d %s is %d stacks and %d extra",
   "commands.ccalcstack.success.empty": "%d items is %d stacks and %d extra",
