501 lines
17 KiB
Python
501 lines
17 KiB
Python
|
#-------------------------------------------------------------------------------
|
||
|
|
# gen_odin.py
|
||
|
|
#
|
||
|
|
# Generate Odin bindings.
|
||
|
|
#-------------------------------------------------------------------------------
|
||
|
|
import gen_ir
|
||
|
|
import gen_util as util
|
||
|
|
import os, shutil, sys
|
||
|
|
|
||
|
|
bindings_root = 'sokol-odin'
|
||
|
|
c_root = f'{bindings_root}/c'
|
||
|
|
module_root = f'{bindings_root}/sokol'
|
||
|
|
|
||
|
|
module_names = {
|
||
|
|
'slog_': 'log',
|
||
|
|
'sg_': 'gfx',
|
||
|
|
'sapp_': 'app',
|
||
|
|
'stm_': 'time',
|
||
|
|
'saudio_': 'audio',
|
||
|
|
'sgl_': 'gl',
|
||
|
|
'sdtx_': 'debugtext',
|
||
|
|
'sshape_': 'shape',
|
||
|
|
'sglue_': 'glue',
|
||
|
|
}
|
||
|
|
|
||
|
|
system_libs = {
|
||
|
|
'sg_': {
|
||
|
|
'windows': {
|
||
|
|
'd3d11': "",
|
||
|
|
'gl': "",
|
||
|
|
},
|
||
|
|
'macos': {
|
||
|
|
'metal': '"system:Cocoa.framework","system:QuartzCore.framework","system:Metal.framework","system:MetalKit.framework"',
|
||
|
|
'gl': '"system:Cocoa.framework","system:QuartzCore.framework","system:OpenGL.framework"'
|
||
|
|
},
|
||
|
|
'linux': {
|
||
|
|
'gl': '"system:GL", "system:dl", "system:pthread"'
|
||
|
|
}
|
||
|
|
},
|
||
|
|
'sapp_': {
|
||
|
|
'windows': {
|
||
|
|
'd3d11': '',
|
||
|
|
'gl': '',
|
||
|
|
},
|
||
|
|
'macos': {
|
||
|
|
'metal': '"system:Cocoa.framework","system:QuartzCore.framework","system:Metal.framework","system:MetalKit.framework"',
|
||
|
|
'gl': '"system:Cocoa.framework","system:QuartzCore.framework","system:OpenGL.framework"',
|
||
|
|
},
|
||
|
|
'linux': {
|
||
|
|
'gl': '"system:X11", "system:Xi", "system:Xcursor", "system:GL", "system:dl", "system:pthread"'
|
||
|
|
}
|
||
|
|
},
|
||
|
|
'saudio_': {
|
||
|
|
'windows': {
|
||
|
|
'd3d11': '',
|
||
|
|
'gl': '',
|
||
|
|
},
|
||
|
|
'macos': {
|
||
|
|
'metal': '"system:AudioToolbox.framework"',
|
||
|
|
'gl': '"system:AudioToolbox.framework"',
|
||
|
|
},
|
||
|
|
'linux': {
|
||
|
|
'gl': '"system:asound", "system:dl", "system:pthread"',
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
c_source_names = {
|
||
|
|
'slog_': 'sokol_log.c',
|
||
|
|
'sg_': 'sokol_gfx.c',
|
||
|
|
'sapp_': 'sokol_app.c',
|
||
|
|
'sapp_sg': 'sokol_glue.c',
|
||
|
|
'stm_': 'sokol_time.c',
|
||
|
|
'saudio_': 'sokol_audio.c',
|
||
|
|
'sgl_': 'sokol_gl.c',
|
||
|
|
'sdtx_': 'sokol_debugtext.c',
|
||
|
|
'sshape_': 'sokol_shape.c',
|
||
|
|
'sglue_': 'sokol_glue.c',
|
||
|
|
}
|
||
|
|
|
||
|
|
ignores = [
|
||
|
|
'sdtx_printf',
|
||
|
|
'sdtx_vprintf',
|
||
|
|
'sg_install_trace_hooks',
|
||
|
|
'sg_trace_hooks',
|
||
|
|
]
|
||
|
|
|
||
|
|
# NOTE: syntax for function results: "func_name.RESULT"
|
||
|
|
overrides = {
|
||
|
|
'context': 'ctx', # reserved keyword
|
||
|
|
'SGL_NO_ERROR': 'SGL_ERROR_NO_ERROR',
|
||
|
|
}
|
||
|
|
|
||
|
|
prim_types = {
|
||
|
|
'int': 'c.int',
|
||
|
|
'bool': 'bool',
|
||
|
|
'char': 'u8',
|
||
|
|
'int8_t': 'i8',
|
||
|
|
'uint8_t': 'u8',
|
||
|
|
'int16_t': 'i16',
|
||
|
|
'uint16_t': 'u16',
|
||
|
|
'int32_t': 'i32',
|
||
|
|
'uint32_t': 'u32',
|
||
|
|
'int64_t': 'i64',
|
||
|
|
'uint64_t': 'u64',
|
||
|
|
'float': 'f32',
|
||
|
|
'double': 'f64',
|
||
|
|
'uintptr_t': 'u64',
|
||
|
|
'intptr_t': 'i64',
|
||
|
|
'size_t': 'u64'
|
||
|
|
}
|
||
|
|
|
||
|
|
prim_defaults = {
|
||
|
|
'int': '0',
|
||
|
|
'bool': 'false',
|
||
|
|
'int8_t': '0',
|
||
|
|
'uint8_t': '0',
|
||
|
|
'int16_t': '0',
|
||
|
|
'uint16_t': '0',
|
||
|
|
'int32_t': '0',
|
||
|
|
'uint32_t': '0',
|
||
|
|
'int64_t': '0',
|
||
|
|
'uint64_t': '0',
|
||
|
|
'float': '0.0',
|
||
|
|
'double': '0.0',
|
||
|
|
'uintptr_t': '0',
|
||
|
|
'intptr_t': '0',
|
||
|
|
'size_t': '0'
|
||
|
|
}
|
||
|
|
|
||
|
|
struct_types = []
|
||
|
|
enum_types = []
|
||
|
|
enum_items = {}
|
||
|
|
out_lines = ''
|
||
|
|
|
||
|
|
def reset_globals():
|
||
|
|
global struct_types
|
||
|
|
global enum_types
|
||
|
|
global enum_items
|
||
|
|
global out_lines
|
||
|
|
struct_types = []
|
||
|
|
enum_types = []
|
||
|
|
enum_items = {}
|
||
|
|
out_lines = ''
|
||
|
|
|
||
|
|
def l(s):
|
||
|
|
global out_lines
|
||
|
|
out_lines += s + '\n'
|
||
|
|
|
||
|
|
def check_override(name, default=None):
|
||
|
|
if name in overrides:
|
||
|
|
return overrides[name]
|
||
|
|
elif default is None:
|
||
|
|
return name
|
||
|
|
else:
|
||
|
|
return default
|
||
|
|
|
||
|
|
def check_ignore(name):
|
||
|
|
return name in ignores
|
||
|
|
|
||
|
|
# PREFIX_BLA_BLUB to BLA_BLUB, prefix_bla_blub to bla_blub
|
||
|
|
def as_snake_case(s, prefix):
|
||
|
|
outp = s
|
||
|
|
if outp.lower().startswith(prefix):
|
||
|
|
outp = outp[len(prefix):]
|
||
|
|
return outp
|
||
|
|
|
||
|
|
def get_odin_module_path(c_prefix):
|
||
|
|
return f'{module_root}/{module_names[c_prefix]}'
|
||
|
|
|
||
|
|
def get_csource_path(c_prefix):
|
||
|
|
return f'{c_root}/{c_source_names[c_prefix]}'
|
||
|
|
|
||
|
|
def make_odin_module_directory(c_prefix):
|
||
|
|
path = get_odin_module_path(c_prefix)
|
||
|
|
if not os.path.isdir(path):
|
||
|
|
os.makedirs(path)
|
||
|
|
|
||
|
|
def as_prim_type(s):
|
||
|
|
return prim_types[s]
|
||
|
|
|
||
|
|
# prefix_bla_blub(_t) => (dep.)Bla_Blub
|
||
|
|
def as_struct_or_enum_type(s, prefix):
|
||
|
|
parts = s.lower().split('_')
|
||
|
|
outp = '' if s.startswith(prefix) else f'{parts[0]}.'
|
||
|
|
for part in parts[1:]:
|
||
|
|
# ignore '_t' type postfix
|
||
|
|
if (part != 't'):
|
||
|
|
outp += part.capitalize()
|
||
|
|
outp += '_'
|
||
|
|
outp = outp[:-1]
|
||
|
|
return outp
|
||
|
|
|
||
|
|
# PREFIX_ENUM_BLA_BLUB => BLA_BLUB, _PREFIX_ENUM_BLA_BLUB => BLA_BLUB
|
||
|
|
def as_enum_item_name(s):
|
||
|
|
outp = s.lstrip('_')
|
||
|
|
parts = outp.split('_')[2:]
|
||
|
|
outp = '_'.join(parts)
|
||
|
|
if outp[0].isdigit():
|
||
|
|
outp = '_' + outp
|
||
|
|
return outp
|
||
|
|
|
||
|
|
def enum_default_item(enum_name):
|
||
|
|
return enum_items[enum_name][0]
|
||
|
|
|
||
|
|
def is_prim_type(s):
|
||
|
|
return s in prim_types
|
||
|
|
|
||
|
|
def is_int_type(s):
|
||
|
|
return s == "int"
|
||
|
|
|
||
|
|
def is_struct_type(s):
|
||
|
|
return s in struct_types
|
||
|
|
|
||
|
|
def is_enum_type(s):
|
||
|
|
return s in enum_types
|
||
|
|
|
||
|
|
def is_const_prim_ptr(s):
|
||
|
|
for prim_type in prim_types:
|
||
|
|
if s == f"const {prim_type} *":
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def is_prim_ptr(s):
|
||
|
|
for prim_type in prim_types:
|
||
|
|
if s == f"{prim_type} *":
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def is_const_struct_ptr(s):
|
||
|
|
for struct_type in struct_types:
|
||
|
|
if s == f"const {struct_type} *":
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def type_default_value(s):
|
||
|
|
return prim_defaults[s]
|
||
|
|
|
||
|
|
def map_type(type, prefix, sub_type):
|
||
|
|
if sub_type not in ['c_arg', 'odin_arg', 'struct_field']:
|
||
|
|
sys.exit(f"Error: map_type(): unknown sub_type '{sub_type}")
|
||
|
|
if type == "void":
|
||
|
|
return ""
|
||
|
|
elif is_prim_type(type):
|
||
|
|
if sub_type == 'odin_arg':
|
||
|
|
# for Odin args, maps C int (32-bit) to Odin int (pointer-sized),
|
||
|
|
# and the C bool type to Odin's bool type
|
||
|
|
if type == 'int' or type == 'uint32_t':
|
||
|
|
return 'int'
|
||
|
|
elif type == 'bool':
|
||
|
|
return 'bool'
|
||
|
|
return as_prim_type(type)
|
||
|
|
elif is_struct_type(type):
|
||
|
|
return as_struct_or_enum_type(type, prefix)
|
||
|
|
elif is_enum_type(type):
|
||
|
|
return as_struct_or_enum_type(type, prefix)
|
||
|
|
elif util.is_void_ptr(type):
|
||
|
|
return "rawptr"
|
||
|
|
elif util.is_const_void_ptr(type):
|
||
|
|
return "rawptr"
|
||
|
|
elif util.is_string_ptr(type):
|
||
|
|
return "cstring"
|
||
|
|
elif is_const_struct_ptr(type):
|
||
|
|
# pass Odin struct args by value, not by pointer
|
||
|
|
if sub_type == 'odin_arg':
|
||
|
|
return f"{as_struct_or_enum_type(util.extract_ptr_type(type), prefix)}"
|
||
|
|
else:
|
||
|
|
return f"^{as_struct_or_enum_type(util.extract_ptr_type(type), prefix)}"
|
||
|
|
elif is_prim_ptr(type):
|
||
|
|
return f"^{as_prim_type(util.extract_ptr_type(type))}"
|
||
|
|
elif is_const_prim_ptr(type):
|
||
|
|
return f"^{as_prim_type(util.extract_ptr_type(type))}"
|
||
|
|
elif util.is_1d_array_type(type):
|
||
|
|
array_type = util.extract_array_type(type)
|
||
|
|
array_sizes = util.extract_array_sizes(type)
|
||
|
|
return f"[{array_sizes[0]}]{map_type(array_type, prefix, sub_type)}"
|
||
|
|
elif util.is_2d_array_type(type):
|
||
|
|
array_type = util.extract_array_type(type)
|
||
|
|
array_sizes = util.extract_array_sizes(type)
|
||
|
|
return f"[{array_sizes[0]}][{array_sizes[1]}]{map_type(array_type, prefix, sub_type)}"
|
||
|
|
elif util.is_func_ptr(type):
|
||
|
|
res_type = funcptr_result_c(type, prefix)
|
||
|
|
res_str = '' if res_type == '' else f' -> {res_type}'
|
||
|
|
return f'proc "c" ({funcptr_args_c(type, prefix)}){res_str}'
|
||
|
|
else:
|
||
|
|
sys.exit(f"Error map_type(): unknown type '{type}'")
|
||
|
|
|
||
|
|
def funcdecl_args_c(decl, prefix):
|
||
|
|
s = ''
|
||
|
|
func_name = decl['name']
|
||
|
|
for param_decl in decl['params']:
|
||
|
|
if s != '':
|
||
|
|
s += ', '
|
||
|
|
param_name = param_decl['name']
|
||
|
|
param_type = check_override(f'{func_name}.{param_name}', default=param_decl['type'])
|
||
|
|
if is_const_struct_ptr(param_type):
|
||
|
|
s += f"#by_ptr {param_name}: {map_type(param_type, prefix, 'odin_arg')}"
|
||
|
|
elif is_int_type(param_type):
|
||
|
|
s += f"#any_int {param_name}: {map_type(param_type, prefix, 'c_arg')}"
|
||
|
|
else:
|
||
|
|
s += f"{param_name}: {map_type(param_type, prefix, 'c_arg')}"
|
||
|
|
return s
|
||
|
|
|
||
|
|
def funcptr_args_c(field_type, prefix):
|
||
|
|
tokens = field_type[field_type.index('(*)')+4:-1].split(',')
|
||
|
|
s = ''
|
||
|
|
arg_index = 0
|
||
|
|
for token in tokens:
|
||
|
|
arg_type = token.strip()
|
||
|
|
if s != '':
|
||
|
|
s += ', '
|
||
|
|
c_arg = map_type(arg_type, prefix, 'c_arg')
|
||
|
|
if c_arg == '':
|
||
|
|
return ''
|
||
|
|
else:
|
||
|
|
s += f'a{arg_index}: {c_arg}'
|
||
|
|
arg_index += 1
|
||
|
|
return s
|
||
|
|
|
||
|
|
def funcptr_result_c(field_type, prefix):
|
||
|
|
res_type = field_type[:field_type.index('(*)')].strip()
|
||
|
|
return map_type(res_type, prefix, 'c_arg')
|
||
|
|
|
||
|
|
def funcdecl_result_c(decl, prefix):
|
||
|
|
func_name = decl['name']
|
||
|
|
decl_type = decl['type']
|
||
|
|
res_c_type = decl_type[:decl_type.index('(')].strip()
|
||
|
|
return map_type(check_override(f'{func_name}.RESULT', default=res_c_type), prefix, 'c_arg')
|
||
|
|
|
||
|
|
def get_system_libs(module, platform, backend):
|
||
|
|
if module in system_libs:
|
||
|
|
if platform in system_libs[module]:
|
||
|
|
if backend in system_libs[module][platform]:
|
||
|
|
libs = system_libs[module][platform][backend]
|
||
|
|
if libs != '':
|
||
|
|
return f", {libs}"
|
||
|
|
return ''
|
||
|
|
|
||
|
|
def gen_c_imports(inp, c_prefix, prefix):
|
||
|
|
clib_prefix = f'sokol_{inp["module"]}'
|
||
|
|
clib_import = f'{clib_prefix}_clib'
|
||
|
|
windows_d3d11_libs = get_system_libs(prefix, 'windows', 'd3d11')
|
||
|
|
windows_gl_libs = get_system_libs(prefix, 'windows', 'gl')
|
||
|
|
macos_metal_libs = get_system_libs(prefix, 'macos', 'metal')
|
||
|
|
macos_gl_libs = get_system_libs(prefix, 'macos', 'gl')
|
||
|
|
linux_gl_libs = get_system_libs(prefix, 'linux', 'gl')
|
||
|
|
l( 'import "core:c"')
|
||
|
|
l( 'when ODIN_OS == .Windows {')
|
||
|
|
l( ' when #config(SOKOL_USE_GL,false) {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_windows_x64_gl_debug.lib"{windows_gl_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_windows_x64_gl_release.lib"{windows_gl_libs} }} }}')
|
||
|
|
l( ' } else {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_windows_x64_d3d11_debug.lib"{windows_d3d11_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_windows_x64_d3d11_release.lib"{windows_d3d11_libs} }} }}')
|
||
|
|
l( ' }')
|
||
|
|
l( '} else when ODIN_OS == .Darwin {')
|
||
|
|
l( ' when #config(SOKOL_USE_GL,false) {')
|
||
|
|
l( ' when ODIN_ARCH == .arm64 {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_macos_arm64_gl_debug.a"{macos_gl_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_macos_arm64_gl_release.a"{macos_gl_libs} }} }}')
|
||
|
|
l( ' } else {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_macos_x64_gl_debug.a"{macos_gl_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_macos_x64_gl_release.a"{macos_gl_libs} }} }}')
|
||
|
|
l( ' }')
|
||
|
|
l( ' } else {')
|
||
|
|
l( ' when ODIN_ARCH == .arm64 {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_macos_arm64_metal_debug.a"{macos_metal_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_macos_arm64_metal_release.a"{macos_metal_libs} }} }}')
|
||
|
|
l( ' } else {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_macos_x64_metal_debug.a"{macos_metal_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_macos_x64_metal_release.a"{macos_metal_libs} }} }}')
|
||
|
|
l( ' }')
|
||
|
|
l( ' }')
|
||
|
|
l( '}')
|
||
|
|
l( 'else {')
|
||
|
|
l(f' when ODIN_DEBUG == true {{ foreign import {clib_import} {{ "{clib_prefix}_linux_x64_gl_debug.a"{linux_gl_libs} }} }}')
|
||
|
|
l(f' else {{ foreign import {clib_import} {{ "{clib_prefix}_linux_x64_gl_release.a"{linux_gl_libs} }} }}')
|
||
|
|
l( '}')
|
||
|
|
|
||
|
|
# Need to special case sapp_sg to avoid Odin's context keyword
|
||
|
|
if c_prefix == "sapp_sg":
|
||
|
|
l(f'@(default_calling_convention="c")')
|
||
|
|
else:
|
||
|
|
l(f'@(default_calling_convention="c", link_prefix="{c_prefix}")')
|
||
|
|
l(f"foreign {clib_import} {{")
|
||
|
|
prefix = inp['prefix']
|
||
|
|
for decl in inp['decls']:
|
||
|
|
if decl['kind'] == 'func' and not decl['is_dep'] and not check_ignore(decl['name']):
|
||
|
|
args = funcdecl_args_c(decl, prefix)
|
||
|
|
res_type = funcdecl_result_c(decl, prefix)
|
||
|
|
res_str = '' if res_type == '' else f'-> {res_type}'
|
||
|
|
# Need to special case sapp_sg to avoid Odin's context keyword
|
||
|
|
if c_prefix == "sapp_sg":
|
||
|
|
l(f' @(link_name="{decl["name"]}")')
|
||
|
|
l(f" {check_override(as_snake_case(decl['name'], c_prefix))} :: proc({args}) {res_str} ---")
|
||
|
|
else:
|
||
|
|
l(f" {as_snake_case(decl['name'], c_prefix)} :: proc({args}) {res_str} ---")
|
||
|
|
l('}')
|
||
|
|
|
||
|
|
def gen_consts(decl, prefix):
|
||
|
|
for item in decl['items']:
|
||
|
|
item_name = check_override(item['name'])
|
||
|
|
l(f"{as_snake_case(item_name, prefix)} :: {item['value']}")
|
||
|
|
|
||
|
|
def gen_struct(decl, prefix):
|
||
|
|
c_struct_name = check_override(decl['name'])
|
||
|
|
struct_name = as_struct_or_enum_type(c_struct_name, prefix)
|
||
|
|
l(f'{struct_name} :: struct {{')
|
||
|
|
for field in decl['fields']:
|
||
|
|
field_name = check_override(field['name'])
|
||
|
|
field_type = map_type(check_override(f'{c_struct_name}.{field_name}', default=field['type']), prefix, 'struct_field')
|
||
|
|
# any field name starting with _ is considered private
|
||
|
|
if field_name.startswith('_'):
|
||
|
|
l(f' _ : {field_type},')
|
||
|
|
else:
|
||
|
|
l(f' {field_name} : {field_type},')
|
||
|
|
l('}')
|
||
|
|
|
||
|
|
def gen_enum(decl, prefix):
|
||
|
|
enum_name = check_override(decl['name'])
|
||
|
|
l(f'{as_struct_or_enum_type(enum_name, prefix)} :: enum i32 {{')
|
||
|
|
for item in decl['items']:
|
||
|
|
item_name = as_enum_item_name(check_override(item['name']))
|
||
|
|
if item_name != 'FORCE_U32':
|
||
|
|
if 'value' in item:
|
||
|
|
l(f" {item_name} = {item['value']},")
|
||
|
|
else:
|
||
|
|
l(f" {item_name},")
|
||
|
|
l('}')
|
||
|
|
|
||
|
|
def gen_imports(dep_prefixes):
|
||
|
|
for dep_prefix in dep_prefixes:
|
||
|
|
dep_module_name = module_names[dep_prefix]
|
||
|
|
l(f'import {dep_prefix[:-1]} "../{dep_module_name}"')
|
||
|
|
l('')
|
||
|
|
|
||
|
|
def gen_helpers(inp):
|
||
|
|
if inp['prefix'] == 'sdtx_':
|
||
|
|
l('import "core:fmt"')
|
||
|
|
l('import "core:strings"')
|
||
|
|
l('printf :: proc(s: string, args: ..any) {')
|
||
|
|
l(' fstr := fmt.tprintf(s, ..args)')
|
||
|
|
l(' putr(strings.unsafe_string_to_cstring(fstr), len(fstr))')
|
||
|
|
l('}')
|
||
|
|
|
||
|
|
def gen_module(inp, c_prefix, dep_prefixes):
|
||
|
|
pre_parse(inp)
|
||
|
|
l('// machine generated, do not edit')
|
||
|
|
l('')
|
||
|
|
l(f"package sokol_{inp['module']}")
|
||
|
|
gen_imports(dep_prefixes)
|
||
|
|
gen_helpers(inp)
|
||
|
|
prefix = inp['prefix']
|
||
|
|
gen_c_imports(inp, c_prefix, prefix)
|
||
|
|
for decl in inp['decls']:
|
||
|
|
if not decl['is_dep']:
|
||
|
|
kind = decl['kind']
|
||
|
|
if kind == 'consts':
|
||
|
|
gen_consts(decl, prefix)
|
||
|
|
elif not check_ignore(decl['name']):
|
||
|
|
if kind == 'struct':
|
||
|
|
gen_struct(decl, prefix)
|
||
|
|
elif kind == 'enum':
|
||
|
|
gen_enum(decl, prefix)
|
||
|
|
|
||
|
|
def pre_parse(inp):
|
||
|
|
global struct_types
|
||
|
|
global enum_types
|
||
|
|
for decl in inp['decls']:
|
||
|
|
kind = decl['kind']
|
||
|
|
if kind == 'struct':
|
||
|
|
struct_types.append(decl['name'])
|
||
|
|
elif kind == 'enum':
|
||
|
|
enum_name = decl['name']
|
||
|
|
enum_types.append(enum_name)
|
||
|
|
enum_items[enum_name] = []
|
||
|
|
for item in decl['items']:
|
||
|
|
enum_items[enum_name].append(as_enum_item_name(item['name']))
|
||
|
|
|
||
|
|
def prepare():
|
||
|
|
print('=== Generating Odin bindings:')
|
||
|
|
if not os.path.isdir(c_root):
|
||
|
|
os.makedirs(c_root)
|
||
|
|
if not os.path.isdir(module_root):
|
||
|
|
os.makedirs(module_root)
|
||
|
|
|
||
|
|
def gen(c_header_path, c_prefix, dep_c_prefixes):
|
||
|
|
if not c_prefix in module_names:
|
||
|
|
print(f' >> warning: skipping generation for {c_prefix} prefix...')
|
||
|
|
return
|
||
|
|
reset_globals()
|
||
|
|
make_odin_module_directory(c_prefix)
|
||
|
|
print(f' {c_header_path} => {module_names[c_prefix]}')
|
||
|
|
shutil.copyfile(c_header_path, f'{c_root}/{os.path.basename(c_header_path)}')
|
||
|
|
csource_path = get_csource_path(c_prefix)
|
||
|
|
module_name = module_names[c_prefix]
|
||
|
|
ir = gen_ir.gen(c_header_path, csource_path, module_name, c_prefix, dep_c_prefixes)
|
||
|
|
gen_module(ir, c_prefix, dep_c_prefixes)
|
||
|
|
with open(f"{module_root}/{ir['module']}/{ir['module']}.odin", 'w', newline='\n') as f_outp:
|
||
|
|
f_outp.write(out_lines)
|