self.classes = { "Mat" : ClassInfo([ 'class Mat', '', [], [] ], self.namespaces) }
self.module = ""
self.Module = ""
+ self.enum_types = []
self.ported_func_list = []
self.skipped_func_list = []
self.def_args_hist = {} # { def_args_cnt : funcs_cnt }
ci.addConst(constinfo)
logging.info('ok: %s', constinfo)
+ def add_enum(self, decl): # [ "enum cname", "", [], [] ]
+ enumname = decl[0].replace("enum ", "").strip()
+ self.enum_types.append(enumname)
+
def add_func(self, decl):
fi = FuncInfo(decl, namespaces=self.namespaces)
classname = fi.classname or self.Module
self.add_class(decl)
elif name.startswith("const"):
self.add_const(decl)
+ elif name.startswith("enum"):
+ # enum
+ self.add_enum(decl)
else: # function
self.add_func(decl)
if tp.endswith("*"):
defval0 = "0"
tp1 = tp.replace("*", "_ptr")
+ tp_candidates = [a.tp, normalize_class_name(self.namespace + "." + a.tp)]
+ if any(tp in codegen.enum_types for tp in tp_candidates):
+ defval0 = "static_cast<%s>(%d)" % (a.tp, 0)
amapping = simple_argtype_mapping.get(tp, (tp, "O", defval0))
parse_name = a.name
self.classes = {}
self.namespaces = {}
self.consts = {}
+ self.enum_types = []
self.code_include = StringIO()
self.code_types = StringIO()
self.code_funcs = StringIO()
py_signatures.append(dict(name=py_name, value=value))
#print(cname + ' => ' + str(py_name) + ' (value=' + value + ')')
+ def add_enum(self, name, decl):
+ enumname = normalize_class_name(name)
+ self.enum_types.append(enumname)
+
def add_func(self, decl):
namespace, classes, barename = self.split_decl_name(decl[0])
cname = "::".join(namespace+classes+[barename])
elif name.startswith("const"):
# constant
self.add_const(name.replace("const ", "").strip(), decl)
+ elif name.startswith("enum"):
+ # enum
+ self.add_enum(name.replace("enum ", "").strip(), decl)
else:
# function
self.add_func(decl)
decl[1] = ": " + ", ".join([self.get_dotted_name(b).replace(".","::") for b in bases])
return stmt_type, classname, True, decl
- if stmt.startswith("enum"):
- return "enum", "", True, None
-
- if stmt.startswith("namespace"):
+ if stmt.startswith("enum") or stmt.startswith("namespace"):
stmt_list = stmt.split()
if len(stmt_list) < 2:
stmt_list.append("<unnamed>")
return stmt_list[0], stmt_list[1], True, None
+
if stmt.startswith("extern") and "\"C\"" in stmt:
return "namespace", "", True, None
if end_token == "}" and context == "enum":
decl = self.parse_enum(stmt)
- return "enum", "", False, decl
+ name = stack_top[self.BLOCK_NAME]
+ return "enum", name, False, decl
if end_token == ";" and stmt.startswith("typedef"):
# TODO: handle typedef's more intelligently
stmt_type, name, parse_flag, decl = self.parse_stmt(stmt, token, docstring=docstring)
if decl:
if stmt_type == "enum":
- for d in decl:
- decls.append(d)
+ if name != "<unnamed>":
+ decls.append(["enum " + self.get_dotted_name(name), "", [], [], None, ""])
+ decls.extend(decl)
else:
decls.append(decl)