Debug.cc

// Debugging support for Zeek policy files.

#include "zeek/Debug.h"

#include "zeek/zeek-config.h"

#include <cctype>
#include <csignal>
#include <cstdarg>
#include <cstdio>
#include <string>

#ifdef HAVE_READLINE
#include <readline/history.h>
#include <readline/readline.h>
#endif

#include "zeek/DbgBreakpoint.h"
#include "zeek/DebugCmds.h"
#include "zeek/Desc.h"
#include "zeek/Expr.h"
#include "zeek/Frame.h"
#include "zeek/Func.h"
#include "zeek/ID.h"
#include "zeek/IntrusivePtr.h"
#include "zeek/PolicyFile.h"
#include "zeek/Reporter.h"
#include "zeek/Scope.h"
#include "zeek/Stmt.h"
#include "zeek/Val.h"
#include "zeek/input.h"
#include "zeek/module_util.h"
#include "zeek/util.h"

extern "C" {
#include "zeek/3rdparty/setsignal.h"
}

using namespace std;

bool zeek::detail::g_policy_debug = false;
zeek::detail::DebuggerState zeek::detail::g_debugger_state;
zeek::detail::TraceState zeek::detail::g_trace_state;
std::map<string, zeek::detail::Filemap*> zeek::detail::g_dbgfilemaps;

// These variables are used only to decide whether or not to print the
// current context; you don't want to do it after a step or next
// command unless you've exited a function.
static bool step_or_next_pending = false;
static zeek::detail::Frame* last_frame;

// The following values are needed by parse.y.
// Evaluates the given expression in the context of the currently selected
// frame.  Returns the resulting value, or nil if none (or there was an error).
zeek::detail::Expr* g_curr_debug_expr = nullptr;
const char* g_curr_debug_error = nullptr;
bool in_debug = false;

// ### fix this hardwired access to external variables etc.
struct yy_buffer_state;
using YY_BUFFER_STATE = struct yy_buffer_state*;
YY_BUFFER_STATE zeek_scan_string(const char*);

extern YYLTYPE yylloc; // holds start line and column of token
extern int line_number;
extern const char* filename;

namespace zeek::detail {

DebuggerState::DebuggerState() {
    next_bp_id = next_watch_id = next_display_id = 1;
    BreakBeforeNextStmt(false);
    curr_frame_idx = 0;
    already_did_list = false;
    BreakFromSignal(false);

    // ### Don't choose this arbitrary size! Extend Frame.
    dbg_locals = new Frame(1024, /* func = */ nullptr, /* fn_args = */ nullptr);
}

DebuggerState::~DebuggerState() { Unref(dbg_locals); }

bool StmtLocMapping::StartsAfter(const StmtLocMapping* m2) {
    if ( ! m2 )
        reporter->InternalError("Assertion failed: m2 != 0");

    return loc.first_line > m2->loc.first_line ||
           (loc.first_line == m2->loc.first_line && loc.first_column > m2->loc.first_column);
}

// Generic debug message output.
int debug_msg(const char* fmt, ...) {
    va_list args;
    int retval;

    va_start(args, fmt);
    retval = vfprintf(stderr, fmt, args);
    va_end(args);

    return retval;
}

// Trace message output

FILE* TraceState::SetTraceFile(const char* trace_filename) {
    FILE* newfile;

    if ( util::streq(trace_filename, "-") )
        newfile = stderr;
    else
        newfile = fopen(trace_filename, "w");

    FILE* oldfile = trace_file;
    if ( newfile ) {
        trace_file = newfile;
    }
    else {
        fprintf(stderr, "Unable to open trace file %s\n", trace_filename);
        trace_file = nullptr;
    }

    return oldfile;
}

void TraceState::TraceOn() {
    fprintf(stderr, "Execution tracing ON.\n");
    dbgtrace = true;
}

void TraceState::TraceOff() {
    fprintf(stderr, "Execution tracing OFF.\n");
    dbgtrace = false;
}

int TraceState::LogTrace(const char* fmt, ...) {
    va_list args;
    int retval;

    va_start(args, fmt);

    // Prefix includes timestamp and file/line info.
    fprintf(trace_file, "%.6f ", run_state::network_time);

    const Stmt* stmt;
    Location loc;
    loc.filename = nullptr;

    if ( g_frame_stack.size() > 0 && g_frame_stack.back() ) {
        stmt = g_frame_stack.back()->GetNextStmt();
        if ( stmt )
            loc = *stmt->GetLocationInfo();
        else {
            const ScriptFunc* f = g_frame_stack.back()->GetFunction();
            if ( f )
                loc = *f->GetLocationInfo();
        }
    }

    if ( ! loc.filename ) {
        static constexpr const char str[] = "<no filename>";
        loc.filename = util::copy_string(str, std::size(str) - 1);
        loc.last_line = 0;
    }

    fprintf(trace_file, "%s:%d", loc.filename, loc.last_line);

    // Each stack frame is indented.
    for ( int i = 0; i < int(g_frame_stack.size()); ++i )
        fprintf(trace_file, "\t");

    retval = vfprintf(trace_file, fmt, args);

    fflush(trace_file);
    va_end(args);

    return retval;
}

// Helper functions.
void get_first_statement(Stmt* list, Stmt*& first, Location& loc) {
    if ( ! list ) {
        first = nullptr;
        return;
    }

    first = list;
    while ( first->Tag() == STMT_LIST ) {
        if ( first->AsStmtList()->Stmts()[0] )
            first = first->AsStmtList()->Stmts()[0].get();
        else
            break;
    }

    loc = *first->GetLocationInfo();
}

static void parse_function_name(vector<ParseLocationRec>& result, ParseLocationRec& plr,
                                const string& s) { // function name
    const auto& id = lookup_ID(s.c_str(), current_module.c_str());

    if ( ! id ) {
        string fullname = make_full_var_name(current_module.c_str(), s.c_str());
        debug_msg("Function %s not defined.\n", fullname.c_str());
        plr.type = PLR_UNKNOWN;
        return;
    }

    if ( ! id->GetType()->AsFuncType() ) {
        debug_msg("Function %s not declared.\n", id->Name());
        plr.type = PLR_UNKNOWN;
        return;
    }

    if ( ! id->HasVal() ) {
        debug_msg("Function %s declared but not defined.\n", id->Name());
        plr.type = PLR_UNKNOWN;
        return;
    }

    const Func* func = id->GetVal()->AsFunc();
    const vector<Func::Body>& bodies = func->GetBodies();

    if ( bodies.size() == 0 ) {
        debug_msg("Function %s is a built-in function\n", id->Name());
        plr.type = PLR_UNKNOWN;
        return;
    }

    Stmt* body = nullptr; // the particular body we care about; 0 = all

    if ( bodies.size() == 1 )
        body = bodies[0].stmts.get();
    else {
        while ( true ) {
            debug_msg(
                "There are multiple definitions of that event handler.\n"
                "Please choose one of the following options:\n");
            for ( unsigned int i = 0; i < bodies.size(); ++i ) {
                Stmt* first;
                Location stmt_loc;
                get_first_statement(bodies[i].stmts.get(), first, stmt_loc);
                debug_msg("[%d] %s:%d\n", i + 1, stmt_loc.filename, stmt_loc.first_line);
            }

            debug_msg("[a] All of the above\n");
            debug_msg("[n] None of the above\n");
            debug_msg("Enter your choice: ");

            char charinput[256];
            if ( ! fgets(charinput, sizeof(charinput) - 1, stdin) ) {
                plr.type = PLR_UNKNOWN;
                return;
            }

            if ( charinput[strlen(charinput) - 1] == '\n' )
                charinput[strlen(charinput) - 1] = 0;

            string input = charinput;

            if ( input == "a" )
                break;

            if ( input == "n" ) {
                plr.type = PLR_UNKNOWN;
                return;
            }

            int option = atoi(input.c_str());
            if ( option > 0 && option <= (int)bodies.size() ) {
                body = bodies[option - 1].stmts.get();
                break;
            }
        }
    }

    plr.type = PLR_FUNCTION;

    // Find first atomic (non-STMT_LIST) statement
    Stmt* first;
    Location stmt_loc;

    if ( body ) {
        get_first_statement(body, first, stmt_loc);
        if ( first ) {
            plr.stmt = first;
            plr.filename = stmt_loc.filename;
            plr.line = stmt_loc.last_line;
        }
    }

    else {
        result.pop_back();
        ParseLocationRec result_plr;

        for ( const auto& body : bodies ) {
            get_first_statement(body.stmts.get(), first, stmt_loc);
            if ( ! first )
                continue;

            result_plr.type = PLR_FUNCTION;
            result_plr.stmt = first;
            result_plr.filename = stmt_loc.filename;
            result_plr.line = stmt_loc.last_line;
            result.push_back(result_plr);
        }
    }
}

vector<ParseLocationRec> parse_location_string(const string& s) {
    vector<ParseLocationRec> result;
    result.emplace_back();
    ParseLocationRec& plr = result[0];

    // If PLR_FILE_AND_LINE, set this to the filename you want; for
    // memory management reasons, the real filename is set when looking
    // up the line number to find the corresponding statement.
    std::string loc_filename;

    if ( sscanf(s.c_str(), "%d", &plr.line) ) { // just a line number (implicitly referring to the current file)
        loc_filename = g_debugger_state.last_loc.filename;
        plr.type = PLR_FILE_AND_LINE;
    }

    else {
        string::size_type pos_colon = s.find(':');
        string::size_type pos_dblcolon = s.find("::");

        if ( pos_colon == string::npos || pos_dblcolon != string::npos )
            parse_function_name(result, plr, s);
        else { // file:line
            string policy_filename = s.substr(0, pos_colon);
            string line_string = s.substr(pos_colon + 1, s.length() - pos_colon);

            if ( ! sscanf(line_string.c_str(), "%d", &plr.line) )
                plr.type = PLR_UNKNOWN;

            string path(util::find_script_file(policy_filename, util::zeek_path()));

            if ( path.empty() ) {
                debug_msg("No such policy file: %s.\n", policy_filename.c_str());
                plr.type = PLR_UNKNOWN;
                return result;
            }

            loc_filename = path;
            plr.type = PLR_FILE_AND_LINE;
        }
    }

    if ( plr.type == PLR_FILE_AND_LINE ) {
        auto iter = g_dbgfilemaps.find(loc_filename);
        if ( iter == g_dbgfilemaps.end() )
            reporter->InternalError("Policy file %s should have been loaded\n", loc_filename.data());

        if ( plr.line > how_many_lines_in(loc_filename.data()) ) {
            debug_msg("No line %d in %s.\n", plr.line, loc_filename.data());
            plr.type = PLR_UNKNOWN;
            return result;
        }

        StmtLocMapping* hit = nullptr;
        for ( const auto entry : *(iter->second) ) {
            plr.filename = entry->Loc().filename;

            if ( entry->Loc().first_line > plr.line )
                break;

            if ( plr.line >= entry->Loc().first_line && plr.line <= entry->Loc().last_line ) {
                hit = entry;
                break;
            }
        }

        if ( hit )
            plr.stmt = hit->Statement();
        else
            plr.stmt = nullptr;
    }

    return result;
}

// Interactive debugging console.

static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector<string>& args);

#ifdef HAVE_READLINE

void using_history(void);

static bool init_readline() {
    // ### Set up custom completion.

    rl_outstream = stderr;
    using_history();

    return false;
}

#endif

void break_signal(int) {
    g_debugger_state.BreakBeforeNextStmt(true);
    g_debugger_state.BreakFromSignal(true);
}

int dbg_init_debugger(const char* cmdfile) {
    if ( ! g_policy_debug )
        return 0; // probably shouldn't have been called

    init_global_dbg_constants();

    // Hit the debugger before running anything.
    g_debugger_state.BreakBeforeNextStmt(true);

    if ( cmdfile )
        // ### Implement this
        debug_msg("Command files not supported. Using interactive mode.\n");

        // ### if ( interactive ) (i.e., not reading cmds from a file)
#ifdef HAVE_READLINE
    init_readline();
#endif

    setsignal(SIGINT, break_signal);
    setsignal(SIGTERM, break_signal);

    return 1;
}

int dbg_shutdown_debugger() {
    // ### TODO: Remove signal handlers
    return 1;
}

// Umesh: I stole this code from libedit; I modified it here to use
// <string>s to avoid memory management problems. The main command is returned
// by the operation argument; the additional arguments are put in the
// supplied vector.
//
// Parse the string into individual tokens, similarly to how shell
// would do it.

void tokenize(const char* cstr, string& operation, vector<string>& arguments) {
    int num_tokens = 0;
    char delim = '\0';
    const string str(cstr);

    for ( int i = 0; i < (signed int)str.length(); ++i ) {
        while ( isspace((unsigned char)str[i]) )
            ++i;

        int start = i;

        for ( ; str[i]; ++i ) {
            if ( str[i] == '\\' ) {
                if ( i < (signed int)str.length() )
                    ++i;
            }

            else if ( ! delim && str[i] == '(' )
                delim = ')';

            else if ( ! delim && (str[i] == '\'' || str[i] == '"') )
                delim = str[i];

            else if ( delim && str[i] == delim ) {
                delim = '\0';
                ++i;
                break;
            }

            else if ( ! delim && isspace(str[i]) )
                break;
        }

        size_t len = i - start;

        if ( ! num_tokens )
            operation = string(str, start, len);
        else
            arguments.emplace_back(str, start, len);

        ++num_tokens;
    }
}

// Given a command string, parse it and send the command to be dispatched.
int dbg_execute_command(const char* cmd) {
    bool matched_history = false;

    if ( ! cmd )
        return 0;

    if ( util::streq(cmd, "") ) // do the GDB command completion
    {
#ifdef HAVE_READLINE
        int i;
        for ( i = history_length; i >= 1; --i ) {
            HIST_ENTRY* entry = history_get(i);
            if ( ! entry )
                return 0;

            const DebugCmdInfo* info = (const DebugCmdInfo*)entry->data;

            if ( info && info->Repeatable() ) {
                cmd = entry->line;
                matched_history = true;
                break;
            }
        }
#endif

        if ( ! matched_history )
            return 0;
    }

    char* localcmd = util::copy_string(cmd);

    string opstring;
    vector<string> arguments;
    tokenize(localcmd, opstring, arguments);

    delete[] localcmd;

    // Make sure we know this op name.
    auto matching_cmds_buf = std::make_unique<const char*[]>(num_debug_cmds());
    auto matching_cmds = matching_cmds_buf.get();
    int num_matches = find_all_matching_cmds(opstring, matching_cmds);

    if ( ! num_matches ) {
        debug_msg("No Matching command for '%s'.\n", opstring.c_str());
        return 0;
    }

    if ( num_matches > 1 ) {
        debug_msg("Ambiguous command; could be\n");

        for ( int i = 0; i < num_debug_cmds(); ++i )
            if ( matching_cmds[i] )
                debug_msg("\t%s\n", matching_cmds[i]);

        return 0;
    }

    // Matched exactly one command: find out which one.
    DebugCmd cmd_code = dcInvalid;
    for ( int i = 0; i < num_debug_cmds(); ++i )
        if ( matching_cmds[i] ) {
            cmd_code = (DebugCmd)i;
            break;
        }

#ifdef HAVE_READLINE
    // Insert command into history.
    if ( ! matched_history && cmd && *cmd ) {
        /* The prototype for add_history(), at least under MacOS,
         * has it taking a char* rather than a const char*.
         * But documentation at
         * http://tiswww.case.edu/php/chet/readline/history.html
         * suggests that it's safe to assume it's really const char*.
         */
        add_history((char*)cmd);
        HISTORY_STATE* state = history_get_history_state();
        state->entries[state->length - 1]->data = (histdata_t*)get_debug_cmd_info(cmd_code);
    }
#endif

    if ( int(cmd_code) >= num_debug_cmds() )
        reporter->InternalError("Assertion failed: int(cmd_code) < num_debug_cmds()");

    // Dispatch to the op-specific handler (with args).
    int retcode = dbg_dispatch_cmd(cmd_code, arguments);
    if ( retcode < 0 )
        return retcode;

    const DebugCmdInfo* info = get_debug_cmd_info(cmd_code);
    if ( ! info )
        reporter->InternalError("Assertion failed: info");

    if ( ! info )
        return -2; // ### yuck, why -2?

    return info->ResumeExecution();
}

// Call the appropriate function for the command.
static int dbg_dispatch_cmd(DebugCmd cmd_code, const vector<string>& args) {
    switch ( cmd_code ) {
        case dcHelp: dbg_cmd_help(cmd_code, args); break;

        case dcQuit: debug_msg("Program Terminating\n"); exit(0);

        case dcNext:
            g_frame_stack.back()->BreakBeforeNextStmt(true);
            step_or_next_pending = true;
            last_frame = g_frame_stack.back();
            break;

        case dcStep:
            g_debugger_state.BreakBeforeNextStmt(true);
            step_or_next_pending = true;
            last_frame = g_frame_stack.back();
            break;

        case dcContinue:
            g_debugger_state.BreakBeforeNextStmt(false);
            debug_msg("Continuing.\n");
            break;

        case dcFinish:
            g_frame_stack.back()->BreakOnReturn(true);
            g_debugger_state.BreakBeforeNextStmt(false);
            break;

        case dcBreak: dbg_cmd_break(cmd_code, args); break;

        case dcBreakCondition: dbg_cmd_break_condition(cmd_code, args); break;

        case dcDeleteBreak:
        case dcClearBreak:
        case dcDisableBreak:
        case dcEnableBreak:
        case dcIgnoreBreak: dbg_cmd_break_set_state(cmd_code, args); break;

        case dcPrint: dbg_cmd_print(cmd_code, args); break;

        case dcBacktrace: return dbg_cmd_backtrace(cmd_code, args);

        case dcFrame:
        case dcUp:
        case dcDown: return dbg_cmd_frame(cmd_code, args);

        case dcInfo: return dbg_cmd_info(cmd_code, args);

        case dcList: return dbg_cmd_list(cmd_code, args);

        case dcDisplay:
        case dcUndisplay: debug_msg("Command not yet implemented.\n"); break;

        case dcTrace: return dbg_cmd_trace(cmd_code, args);

        default:
            debug_msg(
                "INTERNAL ERROR: "
                "Got an unknown debugger command in DbgDispatchCmd: %d\n",
                cmd_code);
            return 0;
    }

    return 0;
}

static char* get_prompt(bool reset_counter = false) {
    static char prompt[512];
    static int counter = 0;

    if ( reset_counter )
        counter = 0;

    snprintf(prompt, sizeof(prompt), "(Zeek [%d]) ", counter++);

    return prompt;
}

string get_context_description(const Stmt* stmt, const Frame* frame) {
    ODesc d;
    const ScriptFunc* func = frame ? frame->GetFunction() : nullptr;

    if ( func )
        func->DescribeDebug(&d, frame->GetFuncArgs());
    else
        d.Add("<unknown function>", 0);

    Location loc;
    if ( stmt )
        loc = *stmt->GetLocationInfo();
    else {
        static constexpr const char str[] = "<no filename>";
        loc.filename = util::copy_string(str, std::size(str) - 1);
        loc.last_line = 0;
    }

    size_t buf_size = strlen(d.Description()) + strlen(loc.filename) + 1024;
    char* buf = new char[buf_size];
    snprintf(buf, buf_size, "In %s at %s:%d", d.Description(), loc.filename, loc.last_line);

    string retval(buf);
    delete[] buf;
    return retval;
}

int dbg_handle_debug_input() {
    static char* input_line = nullptr;
    int status = 0;

    if ( g_debugger_state.BreakFromSignal() ) {
        debug_msg("Program received signal SIGINT: entering debugger\n");

        g_debugger_state.BreakFromSignal(false);
    }

    Frame* curr_frame = g_frame_stack.back();
    const ScriptFunc* func = curr_frame->GetFunction();
    if ( func )
        current_module = extract_module_name(func->Name());
    else
        current_module = GLOBAL_MODULE_NAME;

    const Stmt* stmt = curr_frame->GetNextStmt();
    if ( ! stmt )
        reporter->InternalError("Assertion failed: stmt != 0");

    const Location loc = *stmt->GetLocationInfo();

    if ( ! step_or_next_pending || g_frame_stack.back() != last_frame ) {
        string context = get_context_description(stmt, g_frame_stack.back());
        debug_msg("%s\n", context.c_str());
    }

    step_or_next_pending = false;

    PrintLines(loc.filename, loc.first_line, loc.last_line - loc.first_line + 1, true);
    g_debugger_state.last_loc = loc;

    do {
        // readline returns a pointer to a buffer it allocates; it's
        // freed at the bottom.
#ifdef HAVE_READLINE
        input_line = readline(get_prompt());
#else
        printf("%s", get_prompt());

        // readline uses malloc, and we want to be consistent
        // with it.
        input_line = (char*)util::safe_malloc(1024);
        input_line[1023] = 0;
        // ### Maybe it's not always stdin.
        input_line = fgets(input_line, 1023, stdin);
#endif

        // ### Maybe not stdin; maybe do better cleanup.
        if ( feof(stdin) )
            exit(0);

        status = dbg_execute_command(input_line);

        if ( input_line ) {
            free(input_line); // this was malloc'ed
            input_line = nullptr;
        }
        else
            exit(0);
    } while ( status == 0 );

    // Clear out some state. ### Is there a better place?
    g_debugger_state.curr_frame_idx = 0;
    g_debugger_state.already_did_list = false;

    setsignal(SIGINT, break_signal);
    setsignal(SIGTERM, break_signal);

    return 0;
}

// Return true to continue execution, false to abort.
bool pre_execute_stmt(Stmt* stmt, Frame* f) {
    if ( ! g_policy_debug || stmt->Tag() == STMT_LIST || stmt->Tag() == STMT_NULL )
        return true;

    if ( g_trace_state.DoTrace() ) {
        ODesc d;
        stmt->Describe(&d);

        const char* desc = d.Description();
        const char* s = strchr(desc, '\n');

        int len;
        if ( s )
            len = s - desc;
        else
            len = strlen(desc);

        g_trace_state.LogTrace("%*s\n", len, desc);
    }

    bool should_break = false;

    if ( g_debugger_state.BreakBeforeNextStmt() || f->BreakBeforeNextStmt() ) {
        if ( g_debugger_state.BreakBeforeNextStmt() )
            g_debugger_state.BreakBeforeNextStmt(false);

        if ( f->BreakBeforeNextStmt() )
            f->BreakBeforeNextStmt(false);

        should_break = true;
    }

    if ( stmt->BPCount() ) {
        pair<BPMapType::iterator, BPMapType::iterator> p;

        p = g_debugger_state.breakpoint_map.equal_range(stmt);

        if ( p.first == p.second )
            reporter->InternalError("Breakpoint count nonzero, but no matching breakpoints");

        for ( BPMapType::iterator i = p.first; i != p.second; ++i ) {
            int break_code = i->second->ShouldBreak(stmt);
            if ( break_code == 2 ) // ### 2?
            {
                i->second->SetEnable(false);
                delete i->second;
            }

            should_break = should_break || break_code;
        }
    }

    if ( should_break )
        dbg_handle_debug_input();

    return true;
}

bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, StmtFlowType* flow) {
    // Handle the case where someone issues a "next" debugger command,
    // but we're at a return statement, so the next statement is in
    // some other function.
    if ( *flow == FLOW_RETURN && f->BreakBeforeNextStmt() )
        g_debugger_state.BreakBeforeNextStmt(true);

    // Handle "finish" commands.
    if ( *flow == FLOW_RETURN && f->BreakOnReturn() ) {
        if ( result ) {
            ODesc d;
            result->Describe(&d);
            debug_msg("Return Value: '%s'\n", d.Description());
        }
        else
            debug_msg("Return Value: <none>\n");

        g_debugger_state.BreakBeforeNextStmt(true);
        f->BreakOnReturn(false);
    }

    return true;
}

ValPtr dbg_eval_expr(const char* expr) {
    // Push the current frame's associated scope.
    // Note: g_debugger_state.curr_frame_idx is the user-visible number,
    //       while the array index goes in the opposite direction
    int frame_idx = (g_frame_stack.size() - 1) - g_debugger_state.curr_frame_idx;

    if ( ! (frame_idx >= 0 && (unsigned)frame_idx < g_frame_stack.size()) )
        reporter->InternalError("Assertion failed: frame_idx >= 0 && (unsigned) frame_idx < g_frame_stack.size()");

    Frame* frame = g_frame_stack[frame_idx];
    if ( ! (frame) )
        reporter->InternalError("Assertion failed: frame");

    const ScriptFunc* func = frame->GetFunction();
    if ( func )
        push_existing_scope(func->GetScope());

    // ### Possibly push a debugger-local scope?

    // Set up the lexer to read from the string.
    string parse_string = string("@DEBUG ") + expr;
    zeek_scan_string(parse_string.c_str());

    // Fix filename and line number for the lexer/parser, which record it.
    filename = "<interactive>";
    line_number = 1;
    yylloc.filename = filename;
    yylloc.first_line = yylloc.last_line = line_number = 1;

    // Parse the thing into an expr.
    ValPtr result;
    if ( yyparse() ) {
        if ( g_curr_debug_error )
            debug_msg("Parsing expression '%s' failed: %s\n", expr, g_curr_debug_error);
        else
            debug_msg("Parsing expression '%s' failed\n", expr);

        if ( g_curr_debug_expr ) {
            delete g_curr_debug_expr;
            g_curr_debug_expr = nullptr;
        }
    }
    else
        result = g_curr_debug_expr->Eval(frame);

    if ( func )
        pop_scope();

    delete g_curr_debug_expr;
    g_curr_debug_expr = nullptr;
    delete[] g_curr_debug_error;
    g_curr_debug_error = nullptr;
    in_debug = false;

    return result;
}

} // namespace zeek::detail