Inline Cee

wiki

Example:

local CC = require "inlinec"

local f = CC.compile [[
  int start(lua_State * L) {
    luaL_checkstring(L,1);
    lua_pushstring(L, "hello ");
    lua_pushvalue(L, 1);
    lua_concat(L, 2);
    return 1;
  }
]]

print(f("world"))  --> "hello world"

Implementation:

-- inlinec.lua
-- (c) D.Manura, 2008.
-- Licensed under the same terms as Lua itself (MIT license).
local M = {}

M.debug = false

local preamble = [[
#include <lua.h>
#include <lauxlib.h>
#include <stdio.h>
#include <stdlib.h>
]]

-- Count number of lines in string.
local function numlines(s)
  return # s:gsub("[^\n]", "")
end

-- Add lines to string so that any compile errors
-- properly indicate line numbers in this file.
local function adjustlines(src, level, extralines)
  local line = debug.getinfo(level+1,'l').currentline
  return ("\n"):rep(line - numlines(src) - extralines) .. src
end

-- Create temporary file containing text and extension.
local function make_temp_file(text, ext)
  local filename = os.tmpname() .. '.' .. ext
  local fh = assert(io.open(filename, 'w'))
  fh:write(text)
  fh:close()
  return filename
end

-- Create temporary header file with preamble.
-- The preamble is placed in a separate file so as not
-- to increase line numbers in compiler errors.
local pre_filename
local function make_preamble()
  if not pre_filename then
    pre_filename = make_temp_file(preamble, 'h')
  end
  return pre_filename
end

-- Execute command.
local function exec(cmd)
  if M.debug then print(cmd) end
  assert(os.execute(cmd) == 0, 'command failed')
end

-- Compile C source, returning corresponding Lua function.
-- Function must be named 'start' in C.
local function compile(src)
  local CC = 'gcc -O2'

  local pre_filename = make_preamble()
  src = ('#include %q\n'):format(pre_filename) .. src
  src = adjustlines(src, 2, 1)

  local modname = os.tmpname() .. '.so'

  local srcname = make_temp_file(src, "c")
  local cmd = CC .. " -shared -o '" .. modname .. "' '" .. srcname .. "' -llua"
  exec(cmd)

  local func = assert(package.loadlib(modname, 'start'))
  return func
end
M.compile = compile

return M

Possible improvements:

• Make more robust and flexible. This was just quickly put together for demonstration.
• Cache the compiled code across executions.

Possible applications:

• Allow quicker, simpler calling of C code from Lua.
• The compilation module could abstract away operating system and compiler dependent parts of the C compilation process, thereby allowing C code to be implemented and used readily without bothering about details of the compilation process.
• Various code generation tricks (e.g. optimizing code tailored to input data).
• Possibly integration with LuaToCee to even further reduce the boundaries between Lua and C.

Take #2

To avoid implementing all the platform-dependent code, we might instead reuse LuaRocks to do the building. LuaRocks already abstracts away the platform-dependencies. Example:

-- Example of compiling inline C code using LuaRocks to
-- do the compilation.
-- Tested on LuaRocks 2008-08-16 CVS version.
-- Warning: this was quickly put together for demonstration
-- purposes and might not be robust.
-- D.Manura, 2008-06. 

local build = require "luarocks.build.builtin"
local fs = require "luarocks.fs"
local type_check = require "luarocks.type_check"
local path = require "luarocks.path"
local deps = require "luarocks.deps"
local util = require "luarocks.util"

-- Create temporary file containing text and extension.
local function make_temp_file(text, ext)
  local filename = os.tmpname() .. '.' .. ext
  local fh = assert(io.open(filename, 'w'))
  fh:write(text)
  fh:close()
  return filename
end

-- C code to compile.
local srcfilename = make_temp_file([[
#include <lua.h>
#include <lauxlib.h>
  int hello(lua_State * L) {
    luaL_checkstring(L,1);
    lua_pushstring(L, "hello ");
    lua_pushvalue(L, 1);
    lua_concat(L, 2);
    return 1;
  }
  int luaopen_mymodule(lua_State * L) {
    lua_pushcfunction(L, hello);
    return 1;
  }
]], 'c')


-- LuaRock .rockspec definition
-- (provides build instructions)
local rs = {
  package = "MYPACKAGE",
  version = "1.0.0-1",
  source = { url = "unused" },
  build = {
    type = "module",
    modules = {
      mymodule = {
        srcfilename,
        libraries = {"lua"}
      }
    },
  }
}

-- This long function is based on fetch.lua:load_local_rockspec
-- but differs in that it takes a Lua table rather than a file name
-- as input.
-- FIX: It may be best if such a function were instead incorporated
-- into LuaRocks fetch.lua to avoid redundancy.
function create_rockspec(t, filename)
   assert(type(filename) == "string")

   local rockspec, err = t
   if not rockspec then
      return nil, "Could not load rockspec file "..filename.." ("..err..")"
   end

   local ok, err = type_check.type_check_rockspec(rockspec)
   if not ok then
      return nil, filename..": "..err
   end
   
   if rockspec.rockspec_format then
      if deps.compare_versions(
         rockspec.rockspec_format, type_check.rockspec_format)
      then
         return nil, "Rockspec format "..rockspec.rockspec_format..
                     " is not supported, please upgrade LuaRocks."
      end
   end

   util.platform_overrides(rockspec.build)
   util.platform_overrides(rockspec.dependencies)
   util.platform_overrides(rockspec.external_dependencies)
   util.platform_overrides(rockspec.source)

   local basename = fs.base_name(filename)
   rockspec.name = basename:match("(.*)-[^-]*-[0-9]*")
   if not rockspec.name then
      return nil, "Expected filename in format 'name-version-revision.rockspec'."
   end

   local protocol, pathname = fs.split_url(rockspec.source.url)
   if protocol == "http" or protocol == "https" or
      protocol == "ftp" or protocol == "file"
   then
      rockspec.source.file = rockspec.source.file or fs.base_name(rockspec.source.url)
   end
   rockspec.source.protocol, rockspec.source.pathname = protocol, pathname

   -- Temporary compatibility
   if not rockspec.source.module then
      rockspec.source.module = rockspec.source.cvs_module
      rockspec.source.tag = rockspec.source.cvs_tag
   end

   local name_version = rockspec.package:lower() .. "-" .. rockspec.version
   if basename ~= name_version .. ".rockspec" then
      return nil, "Inconsistency between rockspec filename ("..
          basename..") and its contents ("..name_version..".rockspec)."
   end

   rockspec.local_filename = filename
   local filebase = rockspec.source.file or rockspec.source.url
   local base = fs.base_name(filebase)
   base = base:gsub("%.[^.]*$", ""):gsub("%.tar$", "")
   rockspec.source.dir = rockspec.source.dir
                      or rockspec.source.module
                      or ((filebase:match(".lua$") or filebase:match(".c$")) and ".")
                      or base

   if rockspec.dependencies then
      for i = 1, #rockspec.dependencies do
         local parsed = deps.parse_dep(rockspec.dependencies[i])
         if not parsed then
            return nil, "Parse error processing dependency '"..rockspec.dependencies[i].."'"
         end
         rockspec.dependencies[i] = parsed
      end
   else
      rockspec.dependencies = {}
   end
   local ok, err = path.configure_paths(rockspec)
   if err then
      return nil, "Error verifying paths: "..err
   end

   return rockspec
end


-- Build module
rs = assert(create_rockspec(rs, "mypackage-1.0.0-1.rockspec"))
assert(build.run(rs))

-- Load module
local hello = require "mymodule"
print(hello("world")) --> "hello world"

--DavidManura

See Also

• [Luatcc] - mentioned in "Interpreted C Modules" in the LuaGems? book (not yet published). This appears it may be similar but possibly is restricted to tcc only (?) Using tcc likely has the advantage of allowing the compilation to occur entirely in-process. However, the using an out-of-process compiler as done here can be more flexible, allowing any compiler to be used.
• [Perl Inline] - This Perl module provides a similar approach.
• LuaProxyDll - a related example of metaprogramming a C build from Lua.