move DebugFrame to luceedebug.coreinject.frame package

Author: softwareCobbler

luceedebug/src/main/java/luceedebug/coreinject/CfValueDebuggerBridge.java

@@ -15,8 +15,9 @@
 import lucee.runtime.type.Array;
 import luceedebug.ICfValueDebuggerBridge;
 import luceedebug.IDebugEntity;
+import luceedebug.coreinject.frame.DebugFrame;
 
-class CfValueDebuggerBridge implements ICfValueDebuggerBridge {
+public class CfValueDebuggerBridge implements ICfValueDebuggerBridge {
     // Pin some ephemeral evaluated things so they don't get GC'd immediately.
     // It would be better to pin them to a "session" or something with a meaningful lifetime,
     // rather than hope they live long enough in this cache to be useful.
@@ -27,7 +28,7 @@ class CfValueDebuggerBridge implements ICfValueDebuggerBridge {
         .maximumSize(50)
         .expireAfterWrite(10, TimeUnit.MINUTES)
         .build();
-    static void pin(Object obj) {
+    public static void pin(Object obj) {
         pinnedObjects.put(System.identityHashCode(obj), obj);
     }
 
@@ -45,10 +46,10 @@ public long getID() {
         return id;
     }
 
-    static class MarkerTrait {
-        static class Scope {
+    public static class MarkerTrait {
+        public static class Scope {
             public final Map<?,?> scopelike;
-            Scope(Map<?,?> scopelike) {
+            public Scope(Map<?,?> scopelike) {
                 this.scopelike = scopelike;
             }
         }

luceedebug/src/main/java/luceedebug/coreinject/DebugEntity.java

@@ -3,12 +3,12 @@
 import luceedebug.*;
 
 public class DebugEntity implements IDebugEntity {
-    String name;
-    String value;
-    int namedVariables;
-    int indexedVariables;
-    boolean expensive;
-    long variablesReference;
+    public String name;
+    public String value;
+    public int namedVariables;
+    public int indexedVariables;
+    public boolean expensive;
+    public long variablesReference;
 
     public String getName() { return name; }
     public String getValue() { return value; }

luceedebug/src/main/java/luceedebug/coreinject/DebugManager.java

@@ -32,6 +32,7 @@
 import luceedebug.IDebugEntity;
 import luceedebug.IDebugFrame;
 import luceedebug.IDebugManager;
+import luceedebug.coreinject.frame.DebugFrame;
 
 public class DebugManager implements IDebugManager {
 
@@ -662,10 +663,10 @@ private DebugFrame getTopmostFrame(Thread thread) {
     }
 
     public void pushCfFrame(PageContext pageContext, String sourceFilePath) {
-        pushCfFrame_worker(pageContext, sourceFilePath);
+        maybe_pushCfFrame_worker(pageContext, sourceFilePath);
     }
 
-    private DebugFrame pushCfFrame_worker(PageContext pageContext, String sourceFilePath) {
+    private DebugFrame maybe_pushCfFrame_worker(PageContext pageContext, String sourceFilePath) {
         Thread currentThread = Thread.currentThread();
 
         ArrayList<DebugFrame> stack = cfStackByThread.get(currentThread);
@@ -681,7 +682,12 @@ private DebugFrame pushCfFrame_worker(PageContext pageContext, String sourceFile
         }
 
         final int depth = stack.size(); // first frame is frame 0, and prior to pushing the first frame the stack is length 0; next frame is frame 1, and prior to pushing it the stack is of length 1, ...
-        final DebugFrame frame = new DebugFrame(sourceFilePath, depth, valTracker, pageContext);
+        
+        final DebugFrame frame = DebugFrame.maybeMakeFrame(sourceFilePath, depth, valTracker, pageContext);
+
+        if (frame == null) {
+            return null;
+        }
 
         stack.add(frame);
 
@@ -696,7 +702,11 @@ private DebugFrame pushCfFrame_worker(PageContext pageContext, String sourceFile
     }
 
     public void pushCfFunctionDefaultValueInitializationFrame(lucee.runtime.PageContext pageContext, String sourceFilePath) {
-        DebugFrame frame = pushCfFrame_worker(pageContext, sourceFilePath);
+        DebugFrame frame = maybe_pushCfFrame_worker(pageContext, sourceFilePath);
+        if (frame == null) {
+            return;
+        }
+
         frame.isUdfDefaultValueInitFrame = true;
     }
 

luceedebug/src/main/java/luceedebug/coreinject/ExprEvaluator.java

@@ -8,6 +8,7 @@
 
 import lucee.runtime.PageContext;
 import luceedebug.Either;
+import luceedebug.coreinject.frame.DebugFrame;
 
 import static luceedebug.coreinject.Utils.terminate;
 

luceedebug/src/main/java/luceedebug/coreinject/UnsafeUtils.java

@@ -2,7 +2,7 @@
 
 import lucee.runtime.exp.PageException;
 
-class UnsafeUtils {
+public class UnsafeUtils {
     @SuppressWarnings("unchecked")
     static <T> T uncheckedCast(Object e) {
         return (T)e;

luceedebug/src/main/java/luceedebug/coreinject/DebugFrame.java renamed to luceedebug/src/main/java/luceedebug/coreinject/frame/DebugFrame.java

@@ -1,4 +1,4 @@
-package luceedebug.coreinject;
+package luceedebug.coreinject.frame;
 
 import lucee.runtime.PageContext;
 import lucee.runtime.PageContextImpl;
@@ -18,7 +18,13 @@
 import com.google.common.collect.MapMaker;
 
 import luceedebug.*;
+import luceedebug.coreinject.CfValueDebuggerBridge;
+import luceedebug.coreinject.ClosureScopeLocalScopeAccessorShim;
+import luceedebug.coreinject.DebugEntity;
+import luceedebug.coreinject.UnsafeUtils;
+import luceedebug.coreinject.ValTracker;
 import luceedebug.coreinject.CfValueDebuggerBridge.MarkerTrait;
+import luceedebug.coreinject.CfValueDebuggerBridge.MarkerTrait.Scope;
 
 public class DebugFrame implements IDebugFrame {
     static private AtomicLong nextId = new AtomicLong(0);
@@ -63,6 +69,8 @@ void pin(Object obj) {
         refsToKeepAlive_.add(obj);
     }
 
+    static ThreadLocal<Boolean> isPushingFrame = ThreadLocal.withInitial(() -> false);
+
     // hold strong refs to scopes, because PageContext will swap them out as frames change (variables, local, this)
     // (application, server and etc. maybe could be held as globals)
     // We don't want to construct tracked refs to them until a debugger asks for them, because it is expensive
@@ -76,21 +84,21 @@ void pin(Object obj) {
     // the engine is truly do with its "frame". Fallback here would be use a WeakRef<> but it doesn't
     // seem necessary.
     //
-    static class FrameContext {
-        final PageContext pageContext;
-
-        final lucee.runtime.type.scope.Scope application;
-        final lucee.runtime.type.scope.Argument arguments;
-        final lucee.runtime.type.scope.Scope form;
-        final lucee.runtime.type.scope.Local local;
-        final lucee.runtime.type.scope.Scope request;
-        final lucee.runtime.type.scope.Scope session;
-        final lucee.runtime.type.scope.Scope server;
-        final lucee.runtime.type.scope.Scope url;
-        final lucee.runtime.type.scope.Variables variables;
+    public static class FrameContext {
+        final public PageContext pageContext;
+
+        public final lucee.runtime.type.scope.Scope application;
+        public final lucee.runtime.type.scope.Argument arguments;
+        public final lucee.runtime.type.scope.Scope form;
+        public final lucee.runtime.type.scope.Local local;
+        public final lucee.runtime.type.scope.Scope request;
+        public final lucee.runtime.type.scope.Scope session;
+        public final lucee.runtime.type.scope.Scope server;
+        public final lucee.runtime.type.scope.Scope url;
+        public final lucee.runtime.type.scope.Variables variables;
         // n.b. the `this` scope does not derive from Scope
-        final lucee.runtime.type.Struct this_;
-        final lucee.runtime.type.scope.Scope static_;
+        public final lucee.runtime.type.Struct this_;
+        public final lucee.runtime.type.scope.Scope static_;
 
         // lazy init because it (might?) be expensive to walk scope chains eagerly every frame
         private ArrayList<lucee.runtime.type.scope.ClosureScope> capturedScopeChain = null;
@@ -104,7 +112,7 @@ static class FrameContext {
         // expensive exceptions on literally every frame, e.g. if a scope is disabled by the engine and trying to touch it
         // throws an ExpressionException.
         //
-        FrameContext(PageContext pageContext) {
+        private FrameContext(PageContext pageContext) {
             this.pageContext = pageContext;
             this.application = getScopelikeOrNull(() -> pageContext.applicationScope());
             this.arguments   = getScopelikeOrNull(() -> pageContext.argumentsScope());
@@ -217,11 +225,29 @@ public <T> T doWorkInThisFrame(Supplier<T> f)  {
         }
     }
 
-    public DebugFrame(String sourceFilePath, int depth, ValTracker valTracker, PageContext pageContext) {
+    // DebugFrame >: DummyFrame | Frame
+    static private DebugFrame dummyFrame = new DebugFrame("null", 0, null, null);
+
+    static public DebugFrame maybeMakeFrame(String sourceFilePath, int depth, ValTracker valTracker, PageContext pageContext) {
+        if (isPushingFrame.get()) {
+            return null;
+        }
+        else {
+            try {
+                isPushingFrame.set(true);
+                return new DebugFrame(sourceFilePath, depth, valTracker, pageContext, DebugFrame.tryGetFrameName(pageContext));
+            }
+            finally {
+                isPushingFrame.set(false);
+            }
+        }
+    }
+    
+    private DebugFrame(String sourceFilePath, int depth, ValTracker valTracker, PageContext pageContext) {
         this(sourceFilePath, depth, valTracker, pageContext, DebugFrame.tryGetFrameName(pageContext));
     }
 
-    public DebugFrame(String sourceFilePath, int depth, ValTracker valTracker, PageContext pageContext, String name) {
+    private DebugFrame(String sourceFilePath, int depth, ValTracker valTracker, PageContext pageContext, String name) {
         this.frameContext_ = new FrameContext(pageContext);
         this.sourceFilePath = Objects.requireNonNull(sourceFilePath);
         this.valTracker = Objects.requireNonNull(valTracker);
@@ -321,7 +347,7 @@ public IDebugEntity[] getScopes() {
         return result;
     }
 
-    CfValueDebuggerBridge trackEvalResult(Object obj) {
+    public CfValueDebuggerBridge trackEvalResult(Object obj) {
         var v = new CfValueDebuggerBridge(this, obj);
         CfValueDebuggerBridge.pin(obj);
         return v;