mirror of
https://github.com/idapython/src
synced 2026-06-08 14:47:00 +00:00
Arnaud Diederen
444 lines
16 KiB
Python
444 lines
16 KiB
Python
from __future__ import print_function
|
|
# TODO:
|
|
# * auto_queue_empty must return 1 by default. How should
|
|
# that be specified? In idp.hpp, or in a specific, 'recipe' file?
|
|
|
|
# WARNING: The code you are about to look into, is surprisingly messy and
|
|
# convoluted. Especially since it doesn't do that much. Perhaps a good
|
|
# refactoring is in order?
|
|
|
|
import six
|
|
|
|
from argparse import ArgumentParser
|
|
p = ArgumentParser()
|
|
|
|
p.add_argument("-i", "--input", required=True, dest="input", help="Input file")
|
|
p.add_argument("-o", "--output", required=True, dest="output", help="Output file")
|
|
p.add_argument("-x", "--xml", required=True, dest="xml", help="XML structure containing enumerations information")
|
|
p.add_argument("-c", "--hooks-class", required=True, dest="hooks_class", help="Name of the hooks class")
|
|
p.add_argument("-e", "--enum", required=True, dest="enum", help="Enumeration to look for")
|
|
p.add_argument("-m", "--marker", required=True, dest="marker", help="Marker to look for, to start generating callbacks")
|
|
p.add_argument("-r", "--default-rtype", required=True, dest="def_rtype", help="Default return type, for notifications that don't specify it")
|
|
p.add_argument("-n", "--default-rval", required=True, dest="def_rval", help="Default return value, for notifications that don't specify it")
|
|
p.add_argument("-q", "--qualifier", required=False, dest="qualifier", help="A possible qualifier, to put in front of enumerators", default="")
|
|
p.add_argument("-R", "--recipe", required=False, dest="recipe", help="Special information, needed to generate valid & compatible hooks")
|
|
p.add_argument("-d", "--discard-prefix",required=False, dest="discard_prefix",help="Discard all enum entries starting with the given prefix(es) (multiple prefixes can be specified as a comma-separated list.)")
|
|
p.add_argument("-D", "--discard-doc", required=False, dest="discard_doc", help="Typically for kernwin.hpp: ignore enum entries whose documentation starts with the specified pattern (e.g., 'ui:', which is for 'to UI' codes, and not 'from UI' codes)")
|
|
p.add_argument("-s", "--strip-prefix", required=False, dest="strip_prefix", help="Strip the given prefix from the enumerator name (e.g., 'ui_', for kernwin.hpp notifications)")
|
|
args = p.parse_args()
|
|
|
|
def warn(msg):
|
|
print("#### WARNING: %s" % msg)
|
|
|
|
if args.recipe:
|
|
exec(open(args.recipe).read())
|
|
else:
|
|
recipe = {}
|
|
|
|
from xml.dom import *
|
|
import xml.etree.ElementTree as ET
|
|
tree = ET.parse(args.xml)
|
|
|
|
# Find enum def
|
|
enum_el = tree.find(".//memberdef[@kind='enum']/[name='%s']" % args.enum)
|
|
|
|
|
|
def parse_return_type(desc):
|
|
default = None
|
|
import re
|
|
m = re.match(r".*\(default=([^\)]*)\).*", desc)
|
|
if m:
|
|
default = m.group(1)
|
|
if desc.startswith("void"):
|
|
return "void", default
|
|
else:
|
|
return parse_param_type(desc), default
|
|
|
|
def parse_param_type(desc):
|
|
if desc.startswith("("):
|
|
import re
|
|
m = re.match(r"\(([^\)]*)\)\s*.*", desc)
|
|
if m:
|
|
ptype = m.group(1)
|
|
return ptype.lstrip(":").replace(" ::", " ")
|
|
|
|
def collect_all_text(el):
|
|
bits = []
|
|
for txt in el.itertext():
|
|
bits.append(txt)
|
|
return "".join(bits)
|
|
|
|
enumerators = []
|
|
def add_enum_value(enumval_el, name, enum_name):
|
|
if not name.startswith("OBSOLETE"):
|
|
params = []
|
|
|
|
# Return type
|
|
ret_el = enumval_el.find(".//simplesect[@kind='return']")
|
|
rdata = {"name" : "<return>"}
|
|
rtype = None
|
|
rdefault = None
|
|
rexpr = None
|
|
recipe_data = recipe.get(name, {})
|
|
|
|
if "ignore" in recipe_data and recipe_data["ignore"]:
|
|
return
|
|
|
|
return_data = recipe_data["return"] if (recipe_data and "return" in recipe_data) else {}
|
|
if "type" in return_data:
|
|
rtype = return_data["type"]
|
|
elif ret_el is not None:
|
|
rdesc = ret_el.find("para").text
|
|
rtype, rdefault = parse_return_type(rdesc)
|
|
|
|
if rtype is None:
|
|
rtype = args.def_rtype
|
|
|
|
if rtype != "void" and rdefault is None:
|
|
rdefault = args.def_rval
|
|
assert(rdefault is not None)
|
|
|
|
if "default" in return_data:
|
|
rdefault = return_data["default"]
|
|
if "retexpr" in return_data:
|
|
rexpr = return_data["retexpr"]
|
|
|
|
params.append({
|
|
"name" : "<return>",
|
|
"type" : rtype,
|
|
"default" : rdefault,
|
|
"retexpr" : rexpr,
|
|
})
|
|
|
|
# Parameters
|
|
plist_el = enumval_el.find(".//parameterlist")
|
|
if plist_el is not None:
|
|
for pitem_el in plist_el.findall("./parameteritem"):
|
|
pname = pitem_el.find(".//parametername").text
|
|
if pname != "none" and pname != "...":
|
|
pdesc = collect_all_text(pitem_el.find(".//parameterdescription/para"))
|
|
ptype = parse_param_type(pdesc)
|
|
if ptype is None:
|
|
warn("Couldn't parse parameter description: \"%s\". Dropping notification \"%s\" altogether" % (pdesc, name))
|
|
return
|
|
params.append({
|
|
"name" : pname,
|
|
"type" : ptype,
|
|
})
|
|
|
|
# added parameters
|
|
if "add_params" in recipe_data:
|
|
params.extend(recipe_data["add_params"])
|
|
|
|
enumerators.append({"name" : name, "params" : params, "enum_name" : enum_name})
|
|
|
|
|
|
# for each enum value...
|
|
for enumval_el in enum_el.findall("./enumvalue"):
|
|
discarded = False
|
|
enum_name = enumval_el.find("./name").text
|
|
name = enum_name
|
|
if args.discard_prefix:
|
|
for pfx in args.discard_prefix.split(","):
|
|
if name.startswith(pfx):
|
|
discarded = True
|
|
break
|
|
if not discarded and args.discard_doc:
|
|
discarded = collect_all_text(enumval_el.find("./detaileddescription")).strip().startswith(args.discard_doc) or \
|
|
collect_all_text(enumval_el.find("./briefdescription")).strip().startswith(args.discard_doc)
|
|
if not discarded:
|
|
if args.strip_prefix:
|
|
pfxes = args.strip_prefix.split(",")
|
|
for pfx in pfxes:
|
|
if name.startswith(pfx):
|
|
name = name[len(pfx):]
|
|
break
|
|
add_enum_value(enumval_el, name, enum_name)
|
|
|
|
|
|
def dump():
|
|
for enumerator in enumerators:
|
|
print("%s:" % enumerator["name"])
|
|
rdata = enumerator["params"][0]
|
|
print("\t%s: %s (default=%s)" % (
|
|
rdata["name"], rdata["type"], rdata["default"]))
|
|
for p in enumerator["params"][1:]:
|
|
print("\t%s: %s" % (p["name"], p["type"]))
|
|
|
|
#dump()
|
|
|
|
def gen_methods(out):
|
|
for e in enumerators:
|
|
ename = e["name"]
|
|
if ename in recipe:
|
|
recipe_data = recipe[ename]
|
|
else:
|
|
recipe_data = {}
|
|
|
|
method_name = recipe_data["method_name"] if "method_name" in recipe_data else ename
|
|
|
|
params = e["params"]
|
|
rdata = params[0]
|
|
# We *must* name arguments, or typemaps won't be applied properly.
|
|
# Thus, we must 'qnotused'-them.
|
|
qnotused_decls = ""
|
|
if rdata["type"] == "void":
|
|
retbody = ""
|
|
elif rdata["retexpr"]:
|
|
retbody = "%s;" % rdata["retexpr"]
|
|
else:
|
|
retbody = "return %s;" % rdata["default"]
|
|
arg_strs = []
|
|
for p in (recipe_data["call_params"] if "call_params" in recipe_data else params[1:]):
|
|
if isinstance(p, six.string_types):
|
|
assert(p[0] == "@")
|
|
synth_info = recipe["synthetic_params"][p]
|
|
ptype = synth_info["type"]
|
|
pname = p[1:]
|
|
else:
|
|
pname = p["name"]
|
|
ptype = p["type"]
|
|
suppress_for_call = False
|
|
final_name = pname
|
|
defstr = ""
|
|
if "params" in recipe_data:
|
|
all_pdata = recipe_data["params"]
|
|
if pname in all_pdata:
|
|
pdata = all_pdata[pname]
|
|
if "type" in pdata:
|
|
ptype = pdata["type"]
|
|
if "suppress_for_call" in pdata:
|
|
suppress_for_call = pdata["suppress_for_call"]
|
|
if "rename" in pdata:
|
|
final_name = pdata["rename"]
|
|
if "default" in pdata:
|
|
defstr = "=%s" % pdata["default"]
|
|
if not suppress_for_call:
|
|
arg_strs.append("%s %s%s" % (ptype, final_name, defstr))
|
|
qnotused_decls += "qnotused(%s); " % final_name
|
|
text = "virtual %s %s(%s) {%s%s}\n" % (
|
|
rdata["type"],
|
|
method_name,
|
|
", ".join(arg_strs),
|
|
qnotused_decls,
|
|
retbody)
|
|
out.write(text)
|
|
|
|
def gen_notifications(out):
|
|
for e in enumerators:
|
|
ename = e["name"]
|
|
out.write("case %s%s:\n" % (args.qualifier, e["enum_name"]))
|
|
out.write("{\n")
|
|
params = e["params"]
|
|
rdata = params[0]
|
|
|
|
if ename in recipe:
|
|
recipe_data = recipe[ename]
|
|
else:
|
|
recipe_data = {}
|
|
method_name = recipe_data["method_name"] if "method_name" in recipe_data else ename
|
|
|
|
# first, the arguments to pop from the stack
|
|
nosynth_params = []
|
|
for p in params[1:]:
|
|
pname = p["name"]
|
|
pname = recipe_data.get("params", {}).get(pname, {}).get("rename", pname)
|
|
ptype = p["type"]
|
|
pick_type = ptype
|
|
if ptype in ["bool", "char", "uchar", "uint16", "cref_t",
|
|
"dref_t", "cm_t", "ui_notification_t", "dbg_notification_t",
|
|
"tcc_renderer_type_t", "range_kind_t", "demreq_type_t",
|
|
"ctree_maturity_t", "comp_t"]:
|
|
cast = ptype
|
|
pick_type = "int"
|
|
else:
|
|
cast = ""
|
|
out.write(" %s %s = %s%sva_arg(va, %s)%s;\n" % (
|
|
ptype,
|
|
pname,
|
|
cast,
|
|
"(" if cast else "",
|
|
pick_type,
|
|
")" if cast else ""));
|
|
nosynth_params.append(pname)
|
|
|
|
# then, let's do a second pass, this time over the arguments that need
|
|
# to be actually passed to the method (can differ; e.g., dbg.hpp
|
|
# notifications' "event" is typically scattered into N args)
|
|
|
|
argstr = [] # arguments to pass to the call, minus those explicitly suppressed
|
|
argstr_all = [] # all arguments
|
|
for p in (recipe_data["call_params"] if "call_params" in recipe_data else params[1:]):
|
|
if isinstance(p, six.string_types):
|
|
assert(p[0] == "@")
|
|
synth_info = recipe["synthetic_params"][p]
|
|
ptype = synth_info["type"]
|
|
synth = synth_info["synth"]
|
|
pname = p[1:]
|
|
else:
|
|
pname = p["name"]
|
|
ptype = p["type"]
|
|
synth = None
|
|
param_convertor = None
|
|
suppress_for_call = False
|
|
qnotused = False
|
|
clinked = None
|
|
cast_needed = False
|
|
deref = None
|
|
|
|
if "params" in recipe_data:
|
|
all_pdata = recipe_data["params"]
|
|
if pname in all_pdata:
|
|
pdata = all_pdata[pname]
|
|
if "rename" in pdata:
|
|
pname = pdata["rename"]
|
|
if "convertor" in pdata:
|
|
param_convertor = pdata["convertor"]
|
|
if "deref" in pdata:
|
|
deref = pdata["deref"]
|
|
if "suppress_for_call" in pdata:
|
|
suppress_for_call = pdata["suppress_for_call"]
|
|
if "qnotused" in pdata:
|
|
qnotused = pdata["qnotused"]
|
|
if "clinked" in pdata:
|
|
clinked = pdata["clinked"]
|
|
if "cast_needed" in pdata:
|
|
cast_needed = pdata["cast_needed"]
|
|
|
|
pass_expr = pname
|
|
if deref:
|
|
pass_expr = "%s != NULL ? *(%s) : (%s)" % (
|
|
pname,
|
|
pname,
|
|
deref["ifNULL"])
|
|
if clinked:
|
|
out.write(" ref_t clinked_%s = create_linked_class_instance(%s, %s, %s);\n" %
|
|
(pname, clinked["module_define"], clinked["class_define"], pname))
|
|
out.write(" if ( clinked_%s == NULL )\n" % pname)
|
|
out.write(" break;\n")
|
|
pass_expr = "clinked_%s.o" % pname
|
|
elif synth:
|
|
pass_expr = synth
|
|
elif cast_needed:
|
|
pass_expr = "(%s) %s" % (cast_needed, pname)
|
|
|
|
if not suppress_for_call:
|
|
if param_convertor:
|
|
argstr.append("%s(%s)" % (param_convertor, pass_expr))
|
|
else:
|
|
argstr.append("%s" % (pass_expr))
|
|
if qnotused:
|
|
out.write(" qnotused(%s);\n" % pname)
|
|
argstr_all.append(pname)
|
|
|
|
ret_convertor = None
|
|
ret_convertor_pass_args = False
|
|
ret_convertor_pass_args_nosynth = False
|
|
if "return" in recipe_data:
|
|
retdata = recipe_data["return"]
|
|
if "convertor" in retdata:
|
|
ret_convertor = retdata["convertor"]
|
|
if "convertor_pass_args" in retdata:
|
|
ret_convertor_pass_args = retdata["convertor_pass_args"]
|
|
if "convertor_pass_args_nosynth" in retdata:
|
|
ret_convertor_pass_args_nosynth = retdata["convertor_pass_args_nosynth"]
|
|
|
|
if ret_convertor:
|
|
out.write(" %s _tmp = %s(%s);\n" % (
|
|
retdata["type"],
|
|
ename,
|
|
", ".join(argstr)))
|
|
cvtargs = ["_tmp"]
|
|
if ret_convertor_pass_args:
|
|
if ret_convertor_pass_args_nosynth:
|
|
cvtargs.extend(nosynth_params)
|
|
else:
|
|
cvtargs.extend(argstr_all)
|
|
out.write(" ret = %s(%s);\n" % (ret_convertor, ", ".join(cvtargs)))
|
|
else:
|
|
if rdata["type"] == "void":
|
|
rstr = ""
|
|
else:
|
|
rstr = "ret = "
|
|
out.write(" %s%s(%s);\n" % (
|
|
rstr,
|
|
method_name,
|
|
", ".join(argstr)))
|
|
|
|
out.write("}\n")
|
|
out.write("break;\n\n")
|
|
|
|
|
|
def gen_methodsinfo_decl(out):
|
|
out.write(" static const event_code_to_method_name_t mappings[%d];\n" % len(enumerators))
|
|
out.write(" static const size_t mappings_size;\n")
|
|
|
|
def gen_methodsinfo_def(out):
|
|
out.write("""
|
|
const hooks_base_t::event_code_to_method_name_t %s::mappings[%d] =
|
|
{
|
|
""" % (args.hooks_class, len(enumerators)))
|
|
for e in enumerators:
|
|
ename = e["name"]
|
|
recipe_data = recipe.get(ename, {})
|
|
method_name = recipe_data.get("method_name", ename)
|
|
out.write("{ int(%s%s), \"%s\" },\n" % (args.qualifier, e["enum_name"], method_name))
|
|
|
|
out.write("""
|
|
};
|
|
const size_t %s::mappings_size = %d;
|
|
""" % (args.hooks_class, len(enumerators)))
|
|
|
|
def gen_safecall(out, class_name):
|
|
out.write("""
|
|
// This hook gets called from the kernel. Ensure we hold the GIL.
|
|
PYW_GIL_GET;
|
|
%s *proxy = (%s *) ud;
|
|
ssize_t ret = 0;
|
|
try
|
|
{
|
|
if ( !proxy->has_fixed_method_set() || proxy->has_nondef[int(code)] > 0 )
|
|
{
|
|
if ( proxy->call_requires_new_execution() )
|
|
{
|
|
new_execution_t exec;
|
|
ret = proxy->dispatch(code, va);
|
|
}
|
|
else
|
|
{
|
|
ret = proxy->dispatch(code, va);
|
|
}
|
|
}
|
|
}
|
|
catch ( Swig::DirectorException &e )
|
|
{
|
|
msg("Exception in %%s dispatcher function: %%s\\n", proxy->class_name, e.getMessage());
|
|
PYW_GIL_CHECK_LOCKED_SCOPE();
|
|
if ( PyErr_Occurred() )
|
|
PyErr_Print();
|
|
}
|
|
return ret;
|
|
""" % (class_name, class_name))
|
|
|
|
|
|
with open(args.input) as fin:
|
|
with open(args.output, "w") as fout:
|
|
for line in fin:
|
|
fout.write(line)
|
|
import re
|
|
m = re.match(r".*%s:([^\s]*).*" % args.marker, line)
|
|
if m:
|
|
what = m.group(1)
|
|
if what == "methods":
|
|
gen_methods(fout)
|
|
elif what == "notifications":
|
|
gen_notifications(fout)
|
|
elif what == "methodsinfo_decl":
|
|
gen_methodsinfo_decl(fout)
|
|
elif what == "methodsinfo_def":
|
|
gen_methodsinfo_def(fout)
|
|
elif what.startswith("safecall="):
|
|
gen_safecall(fout, what[9:])
|
|
else:
|
|
raise Exception("Unknown marker type: %s" % what)
|