forked from enlightenment/efl
Pyolian: reformat code to make pycharm happy
and fix some typos in the code
This commit is contained in:
parent
a864d62ecf
commit
d1e27aacfc
|
|
@ -35,8 +35,8 @@ except ImportError:
|
|||
|
||||
_already_halted = False
|
||||
|
||||
### Eolian Enums ############################################################
|
||||
|
||||
# Eolian Enums ##############################################################
|
||||
class Eolian_Function_Type(IntEnum):
|
||||
UNRESOLVED = 0
|
||||
PROPERTY = 1
|
||||
|
|
@ -45,12 +45,14 @@ class Eolian_Function_Type(IntEnum):
|
|||
METHOD = 4
|
||||
FUNCTION_POINTER = 5
|
||||
|
||||
|
||||
class Eolian_Parameter_Direction(IntEnum):
|
||||
UNKNOWN = 0
|
||||
IN = 1
|
||||
OUT = 2
|
||||
INOUT = 3
|
||||
|
||||
|
||||
class Eolian_Class_Type(IntEnum):
|
||||
UNKNOWN_TYPE = 0
|
||||
REGULAR = 1
|
||||
|
|
@ -58,12 +60,14 @@ class Eolian_Class_Type(IntEnum):
|
|||
MIXIN = 3
|
||||
INTERFACE = 4
|
||||
|
||||
|
||||
class Eolian_Object_Scope(IntEnum):
|
||||
UNKNOWN = 0
|
||||
PUBLIC = 1
|
||||
PRIVATE = 2
|
||||
PROTECTED = 3
|
||||
|
||||
|
||||
class Eolian_Typedecl_Type(IntEnum):
|
||||
UNKNOWN = 0
|
||||
STRUCT = 1
|
||||
|
|
@ -72,6 +76,7 @@ class Eolian_Typedecl_Type(IntEnum):
|
|||
ALIAS = 4
|
||||
FUNCTION_POINTER = 5
|
||||
|
||||
|
||||
class Eolian_Type_Type(IntEnum):
|
||||
UNKNOWN_TYPE = 0
|
||||
VOID = 1
|
||||
|
|
@ -79,6 +84,7 @@ class Eolian_Type_Type(IntEnum):
|
|||
CLASS = 3
|
||||
UNDEFINED = 4
|
||||
|
||||
|
||||
class Eolian_Type_Builtin_Type(IntEnum):
|
||||
INVALID = 0
|
||||
BYTE = 1
|
||||
|
|
@ -141,6 +147,7 @@ class Eolian_Type_Builtin_Type(IntEnum):
|
|||
HASH = 47
|
||||
VOID_PTR = 48
|
||||
|
||||
|
||||
class Eolian_Expression_Type(IntEnum):
|
||||
UNKNOWN = 0
|
||||
INT = 1
|
||||
|
|
@ -159,18 +166,20 @@ class Eolian_Expression_Type(IntEnum):
|
|||
UNARY = 14
|
||||
BINARY = 15
|
||||
|
||||
|
||||
class Eolian_Expression_Mask(IntEnum):
|
||||
SINT = 1 << 0
|
||||
UINT = 1 << 1
|
||||
INT = SINT | UINT
|
||||
FLOAT = 1 << 2
|
||||
BOOL = 1 << 3
|
||||
SINT = 1 << 0
|
||||
UINT = 1 << 1
|
||||
INT = SINT | UINT
|
||||
FLOAT = 1 << 2
|
||||
BOOL = 1 << 3
|
||||
STRING = 1 << 4
|
||||
CHAR = 1 << 5
|
||||
NULL = 1 << 6
|
||||
CHAR = 1 << 5
|
||||
NULL = 1 << 6
|
||||
SIGNED = SINT | FLOAT
|
||||
NUMBER = INT | FLOAT
|
||||
ALL = NUMBER | BOOL | STRING | CHAR | NULL
|
||||
ALL = NUMBER | BOOL | STRING | CHAR | NULL
|
||||
|
||||
|
||||
class Eolian_Binary_Operator(IntEnum):
|
||||
INVALID = 0
|
||||
|
|
@ -186,12 +195,13 @@ class Eolian_Binary_Operator(IntEnum):
|
|||
GE = 10 # >= int, float
|
||||
LE = 11 # <= int, float
|
||||
AND = 12 # && all types
|
||||
OR = 13 # || all types
|
||||
OR = 13 # || all types
|
||||
BAND = 14 # & int
|
||||
BOR = 15 # | int
|
||||
BOR = 15 # | int
|
||||
BXOR = 16 # ^ int
|
||||
LSH = 17 # << int
|
||||
RSH = 18 # >> int
|
||||
LSH = 17 # << int
|
||||
RSH = 18 # >> int
|
||||
|
||||
|
||||
class Eolian_Unary_Operator(IntEnum):
|
||||
INVALID = 0
|
||||
|
|
@ -200,6 +210,7 @@ class Eolian_Unary_Operator(IntEnum):
|
|||
NOT = 3 # ! int, float, bool
|
||||
BNOT = 4 # ~ int
|
||||
|
||||
|
||||
class Eolian_Doc_Token_Type(IntEnum):
|
||||
UNKNOWN = 0
|
||||
TEXT = 1
|
||||
|
|
@ -211,12 +222,12 @@ class Eolian_Doc_Token_Type(IntEnum):
|
|||
MARKUP_MONOSPACE = 7
|
||||
|
||||
|
||||
### internal Classes ########################################################
|
||||
# Internal Classes ##########################################################
|
||||
|
||||
class Iterator(object):
|
||||
""" Generic eina iterator wrapper """
|
||||
def __init__(self, conv_func, iterator):
|
||||
self.next = self.__next__ # py2 compat
|
||||
self.next = self.__next__ # py2 compat
|
||||
self._conv = conv_func
|
||||
self._iter = c_void_p(iterator)
|
||||
self._tmp = c_void_p(0)
|
||||
|
|
@ -251,6 +262,7 @@ class cached_property(object):
|
|||
|
||||
class EolianBaseObject(object):
|
||||
__instances_cache = {}
|
||||
|
||||
def __new__(cls, c_obj_pointer=None, *args, **kargs):
|
||||
# cannot cache without a pointer
|
||||
if c_obj_pointer is None:
|
||||
|
|
@ -307,7 +319,7 @@ class EolianBaseObject(object):
|
|||
return self._obj
|
||||
|
||||
|
||||
### Main Eolian Unit ########################################################
|
||||
# Main Eolian Unit ##########################################################
|
||||
|
||||
class Eolian_Unit(EolianBaseObject):
|
||||
def __repr__(self):
|
||||
|
|
@ -451,7 +463,7 @@ class Eolian_State(Eolian_Unit):
|
|||
|
||||
def objects_by_file_get(self, file_name):
|
||||
return Iterator(Object,
|
||||
lib.eolian_state_objects_by_file_get(self, _str_to_bytes(file_name)))
|
||||
lib.eolian_state_objects_by_file_get(self, _str_to_bytes(file_name)))
|
||||
|
||||
def class_by_file_get(self, file_name):
|
||||
c_cls = lib.eolian_state_class_by_file_get(self, _str_to_bytes(file_name))
|
||||
|
|
@ -459,22 +471,22 @@ class Eolian_State(Eolian_Unit):
|
|||
|
||||
def constants_by_file_get(self, file_name):
|
||||
return Iterator(Constant,
|
||||
lib.eolian_state_constants_by_file_get(self, _str_to_bytes(file_name)))
|
||||
lib.eolian_state_constants_by_file_get(self, _str_to_bytes(file_name)))
|
||||
|
||||
def aliases_by_file_get(self, file_name):
|
||||
return Iterator(Typedecl,
|
||||
lib.eolian_state_aliases_by_file_get(self, _str_to_bytes(file_name)))
|
||||
lib.eolian_state_aliases_by_file_get(self, _str_to_bytes(file_name)))
|
||||
|
||||
def structs_by_file_get(self, file_name):
|
||||
return Iterator(Typedecl,
|
||||
lib.eolian_state_structs_by_file_get(self, _str_to_bytes(file_name)))
|
||||
lib.eolian_state_structs_by_file_get(self, _str_to_bytes(file_name)))
|
||||
|
||||
def enums_by_file_get(self, file_name):
|
||||
return Iterator(Typedecl,
|
||||
lib.eolian_state_enums_by_file_get(self, _str_to_bytes(file_name)))
|
||||
lib.eolian_state_enums_by_file_get(self, _str_to_bytes(file_name)))
|
||||
|
||||
|
||||
### Namespace Utility Class #################################################
|
||||
# Namespace Utility Class ###################################################
|
||||
|
||||
class Namespace(object):
|
||||
def __init__(self, unit, namespace_name):
|
||||
|
|
@ -512,55 +524,55 @@ class Namespace(object):
|
|||
def sub_namespaces(self):
|
||||
base = self._name + '.'
|
||||
deep = self._name.count('.') + 1
|
||||
return [ ns for ns in self._unit.all_namespaces
|
||||
if ns.name.startswith(base) and ns.name.count('.') == deep ]
|
||||
return [ns for ns in self._unit.all_namespaces
|
||||
if ns.name.startswith(base) and ns.name.count('.') == deep]
|
||||
|
||||
@property
|
||||
def classes(self):
|
||||
return sorted([ c for c in self._unit.classes
|
||||
if c.namespace == self._name ])
|
||||
return sorted([c for c in self._unit.classes
|
||||
if c.namespace == self._name])
|
||||
|
||||
@property
|
||||
def regulars(self):
|
||||
return sorted([ c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.REGULAR and
|
||||
c.namespace == self._name])
|
||||
return sorted([c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.REGULAR
|
||||
and c.namespace == self._name])
|
||||
|
||||
@property
|
||||
def abstracts(self):
|
||||
return sorted([ c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.ABSTRACT and
|
||||
c.namespace == self._name])
|
||||
return sorted([c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.ABSTRACT
|
||||
and c.namespace == self._name])
|
||||
|
||||
@property
|
||||
def mixins(self):
|
||||
return sorted([ c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.MIXIN and
|
||||
c.namespace == self._name])
|
||||
return sorted([c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.MIXIN
|
||||
and c.namespace == self._name])
|
||||
|
||||
@property
|
||||
def interfaces(self):
|
||||
return sorted([ c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.INTERFACE and
|
||||
c.namespace == self._name])
|
||||
return sorted([c for c in self._unit.classes
|
||||
if c.type == Eolian_Class_Type.INTERFACE
|
||||
and c.namespace == self._name])
|
||||
|
||||
@property
|
||||
def aliases(self):
|
||||
return sorted([ td for td in self._unit.aliases
|
||||
if td.namespace == self._name])
|
||||
return sorted([td for td in self._unit.aliases
|
||||
if td.namespace == self._name])
|
||||
|
||||
@property
|
||||
def structs(self):
|
||||
return sorted([ td for td in self._unit.structs
|
||||
if td.namespace == self._name])
|
||||
return sorted([td for td in self._unit.structs
|
||||
if td.namespace == self._name])
|
||||
|
||||
@property
|
||||
def enums(self):
|
||||
return sorted([ td for td in self._unit.enums
|
||||
if td.namespace == self._name])
|
||||
return sorted([td for td in self._unit.enums
|
||||
if td.namespace == self._name])
|
||||
|
||||
|
||||
### Eolian Classes ##########################################################
|
||||
# Eolian Classes ############################################################
|
||||
|
||||
class Object(EolianBaseObject):
|
||||
def __new__(cls, c_obj_pointer):
|
||||
|
|
@ -680,27 +692,27 @@ class Class(Object):
|
|||
|
||||
@cached_property
|
||||
def inherits_full(self):
|
||||
L = []
|
||||
li = []
|
||||
|
||||
def do_class_recursive(cls):
|
||||
if cls.parent:
|
||||
L.append(cls.parent)
|
||||
li.append(cls.parent)
|
||||
for other in cls.extensions:
|
||||
if other not in L:
|
||||
L.append(other)
|
||||
if other not in li:
|
||||
li.append(other)
|
||||
do_class_recursive(other)
|
||||
|
||||
do_class_recursive(self)
|
||||
return L
|
||||
return li
|
||||
|
||||
@cached_property
|
||||
def hierarchy(self):
|
||||
L = []
|
||||
li = []
|
||||
base = self.parent
|
||||
while base:
|
||||
L.append(base)
|
||||
li.append(base)
|
||||
base = base.parent
|
||||
return L
|
||||
return li
|
||||
|
||||
@cached_property
|
||||
def ctor_enable(self):
|
||||
|
|
@ -710,10 +722,10 @@ class Class(Object):
|
|||
def dtor_enable(self):
|
||||
return bool(lib.eolian_class_dtor_enable_get(self))
|
||||
|
||||
def function_by_name_get(self, func_name,
|
||||
def function_by_name_get(self, function_name,
|
||||
ftype=Eolian_Function_Type.UNRESOLVED):
|
||||
f = lib.eolian_class_function_by_name_get(self,
|
||||
_str_to_bytes(func_name),
|
||||
_str_to_bytes(function_name),
|
||||
ftype)
|
||||
return Function(f) if f else None
|
||||
|
||||
|
|
@ -868,36 +880,40 @@ class Function(Object):
|
|||
return Iterator(Function_Parameter,
|
||||
lib.eolian_function_parameters_get(self))
|
||||
|
||||
def values_get(self, ftype): # TODO rename in property_values_get (or implement a proper Property class?)
|
||||
def values_get(self, ftype):
|
||||
# TODO rename in property_values_get
|
||||
# (or implement a proper Property class?)
|
||||
return Iterator(Function_Parameter,
|
||||
lib.eolian_property_values_get(self, ftype))
|
||||
|
||||
@property
|
||||
def getter_values(self): # TODO rename ...
|
||||
def getter_values(self): # TODO rename ...
|
||||
return self.values_get(Eolian_Function_Type.PROP_GET)
|
||||
|
||||
@property
|
||||
def setter_values(self): # TODO rename ...
|
||||
def setter_values(self): # TODO rename ...
|
||||
return self.values_get(Eolian_Function_Type.PROP_SET)
|
||||
|
||||
def keys_get(self, ftype): # TODO rename in property_keys_get (or implement a proper Property class?)
|
||||
def keys_get(self, ftype):
|
||||
# TODO rename in property_keys_get
|
||||
# (or implement a proper Property class?)
|
||||
return Iterator(Function_Parameter,
|
||||
lib.eolian_property_keys_get(self, ftype))
|
||||
|
||||
@property
|
||||
def getter_keys(self): # TODO rename ...
|
||||
def getter_keys(self): # TODO rename ...
|
||||
return self.keys_get(Eolian_Function_Type.PROP_GET)
|
||||
|
||||
@property
|
||||
def setter_keys(self): # TODO rename ...
|
||||
def setter_keys(self): # TODO rename ...
|
||||
return self.keys_get(Eolian_Function_Type.PROP_SET)
|
||||
|
||||
def return_type_get(self, ftype):
|
||||
c_type = lib.eolian_function_return_type_get(self, ftype)
|
||||
return Type(c_type) if c_type else None
|
||||
|
||||
def return_default_value(self, ftye):
|
||||
c_expr = lib.eolian_function_return_default_value_get(sel._obj, ftype)
|
||||
def return_default_value(self, ftype):
|
||||
c_expr = lib.eolian_function_return_default_value_get(self._obj, ftype)
|
||||
return Expression(c_expr) if c_expr else None
|
||||
|
||||
def return_documentation(self, ftype):
|
||||
|
|
@ -1019,7 +1035,7 @@ class Implement(Object):
|
|||
|
||||
class Type(Object):
|
||||
def __repr__(self):
|
||||
# return "<eolian.Type '{0.name}', type: {0.type!s}, c_type: '{0.c_type}'>".format(self)
|
||||
# return "<eolian.Type '{0.name}', type: {0.type!s}, c_type: '{0.c_type}'>".format(self)
|
||||
return "<eolian.Type '{0.name}', type={0.type!s}>".format(self)
|
||||
|
||||
@cached_property
|
||||
|
|
@ -1326,11 +1342,12 @@ class Documentation_Token(object):
|
|||
return self._ref
|
||||
|
||||
|
||||
### internal string encode/decode ###########################################
|
||||
# internal string encode/decode #############################################
|
||||
|
||||
def _str_to_bytes(s):
|
||||
return s.encode('utf-8')
|
||||
|
||||
|
||||
def _str_to_py(s):
|
||||
if s is None:
|
||||
return None
|
||||
|
|
@ -1345,7 +1362,7 @@ def _str_to_py(s):
|
|||
print('WARNING !!!!!!!!! Unknown type: %s' % type(s))
|
||||
|
||||
|
||||
### internal Object type -> Class mapping ###################################
|
||||
# internal Object type -> Class mapping #####################################
|
||||
|
||||
class _Eolian_Object_Type(IntEnum):
|
||||
UNKNOWN = 0
|
||||
|
|
@ -1364,6 +1381,7 @@ class _Eolian_Object_Type(IntEnum):
|
|||
CONSTRUCTOR = 13
|
||||
DOCUMENTATION = 14
|
||||
|
||||
|
||||
_eolian_type_class_mapping = {
|
||||
_Eolian_Object_Type.UNKNOWN: Object,
|
||||
_Eolian_Object_Type.CLASS: Class,
|
||||
|
|
@ -1382,17 +1400,20 @@ _eolian_type_class_mapping = {
|
|||
_Eolian_Object_Type.DOCUMENTATION: Documentation,
|
||||
}
|
||||
|
||||
### module init/shutdown ####################################################
|
||||
|
||||
# module init/shutdown ######################################################
|
||||
|
||||
def _cleanup():
|
||||
global _already_halted
|
||||
lib.eolian_shutdown()
|
||||
_already_halted = True
|
||||
|
||||
|
||||
lib.eolian_init()
|
||||
atexit.register(_cleanup)
|
||||
|
||||
|
||||
### API coverage statistics #################################################
|
||||
# API coverage statistics ###################################################
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ for lib_dir in search_in:
|
|||
file_path = f
|
||||
|
||||
if not file_path:
|
||||
raise RuntimeError('Error: cannot find a built eolian library in source tree')
|
||||
raise RuntimeError('Error: cannot find a built eolian lib in source tree')
|
||||
|
||||
lib = CDLL(file_path)
|
||||
|
||||
|
|
@ -42,7 +42,8 @@ lib.eolian_init.restype = c_int
|
|||
lib.eolian_shutdown.argtypes = None
|
||||
lib.eolian_shutdown.restype = c_int
|
||||
|
||||
### Eolian_State ############################################################
|
||||
|
||||
# Eolian_State ##############################################################
|
||||
|
||||
# EAPI Eolian_State *eolian_state_new(void);
|
||||
lib.eolian_state_new.argtypes = None
|
||||
|
|
@ -124,7 +125,8 @@ lib.eolian_state_structs_by_file_get.restype = c_void_p
|
|||
lib.eolian_state_enums_by_file_get.argtypes = (c_void_p, c_char_p)
|
||||
lib.eolian_state_enums_by_file_get.restype = c_void_p
|
||||
|
||||
### Eolian_Unit #############################################################
|
||||
|
||||
# Eolian_Unit ###############################################################
|
||||
|
||||
# EAPI Eina_Iterator *eolian_unit_children_get(const Eolian_Unit *unit);
|
||||
lib.eolian_unit_children_get.argtypes = (c_void_p,)
|
||||
|
|
@ -186,7 +188,8 @@ lib.eolian_unit_constant_by_name_get.restype = c_void_p
|
|||
lib.eolian_unit_constants_get.argtypes = (c_void_p,)
|
||||
lib.eolian_unit_constants_get.restype = c_void_p
|
||||
|
||||
### Eolian_Object ###########################################################
|
||||
|
||||
# Eolian_Object #############################################################
|
||||
|
||||
# EAPI Eolian_Object_Type eolian_object_type_get(const Eolian_Object *obj);
|
||||
lib.eolian_object_type_get.argtypes = (c_void_p,)
|
||||
|
|
@ -224,7 +227,8 @@ lib.eolian_object_namespaces_get.restype = c_void_p
|
|||
lib.eolian_object_is_beta.argtypes = (c_void_p,)
|
||||
lib.eolian_object_is_beta.restype = c_bool
|
||||
|
||||
### Eolian_Class ############################################################
|
||||
|
||||
# Eolian_Class ##############################################################
|
||||
|
||||
# EAPI Eolian_Class_Type eolian_class_type_get(const Eolian_Class *klass);
|
||||
lib.eolian_class_type_get.argtypes = (c_void_p,)
|
||||
|
|
@ -302,7 +306,8 @@ lib.eolian_class_c_macro_get.restype = c_void_p # Stringshare TO BE FREED
|
|||
lib.eolian_class_c_data_type_get.argtypes = (c_void_p,)
|
||||
lib.eolian_class_c_data_type_get.restype = c_void_p # Stringshare TO BE FREED
|
||||
|
||||
### Eolian_Function #########################################################
|
||||
|
||||
# Eolian_Function ###########################################################
|
||||
|
||||
# EAPI Eolian_Function_Type eolian_function_type_get(const Eolian_Function *function_id);
|
||||
lib.eolian_function_type_get.argtypes = (c_void_p,)
|
||||
|
|
@ -369,7 +374,8 @@ lib.eolian_property_keys_get.restype = c_void_p
|
|||
lib.eolian_property_values_get.argtypes = (c_void_p, c_int)
|
||||
lib.eolian_property_values_get.restype = c_void_p
|
||||
|
||||
### Eolian_Function_Parameter ###############################################
|
||||
|
||||
# Eolian_Function_Parameter #################################################
|
||||
|
||||
# EAPI Eolian_Parameter_Direction eolian_parameter_direction_get(const Eolian_Function_Parameter *param);
|
||||
lib.eolian_parameter_direction_get.argtypes = (c_void_p,)
|
||||
|
|
@ -391,7 +397,8 @@ lib.eolian_parameter_documentation_get.restype = c_void_p
|
|||
lib.eolian_parameter_is_optional.argtypes = (c_void_p,)
|
||||
lib.eolian_parameter_is_optional.restype = c_bool
|
||||
|
||||
### Eolian_Implement ########################################################
|
||||
|
||||
# Eolian_Implement ##########################################################
|
||||
|
||||
# EAPI const Eolian_Class *eolian_implement_class_get(const Eolian_Implement *impl);
|
||||
lib.eolian_implement_class_get.argtypes = (c_void_p,)
|
||||
|
|
@ -425,7 +432,8 @@ lib.eolian_implement_is_prop_get.restype = c_bool
|
|||
lib.eolian_implement_is_prop_set.argtypes = (c_void_p,)
|
||||
lib.eolian_implement_is_prop_set.restype = c_bool
|
||||
|
||||
### Eolian_Constructor ######################################################
|
||||
|
||||
# Eolian_Constructor ########################################################
|
||||
|
||||
# EAPI const Eolian_Class *eolian_constructor_class_get(const Eolian_Constructor *ctor);
|
||||
lib.eolian_constructor_class_get.argtypes = (c_void_p,)
|
||||
|
|
@ -439,7 +447,8 @@ lib.eolian_constructor_function_get.restype = c_void_p
|
|||
lib.eolian_constructor_is_optional.argtypes = (c_void_p,)
|
||||
lib.eolian_constructor_is_optional.restype = c_bool
|
||||
|
||||
### Eolian_Event ############################################################
|
||||
|
||||
# Eolian_Event ##############################################################
|
||||
|
||||
# EAPI Eina_Stringshare *eolian_event_c_macro_get(const Eolian_Event *event);
|
||||
lib.eolian_event_c_macro_get.argtypes = (c_void_p,)
|
||||
|
|
@ -465,7 +474,8 @@ lib.eolian_event_is_hot.restype = c_bool
|
|||
lib.eolian_event_is_restart.argtypes = (c_void_p,)
|
||||
lib.eolian_event_is_restart.restype = c_bool
|
||||
|
||||
### Eolian_Part #############################################################
|
||||
|
||||
# Eolian_Part ###############################################################
|
||||
|
||||
# EAPI const Eolian_Class *eolian_part_class_get(const Eolian_Part *part);
|
||||
lib.eolian_part_class_get.argtypes = (c_void_p,)
|
||||
|
|
@ -475,7 +485,8 @@ lib.eolian_part_class_get.restype = c_void_p
|
|||
lib.eolian_part_documentation_get.argtypes = (c_void_p,)
|
||||
lib.eolian_part_documentation_get.restype = c_void_p
|
||||
|
||||
### Eolian_Typedecl #########################################################
|
||||
|
||||
# Eolian_Typedecl ###########################################################
|
||||
|
||||
# EAPI Eolian_Typedecl_Type eolian_typedecl_type_get(const Eolian_Typedecl *tp);
|
||||
lib.eolian_typedecl_type_get.argtypes = (c_void_p,)
|
||||
|
|
@ -549,7 +560,8 @@ lib.eolian_typedecl_free_func_get.restype = c_char_p
|
|||
lib.eolian_typedecl_function_pointer_get.argtypes = (c_void_p,)
|
||||
lib.eolian_typedecl_function_pointer_get.restype = c_void_p
|
||||
|
||||
### Eolian_Type #############################################################
|
||||
|
||||
# Eolian_Type ###############################################################
|
||||
|
||||
# EAPI Eolian_Type_Type eolian_type_type_get(const Eolian_Type *tp);
|
||||
lib.eolian_type_type_get.argtypes = (c_void_p,)
|
||||
|
|
@ -588,10 +600,11 @@ lib.eolian_type_is_ptr.argtypes = (c_void_p,)
|
|||
lib.eolian_type_is_ptr.restype = c_bool
|
||||
|
||||
# EAPI Eina_Stringshare *eolian_type_c_type_get(const Eolian_Type *tp);
|
||||
lib.eolian_type_c_type_get.argtypes = (c_void_p)
|
||||
lib.eolian_type_c_type_get.argtypes = (c_void_p,)
|
||||
lib.eolian_type_c_type_get.restype = c_void_p # Stringshare TO BE FREED
|
||||
|
||||
### Eolian_Expression #######################################################
|
||||
|
||||
# Eolian_Expression #########################################################
|
||||
|
||||
# EAPI Eina_Stringshare *eolian_expression_serialize(const Eolian_Expression *expr);
|
||||
lib.eolian_expression_serialize.argtypes = (c_void_p,)
|
||||
|
|
@ -621,7 +634,8 @@ lib.eolian_expression_unary_operator_get.restype = c_int
|
|||
lib.eolian_expression_unary_expression_get.argtypes = (c_void_p,)
|
||||
lib.eolian_expression_unary_expression_get.restype = c_void_p
|
||||
|
||||
### Eolian_Constant #########################################################
|
||||
|
||||
# Eolian_Constant ###########################################################
|
||||
|
||||
# EAPI const Eolian_Documentation *eolian_constant_documentation_get(const Eolian_Constant *var);
|
||||
lib.eolian_constant_documentation_get.argtypes = (c_void_p,)
|
||||
|
|
@ -639,7 +653,8 @@ lib.eolian_constant_value_get.restype = c_void_p
|
|||
lib.eolian_constant_is_extern.argtypes = (c_void_p,)
|
||||
lib.eolian_constant_is_extern.restype = c_bool
|
||||
|
||||
### Eolian_Documentation ####################################################
|
||||
|
||||
# Eolian_Documentation ######################################################
|
||||
|
||||
# EAPI Eina_Stringshare *eolian_documentation_summary_get(const Eolian_Documentation *doc);
|
||||
lib.eolian_documentation_summary_get.argtypes = (c_void_p,)
|
||||
|
|
@ -677,4 +692,3 @@ lib.eolian_doc_token_text_get.restype = c_void_p # char* TO BE FREED
|
|||
# EAPI Eolian_Object_Type eolian_doc_token_ref_resolve(const Eolian_Doc_Token *tok, const Eolian_State *state, const Eolian_Object **data, const Eolian_Object **data2);
|
||||
# lib.eolian_doc_token_ref_resolve.argtypes = (c_void_p, c_void_p, ???, ???)
|
||||
# lib.eolian_doc_token_ref_resolve.restype = c_int
|
||||
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ PYTHON_PATH, fe:
|
|||
"""
|
||||
import os
|
||||
import datetime
|
||||
import atexit
|
||||
|
||||
try:
|
||||
from . import eolian
|
||||
|
|
@ -70,11 +71,13 @@ if not eolian_db.all_eot_files_parse():
|
|||
if not eolian_db.all_eo_files_parse():
|
||||
raise(RuntimeError('Eolian, failed to parse all EO files'))
|
||||
|
||||
|
||||
# cleanup the database on exit
|
||||
import atexit
|
||||
def cleanup_db():
|
||||
global eolian_db
|
||||
del eolian_db
|
||||
|
||||
|
||||
atexit.register(cleanup_db)
|
||||
|
||||
|
||||
|
|
@ -92,11 +95,12 @@ class Template(pyratemp.Template):
|
|||
filename: Template file to load. (REQUIRED)
|
||||
context: User provided context for the template (dict).
|
||||
"""
|
||||
|
||||
def __init__(self, filename, encoding='utf-8', context=None, escape=None,
|
||||
loader_class=pyratemp.LoaderFile,
|
||||
parser_class=pyratemp.Parser,
|
||||
renderer_class=pyratemp.Renderer,
|
||||
eval_class=pyratemp.EvalPseudoSandbox):
|
||||
loader_class=pyratemp.LoaderFile,
|
||||
parser_class=pyratemp.Parser,
|
||||
renderer_class=pyratemp.Renderer,
|
||||
eval_class=pyratemp.EvalPseudoSandbox):
|
||||
|
||||
# Build the global context for the template
|
||||
global_ctx = {}
|
||||
|
|
@ -154,7 +158,7 @@ class Template(pyratemp.Template):
|
|||
eval_class=eval_class)
|
||||
|
||||
def render(self, filename=None, verbose=True, cls=None, ns=None,
|
||||
struct=None, enum=None, alias=None, **kargs):
|
||||
struct=None, enum=None, alias=None, **kargs):
|
||||
# Build the context for the template
|
||||
ctx = {}
|
||||
if kargs:
|
||||
|
|
|
|||
|
|
@ -99,26 +99,26 @@ class TestEolianUnit(unittest.TestCase):
|
|||
|
||||
@unittest.skip('Skipped until unit/state support is fixed')
|
||||
def test_children_listing(self):
|
||||
l = list(eolian_db.children)
|
||||
self.assertGreater(len(l), 500)
|
||||
self.assertIsInstance(l[0], eolian.Eolian_Unit)
|
||||
li = list(eolian_db.children)
|
||||
self.assertGreater(len(li), 500)
|
||||
self.assertIsInstance(li[0], eolian.Eolian_Unit)
|
||||
|
||||
def test_file_listing(self):
|
||||
l = list(eolian_db.eo_file_paths)
|
||||
self.assertGreater(len(l), 400)
|
||||
self.assertTrue(l[0].endswith('.eo'))
|
||||
li = list(eolian_db.eo_file_paths)
|
||||
self.assertGreater(len(li), 400)
|
||||
self.assertTrue(li[0].endswith('.eo'))
|
||||
|
||||
l = list(eolian_db.eo_files)
|
||||
self.assertGreater(len(l), 400)
|
||||
self.assertTrue(l[0].endswith('.eo'))
|
||||
li = list(eolian_db.eo_files)
|
||||
self.assertGreater(len(li), 400)
|
||||
self.assertTrue(li[0].endswith('.eo'))
|
||||
|
||||
l = list(eolian_db.eot_file_paths)
|
||||
self.assertGreater(len(l), 10)
|
||||
self.assertTrue(l[0].endswith('.eot'))
|
||||
li = list(eolian_db.eot_file_paths)
|
||||
self.assertGreater(len(li), 10)
|
||||
self.assertTrue(li[0].endswith('.eot'))
|
||||
|
||||
l = list(eolian_db.eot_files)
|
||||
self.assertGreater(len(l), 10)
|
||||
self.assertTrue(l[0].endswith('.eot'))
|
||||
li = list(eolian_db.eot_files)
|
||||
self.assertGreater(len(li), 10)
|
||||
self.assertTrue(li[0].endswith('.eot'))
|
||||
|
||||
def test_object_listing(self):
|
||||
unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
|
||||
|
|
@ -137,10 +137,10 @@ class TestEolianUnit(unittest.TestCase):
|
|||
self.assertGreater(count, 5)
|
||||
|
||||
def test_enum_listing(self):
|
||||
l = list(eolian_db.enums_by_file_get('efl_ui_win.eo'))
|
||||
self.assertGreater(len(l), 5)
|
||||
self.assertIsInstance(l[0], eolian.Typedecl)
|
||||
self.assertEqual(l[0].type, eolian.Eolian_Typedecl_Type.ENUM)
|
||||
li = list(eolian_db.enums_by_file_get('efl_ui_win.eo'))
|
||||
self.assertGreater(len(li), 5)
|
||||
self.assertIsInstance(li[0], eolian.Typedecl)
|
||||
self.assertEqual(li[0].type, eolian.Eolian_Typedecl_Type.ENUM)
|
||||
|
||||
all_count = 0
|
||||
for enum in eolian_db.enums:
|
||||
|
|
@ -150,10 +150,10 @@ class TestEolianUnit(unittest.TestCase):
|
|||
self.assertGreater(all_count, 50)
|
||||
|
||||
def test_struct_listing(self):
|
||||
l = list(eolian_db.structs_by_file_get('eina_types.eot'))
|
||||
self.assertGreater(len(l), 10)
|
||||
self.assertIsInstance(l[0], eolian.Typedecl)
|
||||
self.assertIn(l[0].type, (
|
||||
li = list(eolian_db.structs_by_file_get('eina_types.eot'))
|
||||
self.assertGreater(len(li), 10)
|
||||
self.assertIsInstance(li[0], eolian.Typedecl)
|
||||
self.assertIn(li[0].type, (
|
||||
eolian.Eolian_Typedecl_Type.STRUCT,
|
||||
eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE))
|
||||
|
||||
|
|
@ -167,27 +167,27 @@ class TestEolianUnit(unittest.TestCase):
|
|||
self.assertGreater(all_count, 50)
|
||||
|
||||
def test_alias_listing(self):
|
||||
l = list(eolian_db.aliases_by_file_get('eina_types.eot'))
|
||||
self.assertGreater(len(l), 2)
|
||||
self.assertIsInstance(l[0], eolian.Typedecl)
|
||||
li = list(eolian_db.aliases_by_file_get('eina_types.eot'))
|
||||
self.assertGreater(len(li), 2)
|
||||
self.assertIsInstance(li[0], eolian.Typedecl)
|
||||
|
||||
all_count = 0
|
||||
for alias in eolian_db.aliases:
|
||||
self.assertIsInstance(alias, eolian.Typedecl)
|
||||
self.assertIn(alias.type, (
|
||||
eolian.Eolian_Typedecl_Type.ALIAS,
|
||||
eolian.Eolian_Typedecl_Type.FUNCTION_POINTER)) # TODO is this correct ??
|
||||
eolian.Eolian_Typedecl_Type.FUNCTION_POINTER)) # TODO is this correct ??
|
||||
all_count += 1
|
||||
self.assertGreater(all_count, 10)
|
||||
|
||||
def test_constant_listing(self):
|
||||
l = list(eolian_db.constants)
|
||||
self.assertGreater(len(l), 2)
|
||||
self.assertIsInstance(l[0], eolian.Constant)
|
||||
li = list(eolian_db.constants)
|
||||
self.assertGreater(len(li), 2)
|
||||
self.assertIsInstance(li[0], eolian.Constant)
|
||||
|
||||
l = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo'))
|
||||
self.assertGreater(len(l), 1)
|
||||
self.assertIsInstance(l[0], eolian.Constant)
|
||||
li = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo'))
|
||||
self.assertGreater(len(li), 1)
|
||||
self.assertIsInstance(li[0], eolian.Constant)
|
||||
|
||||
def test_class_listing(self):
|
||||
all_count = 0
|
||||
|
|
@ -219,7 +219,7 @@ class TestEolianNamespace(unittest.TestCase):
|
|||
'Ector.Software.Buffer',
|
||||
'Eio.Sentry',
|
||||
'Eldbus.Model',
|
||||
]
|
||||
]
|
||||
for ns in eolian_db.all_namespaces:
|
||||
cls = eolian_db.class_by_name_get(ns.name)
|
||||
# Some legacy classes are parsed and still make this fail.
|
||||
|
|
@ -344,8 +344,8 @@ class TestEolianClass(unittest.TestCase):
|
|||
self.assertEqual(cls.c_get_function_name, 'efl_loop_timer_class_get')
|
||||
self.assertEqual(cls.c_macro, 'EFL_LOOP_TIMER_CLASS')
|
||||
self.assertEqual(cls.c_data_type, 'Efl_Loop_Timer_Data')
|
||||
self.assertEqual([f.name for f in cls.methods], ['timer_reset','timer_loop_reset','timer_delay'])
|
||||
self.assertEqual([f.name for f in cls.properties], ['timer_interval','time_pending'])
|
||||
self.assertEqual([f.name for f in cls.methods], ['timer_reset', 'timer_loop_reset', 'timer_delay'])
|
||||
self.assertEqual([f.name for f in cls.properties], ['timer_interval', 'time_pending'])
|
||||
self.assertGreater(len(list(cls.implements)), 5)
|
||||
self.assertIsInstance(list(cls.implements)[0], eolian.Implement)
|
||||
|
||||
|
|
@ -399,7 +399,7 @@ class TestEolianImplement(unittest.TestCase):
|
|||
self.assertEqual(im.name, 'Efl.Loop_Timer.timer_delay')
|
||||
self.assertIsInstance(im.class_, eolian.Class)
|
||||
self.assertIsInstance(im.function, eolian.Function)
|
||||
self.assertIsInstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ?
|
||||
self.assertIsInstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ?
|
||||
self.assertFalse(im.is_auto())
|
||||
self.assertFalse(im.is_empty())
|
||||
self.assertFalse(im.is_pure_virtual())
|
||||
|
|
@ -473,7 +473,7 @@ class TestEolianConstant(unittest.TestCase):
|
|||
self.assertEqual(var.short_name, 'Hint_Expand')
|
||||
self.assertEqual(var.file, 'efl_gfx_hint.eo')
|
||||
self.assertFalse(var.is_extern)
|
||||
self.assertEqual(list(var.namespaces), ['Efl','Gfx'])
|
||||
self.assertEqual(list(var.namespaces), ['Efl', 'Gfx'])
|
||||
self.assertIsInstance(var.documentation, eolian.Documentation)
|
||||
self.assertIsInstance(var.type, eolian.Type)
|
||||
self.assertIsInstance(var.value, eolian.Expression)
|
||||
|
|
@ -487,7 +487,7 @@ class TestEolianTypedecl(unittest.TestCase):
|
|||
self.assertEqual(td.name, 'Efl.Net.Http.Version')
|
||||
self.assertEqual(td.short_name, 'Version')
|
||||
self.assertEqual(td.file, 'efl_net_http_types.eot')
|
||||
self.assertEqual(list(td.namespaces), ['Efl','Net','Http'])
|
||||
self.assertEqual(list(td.namespaces), ['Efl', 'Net', 'Http'])
|
||||
self.assertIsInstance(td.documentation, eolian.Documentation)
|
||||
self.assertIsNone(td.base_type) # TODO find a better test
|
||||
self.assertIsNone(td.free_func) # TODO find a better test
|
||||
|
|
@ -511,7 +511,7 @@ class TestEolianTypedecl(unittest.TestCase):
|
|||
self.assertEqual(td.name, 'Efl.Gfx.Color32')
|
||||
self.assertEqual(td.short_name, 'Color32')
|
||||
self.assertEqual(td.file, 'efl_canvas_filter_internal.eo')
|
||||
self.assertEqual(list(td.namespaces), ['Efl','Gfx'])
|
||||
self.assertEqual(list(td.namespaces), ['Efl', 'Gfx'])
|
||||
self.assertIsInstance(td.documentation, eolian.Documentation)
|
||||
self.assertIsNone(td.base_type) # TODO find a better test
|
||||
self.assertIsNone(td.free_func) # TODO find a better test
|
||||
|
|
@ -544,13 +544,13 @@ class TestEolianType(unittest.TestCase):
|
|||
cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
|
||||
func = cls.function_by_name_get('timer_delay')
|
||||
param = list(func.parameters)[0]
|
||||
t = param.type # type: double
|
||||
t = param.type # type double
|
||||
self.assertIsInstance(t, eolian.Type)
|
||||
self.assertEqual(t.name, 'double')
|
||||
self.assertEqual(t.short_name, 'double')
|
||||
self.assertEqual(t.type, eolian.Eolian_Type_Type.REGULAR)
|
||||
self.assertEqual(t.builtin_type, eolian.Eolian_Type_Builtin_Type.DOUBLE)
|
||||
self.assertEqual(t.file, 'efl_loop_timer.eo') # TODO is this correct ?
|
||||
self.assertEqual(t.file, 'efl_loop_timer.eo') # TODO is this correct ?
|
||||
self.assertIsNone(t.base_type) # TODO find a better test
|
||||
self.assertIsNone(t.next_type) # TODO find a better test
|
||||
self.assertFalse(t.is_const)
|
||||
|
|
@ -563,7 +563,7 @@ class TestEolianType(unittest.TestCase):
|
|||
cls = eolian_db.class_by_name_get('Efl.Gfx.Entity')
|
||||
func = cls.function_by_name_get('geometry')
|
||||
param = list(func.setter_values)[0]
|
||||
t = param.type # type: Eina.Rect
|
||||
t = param.type # type Eina.Rect
|
||||
self.assertIsInstance(t, eolian.Type)
|
||||
self.assertEqual(t.name, 'Eina.Rect')
|
||||
self.assertEqual(t.short_name, 'Rect')
|
||||
|
|
@ -582,7 +582,7 @@ class TestEolianType(unittest.TestCase):
|
|||
cls = eolian_db.class_by_name_get('Efl.Content')
|
||||
func = cls.function_by_name_get('content')
|
||||
param = list(func.setter_values)[0]
|
||||
t = param.type # type: Efl.Gfx (class interface)
|
||||
t = param.type # type Efl.Gfx (class interface)
|
||||
self.assertIsInstance(t, eolian.Type)
|
||||
self.assertEqual(t.name, 'Efl.Gfx.Entity')
|
||||
self.assertEqual(t.short_name, 'Entity')
|
||||
|
|
@ -612,11 +612,11 @@ class TestEolianExpression(unittest.TestCase):
|
|||
self.assertIsInstance(exp, eolian.Expression)
|
||||
self.assertEqual(exp.type, eolian.Eolian_Expression_Type.UNARY)
|
||||
self.assertEqual(float(exp.serialize), 32768.0) # TODO is this a bug? isn't -1.0 ?
|
||||
self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP
|
||||
self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP
|
||||
unary = exp.unary_expression
|
||||
self.assertIsInstance(unary, eolian.Expression)
|
||||
self.assertEqual(unary.type, eolian.Eolian_Expression_Type.INT)
|
||||
self.assertEqual(float(exp.serialize), 32768.0) # Bug too?
|
||||
self.assertEqual(float(exp.serialize), 32768.0) # Bug too?
|
||||
|
||||
# TODO test_expression_binary
|
||||
# exp.binary_operator # TODO find a better test (only works for BINARY expr)
|
||||
|
|
@ -624,7 +624,6 @@ class TestEolianExpression(unittest.TestCase):
|
|||
# exp.binary_rhs # TODO find a better test (only works for BINARY expr)
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
# create main eolian state
|
||||
eolian_db = eolian.Eolian_State()
|
||||
|
|
|
|||
Loading…
Reference in New Issue