lua: Prepare for standalone build

src/lua/bcc-probe

@@ -14,30 +14,8 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ]]
-function setup_path()
-  local str = require("debug").getinfo(2, "S").source:sub(2)
-  local script_path = str:match("(.*/)").."/?.lua;"
-  package.path = script_path..package.path
-end
-
-setup_path()
-local BCC = require("bcc.init")
-local BPF = BCC.BPF
-
-BPF.script_root(arg[1])
-
-local utils = {
-  argparse = require("bcc.vendor.argparse"),
-  posix = require("bcc.vendor.posix"),
-  sym = BCC.sym
-}
-
-local tracefile = table.remove(arg, 1)
-local command = dofile(tracefile)
-local res, err = pcall(command, BPF, utils)
-
-if not res then
-  io.stderr:write("[ERROR] "..err.."\n")
-end
-
-BPF.cleanup_probes()
+local str = require("debug").getinfo(1, "S").source:sub(2)
+local script_path = str:match("(.*/)").."/?.lua;"
+package.path = script_path..package.path
+rawset(_G, "BCC_STANDALONE", false)
+require("bcc.run")()

src/lua/bcc/init.lua

@@ -13,10 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ]]
-require("bcc.vendor.strict")
 require("bcc.vendor.helpers")
-class = require("bcc.vendor.middleclass")
-
 return {
   BPF = require("bcc.bpf"),
   sym = require("bcc.sym"),

src/lua/bcc/libbcc.lua

@@ -98,5 +98,4 @@ int perf_reader_fd(struct perf_reader *reader);
 void perf_reader_set_fd(struct perf_reader *reader, int fd);
 ]]
 
-local libbcc = ffi.load("bcc")
-return libbcc
+return rawget(_G, "BCC_STANDALONE") and ffi.C or ffi.load("bcc")

src/lua/bcc/run.lua

+--[[
+Copyright 2016 GitHub, Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+]]
+
+return function()
+  local BCC = require("bcc.init")
+  local BPF = BCC.BPF
+
+  BPF.script_root(arg[1])
+
+  local utils = {
+    argparse = require("bcc.vendor.argparse"),
+    posix = require("bcc.vendor.posix"),
+    sym = BCC.sym
+  }
+
+  local tracefile = table.remove(arg, 1)
+  local command = dofile(tracefile)
+  local res, err = pcall(command, BPF, utils)
+
+  if not res then
+    io.stderr:write("[ERROR] "..err.."\n")
+  end
+
+  BPF.cleanup_probes()
+  return res, err
+end

src/lua/bcc/vendor/helpers.lua

@@ -156,4 +156,14 @@ local function logline(...)
       os.date("%H:%M:%S"), c_clear, line, msg))
 end
 
-log = { info = logline, enabled = true }
+setmetatable(_G, {
+  __newindex = function (_, n)
+    error("attempt to write to undeclared variable "..n, 2)
+  end,
+  __index = function (_, n)
+    error("attempt to read undeclared variable "..n, 2)
+  end,
+})
+
+rawset(_G, "log", { info = logline, enabled = true })
+rawset(_G, "class", require("bcc.vendor.middleclass"))

src/lua/bcc/vendor/strict.lua

---[[
-  Copyright (C) 2009 Steve Donovan, David Manura.
-  This code is licensed under the MIT License
-  https://github.com/stevedonovan/Penlight
---]]
-
---- Checks uses of undeclared global variables.
--- All global variables must be 'declared' through a regular assignment
--- (even assigning `nil` will do) in a main chunk before being used
--- anywhere or assigned to inside a function.  Existing metatables `__newindex` and `__index`
--- metamethods are respected.
---
--- You can set any table to have strict behaviour using `strict.module`. Creating a new
--- module with `strict.closed_module` makes the module immune to monkey-patching, if
--- you don't wish to encourage monkey business.
---
--- If the global `PENLIGHT_NO_GLOBAL_STRICT` is defined, then this module won't make the
--- global environment strict - if you just want to explicitly set table strictness.
---
--- @module pl.strict
-
-require 'debug' -- for Lua 5.2
-local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
-local strict = {}
-
-local function what ()
-    local d = getinfo(3, "S")
-    return d and d.what or "C"
-end
-
---- make an existing table strict.
--- @string name name of table (optional)
--- @tab[opt] mod table - if `nil` then we'll return a new table
--- @tab[opt] predeclared - table of variables that are to be considered predeclared.
--- @return the given table, or a new table
-function strict.module (name,mod,predeclared)
-    local mt, old_newindex, old_index, old_index_type, global, closed
-    if predeclared then
-        global = predeclared.__global
-        closed = predeclared.__closed
-    end
-    if type(mod) == 'table' then
-        mt = getmetatable(mod)
-        if mt and rawget(mt,'__declared') then return end -- already patched...
-    else
-        mod = {}
-    end
-    if mt == nil then
-        mt = {}
-        setmetatable(mod, mt)
-    else
-        old_newindex = mt.__newindex
-        old_index = mt.__index
-        old_index_type = type(old_index)
-    end
-    mt.__declared = predeclared or {}
-    mt.__newindex = function(t, n, v)
-        if old_newindex then
-            old_newindex(t, n, v)
-            if rawget(t,n)~=nil then return end
-        end
-        if not mt.__declared[n] then
-            if global then
-                local w = what()
-                if w ~= "main" and w ~= "C" then
-                    error("assign to undeclared global '"..n.."'", 2)
-                end
-            end
-            mt.__declared[n] = true
-        end
-        rawset(t, n, v)
-    end
-    mt.__index = function(t,n)
-        if not mt.__declared[n] and what() ~= "C" then
-            if old_index then
-                if old_index_type == "table" then
-                    local fallback = old_index[n]
-                    if fallback ~= nil then
-                        return fallback
-                    end
-                else
-                    local res = old_index(t, n)
-                    if res then return res end
-                end
-            end
-            local msg = "variable '"..n.."' is not declared"
-            if name then
-                msg = msg .. " in '"..name.."'"
-            end
-            error(msg, 2)
-        end
-        return rawget(t, n)
-    end
-    return mod
-end
-
---- make all tables in a table strict.
--- So `strict.make_all_strict(_G)` prevents monkey-patching
--- of any global table
--- @tab T
-function strict.make_all_strict (T)
-    for k,v in pairs(T) do
-        if type(v) == 'table' and v ~= T then
-            strict.module(k,v)
-        end
-    end
-end
-
---- make a new module table which is closed to further changes.
-function strict.closed_module (mod,name)
-    local M = {}
-    mod = mod or {}
-    local mt = getmetatable(mod)
-    if not mt then
-        mt = {}
-        setmetatable(mod,mt)
-    end
-    mt.__newindex = function(t,k,v)
-        M[k] = v
-    end
-    return strict.module(name,M)
-end
-
-if not rawget(_G,'PENLIGHT_NO_GLOBAL_STRICT') then
-    strict.module(nil,_G,{_PROMPT=true,__global=true})
-end
-
-return strict