Allow some exceptions to be handled

src/main/java/carpet/script/exception/ExpressionException.java

@@ -8,28 +8,32 @@ import carpet.script.value.FunctionValue;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Supplier;
 
 /* The expression evaluators exception class. */
 public class ExpressionException extends RuntimeException implements ResolvedException
 {
     public final Context context;
     public final List<FunctionValue> stack = new ArrayList<>();
+    private final Supplier<String> lazyStacktrace;
+    private String cachedMessage = null;
 
     public ExpressionException(Context c, Expression e, String message)
     {
-        super(makeMessage(c, e, null, message));
-        context = c;
+        this(c, e, null, message);
     }
 
     public ExpressionException(Context c, Expression e, Tokenizer.Token t, String message)
     {
-        super(makeMessage(c, e, t, message));
+        super("Error");
+        lazyStacktrace = () -> makeMessage(c, e, t, message);
         context = c;
     }
     public ExpressionException(Context c, Expression e, Tokenizer.Token t, String message, List<FunctionValue> stack)
     {
-        super(makeMessage(c, e, t, message));
+        super("Error");
         this.stack.addAll(stack);
+        lazyStacktrace = () -> makeMessage(c, e, t, message); 
         context = c;
     }
 
@@ -68,4 +72,13 @@ public class ExpressionException extends RuntimeException implements ResolvedExc
         }
         return String.join("\n", errorMaker.apply(e, t, message));
     }
+    
+    @Override
+    public String getMessage() {
+        if (cachedMessage == null)
+        {
+        	cachedMessage = lazyStacktrace.get();
+        }
+        return cachedMessage;
+    }
 }

src/main/java/carpet/script/exception/InternalExpressionException.java

@@ -1,5 +1,8 @@
 package carpet.script.exception;
 
+import carpet.script.Context;
+import carpet.script.Expression;
+import carpet.script.Tokenizer;
 import carpet.script.value.FunctionValue;
 
 import java.util.ArrayList;
@@ -13,4 +16,20 @@ public class InternalExpressionException extends RuntimeException
     {
         super(message);
     }
+    
+    /**
+     * <p>Promotes this simple exception into one with context and extra information.
+     * 
+     * <p>Provides a cleaner way of handling similar exceptions, in this case
+     * {@link InternalExpressionException} and {@link ThrowStatement} 
+     * @param c Context
+     * @param e Expression
+     * @param token Token
+     * @return The new {@link ExpressionException} (or {@link ProcessedThrowStatement}),
+     *         depending on the implementation.
+     */
+    public ExpressionException promote(Context c, Expression e, Tokenizer.Token token)
+    {
+        return new ExpressionException(c, e, token, getMessage(), stack);
+    }
 }

src/main/java/carpet/script/exception/ProcessedThrowStatement.java

@@ -0,0 +1,20 @@
+package carpet.script.exception;
+
+import java.util.List;
+
+import carpet.script.Context;
+import carpet.script.Expression;
+import carpet.script.Tokenizer.Token;
+import carpet.script.value.FunctionValue;
+import carpet.script.value.Value;
+
+public class ProcessedThrowStatement extends ExpressionException {
+    public final Value exceptionName;
+    public final String message;
+    
+    public ProcessedThrowStatement(Context c, Expression e, Token token, String message, List<FunctionValue> stack, Value exceptionName) {
+        super(c, e, token, "Unhandled exception: "+message, stack);
+        this.exceptionName = exceptionName;
+        this.message = message;
+    }
+}

src/main/java/carpet/script/exception/ThrowStatement.java

@@ -1,11 +1,68 @@
 package carpet.script.exception;
 
+import carpet.script.Context;
+import carpet.script.Expression;
+import carpet.script.Tokenizer.Token;
+import carpet.script.value.StringValue;
 import carpet.script.value.Value;
 
-public class ThrowStatement extends ExitStatement
+public class ThrowStatement extends InternalExpressionException
 {
+    public static final String UNKNOWN_ITEM        = "unknown_item";
+    public static final String UNKNOWN_BLOCK       = "unknown_block";
+    public static final String UNKNOWN_BIOME       = "unknown_biome";
+    public static final String UNKNOWN_SOUND       = "unknown_sound";
+    public static final String UNKNOWN_PARTICLE    = "unknown_particle";
+    public static final String UNKNOWN_POI_TYPE    = "unknown_poi_type";
+    public static final String UNKNOWN_DIMENSION   = "unknown_dimension";
+    public static final String UNKNOWN_STRUCTURE   = "unknown_structure";
+    public static final String UNKNOWN_CRITERION   = "unknown_criterion";
+    public static final String NBT_READ_EXCEPTION  = "nbt_read_exception";
+    public static final String JSON_READ_EXCEPTION = "json_read_exception";
+    public final Value retval;
+    /**
+     * Creates a throw exception from a value.
+     * That value will also be used as the message.<br>
+     * To use when throwing from Scarpet's {@code throw}
+     * @param value The value to pass
+     */
     public ThrowStatement(Value value)
     {
-        super(value);
+        super(value.getString());
+        retval = value;
+    }
+    
+    /**
+     * Creates a throw exception from a value, and 
+     * assigns it a specified message.<br>
+     * To use when throwing from Scarpet's {@code throw}
+     * function
+     * @param message The message to display if uncaught
+     * @param value The value to pass
+     */
+    public ThrowStatement(String message, Value value)
+    {
+        super(message);
+        retval = value;
+    }
+
+    /**
+     * Creates a throw exception.<br>
+     * Conveniently creates a value from the {@code value} String
+     * to be used easily in Java code
+     * @param message The message to display when not handled
+     * @param value A String that will be converted 
+     *              to a value to pass to {@code catch}
+     *              blocks
+     */
+    public ThrowStatement(String message, String value)
+    {
+        super(message);
+        retval = new StringValue(value);
+    }
+    
+    @Override
+    public ExpressionException promote(Context c, Expression e, Token token) {
+        return new ProcessedThrowStatement(c, e, token, getMessage(), stack, retval);
     }
 }