194 lines
6.3 KiB
Python
194 lines
6.3 KiB
Python
#! /usr/bin/env python3
|
|
"""
|
|
Vendored from https://github.com/python/cpython/blob/3.8/Tools/scripts/h2py.py
|
|
|
|
Changes since vendored version:
|
|
- Minimal changes to satisfy our checkers.
|
|
- Rename `p_hex` to `p_signed_hex` and improve to include lowercase l
|
|
- Fixed `pytify` to remove leftover L after numbers and actually compute negative hexadecimal constants
|
|
- Added `p_int_cast` and `p_literal_constant`
|
|
|
|
---
|
|
|
|
Read #define's and translate to Python code.
|
|
Handle #include statements.
|
|
Handle #define macros with one argument.
|
|
Anything that isn't recognized or doesn't translate into valid
|
|
Python is ignored.
|
|
|
|
Without filename arguments, acts as a filter.
|
|
If one or more filenames are given, output is written to corresponding
|
|
filenames in the local directory, translated to all uppercase, with
|
|
the extension replaced by ".py".
|
|
|
|
By passing one or more options of the form "-i regular_expression"
|
|
you can specify additional strings to be ignored. This is useful
|
|
e.g. to ignore casts to u_long: simply specify "-i '(u_long)'".
|
|
"""
|
|
|
|
# XXX To do:
|
|
# - turn trailing C comments into Python comments
|
|
# - turn C Boolean operators "&& || !" into Python "and or not"
|
|
# - what to do about #if(def)?
|
|
# - what to do about macros with multiple parameters?
|
|
from __future__ import annotations
|
|
|
|
import ctypes
|
|
import getopt
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
p_define = re.compile(r"^[\t ]*#[\t ]*define[\t ]+([a-zA-Z0-9_]+)[\t ]+")
|
|
|
|
p_macro = re.compile(
|
|
r"^[\t ]*#[\t ]*define[\t ]+" r"([a-zA-Z0-9_]+)\(([_a-zA-Z][_a-zA-Z0-9]*)\)[\t ]+"
|
|
)
|
|
|
|
p_include = re.compile(r"^[\t ]*#[\t ]*include[\t ]+<([^>\n]+)>")
|
|
|
|
p_comment = re.compile(r"/\*([^*]+|\*+[^/])*(\*+/)?")
|
|
p_cpp_comment = re.compile("//.*")
|
|
# Maybe we want these to cause integer truncation instead?
|
|
p_int_cast = re.compile(r"\((DWORD|HRESULT|SCODE|LONG|HWND|HANDLE|int|HBITMAP)\)")
|
|
|
|
ignores = [p_comment, p_cpp_comment, p_int_cast]
|
|
|
|
p_char = re.compile(r"'(\\.[^\\]*|[^\\])'")
|
|
p_signed_hex = re.compile(r"0x([0-9a-fA-F]+)[lL]?")
|
|
p_literal_constant = re.compile(r"((0x[0-9a-fA-F]+?)|([0-9]+?))[uUlL]")
|
|
|
|
filedict: dict[str, None] = {}
|
|
importable: dict[str, str] = {}
|
|
|
|
try:
|
|
searchdirs = os.environ["include"].split(";")
|
|
except KeyError:
|
|
try:
|
|
searchdirs = os.environ["INCLUDE"].split(";")
|
|
except KeyError:
|
|
searchdirs = ["/usr/include"]
|
|
try:
|
|
searchdirs.insert(0, os.path.join("/usr/include", os.environ["MULTIARCH"]))
|
|
except KeyError:
|
|
pass
|
|
|
|
|
|
def main():
|
|
global filedict
|
|
opts, args = getopt.getopt(sys.argv[1:], "i:")
|
|
for o, a in opts:
|
|
if o == "-i":
|
|
ignores.append(re.compile(a))
|
|
if not args:
|
|
args = ["-"]
|
|
for filename in args:
|
|
if filename == "-":
|
|
sys.stdout.write("# Generated by h2py from stdin\n")
|
|
process(sys.stdin, sys.stdout)
|
|
else:
|
|
with open(filename) as fp:
|
|
outfile = os.path.basename(filename)
|
|
i = outfile.rfind(".")
|
|
if i > 0:
|
|
outfile = outfile[:i]
|
|
modname = outfile.upper()
|
|
outfile = modname + ".py"
|
|
with open(outfile, "w") as outfp:
|
|
outfp.write("# Generated by h2py from %s\n" % filename)
|
|
filedict = {}
|
|
for dir in searchdirs:
|
|
if filename[: len(dir)] == dir:
|
|
filedict[filename[len(dir) + 1 :]] = None # no '/' trailing
|
|
importable[filename[len(dir) + 1 :]] = modname
|
|
break
|
|
process(fp, outfp)
|
|
|
|
|
|
def pytify(body):
|
|
# replace ignored patterns by spaces
|
|
for p in ignores:
|
|
body = p.sub(" ", body)
|
|
# replace char literals by ord(...)
|
|
body = p_char.sub("ord('\\1')", body)
|
|
# Compute negative hexadecimal constants
|
|
start = 0
|
|
while 1:
|
|
m = p_signed_hex.search(body, start)
|
|
if not m:
|
|
break
|
|
s, e = m.span()
|
|
val = ctypes.c_int32(int(body[slice(*m.span(1))], 16)).value
|
|
if val < 0:
|
|
body = body[:s] + "(" + str(val) + ")" + body[e:]
|
|
start = s + 1
|
|
# remove literal constant indicator (u U l L)
|
|
body = p_literal_constant.sub("\\1", body)
|
|
return body
|
|
|
|
|
|
def process(fp, outfp, env={}):
|
|
lineno = 0
|
|
while 1:
|
|
line = fp.readline()
|
|
if not line:
|
|
break
|
|
lineno = lineno + 1
|
|
match = p_define.match(line)
|
|
if match:
|
|
# gobble up continuation lines
|
|
while line[-2:] == "\\\n":
|
|
nextline = fp.readline()
|
|
if not nextline:
|
|
break
|
|
lineno = lineno + 1
|
|
line = line + nextline
|
|
name = match.group(1)
|
|
body = line[match.end() :]
|
|
body = pytify(body)
|
|
ok = 0
|
|
stmt = "%s = %s\n" % (name, body.strip())
|
|
try:
|
|
exec(stmt, env)
|
|
except:
|
|
sys.stderr.write("Skipping: %s" % stmt)
|
|
else:
|
|
outfp.write(stmt)
|
|
match = p_macro.match(line)
|
|
if match:
|
|
macro, arg = match.group(1, 2)
|
|
body = line[match.end() :]
|
|
body = pytify(body)
|
|
stmt = "def %s(%s): return %s\n" % (macro, arg, body)
|
|
try:
|
|
exec(stmt, env)
|
|
except:
|
|
sys.stderr.write("Skipping: %s" % stmt)
|
|
else:
|
|
outfp.write(stmt)
|
|
match = p_include.match(line)
|
|
if match:
|
|
regs = match.regs
|
|
a, b = regs[1]
|
|
filename = line[a:b]
|
|
if filename in importable:
|
|
outfp.write("from %s import *\n" % importable[filename])
|
|
elif filename not in filedict:
|
|
filedict[filename] = None
|
|
inclfp = None
|
|
for dir in searchdirs:
|
|
try:
|
|
inclfp = open(dir + "/" + filename)
|
|
break
|
|
except IOError:
|
|
pass
|
|
if inclfp:
|
|
with inclfp:
|
|
outfp.write("\n# Included from %s\n" % filename)
|
|
process(inclfp, outfp, env)
|
|
else:
|
|
sys.stderr.write("Warning - could not find file %s\n" % filename)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|