changed macros in lqt_common.hpp to reflect new header name

[lqt.git] / binder.lua

#!/usr/bin/lua

local binder = {}
local B = nil

-- a string devised to not compile. should not make into code. never.
binder.ERRORSTRING = '<<>>'
binder.WRAPCALL = '__LuaWrapCall__'
binder.debug_type = function(el) return (type(el)=='table'and (el.tag .. ' ' .. el.attr.id) or el) end

function binder:init(filename)
  --require 'lxp'
  --require 'lxp.lom'
  
  if not self.tree then
    local xmlf = io.open(filename, 'r')
    local xmls = xmlf:read('*a')
    xmlf:close()
    --self.tree = lxp.lom.parse(xmls)
                xml.id = {}
                self.tree = xml:collect(xmls)
  end
  
        self.ids = xml.id
  self.type_names = {}
  self.types_to_stack = {
    ['const char *'] = function(i) return 'lua_pushstring(L, ' .. tostring(i) .. ')' end,
    ['short int'] =              function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['unsigned short int'] =     function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['short unsigned int'] =     function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['int'] =                    function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['unsigned int'] =           function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['long int'] =               function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['unsigned long int'] =      function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['long unsigned int'] =      function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['long long int'] =          function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['unsigned long long int'] = function(i) return 'lua_pushinteger(L, ' .. tostring(i) .. ')' end,
    ['float'] =  function(i) return 'lua_pushnumber(L, ' .. tostring(i) .. ')' end,
    ['double'] = function(i) return 'lua_pushnumber(L, ' .. tostring(i) .. ')' end,
    ['bool'] = function(i) return 'lua_pushboolean(L, ' .. tostring(i) .. ')' end,
    ['void *'] =   function(i) return 'lua_pushlightuserdata(L, ' .. tostring(i) .. ')' end,
    ['void * *'] = function(i) return 'lua_pushlightuserdata(L, ' .. tostring(i) .. ')' end,
  }
  self.types_from_stack = {
    ['const char *'] = function(i) return 'lua_tostring(L, ' .. tostring(i) .. ')' end,
    ['short int'] =              function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['unsigned short int'] =     function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['short unsigned int'] =     function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['int'] =                    function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['unsigned int'] =           function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['long int'] =               function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['unsigned long int'] =      function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['long unsigned int'] =      function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['long long int'] =          function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['unsigned long long int'] = function(i) return 'lua_tointeger(L, ' .. tostring(i) .. ')' end,
    ['float'] =  function(i) return 'lua_tonumber(L, ' .. tostring(i) .. ')' end,
    ['double'] = function(i) return 'lua_tonumber(L, ' .. tostring(i) .. ')' end,
    ['bool'] = function(i) return '(bool)lua_toboolean(L, ' .. tostring(i) .. ')' end,
    ['void *'] =   function(i) return 'lua_touserdata(L, ' .. tostring(i) .. ')' end,
    ['void * *'] = function(i) return 'static_cast<void **>(lua_touserdata(L, ' .. tostring(i) .. '))' end,
  }
  self.types_test = {
    ['const char *'] = function(i) return '(lua_type(L, ' .. tostring(i) .. ')==LUA_TSTRING)' end,
    ['short int'] =              function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['unsigned short int'] =     function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['short unsigned int'] =     function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['int'] =                    function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['unsigned int'] =           function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['long int'] =               function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['unsigned long int'] =      function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['long unsigned int'] =      function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['long long int'] =          function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['unsigned long long int'] = function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['float'] =  function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['double'] = function(i) return 'lua_isnumber(L, ' .. tostring(i) .. ')' end,
    ['bool'] = function(i) return 'lua_isboolean(L, ' .. tostring(i) .. ')' end,
    ['void *'] =   function(i) return 'lua_isuserdata(L, ' .. tostring(i) .. ')' end,
    ['void * *'] = function(i) return 'lua_isuserdata(L, ' .. tostring(i) .. ')' end,
  }
--   self.conditions = {}
  
  return self.tree
end

function binder.wrapclass(n)
  return 'LuaBinder< '..n..' >'
end

function binder.lua_proto(s)
  return 'int '..s..' (lua_State *L)'
end

function binder.fake_pointer (id)
  return { tag='PointerType', attr={ type=id } }
end

function binder:find(f, t)
  t = t or self.tree
  if type(t)~='table' then return nil end;
  if f(t) then return t end
  local ret = nil
  for k,v in pairs(t) do
    ret = ret or self:find(f, v)
    if ret then break end
  end;
  return ret;
end

function binder.name_search (n)
  return function (t)
      return (type(t)=='table') and (type(t.attr)=='table') and (t.attr.name==n)
    end
end

function binder.id_search (i)
  return function (t)
      return (type(t)=='table') and (type(t.attr)=='table') and (t.attr.id==i) -- or ((type(i)=='table') and i[t.attr.id])
    end
end

function binder.tag_search (n)
  return function (t)
      return (type(t)=='table') and (t.tag==n) -- or ((type(i)==table) and i[t.attr.id])
    end
end

function binder.pointer_search(id)
  return function (t)
    return (type(t)=='table') and (t.tag=='PointerType') and (type(t.attr)=='table') and (t.attr.type==id)
  end
end

function binder:find_name (n)
  if not self.names then self.names = {} end
  if not self.names[n] then
    self.names[n] = self:find(self.name_search(n))
  end
  return self.names[n]
end

function binder:find_id (n)
  if not self.ids then self.ids = {} end
  if not self.ids[n] then
    self.ids[n] = self:find(self.id_search(n))
  end
  return self.ids[n]
end

function binder:find_pointer (n)
  if not self.pointers then self.pointers = {} end
  if not self.pointers[n] then
    self.pointers[n] = self:find(self.pointer_search(n.attr.id))
  end
  return self.pointers[n]
end

function binder:context_name(el)
    if type(el.attr)~='table' then return '' end
    if type(el.attr.context)~='string' then return '' end
    
    local context_el = self:find_id(el.attr.context)
    
    if not context_el then return '' end
    
    local context = (context_el.attr.name=='::') and '' or (context_el.attr.name..'::')
    return context
end

function binder:type_name(el)
--     print('getting name of', el, el.tag)
    
  self.type_names = self.type_names or {}
  local t = self.type_names
  
  if t[el] then return t[el] end
  
      if el.tag == 'FundamentalType' then
    t[el] = el.attr.name
  elseif (el.tag == 'Class') or (el.tag == 'Struct') or (el.tag=='Union') then
    t[el] = self:context_name(el) .. el.attr.name
  elseif el.tag == 'Typedef' then
    t[el] = self:type_name(self:find_id(el.attr.type))
  elseif el.tag == 'PointerType' then
    t[el] = self:type_name(self:find_id(el.attr.type)) .. ' *'
  elseif el.tag == 'ReferenceType' then
    t[el] = self:type_name(self:find_id(el.attr.type)) .. '&'
  elseif el.tag == 'CvQualifiedType' then
    t[el] = ( (el.attr.volatile=='1') and 'volatile ' or '' )
         .. ( (el.attr.const=='1') and 'const ' or '' )
         .. self:type_name(self:find_id(el.attr.type))
  elseif el.tag == 'Enumeration' then
    t[el] = self:context_name(el) .. el.attr.name
  else
    error('cannot determine type name: ' .. self.debug_type(el))
  end
  return t[el]
end

function binder.wrapcall(m, overload, n)
  if m.tag=='Method' then
    return binder.WRAPCALL..m.attr.name..(overload and '__OverloadedVersion'..tostring(n) or '')
  elseif m.tag=='Constructor' then
    return binder.WRAPCALL..m.attr.name..'__new'..(overload and '__OverloadedVersion'..tostring(n) or '')
  elseif m.tag=='Destructor' then
    -- cannot be overloaded, true?
    return binder.WRAPCALL..m.attr.name..'__delete'..(overload and '__OverloadedVersion'..tostring(n) or '')
  end
  return false
end

function binder.arguments_of(f)
  local ret = {}
  for argi = 1, table.maxn(f) do
    if (type(f[argi])=='table') and (f[argi].tag=='Argument') then
      table.insert(ret, f[argi])
    end
  end
  return ret
end


function binder:base_type(el)
  local ret = self:find_id(el.attr.type)
  while (ret.tag=='Typedef') or (ret.tag=='CvQualifiedType') do
    ret = self:find_id(ret.attr.type)
  end
  return ret
end

function binder:type_from_stack(el)
  local t = self.types_from_stack
  if t[el] then return t[el] end
  
  local name = self:type_name(el)
  if t[name] then
    t[el] = t[name]
    return t[el]
  end

  if (el.tag=='Class') or (el.tag=='Struct') or (el.tag=='Union') then
    t[el] = function(i) return '**static_cast<'..name..'**>(lqtL_checkudata(L, '..tostring(i)..', "' ..name.. '*"))' end
  elseif (el.tag=='CvQualifiedType') then
    t[el] = self:type_from_stack(self:find_id(el.attr.type))
  elseif (el.tag=='ReferenceType') then
    t[el] = self:type_from_stack(self:find_id(el.attr.type))
  elseif (el.tag=='Typedef') then
    t[el] = self:type_from_stack(self:find_id(el.attr.type))
  elseif (el.tag=='Enumeration') then
    t[el] = function (i) return 'static_cast<'..name..'>(lqtL_toenum(L, '..tostring(i)..', "'..name..'"))' end
  elseif (el.tag=='PointerType') then
    local b = self:base_type(el)
    local base_t = self:type_from_stack(b)
    t[el] = (type(base_t)=='function') and function (i)
              local base = base_t(i)
              local c = string.sub(base, 1, 1)
              if (c=='*') then
                return string.sub(base, 2)
              else
                return 'static_cast<'..name..'>(lua_touserdata(L, '..tostring(i)..'))'
              end
            end or function (i) return '0' end
  elseif (el.tag=='FunctionType') then -- FIXME
  end
  
  if t[el]==nil then
    error('cannot deternime how to retrieve type: '.. ((type(el)=='table') and (el.tag..' '..el.attr.id) or el))
  end
  return t[el]
end


function binder:type_to_stack(el)
  local t = self.types_to_stack
  
  if t[el] then return t[el] end
  
  local name = self:type_name(el)
--   print (el.tag, '|'..name..'|', rawget(t,el) or '<>')
  
  if t[name] then
    t[el] = t[name]
    return t[el]
  end

  if (el.tag=='Class') or (el.tag=='Struct') or (el.tag=='Union') then
    -- FIXME: force deep copy if possible
    t[el] = function(i) return 'lqtL_passudata(L, new '..name..'('..tostring(i)..'), "'..name..'*")' end
  elseif (el.tag=='CvQualifiedType') then -- FIXED? FIXME: this is just a mess
    local base_t = self:base_type(el)
    local non_cv = self:type_to_stack(base_t)
    --if (base_t.tag=='Class') or (base_t.tag=='Struct') or (base_t.tag=='Union') then else end
    t[el] = non_cv
  elseif (el.tag=='ReferenceType') then
    local base_t = self:base_type(el)
                if (base_t.tag=='Class') or (base_t.tag=='Struct') or (base_t.tag=='Union') then
                        t[el] = function(i) return 'lqtL_pushudata(L, &('..tostring(i)..'), "'..self:type_name(base_t)..'*")' end
                else
                        t[el] = self:type_to_stack(self:find_id(el.attr.type))
                end
  elseif (el.tag=='Typedef') then
    t[el] = self:type_to_stack(self:find_id(el.attr.type))
  elseif (el.tag=='Enumeration') then
    t[el] = function (i) return 'lqtL_pushenum(L, '..tostring(i)..', "'..name..'")' end
  elseif (el.tag=='PointerType') then
    local base_t = self:base_type(el)
    t[el] = function(i) return 'lqtL_pushudata(L, '..tostring(i)..', "'..self:type_name(base_t)..'*")' end
  end
  
--   print (el.tag, el, rawget(t,el) or '<>')
  if t[el]==nil then
    error('cannot deternime how to push on stack type: '.. self.debug_type(el))
  end
  return t[el]
end



function binder:type_test(el)
  local t = self.types_test
  
  if t[el] then return t[el] end
  
  local name = self:type_name(el)
  
  if t[name] then
    t[el] = t[name]
    return t[el]
  end

  if (el.tag=='Class') or (el.tag=='Struct') or (el.tag=='Union') then
    t[el] = function(i) return 'lqtL_testudata(L, ' .. tostring(i) .. ', "' .. name .. '*")' end
  elseif (el.tag=='CvQualifiedType') then
    t[el] = self:type_test(self:find_id(el.attr.type))
  elseif (el.tag=='ReferenceType') then
    t[el] = self:type_test(self:find_id(el.attr.type))
  elseif (el.tag=='Typedef') then
    t[el] = self:type_test(self:find_id(el.attr.type))
  elseif (el.tag=='Enumeration') then
    t[el] = function (i) return 'lqtL_isenum(L, '..tostring(i)..', "'..name..'")' end
  elseif (el.tag=='PointerType') then
    t[el] = self:type_test(self:find_id(el.attr.type)) or function() return '(true)' end
  elseif (el.tag=='FunctionType') then -- FIXME
  end
  
--   print (el.tag, el, rawget(t,el) or '<>')
  if t[el]==nil then
    error('cannot deternime how to test type: '.. self.debug_type(el))
  end
  return t[el]
end


function binder:function_body(f)
  if f.attr.pure_virtual=='1' then error'cannot call pure vitual functions' end

  local body = '{\n'
  local has_this = 0
  --local base_class = nil
  local args = self.arguments_of(f)
  local funcname = self:context_name(f) .. f.attr.name
  local ret_type = nil
  local pointer_to_class = self.fake_pointer(f.attr.context)
  
  --if f.attr.context then base_class = self:find_id(f.attr.context) end
  --if base_class and ((base_class.tag=='Class') or (base_class.tag=='Struct')) then
    --pointer_base = self:find(self.pointer_search(f.attr.context)) 
  --end
  
  -- NEEDS THIS POINTER?
  if ( (f.tag=='Method') and (f.attr.static~='1') ) or (f.tag == 'Destructor') then
    local pointer_base = pointer_to_class
    body = body .. '  ' .. self:type_name(pointer_base) .. '& __lua__obj = '
                .. self:type_from_stack(pointer_base)(1) .. ';\n';
---[==[
    body = body .. [[
        if (__lua__obj==0) {
                lua_pushstring(L, "trying to reference deleted pointer");
                lua_error(L);
                return 0;
        }
]]
--]==]
    has_this = 1
  end
  
  -- GETTING ARGUMENTS
  for argi = 1, table.maxn(args) do
    local arg = args[argi]
    local argname = 'arg' .. tostring(argi)
    
    local argt = self:find_id(arg.attr.type)
    local argtype = self:type_name(argt)
    local def = arg.attr.default
    
    if def and string.match(string.sub(def, 1, 1), '[%l%u]') then
      def = self:context_name(argt)..def
    elseif def then
      def = 'static_cast< ' .. argtype .. ' >(' .. def .. ')'
    end
    
    --print ('getting arg type', argtype, arg.attr.type)
    
    body = body .. '  ' .. argtype .. ' ' .. argname .. ' = '
                .. (def and (self:type_test(argt)(argi+has_this) .. '?') or '')
                .. self:type_from_stack(argt)(argi+has_this)
    body = body .. (def and (':' .. tostring(def)) or '') .. ';\n' --  '// default = '..tostring(def)..'\n'
  end
  body = body .. '  '
  
  if f.tag=='Constructor' then
                --[[
                local my_class = self:find_id(f.attr.context)
                if my_class.attr.abstract='1' then error'cannot construct abstract class' end
                --]]
    ret_type = pointer_to_class
    funcname = 'new ' .. self.wrapclass(f.attr.name)
    
--     ret_type = self:find_id(f.attr.context) -- wrong?
--     body = body .. self:type_name(ret_type) .. ' * ret = new '
--     print (self:type_name(ret_type))
  elseif f.tag=='Destructor' then
    -- TREATED AS SPECIAL CASE
    body = body .. 'delete __lua__obj;\n'
    body = body .. '  __lua__obj = 0;\n';
    body = body .. '  return 0;\n}\n'
    return body
  else
    ret_type = self:find_id(f.attr.returns)
  end

  -- GET RETURN TYPE
  if ret_type.attr.name=='void' then
    ret_type = nil
  else
    body = body .. self:type_name(ret_type) .. ' ret = '
  end

  -- CALL FUNCTION    
  if has_this==1 then
    body = body .. '__lua__obj->' .. funcname .. '('
  else
    body = body .. funcname .. '('
  end
  
  -- IF OVERRIDING CONSTRUCTOR ADD STATE POINTER
  if f.tag=='Constructor' then
    body = body .. 'L' .. ((table.maxn(args) > 0) and ', ' or '')
  end
  
  -- ADD ARGS TO FUNCTION CALL
  if table.maxn(args) > 0 then body = body .. 'arg1' end
  for argi = 2, table.maxn(args) do
    body = body .. ', arg' .. tostring(argi)
  end
  
  body = body .. ');\n'

  -- HANDLE RETURN VALUE
  if f.tag=='Constructor' then
                body = body .. '  lqtL_passudata(L, ret, "'..f.attr.name..'*");\n'
    body = body .. '  return 1;\n}\n'
        elseif ret_type then
    -- print('pushing', binder:type_name(ret_type))
    local ret_to_stack = self:type_to_stack(ret_type)'ret'
    body = body .. '  ' .. ret_to_stack .. ';\n'
    body = body .. '  return 1;\n}\n'
  else
    body = body .. '  return 0;\n}\n'
  end
  
  return body
end

function binder:function_test(p, score)
  local ret = ''
  local isstatic = 0
  
  ret = ret .. '  ' .. score .. ' = 0;\n'
  
  if p.attr.static~='1' and p.tag=='Method' then
    ret = ret .. '  ' .. score .. ' += ' .. self:type_test( self.fake_pointer(p.attr.context) )(1)
              .. '?premium:-premium*premium;\n' 
    isstatic = 1
  end
  
  local args = self.arguments_of(p)
  
  for argi = 1, table.maxn(args) do
    local arg = args[argi]
    --print ( 'ARGUMENT TEST', argi)
    local argname = 'arg' .. tostring(argi)
    if (type(arg)=='table') and (arg.tag=='Argument') then
      ret = ret .. '  if (' .. self:type_test( self:find_id(arg.attr.type) )(argi+isstatic)  .. ') {\n'
      ret = ret .. '    ' .. score .. ' += premium;\n'
      ret = ret .. '  } else if (' .. tostring(arg.attr.default and true or false) .. ') {\n'
      ret = ret .. '    ' .. score .. ' += premium-1; // '..tostring(arg, arg.attr.default)..';\n'
      ret = ret .. '  } else {\n'
      ret = ret .. '    ' .. score .. ' -= premium*premium;\n'
      ret = ret .. '  }\n'
      
--       ret = ret .. '  ' .. score .. ' += ' .. type_on_stack_test( find_id(arg.attr.type) , argi+isstatic )
--                 .. '?' .. tostring(premium) .. ':-' .. tostring(premium) .. '*' .. tostring(premium) .. ';\n' 
    end
  end
  
  return ret
end

function binder:get_members (c)
  if not self.members then self.members = {} end
  if not self.members[c] then
    local ret = { functions={}, enumerations={}, classes={}, methods={}, constructors={}, virtuals={} }
    for s in string.gmatch(c.attr.members, '(_%d+) ') do
      local m = self:find_id(s)
      local n = m.attr.name
      print("member of", c.attr.name , "found:", s, "name:", n)

                        local filtered, motive = false, ''
                        if self.filter then
                                filtered, motive = self.filter(m)
                        end

                        if filtered then
                                print('Filtered member: '..n..' for '..(motive or 'no apparent reason.'))
                        elseif m.tag=='Enumeration' then
        table.insert(ret.enumerations, m)
      elseif m.tag=='Function' then
        ret.functions[n] = ret.functions[n] or {}
        table.insert(ret.functions[n], m)
      elseif m.tag=='Method' and (m.attr.access=='public') then
        ret.methods[n] = ret.methods[n] or {}
        table.insert(ret.methods[n], m)
      elseif m.tag=='Constructor' and (m.attr.access=='public') then
        table.insert(ret.constructors, m)
      elseif m.tag=='Destructor' then
        ret.destructor = m
      elseif m.tag=='Class' or m.tag=='Struct' then
        table.insert(ret.classes, m)
      end

      if (m.attr.virtual=='1') and (m.tag~='Constructor') and (m.tag~='Destructor') and not filtered then
        table.insert(ret.virtuals, m)
      end
      --[[
      local n = n..' < < of type > > '.. m.tag ..' < < with access > > ' .. m.attr.access
      ret.cache[n] = ret.cache[n] or {}
      table.insert(ret.cache[n], m)
      ]]
    end
    self.members[c] = ret
  end
  return self.members[c]
end

function binder:code_function (f)
  local body, test = {}, {}

  for i, m in ipairs(f) do
    local fname = self.wrapcall(m, overloaded, j)
    
    if not fname then error'this shout *NOT* happen!' end
    local st, err
    
    st, err = pcall(self.function_body, self, m)
    if st then
      body[i] = err
    else
      print(err)
      body[i] = nil
    end
    
    st, err = pcall(self.function_test, self, m, 'score['..i..']')
    if st then
      test[i] = err
    else
      print(err)
      test[i] = nil
    end

    --body[i] = self:function_body(m)
    --test[i] = self:function_test(m, 'score['..i..']')
  end
  
  return body, test
end

function binder:begin_dispatch(n, m)
    return self.lua_proto(n) .. ' {\n  int score[' .. (m+1)
                     ..'];\n  const int premium = 11+lua_gettop(L);\n'
end

function binder:choose_dispatch(m)
  return [[
  int best = 1;
  for (int i=1;i<=]]..m..[[;i++) {
    if (score[best] < score[i]) { best = i; }
  }
  switch (best) {
]]
end

function binder:solve_overload (f, n, c)
  local proto, def = '', ''
  local body, test = self:code_function(f)

  local number = 0
  for i = 1,table.maxn(f) do if (type(body[i])=='string') and (type(test[i])=='string') then number = number + 1 end end
  
  if number>1 then
    local fulltest = self:begin_dispatch(c..n, table.maxn(f))

    for i = 1,table.maxn(f) do
      local fullname = n..'__OverloadedVersion__'..i
      if (type(body[i])=='string') and (type(test[i])=='string') then
        proto = proto .. '  static '..self.lua_proto(fullname)..';\n'
        def = def .. self.lua_proto(c..fullname)..' '..body[i]
        fulltest = fulltest .. test[i]
      end
    end

    fulltest = fulltest .. self:choose_dispatch(table.maxn(f))

    for i = 1,table.maxn(f) do
      if (type(body[i])=='string') and (type(test[i])=='string') then
        local fullname = n..'__OverloadedVersion__'..i
        fulltest = fulltest .. '    case ' .. i .. ': return ' .. fullname ..'(L); break;\n'
      end
    end

    -- TODO: move to a function?
                -- TODO: trigger an error
    fulltest = fulltest .. [[
        }
        lua_pushstring(L, "no overload of function ]].. n ..[[ matching arguments");
        lua_error(L);
        return 0;
}
]]

    proto = proto .. '  static '..self.lua_proto(n)..';\n'
    def = def .. fulltest
  elseif number==1 then
    proto, def = nil, nil
    for i, v in ipairs(body) do
      proto = '  static '..self.lua_proto(n)..';\n'
      def = self.lua_proto(c..n)..' '..v
    end
  else
    proto, def = nil, nil
  end
  
  return proto, def
end

function binder:enum_push_body(id, c)
        local enum = (type(id)=='string') and self:find_id(id) or id
        local e_static = (self:find_id(enum.attr.context).tag == 'Class') and 'static ' or ''
        local e_context = self:context_name(enum)
        local e_name = 'lqt_pushenum_' .. enum.attr.name
        local e_proto, e_def = '', ''

        e_proto = e_proto .. '  ' .. e_static .. self.lua_proto(e_name) .. ';\n'
        e_def = e_def .. self.lua_proto(c .. e_name) .. ' '
        e_def = e_def .. '{\n'
        e_def = e_def .. '  int enum_table = 0;\n'
        e_def = e_def .. '  lua_getfield(L, LUA_REGISTRYINDEX, LQT_ENUMS);\n'
        e_def = e_def .. '  if (!lua_istable(L, -1)) {\n'
        e_def = e_def .. '    lua_pop(L, 1);\n'
        e_def = e_def .. '    lua_newtable(L);\n'
        e_def = e_def .. '    lua_pushvalue(L, -1);\n'
        e_def = e_def .. '    lua_setfield(L, LUA_REGISTRYINDEX, LQT_ENUMS);\n'
        e_def = e_def .. '  }\n'

        e_def = e_def .. '  lua_newtable(L);\n'
        e_def = e_def .. '  enum_table = lua_gettop(L);\n'
        for i, e in ipairs(enum) do
                if (type(e)=='table') and (e.tag=='EnumValue') then
                        e_def = e_def .. '  lua_pushstring(L, "' .. e.attr.name .. '");\n'
                        e_def = e_def .. '  lua_rawseti(L, enum_table, ' .. e.attr.init .. ');\n'
                        e_def = e_def .. '  lua_pushinteger(L, ' .. e.attr.init .. ');\n'
                        e_def = e_def .. '  lua_setfield(L, enum_table, "' .. e.attr.name .. '");\n'
                end
        end
        e_def = e_def .. '  lua_pushvalue(L, -1);\n'
        e_def = e_def .. '  lua_setfield(L, -3, "' .. e_context .. enum.attr.name .. '");\n'
        e_def = e_def .. '  lua_remove(L, -2);\n'
        e_def = e_def .. '  return 1;\n'
        e_def = e_def .. '}\n'
        --print (e_def)
        return e_proto, e_def, e_name
end

function binder:mangled (f)
  local args = self:arguments_of(f)
  local k = f.attr.name..'('
  for i = 1, table.maxn(args) do
    k = k..', '..self:type_name(args.attr.type)
  end
  k = k..')'
  return k
end

function binder:get_virtuals (c)
  local c_v = self:get_members(c).virtuals
  local mang_virtuals = {}

  for n, f in pairs(c_v) do
    if f.attr.virtual=='1' then
      local k = self:mangled(f)
      mang_virtuals[k] = mang_virtuals[k] or f
    end
  end


  for s in string.gmatch(c.attr.bases or '', '(_%d+) ') do
    local my_base = self:find_id(s)
    local my_virtual = self:get_virtuals(my_base)
    for k, f in pairs(my_virtual) do
      mang_virtuals[k] = mang_virtuals[k] or f
    end
  end

  return mang_virtuals
end

function binder:proto_preamble (n, ...)
  -- FIXME: this is only Qt (the inclusion by name of class)
  -- FIXED?
  i = i or n
  local ret = [[
#include "lqt_common.hpp"
]]
  for n = 1,select('#', ...) do
                local i = select(n, ...)
                ret = ret .. '#include <'..i..'>\n'
        end

  ret = ret .. [[

template <> class ]] .. self.wrapclass(n) .. [[ : public ]]  .. n .. [[ {
  private:
  lua_State *L;
  public:
]]
  return ret
end

function binder:proto_ending (n)
 return [[
};

]]
end

function binder:copy_constructor(c)
      local constr = '  '
      local args = self.arguments_of(c)
      constr = constr .. self.wrapclass(c.attr.name) .. ' (lua_State *l'
      for argi = 1, table.maxn(args) do
        local argt = self:find_id(args[argi].attr.type)
        local argtype = self:type_name(argt)
        constr = constr .. ', ' .. argtype .. ' arg'..tostring(argi)
      end
      constr = constr .. '):'..c.attr.name..'('
      for argi = 1, table.maxn(args) do
        constr = constr .. ((argi>1) and ', ' or '') .. 'arg'..tostring(argi)
      end
      constr = constr .. '), L(l) {}\n'
      return constr, nil
end

function binder.meta_constr_proto (n) return 'int luaopen_'..n..' (lua_State *L);\n' end
function binder.meta_constr_preamble (n)
  return [[
int luaopen_]]..n..[[ (lua_State *L) {
  if (luaL_newmetatable(L, "]]..n..[[*")) {
]]
end
function binder.meta_constr_method (n, c)
  c = c or ''
  return '    lua_pushcfunction(L, '..c..n..');\n    lua_setfield(L, -2, "'..n..'");\n'
end
function binder.meta_constr_ending (n)
  return [[
    lua_pushcfunction(L, lqtL_newindex);
    lua_setfield(L, -2, "__newindex");
    lua_pushcfunction(L, lqtL_index);
    lua_setfield(L, -2, "__index");
    lua_pushcfunction(L, lqtL_gc);
    lua_setfield(L, -2, "__gc");
    lua_pushstring(L, "]]..n..[[");
    lua_setfield(L, -2, "__qtype");
                lua_setglobal(L, "]]..n..[[");
  } else {
                lua_pop(L, 1);
        }
  return 0;
}
]]
end

function binder:virtual_overload (f, c, id)
        --if f.attr.access~='public' then error'only public virtual function are exported' end
        if f.attr.access=='private' then error'private virtual function are not exported' end

  c = c or ''
  local args = self.arguments_of(f)
  local ret_t = f.attr.returns and self:find_id(f.attr.returns)
  local ret_n = ret_t and self:type_name(ret_t) or 'void'
  local fh, fb = '  ', ''
  fh = fh .. ret_n .. ' ' .. f.attr.name .. ' ('
  fb = fb .. ret_n .. ' ' .. c .. f.attr.name .. ' ('
  
  -- GETTING ARGUMENTS
  for argi = 1, table.maxn(args) do
    local arg = args[argi]
    local argname = 'arg' .. tostring(argi)
    
    local argt = self:find_id(arg.attr.type)
    local argtype = self:type_name(argt)
    local def = arg.attr.default or nil
    
    def = def and (self:context_name(argt)..def)
    
    --print ('signing arg type', argtype)
    
    if argi>1 then fh = fh .. ', ' fb = fb .. ', ' end
    fh = fh .. argtype .. ' ' .. argname .. (def and (' = '..def) or '')
    fb = fb .. argtype .. ' ' .. argname
  end
  
  fh = fh .. ')' .. (f.attr.const and ' const' or '') .. ';\n'

  if f.attr.access~='public' then
    fh = f.attr.access .. ':\n' .. fh .. 'public:\n'
  end

  fb = fb .. ')' .. (f.attr.const and ' const' or '') .. ' {\n'
  fb = fb .. '  bool absorbed = false;\n  int oldtop = lua_gettop(L);\n'
  
  local context = self:context_name(f)
  local pointer_to_class = self.fake_pointer ( id or f.attr.context )
  local push_this = self:type_to_stack(pointer_to_class)'this'
  --fb = fb .. '  ' .. push_this .. ';\n'
  --fb = fb .. '  lua_getfield(L, -1, "'..(f.attr.name)..'");\n  lua_insert(L, -2);\n' 
---[=[
  fb = fb .. '  ' .. push_this .. [[;
        if (lua_getmetatable(L, -1)) {
                lua_getfield(L, -1, "]]..(f.attr.name)..[[");
                lua_remove(L, -2);
        } else {
                lua_pushnil(L);
        }
        lua_insert(L, -2);
]]
--]=]


  for argi = 1, table.maxn(args) do
    local arg = args[argi]
    local argname = 'arg' .. tostring(argi)
    
    local argt = self:find_id(arg.attr.type)
    local argtype = self:type_name(argt)
    local def = arg.attr.default
    
    def = def and (self:context_name(argt)..def)
    
    local to_stack = self:type_to_stack(argt)(argname)
    --to_stack = (type(to_stack)=='string') and to_stack or table.concat(to_stack, '\n  ')
    fb = fb .. '  ' .. to_stack .. ';\n'
  end
  
  local sig = '(' .. (args[1] and 'arg1' or '')
  for argi = 2, table.maxn(args) do
    sig = sig .. ', arg' .. argi
  end
  sig = sig .. ')'

  fb = fb .. [[
  if (lua_isfunction(L, -]]..table.maxn(args)..[[-2)) {
    lua_pcall(L, ]] .. table.maxn(args) .. [[+1, 2, 0);
                absorbed = (bool)lua_toboolean(L, -1) || (bool)lua_toboolean(L, -2);
                lua_pop(L, 1);
  }
  if (!absorbed) {
    lua_settop(L, oldtop);
    ]] .. (f.attr.pure_virtual~='1' and (((ret_n~='void') and 'return ' or '')..'this->'..context..f.attr.name..sig..';\n') or '') .. [[
  }
]]
--   fb = fb .. '  if (!lua_isnil)' -- TODO: check?
  if ret_n~='void' then
    fb = fb .. '  ' .. ret_n .. ' ret = ' .. self:type_from_stack(ret_t)(-1) .. ';\n'
    fb = fb .. '  lua_settop(L, oldtop);\n'
    fb = fb .. '  return ret;\n'
  else
    fb = fb .. '  lua_settop(L, oldtop);\n'
  end
  fb = fb .. '}\n'
  
  return fh, fb
end

function binder:virtual_destructor (f, c)
  c = c or ''
  local lname = self.wrapclass(f.attr.name)
  local pclass = self.fake_pointer(f.attr.context)
  local push_this = self:type_to_stack(pclass)'this'
  return [[
  ~]]..lname..[[ ();
]], 
c .. [[
  ~]]..lname..[[ () {
  int oldtop = lua_gettop(L);
  ]] .. push_this .. [[;
  lua_getfield(L, -1, "~]]..f.attr.name..[[");

  if (lua_isfunction(L, -1)) {
    lua_insert(L, -2);
    lua_pcall(L, 1, 1, 0);
  } else {
  }
  lua_settop(L, oldtop);
}
]]

end

function binder:make_namespace(tname, include_file, ...)
  local bind_file = 'lqt_bind_'..include_file..'.hpp'
  if string.match(include_file, '(%.[hH]([pP]?)%2)$') then
    bind_file = 'lqt_bind_'..include_file
  end

  local my_class = self:find_id(tname) or self:find_name(tname)
  local my_context = self.wrapclass(tname)..'::'

  local my = self:get_members(my_class)

  local my_enums = nil
  my.virtuals = self:get_virtuals(my_class)

  print 'writing preambles'

  local fullproto = self:proto_preamble(tname, include_file, ...)
  local fulldef = '#include "'..bind_file..'"\n\n'
  local metatable_constructor = self.meta_constr_preamble(tname)

  print 'binding each member'

  local my_members = {}
  table.foreach(my.methods, function(k, v) my_members[k] = v end)
  my_members.new = my.constructors
  my_members.delete = { my.destructor }
  for n, l in pairs(my_members) do
    local fname = self.WRAPCALL..n
    local proto, def = self:solve_overload(l, fname, my_context)
    if (proto and def) then
      fullproto = fullproto .. proto
      fulldef = fulldef .. def
      metatable_constructor = metatable_constructor .. self.meta_constr_method (n, my_context..self.WRAPCALL)
    end
  end

  print'binding virtual methods'

  for s, f in pairs(my.virtuals) do
    print ('virtual', s)
    local ret, h, c = pcall(self.virtual_overload, self, f, my_context, my_class.attr.id)
                if ret then
                        fullproto, fulldef = fullproto..h, fulldef..c
                else
                        print(h)
                end
  end

  print'overriding virtual destructor'
  if my.destructor and my.destructor.attr.virtual == '1' then
    local h, c = self:virtual_destructor(my.destructor, my_context)
    fullproto, fulldef = fullproto..h, fulldef..c
  end

        print'creating enum translation tables'
        for k, e in pairs(my.enumerations) do
                local e_p, e_d, e_n = self:enum_push_body(e, my_context)
                fulldef = fulldef .. e_d
                fullproto = fullproto .. e_p
                metatable_constructor = metatable_constructor .. '    ' .. my_context .. e_n .. '(L);\n    lua_setfield(L, -2, "'..e.attr.name..'");\n'
        end

  print'copying constructors'
  for i, v in ipairs(my.constructors) do
    fullproto = fullproto..self:copy_constructor(v)
  end
  fullproto = fullproto .. self:proto_ending(tname) .. self.meta_constr_proto (tname)

  print'specifying bases'
  metatable_constructor = metatable_constructor .. '    lua_newtable(L);\n'
        local deep_bases = {}
  for s in string.gmatch(my_class.attr.bases or '', '(_%d+) ') do
    local base = self:find_id(s)
    local bname = self:type_name(base)
    metatable_constructor = metatable_constructor .. [[
    lua_pushboolean(L, 1);
    lua_setfield(L, -2, "]]..bname..[[*");
]]
                deep_bases = self.set_union(deep_bases, self:tree_of_bases(base))
  end
  for n in pairs(deep_bases) do
    metatable_constructor = metatable_constructor .. [[
    lua_pushboolean(L, 0);
    lua_setfield(L, -2, "]]..n..[[*");
]]
  end
  metatable_constructor = metatable_constructor .. '    lua_setfield(L, -2, "__base");\n'


  print'finalizing code'
  metatable_constructor = metatable_constructor .. self.meta_constr_ending (tname)
  fulldef = fulldef .. metatable_constructor

  return fullproto, fulldef
end

function binder.set_union(...)
  local ret = {}
  for _, s in ipairs{...} do
    for v, t in pairs(s) do
      if t==true then ret[v] = true end
    end
  end
  return ret
end

function binder:tree_of_bases(c)
  local ret = {}
  for s in string.gmatch(c.attr.bases or '', '(_%d+) ') do
    local b = self:find_id(s)
    ret[b.attr.name] = true
    local bb = self:tree_of_bases(b)
    ret = self.set_union(ret, bb)
  end
  return ret
end


return binder