Use our own stack counter to determine when a StackOverflow happens.

Author: LadyCailin

src/main/java/com/laytonsmith/core/environments/GlobalEnv.java

@@ -400,7 +400,7 @@ public List<Iterator> GetArrayAccessIteratorsFor(ArrayAccess array) {
 	public StackTraceManager GetStackTraceManager() {
 		Thread currentThread = Thread.currentThread();
 		if(this.stackTraceManager == null || currentThread != this.stackTraceManagerThread) {
-			this.stackTraceManager = new StackTraceManager();
+			this.stackTraceManager = new StackTraceManager(this);
 			this.stackTraceManagerThread = currentThread;
 		}
 		return this.stackTraceManager;

src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java

@@ -1,6 +1,11 @@
 package com.laytonsmith.core.exceptions;
 
+import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
+import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -11,22 +16,45 @@
  */
 public class StackTraceManager {
 
+	/**
+	 * The runtime setting key for configuring the maximum call depth.
+	 */
+	public static final String MAX_CALL_DEPTH_SETTING = "system.max_call_depth";
+
+	/**
+	 * The default maximum call depth. Can be overridden at runtime via the
+	 * {@code system.max_call_depth} runtime setting.
+	 */
+	public static final int DEFAULT_MAX_CALL_DEPTH = 1024;
+
+	private static final CInt DEFAULT_MAX_DEPTH_MIXED
+			= new CInt(DEFAULT_MAX_CALL_DEPTH, Target.UNKNOWN);
+
 	private final Stack<ConfigRuntimeException.StackTraceElement> elements = new Stack<>();
+	private final GlobalEnv gEnv;
 
 	/**
 	 * Creates a new, empty StackTraceManager object.
+	 *
+	 * @param gEnv The global environment, used to read runtime settings for the call depth limit.
 	 */
-	public StackTraceManager() {
-		//
+	public StackTraceManager(GlobalEnv gEnv) {
+		this.gEnv = gEnv;
 	}
 
 	/**
-	 * Adds a new stack trace trail
+	 * Adds a new stack trace element and checks the call depth against the configured maximum.
+	 * If the depth exceeds the limit, a {@link CREStackOverflowError} is thrown.
 	 *
 	 * @param element The element to be pushed on
 	 */
 	public void addStackTraceElement(ConfigRuntimeException.StackTraceElement element) {
 		elements.add(element);
+		Mixed setting = gEnv.GetRuntimeSetting(MAX_CALL_DEPTH_SETTING, DEFAULT_MAX_DEPTH_MIXED);
+		int maxDepth = ArgumentValidation.getInt32(setting, element.getDefinedAt(), null);
+		if(elements.size() > maxDepth) {
+			throw new CREStackOverflowError("Stack overflow", element.getDefinedAt());
+		}
 	}
 
 	/**
@@ -65,6 +93,15 @@ public boolean isStackSingle() {
 		return elements.size() == 1;
 	}
 
+	/**
+	 * Returns the current depth of the stack trace (the number of proc/closure frames currently active).
+	 *
+	 * @return The current stack depth
+	 */
+	public int getDepth() {
+		return elements.size();
+	}
+
 	/**
 	 * Sets the current element's target. This should be changed at every new element execution.
 	 *

src/test/java/com/laytonsmith/testing/ProcedureTest.java

@@ -3,7 +3,10 @@
 import com.laytonsmith.abstraction.MCPlayer;
 import static com.laytonsmith.testing.StaticTest.SRun;
 
+import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
+import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
+import com.laytonsmith.core.exceptions.StackTraceManager;
 import org.bukkit.plugin.Plugin;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -133,4 +136,29 @@ public void testProcCalledMultipleTimesWithAssign() throws Exception {
 		verify(fakePlayer, times(3)).sendMessage("{1, 3, 5, 7}");
 	}
 
+	@Test
+	public void testInfiniteRecursionThrowsStackOverflow() throws Exception {
+		try {
+			SRun("proc _recurse() { _recurse() } _recurse()", fakePlayer);
+			fail("Expected CREStackOverflowError from infinite recursion");
+		} catch(CREStackOverflowError ex) {
+			// Test passed — infinite recursion was caught
+		}
+	}
+
+	@Test
+	public void testCustomCallDepthLimit() throws Exception {
+		try {
+			SRun("set_runtime_setting('system.max_call_depth', 10)"
+					+ " proc _recurse() { _recurse() } _recurse()", fakePlayer);
+			fail("Expected CREStackOverflowError from infinite recursion");
+		} catch(CREStackOverflowError ex) {
+			// Test passed — custom limit was enforced
+		} finally {
+			// Reset the runtime setting so it doesn't affect other tests
+			GlobalEnv gEnv = StaticTest.env.getEnv(GlobalEnv.class);
+			gEnv.SetRuntimeSetting(StackTraceManager.MAX_CALL_DEPTH_SETTING, null);
+		}
+	}
+
 }