在前一篇中我们支持了通过函数名称来添加断点，我们同时也提到了在Lua中一个函数的名称的并不是确定的。准确的说，Lua中的函数并没有名称，所谓名称其实是保存这个函数值的变量的名称。
于是通过函数名称添加断点就造成了一定的不确定性，因为函数被调用时并不一定是以这个名字被调用的。另外，多个不同的函数也可能以相同的名字进行调用。
所以为了解决这个问题，本篇我们将继续扩展断点的设置接口，支持通过包名来添加断点。因为包名相对更具确定性，配合行号可以进行精确定位。
源码已经上传Github，欢迎watch/star😘。
本博客已迁移至CatBro's Blog，那是我自己搭建的个人博客，欢迎关注。本文链接
实现分析
为何选用包名的方式
其实一开始的想法并不是通过包名来添加断点，而是通过源文件名。但是源文件名同样存在重复的可能，我们只能考虑使用类似后缀匹配这种模糊的方式进行查找。这样的话，每个call事件中都需要对通过源文件名设置的断点表进行遍历。
使用绝对路径虽然可以解决重复的问题，但是使用上不方便，在添加断点的时候也不一定知道源文件的具体位置，况且short_src也不一定是绝对路径。
所以出于性能及易用性的考虑，采用了通过包名来设置断点的方式，这样就可以利用Lua本身的包名搜索机制，使用搜索包路径的方法package.searchpackage()将包名转成路径。而这个路径就是debug.getinfo获取到的调试信息中的short_src。
下面是一个例子：
package.searchpath( "foo.bar.baz", package.path )
--> (e.g.) "/usr/share/lua/5.3/foo/bar/baz.lua"
断点的保存解析和查找
跟上一篇中通过函数名称添加的断点不同的是，通过包名添加的断点都是确定的，所以最终都可以将其转换为函数的断点。但是只有当执行过该函数之后，我们才能获取到该函数的相关信息，进行断点的转换，所以在此之前我们需要将它们临时存放在一个表中，跟之前的status.funcbpt、status.namebpt类似，我们把这个表定义为status.srcbpt。
当执行到该函数之后，我们就可以将status.srcbpt中对应的断点转移到status.funcbpt表中，后续就可以通过普通函数断点的方式进行处理了。
为了提升性能，我们可以将之前执行过的函数的信息保存下来，后续再（通过包名方式）在相同的函数中添加断点时，就可以快速地确定其所在函数，直接在添加断点的时候就转换为普通函数断点了，而不需要推迟到后面进行查找比对转换了。之前我们已经有了一个保存函数信息的表status.funcinfos，但是那个表是以函数作为键，而这里我们需要通过源文件路径进行查找，所以需要新的数据结构。
解决断点歧义
通过包名添加断点存在着一种歧义的情况：当断点落在函数定义的范围之内时，它是表示对mainchunk中的函数声明添加断点，还是表示在该子函数执行时添加断点。（本质上是因为mainchunk的有效行和子函数有效行存在重叠）
所以为了优雅地解决这个歧义问题，我们使用行号的正负表示是在mainchunk中还是在子函数中添加断点。如果行号是正数，表示子函数，跟前几篇中的情况保持一致；如果行号是负数，则表示在mainchunk中添加断点。
好了，解决了最关键的几个问题，我们就可以开始着手写代码了
添加断点
同样依照惯例，我们先修改设置断点函数。它的改动较大，因为函数名称和包名称都是通过字符串参数指定，所以需要一个区分手段，我们这里采用了一个跟在名称后面的特殊字符来进行区分。如果后面跟的是@，表示是函数名称，如果后面跟的是:，表示是包名。
先来看通过包名添加断点的情况，首先查找标记符号:，如果找到则前面部分表示包名，后面部分表示行号。切分之后，检查包名是否为空，再检查行号是否合法。如果没有指定行号，那么默认设置为-1，也就是mainchunk的第一行。接下来调用package.searchpath()将包名转化为路径，如果找到了指定的包，再通过setsrcbp()函数来设置断点。setsrcbp()我们稍后介绍。
local function setbreakpoint(where, line)
-- 省略
if type(where) == "function" then
return setfuncbp(where, line)
else -- "string"
local i = string.find(where, ":")
if i then -- package name
local packname = string.sub(where, 1, i-1)
local line = string.sub(where, i+1)
if packname == "" then
io.write("no package name specified!\n")
return nil
end
if line ~= "" then
line = tonumber(line)
if not line then
io.write("no valid line number specified!\n")
return nil
end
else
line = -1
end
local path, err = package.searchpath(packname, package.path)
if not path then
io.write(err)
return nil
end
return setsrcbp(path, line)
else
end
通过函数名称添加断点的情况也是类似，不过省了路径转换的步骤。首先查找标记符号@，然后切分函数名和行号，检查函数名是否为空，检查行号是否合法，都ok之后再交给setnamebp()进行后面的工作。setnamebp()函数我们在上一篇已经介绍过了。
local function setbreakpoint(where, line)
-- 省略
else
local i = string.find(where, "@")
if i then -- function name
local funcname = string.sub(where, 1, i-1)
local line = string.sub(where, i+1)
if funcname == "" then
io.write("no function name specified!\n")
return nil
end
if line ~= "" then
line = tonumber(line)
if not line then
io.write("no valid line number specified!\n")
return nil
end
else
line = nil
end
return setnamebp(funcname, line)
end
end
end
end
下面我们来看setsrcbp()函数的实现，这个函数跟setnamebp()大体上类似，开头部分稍有不同。首先会通过lookforfunc()查看断点是否位于已知函数中，如果是的话返回该函数，然后直接调用setfuncbp()函数作为函数断点处理。lookforfunc()我们稍晚一点再介绍。后面的流程跟setnamebp()并无二致就不再赘述。
local function setsrcbp(src, line)
local s = status
-- 检查断点是否位于已知函数中
local func = lookforfunc(src, line)
if func then
return setfuncbp(func, line)
end
local srcbp = s.srcbpt[src]
-- 检查相同的断点是否已经设置
if srcbp and srcbp[line] then
return srcbp[line]
end
-- 省略
end
钩子函数
钩子函数的改动都是在call事件中。首先，在获取到当前函数及其信息之后，调用solvesrcbp()处理status.srcbpt表中还未转换的断点，如果发现有位于当前函数中的断点，那么就进行相应的断点转换。接下来，如果当前函数不是C函数，就调用setsrcfunc()函数保存函数信息。
local function hook (event, line)
local s = status
if event == "call" or event == "tail call" then
local stackinfo = debug.getinfo(2, "nf")
local func = stackinfo.func
local name = stackinfo.name
local funcinfo = getfuncinfo(func)
local hasbreak = false
-- 处理通过包名添加的还未转换的断点
solvesrcbp(funcinfo, func)
if funcinfo.what ~= "C" then
setsrcfunc(funcinfo, func)
end
if s.funcbpt[func] then
local id = s.funcbpt[func]
if s.bptable[id] and not s.bptable[id].src then
s.bptable[id].src = funcinfo.short_src
end
hasbreak = true
end
-- 省略
end
断点转换
接下来看下solvesrcbp()函数的实现，如果当前源文件中存在未转换的断点，那么遍历这些断点，调用verifyfuncline()判断断点是否在当前函数中，如果是的话就调用modsrcbp()函数进行实际的转换操作。
local function solvesrcbp (info, func)
local s = status
local srcbp = s.srcbpt[info.short_src]
if srcbp then
for k, v in pairs(srcbp) do
if k ~= "num" then
line = verifyfuncline(info, k)
if line then
modsrcbp(info.short_src, func, k, line)
end
end
end
end
end
modsrcbp()函数的实现如下，它有4个参数第一个src是源文件路径、第二个func是函数、第三个oline是设置断点时的行号、第四个nline是verifyfuncline()进行修正后的行号。
该函数首先以src和oline为索引将断点从status.srcbpt表中移除，然后设置到status.funcbpt表中。如果同一个断点已经设置过了，那么将新添加的断点删除，然后返回旧的断点id。
local function modsrcbp(src, func, oline, nline)
local s = status
local srcbp = s.srcbpt[src]
local id = srcbp[oline]
-- 从srcbpt中移除
srcbp.num = srcbp.num - 1
srcbp[oline] = nil
if srcbp.num == 0 then
srcbp = nil
end
-- 设置funcbpt
local funcbp = s.funcbpt[func]
-- 检查是否已经设置了相同的断点
if funcbp and funcbp[nline] then
s.bptable[id] = nil -- 如果已经设置了，删除新加的断点
s.bpnum = s.bpnum - 1
assert(s.bpnum > 0)
return funcbp[nline] -- 返回旧的断点id
end
-- 省略
end
如果还未添加过这个断点，那么就在status.funcbpt中添加该断点，然后将断点所在的函数和修正后的行号更新到s.bptable表中。
local function modsrcbp(src, func, oline, nline)
-- 省略
if not funcbp then -- 该函数的第一个断点
s.funcbpt[func] = {}
funcbp = s.funcbpt[func]
funcbp.num = 0
end
funcbp.num = funcbp.num + 1
funcbp[nline] = id
-- 更新bptable中字段
s.bptable[id].func = func
s.bptable[id].line = nline
return id
end
行号扩展
因为我们对行号进行了扩展了，使用负数来表示mainchunk中的断点，所以verifyfuncline()也需要进行相应的扩展。对于行号是负数的情况，如果不是mainchunk函数，直接返回nil，否则对行号取反还原为正常的行号。
local function verifyfuncline (info, line)
if not line then
return info.sortedlines[1]
end
if line < 0 then
if info.what ~= "main" then
return nil
end
line = -line
end
if line < info.linedefined or line > info.lastlinedefined then
return nil
end
for _, v in ipairs(info.sortedlines) do
if v >= line then
return v
end
end
assert(false) -- impossible to reach here
end
这里还有一个问题，通过debug.getinfo()函数获取到的函数信息中，对于mainchunk的情况，linedefined和lastlinedefined字段的值都是0，于是我们的getfuncinfo()函数也要进行相应的调整：
local function getfuncinfo (func)
local s = status
local info = s.funcinfos[func]
if not info then
info = debug.getinfo(func, "SL")
if (info.activelines) then
info.sortedlines = {}
for k, _ in pairs(info.activelines) do
table.insert(info.sortedlines, k)
end
table.sort(info.sortedlines)
-- mainchunk需要特殊处理以使`verifyfuncline`能够正常工作
if info.what == "main" then
info.linedefined = 1
info.lastlinedefined = info.sortedlines[#info.sortedlines]
end
end
s.funcinfos[func] = info
end
return info
end
对于mainchunk函数进行特殊处理，将linedefined设置为1，将lastlinedefined设置为最后一个有效行的行号。
缓存及查找源文件的函数
我们在钩子函数中调用setsrcfunc()保存函数信息，将函数与源文件关联。在setsrcbp()中调用lookforfunc()通过源文件和行号查找对应的函数。先来看setsrcfunc()函数实现：
local function setsrcfunc (info, func)
local s = status
local srcfunc = s.srcfuncmap[info.short_src]
if not srcfunc then
srcfunc = {}
s.srcfuncmap[info.short_src] = srcfunc
end
if not srcfunc[func] then
srcfunc[func] = info
end
end
其中status.srcfuncmap就是我们新增的数据结构，它是一个以源文件路径为键的表，其值也是一个表，保存位于该源文件中的函数信息，以函数为键，以函数信息为值。
再来看lookforfunc()函数的实现：
local function lookforfunc (src, line)
assert(line)
local srcfunc = status.srcfuncmap[src]
if srcfunc then
for func, info in pairs(srcfunc) do
if info.what == "main" then
if line < 0 then
return func
end
elseif line >= info.linedefined
and line <= info.lastlinedefined then
return func
end
end
end
return nil
end
lookforfunc()函数中首先判断该源文件是否有缓存的函数信息，如果有则进行遍历。如果行号是负数，则只要找到mainchunk就可以返回了。否则，需要判断断点的行号是否在函数定义的范围内。找到了，就返回断点所在函数；没有找到返回nil。
测试
首先，编写一个用于测试的包testlib.lua，实现了两个简单的函数foo和bar。
local function foo ()
local a = 1
end
local function bar()
local a = 1
end
local a = 1
return {
foo = foo,
bar = bar,
}
测试通过函数名和包名添加断点
我们通过函数名添加了两个断点，其中一个省略行号，默认为函数第一个有效行。又通过包名添加了两个有效断点id3和id4，id5虽然能添加成功，但是并不落在有效函数范围内。id6和id7都是参数错误的情况，添加断点失败。
设置完断点，先分别调用foo和bar函数一次，预期都在foo函数第2行第3行会碰到断点，然后在bar函数的第6行第7行碰到断点。接着分别删除foo和bar函数中的1个断点，再分别调用foo和bar函数一次，预期在foo函数的第3行和bar函数的第7行碰到断点。最后删除foo和bar函数中的另一个断点，再分别调用foo和bar函数一次，预期不再碰到断点。
local ldb = require "luadebug"
local lib = require "testlib"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint
local id1 = setbp("foo@") -- foo 2
local id2 = setbp("foo@3") -- foo 3
local id3 = setbp("testlib:5") -- bar 6
local id4 = setbp("testlib:7") -- bar 7
local id5 = setbp("testlib:100") -- invalid line
local id6 = setbp(":5")
assert(not id6)
local id7 = setbp("testlib:aa")
assert(not id7)
lib.foo(1) -- break twice
lib.bar(1) -- break twice
rmbp(id1)
rmbp(id3)
lib.foo(2) -- break once
lib.bar(2) -- break once
rmbp(id2)
rmbp(id4)
lib.foo(3) -- not break
lib.bar(3) -- not break
运行测试脚本，分别在foo函数和bar函数中碰到两个断点。
$ lua setbpbysrc.lua
no package name specified!
no valid line number specified!
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:6
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:7
lua_debug>
继续执行，分别在foo函数和bar函数中碰到一个断点。
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:7
lua_debug>
继续执行，没有再碰到断点。
lua_debug> cont
$
测试行号扩展
编写如下测试脚本，在mainchunk中添加了4个断点，其中不指定行号时默认是mainchunk的第一个有效行。当require该包时，预期在mainchunk的第3行、第7行、第9行和第13行分别碰到断点。
接着在子函数foo中添加两个断点，调用foo函数，预期在foo函数第2行和第3行碰到断点。然后其中一个断点，再调用foo函数，预期在foo函数第3行碰到断点。最后删除剩余一个断点，再调用foo函数，预期不再碰到断点。
local ldb = require "luadebug"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint
local id1 = setbp("testlib:") -- main 3
local id2 = setbp("testlib:-5") -- main 7
local id3 = setbp("testlib:-9") -- main 9
local id4 = setbp("testlib:-13") -- main 13
local lib = require "testlib" -- break 4 times
local id5 = setbp("testlib:2") -- foo 2
local id6 = setbp("testlib:3") -- foo 3
lib.foo() -- break 2 times
rmbp(id5)
lib.foo() -- break 1 time
rmbp(id6)
lib.foo() -- not break
运行测试脚本，首先碰到了mainchunk中的4个断点
lua mainchunk.lua
main ()nil /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:7
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:9
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:13
lua_debug>
继续执行，碰到foo函数中两个断点
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug>
再继续执行，碰到foo函数中一个断点
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug>
再cont就结束了。
lua_debug> cont
$
测试断点重复及缓存源文件的函数
编写如下测试脚本，首先我们通过函数添加一个断点，然后再通过包名添加一个断点。虽然这两个实际是同一个断点，但是刚开始的时候因为还没有缓存信息，所以第二个断点也会添加成功。接着调用 foo函数，预期在foo函数第2行碰到断点。在钩子函数call事件中会处理未转换的断点2，因为已经存在同样的断点了，所以会将断点2删除。
接下来我们删除断点1之后，就没有断点了，再次调用foo函数，预期不会碰到断点。
然后我们再通过包名添加一个断点，这里因为已经有了对应的函数信息，所以预期会直接转换成对应的函数断点。当我们再对函数添加同样的断点的时候预期返回之前的断点号。
调用foo函数，预期在foo函数第3行碰到断点。删除断点3，预期不再碰到断点。
local ldb = require "luadebug"
local lib = require "testlib"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint
local id1 = setbp(lib.foo)
local id2 = setbp("testlib:1") -- foo 2
lib.foo() -- break once
rmbp(id1)
lib.foo() -- not break
print("not break")
local id3 = setbp("testlib:3") -- foo 3
assert(id3 == 3)
local id4 = setbp(lib.foo, 3)
assert(id3 == id4)
lib.foo() -- break once
rmbp(id3)
lib.foo() -- not break
运行测试脚本，结果符合预期。
$ lua srcfuncmap.lua
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
not break
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont