refactor: change filename and funcname parameters to JSAtom in debug trace functions

suggestion form @jprendes at #1421 (comment)

Author: G-Yong

api-test.c

@@ -1017,27 +1017,25 @@ static struct {
     int call_count;
     int last_line;
     int last_col;
-    char last_filename[256];
-    char last_funcname[256];
+    JSAtom last_filename;
+    JSAtom last_funcname;
     int stack_depth;
     int max_local_count;
     int abort_at;        /* abort (return -1) on this call, 0 = never */
 } trace_state;
 
 static int debug_trace_cb(JSContext *ctx,
-                          const char *filename,
-                          const char *funcname,
+                          JSAtom filename,
+                          JSAtom funcname,
                           int line,
                           int col,
                           void *opaque)
 {
     trace_state.call_count++;
     trace_state.last_line = line;
     trace_state.last_col = col;
-    snprintf(trace_state.last_filename, sizeof(trace_state.last_filename),
-             "%s", filename);
-    snprintf(trace_state.last_funcname, sizeof(trace_state.last_funcname),
-             "%s", funcname);
+    trace_state.last_filename = filename;
+    trace_state.last_funcname = funcname;
     trace_state.stack_depth = JS_GetStackDepth(ctx);
     int count = 0;
     JSDebugLocalVar *vars = NULL;
@@ -1072,7 +1070,11 @@ static void debug_trace(void)
         assert(!JS_IsException(ret));
         JS_FreeValue(ctx, ret);
         assert(trace_state.call_count > 0);
-        assert(!strcmp(trace_state.last_filename, "<input>"));
+        {
+            const char *fn = JS_AtomToCString(ctx, trace_state.last_filename);
+            assert(fn && !strcmp(fn, "<input>"));
+            JS_FreeCString(ctx, fn);
+        }
     }
 
     {

quickjs.c

@@ -17833,25 +17833,13 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 uint32_t pc_index = (uint32_t)(pc - b->byte_code_buf - 1);
                 line_num = find_line_num(ctx, b, pc_index, &col_num);
 
-                /* Use JS_AtomToCString to get the full filename / funcname
-                   without the 63-byte truncation that a stack buffer would
-                   impose. The pointers are only valid for the duration of
-                   the callback. */
-                const char *filename = JS_AtomToCString(ctx, b->filename);
-                if (unlikely(!filename)) {
-                    /* OOM: a pending exception has been raised */
-                    goto exception;
-                }
-                const char *funcname = JS_AtomToCString(ctx, b->func_name);
-                if (unlikely(!funcname)) {
-                    JS_FreeCString(ctx, filename);
-                    goto exception;
-                }
-                int ret = ctx->debug_trace(ctx, filename, funcname,
+                /* Pass the JSAtom values directly — no heap allocation.
+                   The atoms are valid for the lifetime of the bytecode
+                   object, which outlives the callback.  The embedder must
+                   call JS_DupAtom() if it needs to retain them. */
+                int ret = ctx->debug_trace(ctx, b->filename, b->func_name,
                                            line_num, col_num,
                                            ctx->debug_trace_opaque);
-                JS_FreeCString(ctx, filename);
-                JS_FreeCString(ctx, funcname);
 
                 if (ret != 0 || JS_HasException(ctx)) {
                     /* If the callback indicated failure but did not raise

quickjs.h

@@ -540,10 +540,19 @@ JS_EXTERN JSValue JS_GetFunctionProto(JSContext *ctx);
    is parsed (e.g. by JS_Eval / JS_Compile) AFTER JS_SetDebugTraceHandler
    has been called will be instrumented; previously compiled bytecode
    will not invoke the callback.  In practice, install the handler before
-   evaluating any application code. */
+   evaluating any application code.
+
+   'filename' and 'funcname' are JSAtom values identifying the source file
+   and enclosing function name.  They are valid only for the duration of
+   the callback; call JS_DupAtom() if you need to retain them.  Either
+   may be JS_ATOM_NULL (0) for anonymous functions or eval code.  Use
+   JS_AtomToCString() / JS_AtomToString() to convert to a C string or
+   JSValue when needed.  Accepting JSAtom avoids a heap allocation on
+   every instrumented statement when the embedder only needs to compare
+   against a known set of breakpoint locations. */
 typedef int JSDebugTraceFunc(JSContext *ctx,
-                             const char *filename,
-                             const char *funcname,
+                             JSAtom filename,
+                             JSAtom funcname,
                              int line,
                              int col,
                              void *opaque);