swiglite-lua

#!/usr/bin/env ruby

# Poor man's lite "SWIG" just for lua, which uses STDIN and STDOUT.
#
#   ./swiglite-lua <module_name> [opt.h opt2.h ...]
#
# Example:
#
#   grep -v "#include" some.h | cpp | \
#     ./swiglite-lua some_wrap some.h > some_wrap.c
#
# License   : Apache 2.0
# Copyright : Steve Yen, Inc., 2011.
#
load('swiglite')

require 'rubygems'
require 'erb'

# ---------------------------------------------

SKIP = {}

MAP_TYPE = {
  # [ luaL_check$VAL, lua_push$VAL ]
  'int'     => ['int', 'integer'],
  'long'    => ['long', 'integer'],
  'int64_t' => ['long', 'integer'], # TODO: Revisit int64_t.
  'size_t'  => ['long', 'integer'],
  'double'  => ['number', 'number'],
  'char *'  => ['string', 'string']
}

$module_name   = ARGV[0]
$include_files = ARGV[1..-1]

$src = STDIN.read
$src = $src.gsub(/^\s*#.+$/, '')

KINDS      = {} # Result of parse.
REGISTER   = [] # Functions that will be registered with the module.
ALLOCATORS = [] # Types that will have explicit allocator functions,
                # with optional cast types.  Each entry looks like...
                # [type-name, cast0, cast1, ...]

# User's module-specific specializations loaded here.
#
[ ".swiglite", ".swiglite-lua" ].each do |x|
  load($module_name + x) if File.exists?($module_name + x)
end

parse($src, KINDS)

ENUMS     = KINDS['enum']     || {}
FUNCTIONS = KINDS['function'] || {}

# ---------------------------------------------

def name_for_type(type)
  return type.gsub('*', ' * ').
              gsub('*', 'ptr').
              gsub('struct ', '').
              gsub('const ', '').
              squeeze(' ').strip.
              gsub(' ', '_')
end

def map_type(c_type) # Ex: ['char *'] or ['char', '*'].
  type_key = c_type.join(' ').
                    gsub('unsigned ', '').
                    gsub('signed ', '')

  check_val, push_val = MAP_TYPE[type_key]

  if check_val.nil? and ENUMS[type_key]
    check_val, push_val = MAP_TYPE['int'] # Treat enum as int.
  end

  return name_for_type(type_key), check_val, push_val
end

def arg_from_lua(func_name, arg_type, arg_name, arg_i)
  i = arg_i + 1
  type_name, check_val, push_val = map_type(arg_type)
  if check_val
    "#{arg_name} = (#{arg_type.join(' ')})" +
      " luaL_check#{check_val}(L, #{i});\n"
  else
    res = <<-EOF
#{arg_type.join(' ')} *#{arg_name}_p =
        luaL_checkudata(L, #{i}, "#{type_name}");
    #{arg_name} = *#{arg_name}_p;
EOF

    if arg_type.include?('*')
      res = res + "    printf(\"  #{func_name}.#{arg_name}: %p\\n\", #{arg_name});\n"
    end

    res
  end
end

# ---------------------------------------------

print <<-EOF
// wrapping for #{$module_name} generated by swiglite-lua.

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#{$include_files.map {|x| "#include \"#{x}\"" }.join("\n")}

EOF

# ---------------------------------------------

FUNCTIONS.keys.sort.each do |k|
  decl = FUNCTIONS[k]

  name, kind, return_type = parse_decl(decl)

  args_s = decl[(decl.rindex("(") + 1)..-2].join('').strip
  args_s = "" if args_s == "void"
  args   = args_s.split(',')

  unless SKIP[name]
    wrap_name = "wrap_#{name}"
    REGISTER << [name, wrap_name]
    print(ERB.new(<<-'EOF', 0, "%<>").result(binding))
int <%= wrap_name %>(lua_State *L) {
% args.each_index do |arg_i|
%   arg_type, arg_name = arg_parts(args[arg_i], arg_i)
    <%= arg_type.join(' ') %> <%= arg_name %>;
    <%= arg_from_lua(wrap_name, arg_type, arg_name, arg_i) %>
% end
% if return_type.include?('void')
    <%= name %>(<%= args_names(args).join(', ') %>);
    return 0;
% else
%   return_s = return_type.join(' ').
%                          gsub('*', ' * ').
%                          gsub('const ', '').
%                          squeeze(' ').strip
    <%= return_s %> res = (<%= return_s %>)
        <%= name %>(<%= args_names(args).join(', ') %>);
%   type_name, check_val, push_val = map_type(return_s.split(' '))
%   if push_val
    lua_push<%= push_val %>(L, res);
    return 1;
%   else
    <%= return_s %> *res_ud =
        lua_newuserdata(L, sizeof(<%= return_s %>));
    if (res_ud != NULL) {
        *res_ud = res;
%     if return_s.include?('*')
        printf("return wrap_<%= name %> %p\n", *res_ud);
%     end

        luaL_newmetatable(L, "<%= type_name %>");
        lua_setmetatable(L, -2);
        return 1;
    }
    return 0;
%   end
% end
}
EOF
  end
end

# ---------------------------------------------

ALLOCATORS.sort.each do |type_casts|
  type   = type_casts[0]
  type_s = name_for_type(type)

  REGISTER << ["alloc_#{type_s}_ptr"]
  REGISTER << ["deref_#{type_s}_ptr"]

  print(ERB.new(<<-'EOF', 0, "%<>").result(binding))
int alloc_<%= type_s %>_ptr(lua_State *L) {
    <%= type %> * *pp =
        lua_newuserdata(L, sizeof(<%= type %> *) + sizeof(<%= type %>));
    if (pp != NULL) {
        *pp = (<%= type %> *) &pp[1];
        printf("return alloc_<%= type_s %>_ptr %p\n", *pp);
        luaL_newmetatable(L, "<%= type_s %>_ptr");
        lua_setmetatable(L, -2);
        return 1;
    }
    return 0;
}
int deref_<%= type_s %>_ptr(lua_State *L) {
    <%= type %> *p;
    <%= type %> * *pp =
        luaL_checkudata(L, 1, "<%= type_s %>_ptr");
    p = *pp;

    <%= type %> *res =
        lua_newuserdata(L, sizeof(*res));
    if (res != NULL) {
        *res = *p;
        luaL_newmetatable(L, "<%= type_s %>");
        lua_setmetatable(L, -2);
        return 1;
    }
    return 0;
}
EOF

  type_casts[1..-1].sort.each do |cast|
    cast_s = name_for_type(cast)
    cast_f = "cast_#{type_s}_ptr_to_#{cast_s}_ptr"

    REGISTER << [cast_f]

    print(ERB.new(<<-'EOF', 0, "%<>").result(binding))
int <%= cast_f %>(lua_State *L) {
    <%= type %> *p;
    <%= type %> * *pp =
        luaL_checkudata(L, 1, "<%= type_s %>_ptr");
    p = *pp;

    <%= cast %> * *res =
        lua_newuserdata(L, sizeof(*res));
    if (res != NULL) {
        *res = (<%= cast %> *) p;
        printf("return <%= cast_f %>_ptr %p\n", *res);
        luaL_newmetatable(L, "<%= cast_s %>_ptr");
        lua_setmetatable(L, -2);
        return 1;
    }
    return 0;
}
EOF

  end
end

# ---------------------------------------------

REGISTER.sort.each do |register|
  print("int #{register[-1]}(lua_State *L);\n")
end

print(ERB.new(<<-'EOF', 0, "%<>").result(binding))
LUA_API int luaopen_<%= $module_name %>(lua_State *L) {
    luaL_reg reg[] = {
% REGISTER.sort.each do |register|
        {"<%= register[0] %>", <%= register[-1] %>},
% end
        {NULL, NULL}
    };
    luaL_register(L, "<%= $module_name %>", reg);

% ENUMS.keys.sort.each do |k|
%   parse_enum_values(ENUMS[k]).each do |v|
    lua_pushinteger(L, (lua_Integer) <%= v %>);
    lua_setfield(L, -2, "<%= v %>");

%   end
% end
    return 1;
}
EOF