You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
9.2 KiB
Python
282 lines
9.2 KiB
Python
#!/usr/bin/env python3
|
|
import subprocess
|
|
import os
|
|
from typing import List, Tuple, Optional
|
|
|
|
import regex
|
|
|
|
INCLUDES = [
|
|
"extern/CrabNet/include/raknet",
|
|
"extern/tes3mp/apps/openmw-mp",
|
|
"extern/tes3mp"
|
|
]
|
|
|
|
|
|
def normalize_var(var: str):
|
|
normalized = ''.join([char if char.islower() else ('_' + char.lower()) for char in var]).lstrip('_') \
|
|
.replace('a_i', 'ai') \
|
|
.replace('s_h_a_2_5_6', 'sha256') \
|
|
.replace('i_p', 'ip')
|
|
|
|
if normalized == 'type':
|
|
return '_type'
|
|
|
|
return normalized
|
|
|
|
|
|
class CPPFunction:
|
|
def __init__(self, name: str, args: List[Tuple[str, str]], return_type: str, comment: Optional[str]):
|
|
self.name = name.strip()
|
|
self.args = args
|
|
self.return_type = return_type
|
|
self.comment = comment
|
|
|
|
def __str__(self):
|
|
args = ', '.join(map(str, self.args))
|
|
return f'{self.comment}\n<CPPFunction "{self.name}" ({args}) -> {self.return_type}>'
|
|
|
|
|
|
class CPPClass:
|
|
def __init__(self, name: str):
|
|
self.name = name
|
|
self.functions = dict()
|
|
|
|
def __str__(self):
|
|
funcs = '\n\t'.join(map(str, self.functions)).lstrip()
|
|
return f'<CPPClass "{self.name}" functions=[\n\t{funcs}\n]>'
|
|
|
|
|
|
class PrimitiveHeaderParser:
|
|
STATE_NONE = 0
|
|
STATE_FUNC_LIST = 1
|
|
|
|
RE_CLASS = regex.compile(r'^\s*class\s+(\w+)')
|
|
RE_START_COMMENT = regex.compile(r'\s*\/\*\*')
|
|
RE_END_COMMENT = regex.compile(r'.+\*\/')
|
|
RE_FUNCTION = regex.compile(r'^\s*static\s+((?:[a-zA-Z_\:\<\>\*\&0-9]+\s+[\*\&]?)+)([a-zA-Z0-9_]+)\(([^\)]+)?\)')
|
|
RE_ARG = regex.compile(r'^\s*([a-zA-Z_\:\<\>\s\*\&0-9\.]+?)(?:(\s[\.\*\&]*)([a-zA-Z0-9_]+))?$')
|
|
RE_FUNC_PAIR = regex.compile(r'{\s*"([A-Za-z0-9_\s]+)"\s*,\s*([A-Za-z0-9]+)\:\:([A-Za-z0-9]+)\s*}')
|
|
|
|
def __init__(self):
|
|
self.classes = dict()
|
|
self.current_class = None
|
|
self.current_comment = None
|
|
self.last_comment = None
|
|
self.line = -1
|
|
self.state = self.STATE_NONE
|
|
self.functions = dict()
|
|
self.current_line = ""
|
|
|
|
def parse_line(self, line: str):
|
|
self.line += 1
|
|
if line.rstrip().endswith(",") and self.current_comment is None:
|
|
self.current_line += " " + line.rstrip()
|
|
return
|
|
|
|
line = self.current_line + line
|
|
self.current_line = ""
|
|
|
|
last_comment = self.last_comment
|
|
self.last_comment = None
|
|
|
|
if self.state == self.STATE_FUNC_LIST:
|
|
self.parse_function_list(line)
|
|
return
|
|
|
|
new_class = self.RE_CLASS.match(line)
|
|
if new_class is not None:
|
|
self.current_class = CPPClass(new_class[1])
|
|
self.classes[self.current_class.name] = self.current_class
|
|
|
|
if self.current_comment is None:
|
|
new_comment = self.RE_START_COMMENT.match(line)
|
|
if new_comment is not None:
|
|
self.current_comment = new_comment[0]
|
|
else:
|
|
self.current_comment += "\n" + line
|
|
if self.RE_END_COMMENT.match(line) is not None:
|
|
self.last_comment = self.current_comment
|
|
self.current_comment = None
|
|
|
|
return
|
|
|
|
new_function = self.RE_FUNCTION.match(line)
|
|
if new_function is not None:
|
|
failed_func = False
|
|
args = []
|
|
if new_function[3] is not None:
|
|
for arg in new_function[3].split(','):
|
|
arg = arg.split('=')[0].strip()
|
|
|
|
if arg in ['void', '...']:
|
|
args.append(('', arg))
|
|
continue
|
|
|
|
argr = self.RE_ARG.match(arg)
|
|
if argr is None:
|
|
print(f"Can't parse: {arg}")
|
|
failed_func = True
|
|
break
|
|
else:
|
|
name = "" if argr[3] is None else argr[3]
|
|
type = "" if argr[1] is None else argr[1]
|
|
pointer = "" if argr[2] is None else argr[2]
|
|
|
|
args.append((name.strip(), type.strip() + pointer.strip()))
|
|
|
|
if not failed_func:
|
|
self.current_class.functions[new_function[2].strip()] = CPPFunction(new_function[2].strip(), args,
|
|
new_function[1].strip(),
|
|
last_comment)
|
|
|
|
if line.lstrip().startswith('static constexpr ScriptFunctionData functions'):
|
|
self.state = self.STATE_FUNC_LIST
|
|
|
|
def parse_function_list(self, line):
|
|
if line.strip().startswith('};'):
|
|
self.state = self.STATE_NONE
|
|
return
|
|
|
|
for item in regex.findall(self.RE_FUNC_PAIR, line):
|
|
self.functions[item[0]] = (item[1], item[2])
|
|
|
|
|
|
TYPE_TRANSLATION = {
|
|
'const char*': '*const i8',
|
|
'const char *': '*const i8',
|
|
'bool': 'bool',
|
|
'unsigned short': 'u16',
|
|
'ScriptFunc': 'fn()',
|
|
'int': 'i16',
|
|
'unsigned int': 'u16',
|
|
'unsigned char': 'u8',
|
|
'char': 'i8',
|
|
'float': 'f32',
|
|
'double': 'f64',
|
|
# No good way with these 2 types yet
|
|
'va_list': '<REMOVE>',
|
|
'boost::any': '<REMOVE>'
|
|
}
|
|
|
|
PREFIX = 'rust'
|
|
|
|
RE_COMMENT_PREFIX = regex.compile(r'^([\\/\*]*)(.*)')
|
|
RE_PARAM_PREFIX = regex.compile(r'\\param ([a-zA-Z_-]+)')
|
|
RE_BRIEF = regex.compile(r'\\brief\s+')
|
|
RE_RETURN = regex.compile(r'\s+[\\@]returns? ([a-zA-Z])')
|
|
|
|
|
|
def main():
|
|
os.chdir(os.path.dirname(__file__))
|
|
gcc_command = list(["gcc", "-C", "-E"])
|
|
|
|
for include in INCLUDES:
|
|
gcc_command.append('-I')
|
|
gcc_command.append(include)
|
|
|
|
gcc_command.append("extern/tes3mp/apps/openmw-mp/Script/ScriptFunctions.hpp")
|
|
|
|
parser = PrimitiveHeaderParser()
|
|
|
|
with subprocess.Popen(gcc_command, stdout=subprocess.PIPE) as p:
|
|
out, err = p.communicate()
|
|
for line in out.splitlines():
|
|
parser.parse_line(line.decode())
|
|
|
|
raw = f"#[no_mangle]\npub static mut prefix: [u8; {len(PREFIX)}] = *b\"{PREFIX}\";\n"
|
|
|
|
fancy = ""
|
|
|
|
for func_name in parser.functions:
|
|
ref = parser.functions[func_name]
|
|
func = parser.classes[ref[0]].functions[ref[1]]
|
|
|
|
args = ', '.join([TYPE_TRANSLATION[arg[1]] for arg in func.args])
|
|
ret = ""
|
|
|
|
if func.return_type in ['const char*', 'const char *']:
|
|
ret = " -> *const i8"
|
|
elif func.return_type != "void":
|
|
ret = f" -> {TYPE_TRANSLATION[func.return_type]}"
|
|
|
|
place_holder = "|" + ', '.join(['_'] * len(func.args)) + f'| {{ unreachable!("{func_name} was called before ' \
|
|
f'set by TES3MP"); }};'
|
|
|
|
func_def = f"#[no_mangle]\npub static mut {PREFIX}{func_name}: fn({args}){ret} = {place_holder}"
|
|
|
|
if '<REMOVE>' in func_def:
|
|
continue
|
|
|
|
raw += func_def + "\n"
|
|
|
|
fancy_name = normalize_var(func_name)
|
|
fancy_args = []
|
|
|
|
for arg in func.args:
|
|
fancy_arg = normalize_var(arg[0])
|
|
|
|
fancy_arg = fancy_arg.replace('__', '_')
|
|
|
|
if arg[1] in ['const char*', 'const char *']:
|
|
fancy_args.append((fancy_arg, '&str', f'CString::new({fancy_arg}).unwrap_or_default().as_ptr()'))
|
|
else:
|
|
fancy_args.append((fancy_arg, TYPE_TRANSLATION[arg[1]], fancy_arg))
|
|
|
|
ret = ""
|
|
if func.return_type in ['const char*', 'const char *']:
|
|
ret = " -> String"
|
|
elif func.return_type != "void":
|
|
ret = f" -> {TYPE_TRANSLATION[func.return_type]}"
|
|
|
|
func_args = ', '.join([f"{x[0]}: {x[1]}" for x in fancy_args])
|
|
call_args = ', '.join([x[2] for x in fancy_args])
|
|
|
|
if func.comment is not None:
|
|
comment = ""
|
|
for line in func.comment.strip().splitlines():
|
|
line = line.strip()
|
|
m = regex.match(RE_COMMENT_PREFIX, line)
|
|
comment += ("///" + (' ' * len(m[1])) + m[2]).rstrip() + "\n"
|
|
|
|
comment = regex.sub(RE_BRIEF, '', comment)
|
|
|
|
def replace_param(m):
|
|
return f"[`{normalize_var(m[1])}`]"
|
|
|
|
def replace_return(m):
|
|
return f"\n/// Returns {m[1].lower()}"
|
|
|
|
comment = regex.sub(RE_PARAM_PREFIX, replace_param, comment)
|
|
comment = regex.sub(RE_RETURN, replace_return, comment)
|
|
comment = comment.replace('"[Script]:"', '`[Script]:`')
|
|
|
|
fancy += comment
|
|
|
|
fancy += f"pub fn {fancy_name}({func_args}){ret} {{\n"
|
|
fancy += " unsafe {\n"
|
|
|
|
if func.return_type in ['const char*', 'const char *']:
|
|
fancy += f" CStr::from_ptr(raw::{PREFIX}{func_name}({call_args}))\n"
|
|
fancy += f" .to_str()\n"
|
|
fancy += f" .unwrap_or_default()\n"
|
|
fancy += f" .to_string()\n"
|
|
else:
|
|
fancy += f" raw::{PREFIX}{func_name}({call_args})\n"
|
|
|
|
fancy += " }\n"
|
|
fancy += "}\n\n"
|
|
|
|
whole = "use std::ffi::{CStr, CString};\n\n"
|
|
whole += "#[allow(non_upper_case_globals)]\npub mod raw {\n"
|
|
for line in raw.splitlines():
|
|
whole += " " + line + "\n"
|
|
whole += "}\n\n"
|
|
whole += fancy
|
|
|
|
with open("tes3mp-plugin/src/plugin/generated.rs", "w") as f:
|
|
f.write(whole)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|