local handle = self.handle

for _, j in ipairs {...} do

assert(handle:write(j))

end

return true, nil, nil

self:emit('STRUCT_STATIC struct Struct_', name, ' {\n')

local initializers = {}

local initializer_length = 0

for i = 2, #arguments do

local name = argument_names[i]

if not indexes[name] then

self:emit(' ', arguments[i], ';\n')

initializer_length = initializer_length + 1

initializers[initializer_length] = name

end

end

self:emit '};\n'

assert(#initializers > 0)

return initializers

local z = {''}

for i, j in ipairs(argument_names) do

if i ~= 1 then

z[i] = indexes[j] or 'args->'..j

end

end

return z

if not (find(ty, '^[%s_%w%b()%*]*$') and find(ty, '^[%s_%w%(%)%*]*$')) then

error(('String %q is not a valid C type'):format(ty))

end

check_metatable(self)

self.header_handle:write(prototype)

self.header_handle:write ';\n'

-- Emit trampoline code.

self:emit('static int trampoline_', name, '(lua_State *L) {\n')

if needs_struct then

self:emit(' struct Struct_', name, ' *args = CAST(struct Struct_', name,

' *, TLS);\n')

end

for i = #stack_in, 1, -1 do

self:emit(' lua_pushvalue(L, ', stack_in[i], ');\n')

if popped ~= 0 then

self:emit(' lua_insert(L, ', -i - popped, ');\n')

end

end

check_metatable(self)

local return_type, name, arguments, argument_names, argument_types =

parse_prototype.extract_args(prototype)

assert(#arguments > 0, 'No Lua API function takes no arguments')

-- Consistency checks on the arguments

self.check_type(return_type)

self.check_ident(name)

tonumber(popped)

tonumber(pushed)

-- Generate indexes table. Map from argument names to stack indexes.

local indexes = {}

for i, j in ipairs(stack_in) do

indexes[j] = i + popped

end

self:emit_lua_function_prototype(name, prototype)

local call_string = emit_arglist(argument_names, indexes)

-- C needs different handling of `void` than of other types. Boo.

local trampoline_type = return_type == 'void'

and ' VOID_TRAMPOLINE('

or ' TRAMPOLINE('

-- Initial newline

self:emit '\n'

do

-- C does not allow empty structs or initializers. Boo.

local needs_struct = #arguments > #stack_in + 1

local initializers = {}

if needs_struct then

-- At least one argument that is not a stack index.

-- Actually emit the struct and get the initializers.

initializers = self:emit_struct(name, arguments, argument_names,

indexes)

--needs_struct = #initializers ~= 0

end

-- local args = concat({name, argcount}, ', ')

emit_trampoline(self, name, needs_struct)

self:emit(trampoline_type, return_type, ', ', name, ', ', pushed, ', L',

concat(call_string, ', ') ,');\n}\n')

do

name_to_emit = name_to_emit or 'safe_'..name

end

-- Emit main function

local prototype = concat {

return_type, ' ', name_to_emit, '(int *success, ',

concat(arguments, ',') ,')' }

self:emit_binding_function_prototype(prototype)

self:emit(prototype, ' {\n')

if needs_struct then

self:emit([[

struct Struct_]], name, ' local = {', concat(initializers, ','), [[};

]])

end

end

handle_stack(self, stack_in, popped)

self:emit ' '

if return_type ~= 'void' then

self:emit 'uintptr_t succeeded = '

end

self:emit('protected_call(L, &trampoline_', name,' , success, ',

popped, ');\n')

if return_type ~= 'void' then

self:emit(' return CAST(', return_type,

', succeeded ? TLS : CAST(uintptr_t, 0));\n')

else

self:emit(' return;\n')

end

self:emit '}\n'

assert(self.handle and self.header_handle)

check_metatable(self)

for _, j in ipairs(table_) do

self:emit_wrapper(j.popped or 0, j.pushed or 0, j.stack_in, j.prototype, j.name)

end

assert(handle and header_handle)

return setmetatable({ handle = handle,

header_handle = header_handle }, metatable)

assert(type(prototype) == 'string')

return function(metadata)

self:emit_wrapper(metadata.popped,

metadata.pushed,

metadata.stack_in,

prototype,

metadata.name)

end