neovim

debugger.c (24240B)

---

/// @file debugger.c
///
/// Vim script debugger functions

#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

#include "nvim/ascii_defs.h"
#include "nvim/buffer_defs.h"
#include "nvim/charset.h"
#include "nvim/cmdexpand_defs.h"
#include "nvim/debugger.h"
#include "nvim/drawscreen.h"
#include "nvim/errors.h"
#include "nvim/eval.h"
#include "nvim/eval/typval.h"
#include "nvim/eval/typval_defs.h"
#include "nvim/ex_cmds_defs.h"
#include "nvim/ex_docmd.h"
#include "nvim/ex_getln.h"
#include "nvim/fileio.h"
#include "nvim/garray.h"
#include "nvim/garray_defs.h"
#include "nvim/getchar.h"
#include "nvim/getchar_defs.h"
#include "nvim/gettext_defs.h"
#include "nvim/globals.h"
#include "nvim/keycodes.h"
#include "nvim/macros_defs.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/os/os.h"
#include "nvim/os/os_defs.h"
#include "nvim/path.h"
#include "nvim/pos_defs.h"
#include "nvim/regexp.h"
#include "nvim/runtime.h"
#include "nvim/runtime_defs.h"
#include "nvim/state_defs.h"
#include "nvim/types_defs.h"
#include "nvim/vim_defs.h"

/// batch mode debugging: don't save and restore typeahead.
static bool debug_greedy = false;

static char *debug_oldval = NULL;  // old and newval for debug expressions
static char *debug_newval = NULL;

/// The list of breakpoints: dbg_breakp.
/// This is a grow-array of structs.
struct debuggy {
 int dbg_nr;                   ///< breakpoint number
 int dbg_type;                 ///< DBG_FUNC or DBG_FILE or DBG_EXPR
 char *dbg_name;               ///< function, expression or file name
 regprog_T *dbg_prog;          ///< regexp program
 linenr_T dbg_lnum;            ///< line number in function or file
 int dbg_forceit;              ///< ! used
 typval_T *dbg_val;            ///< last result of watchexpression
 int dbg_level;                ///< stored nested level for expr
};

#include "debugger.c.generated.h"

/// Debug mode. Repeatedly get Ex commands, until told to continue normal
/// execution.
void do_debug(char *cmd)
{
 int save_msg_scroll = msg_scroll;
 int save_State = State;
 int save_did_emsg = did_emsg;
 const bool save_cmd_silent = cmd_silent;
 int save_msg_silent = msg_silent;
 int save_emsg_silent = emsg_silent;
 bool save_redir_off = redir_off;
 tasave_T typeaheadbuf;
 bool typeahead_saved = false;
 int save_ignore_script = 0;
 char *cmdline = NULL;
 char *p;
 char *tail = NULL;
 static int last_cmd = 0;
#define CMD_CONT        1
#define CMD_NEXT        2
#define CMD_STEP        3
#define CMD_FINISH      4
#define CMD_QUIT        5
#define CMD_INTERRUPT   6
#define CMD_BACKTRACE   7
#define CMD_FRAME       8
#define CMD_UP          9
#define CMD_DOWN        10

 RedrawingDisabled++;          // don't redisplay the window
 no_wait_return++;             // don't wait for return
 did_emsg = false;             // don't use error from debugged stuff
 cmd_silent = false;           // display commands
 msg_silent = false;           // display messages
 emsg_silent = false;          // display error messages
 redir_off = true;             // don't redirect debug commands

 State = MODE_NORMAL;
 debug_mode = true;

 if (!debug_did_msg) {
   msg(_("Entering Debug mode.  Type \"cont\" to continue."), 0);
 }
 if (debug_oldval != NULL) {
   smsg(0, _("Oldval = \"%s\""), debug_oldval);
   XFREE_CLEAR(debug_oldval);
 }
 if (debug_newval != NULL) {
   smsg(0, _("Newval = \"%s\""), debug_newval);
   XFREE_CLEAR(debug_newval);
 }
 char *sname = estack_sfile(ESTACK_NONE);
 if (sname != NULL) {
   msg(sname, 0);
 }
 xfree(sname);
 if (SOURCING_LNUM != 0) {
   smsg(0, _("line %" PRId64 ": %s"), (int64_t)SOURCING_LNUM, cmd);
 } else {
   smsg(0, _("cmd: %s"), cmd);
 }

 // Repeat getting a command and executing it.
 while (true) {
   msg_scroll = true;
   need_wait_return = false;

   // Save the current typeahead buffer and replace it with an empty one.
   // This makes sure we get input from the user here and don't interfere
   // with the commands being executed.  Reset "ex_normal_busy" to avoid
   // the side effects of using ":normal". Save the stuff buffer and make
   // it empty. Set ignore_script to avoid reading from script input.
   int save_ex_normal_busy = ex_normal_busy;
   ex_normal_busy = 0;
   if (!debug_greedy) {
     save_typeahead(&typeaheadbuf);
     typeahead_saved = true;
     save_ignore_script = ignore_script;
     ignore_script = true;
   }

   // don't debug any function call, e.g. from an expression mapping
   int n = debug_break_level;
   debug_break_level = -1;

   xfree(cmdline);
   cmdline = getcmdline_prompt('>', NULL, 0, EXPAND_NOTHING, NULL, CALLBACK_NONE, false, NULL);

   debug_break_level = n;
   if (typeahead_saved) {
     restore_typeahead(&typeaheadbuf);
     ignore_script = save_ignore_script;
   }
   ex_normal_busy = save_ex_normal_busy;

   cmdline_row = msg_row;
   msg_starthere();
   if (cmdline != NULL) {
     // If this is a debug command, set "last_cmd".
     // If not, reset "last_cmd".
     // For a blank line use previous command.
     p = skipwhite(cmdline);
     if (*p != NUL) {
       switch (*p) {
       case 'c':
         last_cmd = CMD_CONT;
         tail = "ont";
         break;
       case 'n':
         last_cmd = CMD_NEXT;
         tail = "ext";
         break;
       case 's':
         last_cmd = CMD_STEP;
         tail = "tep";
         break;
       case 'f':
         last_cmd = 0;
         if (p[1] == 'r') {
           last_cmd = CMD_FRAME;
           tail = "rame";
         } else {
           last_cmd = CMD_FINISH;
           tail = "inish";
         }
         break;
       case 'q':
         last_cmd = CMD_QUIT;
         tail = "uit";
         break;
       case 'i':
         last_cmd = CMD_INTERRUPT;
         tail = "nterrupt";
         break;
       case 'b':
         last_cmd = CMD_BACKTRACE;
         if (p[1] == 't') {
           tail = "t";
         } else {
           tail = "acktrace";
         }
         break;
       case 'w':
         last_cmd = CMD_BACKTRACE;
         tail = "here";
         break;
       case 'u':
         last_cmd = CMD_UP;
         tail = "p";
         break;
       case 'd':
         last_cmd = CMD_DOWN;
         tail = "own";
         break;
       default:
         last_cmd = 0;
       }
       if (last_cmd != 0) {
         // Check that the tail matches.
         p++;
         while (*p != NUL && *p == *tail) {
           p++;
           tail++;
         }
         if (ASCII_ISALPHA(*p) && last_cmd != CMD_FRAME) {
           last_cmd = 0;
         }
       }
     }

     if (last_cmd != 0) {
       // Execute debug command: decide where to break next and return.
       switch (last_cmd) {
       case CMD_CONT:
         debug_break_level = -1;
         break;
       case CMD_NEXT:
         debug_break_level = ex_nesting_level;
         break;
       case CMD_STEP:
         debug_break_level = 9999;
         break;
       case CMD_FINISH:
         debug_break_level = ex_nesting_level - 1;
         break;
       case CMD_QUIT:
         got_int = true;
         debug_break_level = -1;
         break;
       case CMD_INTERRUPT:
         got_int = true;
         debug_break_level = 9999;
         // Do not repeat ">interrupt" cmd, continue stepping.
         last_cmd = CMD_STEP;
         break;
       case CMD_BACKTRACE:
         do_showbacktrace(cmd);
         continue;
       case CMD_FRAME:
         if (*p == NUL) {
           do_showbacktrace(cmd);
         } else {
           p = skipwhite(p);
           do_setdebugtracelevel(p);
         }
         continue;
       case CMD_UP:
         debug_backtrace_level++;
         do_checkbacktracelevel();
         continue;
       case CMD_DOWN:
         debug_backtrace_level--;
         do_checkbacktracelevel();
         continue;
       }
       // Going out reset backtrace_level
       debug_backtrace_level = 0;
       break;
     }

     // don't debug this command
     n = debug_break_level;
     debug_break_level = -1;
     do_cmdline(cmdline, getexline, NULL, DOCMD_VERBOSE|DOCMD_EXCRESET);
     debug_break_level = n;
   }
   lines_left = Rows - 1;
 }
 xfree(cmdline);

 RedrawingDisabled--;
 no_wait_return--;
 redraw_all_later(UPD_NOT_VALID);
 need_wait_return = false;
 msg_scroll = save_msg_scroll;
 lines_left = Rows - 1;
 State = save_State;
 debug_mode = false;
 did_emsg = save_did_emsg;
 cmd_silent = save_cmd_silent;
 msg_silent = save_msg_silent;
 emsg_silent = save_emsg_silent;
 redir_off = save_redir_off;

 // Only print the message again when typing a command before coming back here.
 debug_did_msg = true;
}

static int get_maxbacktrace_level(char *sname)
{
 int maxbacktrace = 0;

 if (sname == NULL) {
   return 0;
 }

 char *p = sname;
 char *q;
 while ((q = strstr(p, "..")) != NULL) {
   p = q + 2;
   maxbacktrace++;
 }
 return maxbacktrace;
}

static void do_setdebugtracelevel(char *arg)
{
 int level = atoi(arg);
 if (*arg == '+' || level < 0) {
   debug_backtrace_level += level;
 } else {
   debug_backtrace_level = level;
 }

 do_checkbacktracelevel();
}

static void do_checkbacktracelevel(void)
{
 if (debug_backtrace_level < 0) {
   debug_backtrace_level = 0;
   msg(_("frame is zero"), 0);
 } else {
   char *sname = estack_sfile(ESTACK_NONE);
   int max = get_maxbacktrace_level(sname);

   if (debug_backtrace_level > max) {
     debug_backtrace_level = max;
     smsg(0, _("frame at highest level: %d"), max);
   }
   xfree(sname);
 }
}

static void do_showbacktrace(char *cmd)
{
 char *sname = estack_sfile(ESTACK_NONE);
 int max = get_maxbacktrace_level(sname);
 if (sname != NULL) {
   int i = 0;
   char *cur = sname;
   while (!got_int) {
     char *next = strstr(cur, "..");
     if (next != NULL) {
       *next = NUL;
     }
     if (i == max - debug_backtrace_level) {
       smsg(0, "->%d %s", max - i, cur);
     } else {
       smsg(0, "  %d %s", max - i, cur);
     }
     i++;
     if (next == NULL) {
       break;
     }
     *next = '.';
     cur = next + 2;
   }
   xfree(sname);
 }

 if (SOURCING_LNUM != 0) {
   smsg(0, _("line %" PRId64 ": %s"), (int64_t)SOURCING_LNUM, cmd);
 } else {
   smsg(0, _("cmd: %s"), cmd);
 }
}

/// ":debug".
void ex_debug(exarg_T *eap)
{
 int debug_break_level_save = debug_break_level;

 debug_break_level = 9999;
 do_cmdline_cmd(eap->arg);
 debug_break_level = debug_break_level_save;
}

static char *debug_breakpoint_name = NULL;
static linenr_T debug_breakpoint_lnum;

/// When debugging or a breakpoint is set on a skipped command, no debug prompt
/// is shown by do_one_cmd().  This situation is indicated by debug_skipped, and
/// debug_skipped_name is then set to the source name in the breakpoint case. If
/// a skipped command decides itself that a debug prompt should be displayed, it
/// can do so by calling dbg_check_skipped().
static bool debug_skipped;
static char *debug_skipped_name;

/// Go to debug mode when a breakpoint was encountered or "ex_nesting_level" is
/// at or below the break level.  But only when the line is actually
/// executed.  Return true and set breakpoint_name for skipped commands that
/// decide to execute something themselves.
/// Called from do_one_cmd() before executing a command.
void dbg_check_breakpoint(exarg_T *eap)
{
 debug_skipped = false;
 if (debug_breakpoint_name != NULL) {
   if (!eap->skip) {
     char *p;
     // replace K_SNR with "<SNR>"
     if ((uint8_t)debug_breakpoint_name[0] == K_SPECIAL
         && (uint8_t)debug_breakpoint_name[1] == KS_EXTRA
         && debug_breakpoint_name[2] == KE_SNR) {
       p = "<SNR>";
     } else {
       p = "";
     }
     smsg(0, _("Breakpoint in \"%s%s\" line %" PRId64),
          p,
          debug_breakpoint_name + (*p == NUL ? 0 : 3),
          (int64_t)debug_breakpoint_lnum);
     debug_breakpoint_name = NULL;
     do_debug(eap->cmd);
   } else {
     debug_skipped = true;
     debug_skipped_name = debug_breakpoint_name;
     debug_breakpoint_name = NULL;
   }
 } else if (ex_nesting_level <= debug_break_level) {
   if (!eap->skip) {
     do_debug(eap->cmd);
   } else {
     debug_skipped = true;
     debug_skipped_name = NULL;
   }
 }
}

/// Go to debug mode if skipped by dbg_check_breakpoint() because eap->skip was
/// set.
///
/// @return true when the debug mode is entered this time.
bool dbg_check_skipped(exarg_T *eap)
{
 if (!debug_skipped) {
   return false;
 }

 // Save the value of got_int and reset it.  We don't want a previous
 // interruption cause flushing the input buffer.
 bool prev_got_int = got_int;
 got_int = false;
 debug_breakpoint_name = debug_skipped_name;
 // eap->skip is true
 eap->skip = false;
 dbg_check_breakpoint(eap);
 eap->skip = true;
 got_int |= prev_got_int;
 return true;
}

static garray_T dbg_breakp = { 0, 0, sizeof(struct debuggy), 4, NULL };
#define BREAKP(idx)             (((struct debuggy *)dbg_breakp.ga_data)[idx])
#define DEBUGGY(gap, idx)       (((struct debuggy *)(gap)->ga_data)[idx])
static int last_breakp = 0;     // nr of last defined breakpoint
static bool has_expr_breakpoint = false;

// Profiling uses file and func names similar to breakpoints.
static garray_T prof_ga = { 0, 0, sizeof(struct debuggy), 4, NULL };
#define DBG_FUNC        1
#define DBG_FILE        2
#define DBG_EXPR        3

/// Evaluate the "bp->dbg_name" expression and return the result.
/// Disables error messages.
static typval_T *eval_expr_no_emsg(struct debuggy *const bp)
 FUNC_ATTR_NONNULL_ALL
{
 // Disable error messages, a bad expression would make Vim unusable.
 emsg_off++;
 typval_T *const tv = eval_expr(bp->dbg_name, NULL);
 emsg_off--;
 return tv;
}

/// Parse the arguments of ":profile", ":breakadd" or ":breakdel" and put them
/// in the entry just after the last one in dbg_breakp.  Note that "dbg_name"
/// is allocated.
/// Returns FAIL for failure.
///
/// @param arg
/// @param gap  either &dbg_breakp or &prof_ga
static int dbg_parsearg(char *arg, garray_T *gap)
{
 char *p = arg;
 bool here = false;

 ga_grow(gap, 1);

 struct debuggy *bp = &DEBUGGY(gap, gap->ga_len);

 // Find "func" or "file".
 if (strncmp(p, "func", 4) == 0) {
   bp->dbg_type = DBG_FUNC;
 } else if (strncmp(p, "file", 4) == 0) {
   bp->dbg_type = DBG_FILE;
 } else if (gap != &prof_ga && strncmp(p, "here", 4) == 0) {
   if (curbuf->b_ffname == NULL) {
     emsg(_(e_noname));
     return FAIL;
   }
   bp->dbg_type = DBG_FILE;
   here = true;
 } else if (gap != &prof_ga && strncmp(p, "expr", 4) == 0) {
   bp->dbg_type = DBG_EXPR;
 } else {
   semsg(_(e_invarg2), p);
   return FAIL;
 }
 p = skipwhite(p + 4);

 // Find optional line number.
 if (here) {
   bp->dbg_lnum = curwin->w_cursor.lnum;
 } else if (gap != &prof_ga && ascii_isdigit(*p)) {
   bp->dbg_lnum = getdigits_int32(&p, true, 0);
   p = skipwhite(p);
 } else {
   bp->dbg_lnum = 0;
 }

 // Find the function or file name.  Don't accept a function name with ().
 if ((!here && *p == NUL)
     || (here && *p != NUL)
     || (bp->dbg_type == DBG_FUNC && strstr(p, "()") != NULL)) {
   semsg(_(e_invarg2), arg);
   return FAIL;
 }

 if (bp->dbg_type == DBG_FUNC) {
   bp->dbg_name = xstrdup(strncmp(p, "g:", 2) == 0 ? p + 2 : p);
 } else if (here) {
   bp->dbg_name = xstrdup(curbuf->b_ffname);
 } else if (bp->dbg_type == DBG_EXPR) {
   bp->dbg_name = xstrdup(p);
   bp->dbg_val = eval_expr_no_emsg(bp);
 } else {
   // Expand the file name in the same way as do_source().  This means
   // doing it twice, so that $DIR/file gets expanded when $DIR is
   // "~/dir".
   char *q = expand_env_save(p);
   if (q == NULL) {
     return FAIL;
   }
   p = expand_env_save(q);
   xfree(q);
   if (p == NULL) {
     return FAIL;
   }
   if (*p != '*') {
     bp->dbg_name = fix_fname(p);
     xfree(p);
   } else {
     bp->dbg_name = p;
   }
 }

 if (bp->dbg_name == NULL) {
   return FAIL;
 }
 return OK;
}

/// ":breakadd".  Also used for ":profile".
void ex_breakadd(exarg_T *eap)
{
 garray_T *gap = &dbg_breakp;
 if (eap->cmdidx == CMD_profile) {
   gap = &prof_ga;
 }

 if (dbg_parsearg(eap->arg, gap) != OK) {
   return;
 }

 struct debuggy *bp = &DEBUGGY(gap, gap->ga_len);
 bp->dbg_forceit = eap->forceit;

 if (bp->dbg_type != DBG_EXPR) {
   char *pat = file_pat_to_reg_pat(bp->dbg_name, NULL, NULL, false);
   if (pat != NULL) {
     bp->dbg_prog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
     xfree(pat);
   }
   if (pat == NULL || bp->dbg_prog == NULL) {
     xfree(bp->dbg_name);
   } else {
     if (bp->dbg_lnum == 0) {           // default line number is 1
       bp->dbg_lnum = 1;
     }
     if (eap->cmdidx != CMD_profile) {
       DEBUGGY(gap, gap->ga_len).dbg_nr = ++last_breakp;
       debug_tick++;
     }
     gap->ga_len++;
   }
 } else {
   // DBG_EXPR
   DEBUGGY(gap, gap->ga_len++).dbg_nr = ++last_breakp;
   debug_tick++;
   if (gap == &dbg_breakp) {
     has_expr_breakpoint = true;
   }
 }
}

/// ":debuggreedy".
void ex_debuggreedy(exarg_T *eap)
{
 if (eap->addr_count == 0 || eap->line2 != 0) {
   debug_greedy = true;
 } else {
   debug_greedy = false;
 }
}

static void update_has_expr_breakpoint(void)
{
 has_expr_breakpoint = false;
 for (int i = 0; i < dbg_breakp.ga_len; i++) {
   if (BREAKP(i).dbg_type == DBG_EXPR) {
     has_expr_breakpoint = true;
     break;
   }
 }
}

/// ":breakdel" and ":profdel".
void ex_breakdel(exarg_T *eap)
{
 int todel = -1;
 bool del_all = false;
 linenr_T best_lnum = 0;
 garray_T *gap = &dbg_breakp;

 if (eap->cmdidx == CMD_profdel) {
   gap = &prof_ga;
 }

 if (ascii_isdigit(*eap->arg)) {
   // ":breakdel {nr}"
   int nr = atoi(eap->arg);
   for (int i = 0; i < gap->ga_len; i++) {
     if (DEBUGGY(gap, i).dbg_nr == nr) {
       todel = i;
       break;
     }
   }
 } else if (*eap->arg == '*') {
   todel = 0;
   del_all = true;
 } else {
   // ":breakdel {func|file|expr} [lnum] {name}"
   if (dbg_parsearg(eap->arg, gap) == FAIL) {
     return;
   }
   struct debuggy *bp = &DEBUGGY(gap, gap->ga_len);
   for (int i = 0; i < gap->ga_len; i++) {
     struct debuggy *bpi = &DEBUGGY(gap, i);
     if (bp->dbg_type == bpi->dbg_type
         && strcmp(bp->dbg_name, bpi->dbg_name) == 0
         && (bp->dbg_lnum == bpi->dbg_lnum
             || (bp->dbg_lnum == 0
                 && (best_lnum == 0
                     || bpi->dbg_lnum < best_lnum)))) {
       todel = i;
       best_lnum = bpi->dbg_lnum;
     }
   }
   xfree(bp->dbg_name);
 }

 if (todel < 0) {
   semsg(_("E161: Breakpoint not found: %s"), eap->arg);
   return;
 }

 while (!GA_EMPTY(gap)) {
   xfree(DEBUGGY(gap, todel).dbg_name);
   if (DEBUGGY(gap, todel).dbg_type == DBG_EXPR
       && DEBUGGY(gap, todel).dbg_val != NULL) {
     tv_free(DEBUGGY(gap, todel).dbg_val);
   }
   vim_regfree(DEBUGGY(gap, todel).dbg_prog);
   gap->ga_len--;
   if (todel < gap->ga_len) {
     memmove(&DEBUGGY(gap, todel), &DEBUGGY(gap, todel + 1),
             (size_t)(gap->ga_len - todel) * sizeof(struct debuggy));
   }
   if (eap->cmdidx == CMD_breakdel) {
     debug_tick++;
   }
   if (!del_all) {
     break;
   }
 }

 // If all breakpoints were removed clear the array.
 if (GA_EMPTY(gap)) {
   ga_clear(gap);
 }
 if (gap == &dbg_breakp) {
   update_has_expr_breakpoint();
 }
}

/// ":breaklist".
void ex_breaklist(exarg_T *eap)
{
 if (GA_EMPTY(&dbg_breakp)) {
   msg(_("No breakpoints defined"), 0);
   return;
 }

 for (int i = 0; i < dbg_breakp.ga_len; i++) {
   struct debuggy *bp = &BREAKP(i);
   if (bp->dbg_type == DBG_FILE) {
     home_replace(NULL, bp->dbg_name, NameBuff, MAXPATHL, true);
   }
   if (bp->dbg_type != DBG_EXPR) {
     smsg(0, _("%3d  %s %s  line %" PRId64),
          bp->dbg_nr,
          bp->dbg_type == DBG_FUNC ? "func" : "file",
          bp->dbg_type == DBG_FUNC ? bp->dbg_name : NameBuff,
          (int64_t)bp->dbg_lnum);
   } else {
     smsg(0, _("%3d  expr %s"), bp->dbg_nr, bp->dbg_name);
   }
 }
}

/// Find a breakpoint for a function or sourced file.
/// Returns line number at which to break; zero when no matching breakpoint.
///
/// @param file  true for a file, false for a function
/// @param fname  file or function name
/// @param after  after this line number
linenr_T dbg_find_breakpoint(bool file, char *fname, linenr_T after)
{
 return debuggy_find(file, fname, after, &dbg_breakp, NULL);
}

/// @param file     true for a file, false for a function
/// @param fname    file or function name
/// @param fp[out]  forceit
///
/// @returns true if profiling is on for a function or sourced file.
bool has_profiling(bool file, char *fname, bool *fp)
{
 return debuggy_find(file, fname, 0, &prof_ga, fp)
        != 0;
}

/// Common code for dbg_find_breakpoint() and has_profiling().
///
/// @param file  true for a file, false for a function
/// @param fname  file or function name
/// @param after  after this line number
/// @param gap  either &dbg_breakp or &prof_ga
/// @param fp  if not NULL: return forceit
static linenr_T debuggy_find(bool file, char *fname, linenr_T after, garray_T *gap, bool *fp)
{
 struct debuggy *bp;
 linenr_T lnum = 0;
 char *name = fname;

 // Return quickly when there are no breakpoints.
 if (GA_EMPTY(gap)) {
   return 0;
 }

 // Replace K_SNR in function name with "<SNR>".
 if (!file && (uint8_t)fname[0] == K_SPECIAL) {
   name = xmalloc(strlen(fname) + 3);
   STRCPY(name, "<SNR>");
   STRCPY(name + 5, fname + 3);
 }

 for (int i = 0; i < gap->ga_len; i++) {
   // Skip entries that are not useful or are for a line that is beyond
   // an already found breakpoint.
   bp = &DEBUGGY(gap, i);
   if ((bp->dbg_type == DBG_FILE) == file
       && bp->dbg_type != DBG_EXPR
       && (gap == &prof_ga
           || (bp->dbg_lnum > after && (lnum == 0 || bp->dbg_lnum < lnum)))) {
     // Save the value of got_int and reset it.  We don't want a
     // previous interruption cancel matching, only hitting CTRL-C
     // while matching should abort it.
     bool prev_got_int = got_int;
     got_int = false;
     if (vim_regexec_prog(&bp->dbg_prog, false, name, 0)) {
       lnum = bp->dbg_lnum;
       if (fp != NULL) {
         *fp = bp->dbg_forceit;
       }
     }
     got_int |= prev_got_int;
   } else if (bp->dbg_type == DBG_EXPR) {
     bool line = false;

     typval_T *const tv = eval_expr_no_emsg(bp);
     if (tv != NULL) {
       if (bp->dbg_val == NULL) {
         xfree(debug_oldval);
         debug_oldval = typval_tostring(NULL, true);
         bp->dbg_val = tv;
         xfree(debug_newval);
         debug_newval = typval_tostring(bp->dbg_val, true);
         line = true;
       } else {
         if (typval_compare(tv, bp->dbg_val, EXPR_IS, false) == OK
             && tv->vval.v_number == false) {
           line = true;
           xfree(debug_oldval);
           debug_oldval = typval_tostring(bp->dbg_val, true);
           // Need to evaluate again, typval_compare() overwrites "tv".
           typval_T *const v = eval_expr_no_emsg(bp);
           xfree(debug_newval);
           debug_newval = typval_tostring(v, true);
           tv_free(bp->dbg_val);
           bp->dbg_val = v;
         }
         tv_free(tv);
       }
     } else if (bp->dbg_val != NULL) {
       xfree(debug_oldval);
       debug_oldval = typval_tostring(bp->dbg_val, true);
       xfree(debug_newval);
       debug_newval = typval_tostring(NULL, true);
       tv_free(bp->dbg_val);
       bp->dbg_val = NULL;
       line = true;
     }

     if (line) {
       lnum = after > 0 ? after : 1;
       break;
     }
   }
 }
 if (name != fname) {
   xfree(name);
 }

 return lnum;
}

/// Called when a breakpoint was encountered.
void dbg_breakpoint(char *name, linenr_T lnum)
{
 // We need to check if this line is actually executed in do_one_cmd()
 debug_breakpoint_name = name;
 debug_breakpoint_lnum = lnum;
}