gccxml / pygccxml / 362

pending completion

Build # 362

Build Type

Pull #35

travis-ci

Committed by

praetorian20

Commit Message

<a href="https://github.com/gccxml/pygccxml/commit/1917d72dd">Fixes for cv-qualified arrays

Combined type_traits_castxml.hpp and type_traits_gccxml.hpp into a
single file - type_traits.hpp.

Disabled tests for const volatile arrays for gccxml, these are
incorrectly being detected a non-const; this needs to be looked into.

Disabled tests for &quot;has_trivial_constructor&quot; for gccxml, these are being
detected as False, while castxml detects them as True. At this time I&#39;m
not sure which one is correct; need to look into this as well.

Change-Id: I</a><a class="double-link" href="https://github.com/gccxml/pygccxml/commit/27ef6d370">27ef6d370</a>

Pull Request Pull Request #35: Fixes for cv-qualified arrays

Run Details

71 of 71 new or added lines in 3 files covered. (100.0%)

8262 of 10018 relevant lines covered (82.47%)

8.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.51

/pygccxml/declarations/class_declaration.py

# Copyright 2014-2016 Insight Software Consortium.
# Copyright 2004-2008 Roman Yakovenko.
# Distributed under the Boost Software License, Version 1.0.
# See http://www.boost.org/LICENSE_1_0.txt

"""
defines classes, that describes C++ classes

This modules contains definition for next C++ declarations:
    - class definition
    - class declaration
    - small helper class for describing C++ class hierarchy
"""

from . import scopedef
from . import algorithm
from . import declaration
from . import dependencies
from pygccxml import utils


class ACCESS_TYPES(object):

    """class that defines "access" constants"""
    PUBLIC = "public"
    PRIVATE = "private"
    PROTECTED = "protected"
    ALL = [PUBLIC, PRIVATE, PROTECTED]


class CLASS_TYPES(object):

    """class that defines "class" type constants"""
    CLASS = "class"
    STRUCT = "struct"
    UNION = "union"
    ALL = [CLASS, STRUCT, UNION]


def get_partial_name(name):
    from . import templates
    from . import container_traits  # prevent cyclic dependencies
    ct = container_traits.find_container_traits(name)
    if ct:
        return ct.remove_defaults(name)
    elif templates.is_instantiation(name):
        tmpl_name, args = templates.split(name)
        for i, arg_name in enumerate(args):
            args[i] = get_partial_name(arg_name.strip())
        return templates.join(tmpl_name, args)
    else:
        return name


class hierarchy_info_t(object):

    """describes class relationship"""

    def __init__(self, related_class=None, access=None, is_virtual=False):
        """creates class that contains partial information about class
        relationship"""
        if related_class:
            assert(isinstance(related_class, class_t))
        self._related_class = related_class
        if access:
            assert(access in ACCESS_TYPES.ALL)
        self._access = access
        self._is_virtual = is_virtual

    def __eq__(self, other):
        if not isinstance(other, hierarchy_info_t):
            return False
        return algorithm.declaration_path(self.related_class) == \
            algorithm.declaration_path(other.related_class) \
            and self.access == other.access \
            and self.is_virtual == other.is_virtual

    def __hash__(self):
        return hash(algorithm.declaration_path(self.related_class))

    def __ne__(self, other):
        return not self.__eq__(other)

    def __lt__(self, other):
        if not isinstance(other, self.__class__):
            return self.__class__.__name__ < other.__class__.__name__
        return (
            algorithm.declaration_path(self.related_class),
            self.access,
            self.is_virtual) < (
            algorithm.declaration_path(
                other.related_class),
            other.access,
            self.is_virtual)

    @property
    def related_class(self):
        "reference to base or derived :class:`class <class_t>`"
        return self._related_class

    @related_class.setter
    def related_class(self, new_related_class):
        if new_related_class:
            assert(isinstance(new_related_class, class_t))
        self._related_class = new_related_class

    @property
    def access(self):
        return self._access

    @access.setter
    def access(self, new_access):
        assert(new_access in ACCESS_TYPES.ALL)
        self._access = new_access

    # TODO: Why is there an access_type / access which are the same ?
    @property
    def access_type(self):
        "describes :class:`hierarchy type <ACCESS_TYPES>`"
        return self.access

    @access_type.setter
    def access_type(self, new_access_type):
        self.access = new_access_type

    # TODO: check whether GCC XML support this and if so parser this
    # information
    @property
    def is_virtual(self):
        "indicates whether the inheritance is virtual or not"
        return self._is_virtual

    @is_virtual.setter
    def is_virtual(self, new_is_virtual):
        self._is_virtual = new_is_virtual


class class_declaration_t(declaration.declaration_t):

    """describes class declaration"""

    def __init__(self, name=''):
        """creates class that describes C++ class declaration
        ( and not definition )"""
        declaration.declaration_t.__init__(self, name)
        self._aliases = []
        self._container_traits = None
        self._container_traits_set = False

    def _get__cmp__items(self):
        """implementation details"""
        return []

    def i_depend_on_them(self, recursive=True):
        return []

    @property
    def aliases(self):
        "List of :class:`aliases <typedef_t>` to this instance"
        return self._aliases

    @aliases.setter
    def aliases(self, new_aliases):
        self._aliases = new_aliases

    @property
    def container_traits(self):
        """reference to :class:`container_traits_impl_t` or None"""
        if self._container_traits_set is False:
            from . import container_traits  # prevent cyclic dependencies
            self._container_traits_set = True
            self._container_traits = container_traits.find_container_traits(
                self)
        return self._container_traits

    def _get_partial_name_impl(self):
        return get_partial_name(self.name)


class class_t(scopedef.scopedef_t):

    """describes class definition"""

    # Can be set from outside
    USE_DEMANGLED_AS_NAME = True

    def __init__(
            self,
            name='',
            class_type=CLASS_TYPES.CLASS,
            is_abstract=False):
        """creates class that describes C++ class definition"""
        scopedef.scopedef_t.__init__(self, name)
        if class_type:
            assert(class_type in CLASS_TYPES.ALL)
        self._class_type = class_type
        self._bases = []
        self._derived = []
        self._is_abstract = is_abstract
        self._public_members = []
        self._private_members = []
        self._protected_members = []
        self._aliases = []
        self._byte_size = 0
        self._byte_align = 0
        self._container_traits = None
        self._container_traits_set = False
        self._recursive_bases = None
        self._recursive_derived = None
        self._use_demangled_as_name = False

    @property
    def use_demangled_as_name(self):
        if "GCC" in utils.xml_generator:
            return class_t.USE_DEMANGLED_AS_NAME
        elif "CastXML" in utils.xml_generator:
            return False

    @use_demangled_as_name.setter
    def use_demangled_as_name(self, use_demangled_as_name):
        self._use_demangled_as_name = use_demangled_as_name

    def _get_name_impl(self):
        if not self._name:  # class with empty name
            return self._name
        elif self.use_demangled_as_name and self.demangled:

            if not self.cache.demangled_name:
                fname = algorithm.full_name(self.parent)
                if fname.startswith('::') and \
                        not self.demangled.startswith('::'):
                    fname = fname[2:]
                if self.demangled.startswith(fname):
                    tmp = self.demangled[len(fname):]  # demangled::name
                    if tmp.startswith('::'):
                        tmp = tmp[2:]
                    if '<' not in tmp and '<' in self._name:
                        # we have template class, but for some reason demangled
                        # name doesn't contain any template
                        # This happens for std::string class, but this breaks
                        # other cases, because this behaviour is not consistent
                        self.cache.demangled_name = self._name
                        return self.cache.demangled_name
                    else:
                        self.cache.demangled_name = tmp
                        return tmp
                else:
                    self.cache.demangled_name = self._name
                    return self._name
            else:
                return self.cache.demangled_name
        else:
            return self._name

    def __str__(self):
        name = algorithm.full_name(self)
        if name[:2] == "::":
            name = name[2:]
        return "%s [%s]" % (name, self.class_type)

    def _get__cmp__scope_items(self):
        """implementation details"""
        return [self.class_type,
                self._sorted_list(
                    [algorithm.declaration_path(base.related_class)
                        for base in self.bases]),
                self._sorted_list(
                    [algorithm.declaration_path(derive.related_class)
                        for derive in self.derived]),
                self.is_abstract,
                self._sorted_list(self.public_members),
                self._sorted_list(self.private_members),
                self._sorted_list(self.protected_members)]

    def __eq__(self, other):
        if not scopedef.scopedef_t.__eq__(self, other):
            return False
        return self.class_type == other.class_type \
            and self._sorted_list(
                [algorithm.declaration_path(base.related_class)
                    for base in self.bases]) \
            == other._sorted_list(
                [algorithm.declaration_path(base.related_class)
                    for base in other.bases]) \
            and self._sorted_list(
                [algorithm.declaration_path(derive.related_class)
                    for derive in self.derived]) \
            == other._sorted_list(
                [algorithm.declaration_path(derive.related_class)
                    for derive in other.derived]) \
            and self.is_abstract == other.is_abstract \
            and self._sorted_list(self.public_members) \
            == other._sorted_list(other.public_members) \
            and self._sorted_list(self.private_members) \
            == other._sorted_list(other.private_members) \
            and self._sorted_list(self.protected_members) \
            == self._sorted_list(other.protected_members)

    def __hash__(self):
        return hash(self.class_type)

    @property
    def class_type(self):
        "describes class :class:`type <CLASS_TYPES>`"
        return self._class_type

    @class_type.setter
    def class_type(self, new_class_type):
        if new_class_type:
            assert(new_class_type in CLASS_TYPES.ALL)
        self._class_type = new_class_type

    @property
    def bases(self):
        "list of :class:`base classes <hierarchy_info_t>`"
        return self._bases

    @bases.setter
    def bases(self, new_bases):
        self._bases = new_bases

    @property
    def recursive_bases(self):
        """list of all :class:`base classes <hierarchy_info_t>`"""
        if self._recursive_bases is None:
            to_go = self.bases[:]
            all_bases = []
            while to_go:
                base = to_go.pop()
                if base not in all_bases:
                    all_bases.append(base)
                    to_go.extend(base.related_class.bases)
            self._recursive_bases = all_bases
        return self._recursive_bases

    @property
    def derived(self):
        "list of :class:`derived classes <hierarchy_info_t>`"
        return self._derived

    @derived.setter
    def derived(self, new_derived):
        self._derived = new_derived

    @property
    def recursive_derived(self):
        """list of all :class:`derive classes <hierarchy_info_t>`"""
        if self._recursive_derived is None:
            to_go = self.derived[:]
            all_derived = []
            while to_go:
                derive = to_go.pop()
                if derive not in all_derived:
                    all_derived.append(derive)
                    to_go.extend(derive.related_class.derived)
            self._recursive_derived = all_derived
        return self._recursive_derived

    @property
    def is_abstract(self):
        "describes whether class abstract or not"
        return self._is_abstract

    @is_abstract.setter
    def is_abstract(self, is_abstract):
        self._is_abstract = is_abstract

    @property
    def public_members(self):
        "list of all public :class:`members <declarationt_>`"
        return self._public_members

    @public_members.setter
    def public_members(self, new_public_members):
        self._public_members = new_public_members

    @property
    def private_members(self):
        "list of all private :class:`members <declarationt_>`"
        return self._private_members

    @private_members.setter
    def private_members(self, new_private_members):
        self._private_members = new_private_members

    @property
    def protected_members(self):
        "list of all protected :class:`members <declarationt_>`"
        return self._protected_members

    @protected_members.setter
    def protected_members(self, new_protected_members):
        self._protected_members = new_protected_members

    @property
    def aliases(self):
        "List of :class:`aliases <typedef_t>` to this instance"
        return self._aliases

    @aliases.setter
    def aliases(self, new_aliases):
        self._aliases = new_aliases

    @property
    def byte_size(self):
        "Size of this class in bytes @type: int"
        return self._byte_size

    @byte_size.setter
    def byte_size(self, new_byte_size):
        self._byte_size = new_byte_size

    @property
    def byte_align(self):
        "Alignment of this class in bytes @type: int"
        return self._byte_align

    @byte_align.setter
    def byte_align(self, new_byte_align):
        self._byte_align = new_byte_align

    def _get_declarations_impl(self):
        return self.get_members()

    def get_members(self, access=None):
        """
        returns list of members according to access type

        If access equals to None, then returned list will contain all members.
        You should not modify the list content, otherwise different
        optimization data will stop work and may to give you wrong results.

        :param access: describes desired members
        :type access: :class:ACCESS_TYPES

        :rtype: [ members ]
        """
        if access == ACCESS_TYPES.PUBLIC:
            return self.public_members
        elif access == ACCESS_TYPES.PROTECTED:
            return self.protected_members
        elif access == ACCESS_TYPES.PRIVATE:
            return self.private_members
        else:
            all_members = []
            all_members.extend(self.public_members)
            all_members.extend(self.protected_members)
            all_members.extend(self.private_members)
            return all_members

    def adopt_declaration(self, decl, access):
        """adds new declaration to the class

        :param decl: reference to a :class:`declaration_t`

        :param access: member access type
        :type access: :class:ACCESS_TYPES
        """
        if access == ACCESS_TYPES.PUBLIC:
            self.public_members.append(decl)
        elif access == ACCESS_TYPES.PROTECTED:
            self.protected_members.append(decl)
        elif access == ACCESS_TYPES.PRIVATE:
            self.private_members.append(decl)
        else:
            raise RuntimeError("Invalid access type: %s." % access)
        decl.parent = self
        decl.cache.reset()
        decl.cache.access_type = access

    def remove_declaration(self, decl):
        """
        removes decl from  members list

        :param decl: declaration to be removed
        :type decl: :class:`declaration_t`
        """

        access_type = self.find_out_member_access_type(decl)
        if access_type == ACCESS_TYPES.PUBLIC:
            container = self.public_members
        elif access_type == ACCESS_TYPES.PROTECTED:
            container = self.protected_members
        else:  # decl.cache.access_type == ACCESS_TYPES.PRVATE
            container = self.private_members
        del container[container.index(decl)]
        decl.cache.reset()

    def find_out_member_access_type(self, member):
        """
        returns member access type

        :param member: member of the class
        :type member: :class:`declaration_t`

        :rtype: :class:ACCESS_TYPES
        """
        assert member.parent is self
        if not member.cache.access_type:
            if member in self.public_members:
                access_type = ACCESS_TYPES.PUBLIC
            elif member in self.protected_members:
                access_type = ACCESS_TYPES.PROTECTED
            elif member in self.private_members:
                access_type = ACCESS_TYPES.PRIVATE
            else:
                raise RuntimeError(
                    "Unable to find member within internal members list.")
            member.cache.access_type = access_type
            return access_type
        else:
            return member.cache.access_type

    def __find_out_member_dependencies(self, access_type):
        members = self.get_members(access_type)
        answer = []
        for mem in members:
            answer.extend(mem.i_depend_on_them(recursive=True))
        member_ids = set([id(m) for m in members])
        for dependency in answer:
            if id(dependency.declaration) in member_ids:
                dependency.access_type = access_type
        return answer

    def i_depend_on_them(self, recursive=True):

        answer = []

        for base in self.bases:
            answer.append(
                dependencies.dependency_info_t(
                    self,
                    base.related_class,
                    base.access_type,
                    "base class"))

        if recursive:
            for access_type in ACCESS_TYPES.ALL:
                answer.extend(self.__find_out_member_dependencies(access_type))

        return answer

    @property
    def container_traits(self):
        """reference to :class:`container_traits_impl_t` or None"""
        if self._container_traits_set is False:
            from . import container_traits  # prevent cyclic dependencies
            self._container_traits_set = True
            self._container_traits = container_traits.find_container_traits(
                self)
        return self._container_traits

    def find_copy_constructor(self):
        copy_ = self.constructors(
            lambda x: x.is_copy_constructor,
            recursive=False,
            allow_empty=True)
        if copy_:
            return copy_[0]
        else:
            return None

    def find_trivial_constructor(self):
        trivial = self.constructors(
            lambda x: x.is_trivial_constructor,
            recursive=False,
            allow_empty=True)
        if trivial:
            return trivial[0]
        else:
            return None

    def _get_partial_name_impl(self):
        from . import type_traits  # prevent cyclic dependencies
        if type_traits.is_std_string(self):
            return 'string'
        elif type_traits.is_std_wstring(self):
            return 'wstring'
        else:
            return get_partial_name(self.name)

    def find_noncopyable_vars(self):
        """returns list of all `noncopyable` variables"""

        from . import type_traits as tt  # prevent cyclic dependencies

        logger = utils.loggers.cxx_parser
        mvars = self.variables(
            lambda v: not v.type_qualifiers.has_static,
            recursive=False,
            allow_empty=True)
        noncopyable_vars = []

        message = (
            "__contains_noncopyable_mem_var - %s - TRUE - " +
            "containes const member variable")

        for mvar in mvars:

            type_ = tt.remove_reference(mvar.type)

            if tt.is_const(type_):
                no_const = tt.remove_const(type_)
                if tt.is_fundamental(no_const) or tt.is_enum(no_const):
                    logger.debug((
                        message + "- fundamental or enum")
                        % self.decl_string)
                    noncopyable_vars.append(mvar)
                if tt.is_class(no_const):
                    logger.debug((message + " - class") % self.decl_string)
                    noncopyable_vars.append(mvar)
                if tt.is_array(no_const):
                    logger.debug((message + " - array") % self.decl_string)
                    noncopyable_vars.append(mvar)

            if tt.class_traits.is_my_case(type_):

                cls = tt.class_traits.get_declaration(type_)
                if tt.is_noncopyable(cls):
                    logger.debug((
                        message + " - class that is not copyable")
                        % self.decl_string)
                    noncopyable_vars.append(mvar)

        logger.debug((
            "__contains_noncopyable_mem_var - %s - FALSE - doesn't " +
            "contain noncopyable members") % self.decl_string)

        return noncopyable_vars

    @property
    def has_vtable(self):
        """True, if class has virtual table, False otherwise"""
        from . import calldef
        return bool(
            self.calldefs(
                lambda f: isinstance(f, calldef.member_function_t) and
                f.virtuality != calldef.VIRTUALITY_TYPES.NOT_VIRTUAL,
                recursive=False,
                allow_empty=True))

    @property
    def top_class(self):
        """reference to a parent class, which contains this class and defined
        within a namespace

        if this class is defined under a namespace, self will be returned"""
        curr = self
        parent = self.parent
        while isinstance(parent, class_t):
            curr = parent
            parent = parent.parent
        return curr

class_types = (class_t, class_declaration_t)

1	# Copyright 2014-2016 Insight Software Consortium.
2	# Copyright 2004-2008 Roman Yakovenko.
3	# Distributed under the Boost Software License, Version 1.0.
4	# See http://www.boost.org/LICENSE_1_0.txt
5
6	"""	8✔
7	defines classes, that describes C++ classes
8
9	This modules contains definition for next C++ declarations:
10	- class definition
11	- class declaration
12	- small helper class for describing C++ class hierarchy
13	"""
14
15	from . import scopedef	8✔
16	from . import algorithm	8✔
17	from . import declaration	8✔
18	from . import dependencies	8✔
19	from pygccxml import utils	8✔
20
21
22	class ACCESS_TYPES(object):	8✔
23
24	"""class that defines "access" constants"""
25	PUBLIC = "public"	8✔
26	PRIVATE = "private"	8✔
27	PROTECTED = "protected"	8✔
28	ALL = [PUBLIC, PRIVATE, PROTECTED]	8✔
29
30
31	class CLASS_TYPES(object):	8✔
32
33	"""class that defines "class" type constants"""
34	CLASS = "class"	8✔
35	STRUCT = "struct"	8✔
36	UNION = "union"	8✔
37	ALL = [CLASS, STRUCT, UNION]	8✔
38
39
40	def get_partial_name(name):	8✔
41	from . import templates	8✔
42	from . import container_traits # prevent cyclic dependencies	8✔
43	ct = container_traits.find_container_traits(name)	8✔
44	if ct:	8✔
45	return ct.remove_defaults(name)	8✔
46	elif templates.is_instantiation(name):	8✔
47	tmpl_name, args = templates.split(name)	8✔
48	for i, arg_name in enumerate(args):	8✔
49	args[i] = get_partial_name(arg_name.strip())	8✔
50	return templates.join(tmpl_name, args)	8✔
51	else:
52	return name	8✔
53
54
55	class hierarchy_info_t(object):	8✔
56
57	"""describes class relationship"""
58
59	def __init__(self, related_class=None, access=None, is_virtual=False):	8✔
60	"""creates class that contains partial information about class
61	relationship"""
62	if related_class:	8✔
63	assert(isinstance(related_class, class_t))	8✔
64	self._related_class = related_class	8✔
65	if access:	8✔
66	assert(access in ACCESS_TYPES.ALL)	8✔
67	self._access = access	8✔
68	self._is_virtual = is_virtual	8✔
69
70	def __eq__(self, other):	8✔
71	if not isinstance(other, hierarchy_info_t):	8✔
72	return False	×
73	return algorithm.declaration_path(self.related_class) == \	8✔
74	algorithm.declaration_path(other.related_class) \
75	and self.access == other.access \
76	and self.is_virtual == other.is_virtual
77
78	def __hash__(self):	8✔
79	return hash(algorithm.declaration_path(self.related_class))	×
80
81	def __ne__(self, other):	8✔
82	return not self.__eq__(other)	×
83
84	def __lt__(self, other):	8✔
85	if not isinstance(other, self.__class__):	×
86	return self.__class__.__name__ < other.__class__.__name__	×
87	return (	×
88	algorithm.declaration_path(self.related_class),
89	self.access,
90	self.is_virtual) < (
91	algorithm.declaration_path(
92	other.related_class),
93	other.access,
94	self.is_virtual)
95
96	@property	8✔
97	def related_class(self):
98	"reference to base or derived :class:`class <class_t>`"
99	return self._related_class	8✔
100
101	@related_class.setter	8✔
102	def related_class(self, new_related_class):
103	if new_related_class:	8✔
104	assert(isinstance(new_related_class, class_t))	8✔
105	self._related_class = new_related_class	8✔
106
107	@property	8✔
108	def access(self):
109	return self._access	8✔
110
111	@access.setter	8✔
112	def access(self, new_access):
113	assert(new_access in ACCESS_TYPES.ALL)	×
114	self._access = new_access	×
115
116	# TODO: Why is there an access_type / access which are the same ?
117	@property	8✔
118	def access_type(self):
119	"describes :class:`hierarchy type <ACCESS_TYPES>`"
120	return self.access	8✔
121
122	@access_type.setter	8✔
123	def access_type(self, new_access_type):
124	self.access = new_access_type	×
125
126	# TODO: check whether GCC XML support this and if so parser this
127	# information
128	@property	8✔
129	def is_virtual(self):
130	"indicates whether the inheritance is virtual or not"
131	return self._is_virtual	8✔
132
133	@is_virtual.setter	8✔
134	def is_virtual(self, new_is_virtual):
135	self._is_virtual = new_is_virtual	×
136
137
138	class class_declaration_t(declaration.declaration_t):	8✔
139
140	"""describes class declaration"""
141
142	def __init__(self, name=''):	8✔
143	"""creates class that describes C++ class declaration
144	( and not definition )"""
145	declaration.declaration_t.__init__(self, name)	8✔
146	self._aliases = []	8✔
147	self._container_traits = None	8✔
148	self._container_traits_set = False	8✔
149
150	def _get__cmp__items(self):	8✔
151	"""implementation details"""
152	return []	8✔
153
154	def i_depend_on_them(self, recursive=True):	8✔
155	return []	8✔
156
157	@property	8✔
158	def aliases(self):
159	"List of :class:`aliases <typedef_t>` to this instance"
160	return self._aliases	8✔
161
162	@aliases.setter	8✔
163	def aliases(self, new_aliases):
164	self._aliases = new_aliases	×
165
166	@property	8✔
167	def container_traits(self):
168	"""reference to :class:`container_traits_impl_t` or None"""
169	if self._container_traits_set is False:	8✔
170	from . import container_traits # prevent cyclic dependencies	8✔
171	self._container_traits_set = True	8✔
172	self._container_traits = container_traits.find_container_traits(	8✔
173	self)
174	return self._container_traits	8✔
175
176	def _get_partial_name_impl(self):	8✔
177	return get_partial_name(self.name)	8✔
178
179
180	class class_t(scopedef.scopedef_t):	8✔
181
182	"""describes class definition"""
183
184	# Can be set from outside
185	USE_DEMANGLED_AS_NAME = True	8✔
186
187	def __init__(	8✔
188	self,
189	name='',
190	class_type=CLASS_TYPES.CLASS,
191	is_abstract=False):
192	"""creates class that describes C++ class definition"""
193	scopedef.scopedef_t.__init__(self, name)	8✔
194	if class_type:	8✔
195	assert(class_type in CLASS_TYPES.ALL)	8✔
196	self._class_type = class_type	8✔
197	self._bases = []	8✔
198	self._derived = []	8✔
199	self._is_abstract = is_abstract	8✔
200	self._public_members = []	8✔
201	self._private_members = []	8✔
202	self._protected_members = []	8✔
203	self._aliases = []	8✔
204	self._byte_size = 0	8✔
205	self._byte_align = 0	8✔
206	self._container_traits = None	8✔
207	self._container_traits_set = False	8✔
208	self._recursive_bases = None	8✔
209	self._recursive_derived = None	8✔
210	self._use_demangled_as_name = False	8✔
211
212	@property	8✔
213	def use_demangled_as_name(self):
214	if "GCC" in utils.xml_generator:	8✔
215	return class_t.USE_DEMANGLED_AS_NAME	8✔
216	elif "CastXML" in utils.xml_generator:	2 only XML_GENERATOR="castxml", XML_GENERATOR="castxml", XML_GENERATOR="castxml" TRAVIS_PYTHON_VERSION="2", and XML_GENERATOR="castxml" TRAVIS_PYTHON_VERSION="3" ✔
217	return False	2 only XML_GENERATOR="castxml", XML_GENERATOR="castxml", XML_GENERATOR="castxml" TRAVIS_PYTHON_VERSION="2", and XML_GENERATOR="castxml" TRAVIS_PYTHON_VERSION="3" ✔
218
219	@use_demangled_as_name.setter	8✔
220	def use_demangled_as_name(self, use_demangled_as_name):
221	self._use_demangled_as_name = use_demangled_as_name	×
222
223	def _get_name_impl(self):	8✔
224	if not self._name: # class with empty name	8✔
225	return self._name	8✔
226	elif self.use_demangled_as_name and self.demangled:	8✔
227
228	if not self.cache.demangled_name:	8✔
229	fname = algorithm.full_name(self.parent)	8✔
230	if fname.startswith('::') and \	8✔
231	not self.demangled.startswith('::'):
232	fname = fname[2:]	8✔
233	if self.demangled.startswith(fname):	8✔
234	tmp = self.demangled[len(fname):] # demangled::name	8✔
235	if tmp.startswith('::'):	8✔
236	tmp = tmp[2:]	8✔
237	if '<' not in tmp and '<' in self._name:	8✔
238	# we have template class, but for some reason demangled
239	# name doesn't contain any template
240	# This happens for std::string class, but this breaks
241	# other cases, because this behaviour is not consistent
242	self.cache.demangled_name = self._name	8✔
243	return self.cache.demangled_name	8✔
244	else:
245	self.cache.demangled_name = tmp	8✔
246	return tmp	8✔
247	else:
248	self.cache.demangled_name = self._name	8✔
249	return self._name	8✔
250	else:
251	return self.cache.demangled_name	8✔
252	else:
253	return self._name	8✔
254
255	def __str__(self):	8✔
256	name = algorithm.full_name(self)	8✔
257	if name[:2] == "::":	8✔
258	name = name[2:]	8✔
259	return "%s [%s]" % (name, self.class_type)	8✔
260
261	def _get__cmp__scope_items(self):	8✔
262	"""implementation details"""
263	return [self.class_type,	8✔
264	self._sorted_list(
265	[algorithm.declaration_path(base.related_class)
266	for base in self.bases]),
267	self._sorted_list(
268	[algorithm.declaration_path(derive.related_class)
269	for derive in self.derived]),
270	self.is_abstract,
271	self._sorted_list(self.public_members),
272	self._sorted_list(self.private_members),
273	self._sorted_list(self.protected_members)]
274
275	def __eq__(self, other):	8✔
276	if not scopedef.scopedef_t.__eq__(self, other):	8✔
277	return False	8✔
278	return self.class_type == other.class_type \	8✔
279	and self._sorted_list(
280	[algorithm.declaration_path(base.related_class)
281	for base in self.bases]) \
282	== other._sorted_list(
283	[algorithm.declaration_path(base.related_class)
284	for base in other.bases]) \
285	and self._sorted_list(
286	[algorithm.declaration_path(derive.related_class)
287	for derive in self.derived]) \
288	== other._sorted_list(
289	[algorithm.declaration_path(derive.related_class)
290	for derive in other.derived]) \
291	and self.is_abstract == other.is_abstract \
292	and self._sorted_list(self.public_members) \
293	== other._sorted_list(other.public_members) \
294	and self._sorted_list(self.private_members) \
295	== other._sorted_list(other.private_members) \
296	and self._sorted_list(self.protected_members) \
297	== self._sorted_list(other.protected_members)
298
299	def __hash__(self):	8✔
300	return hash(self.class_type)	×
301
302	@property	8✔
303	def class_type(self):
304	"describes class :class:`type <CLASS_TYPES>`"
305	return self._class_type	8✔
306
307	@class_type.setter	8✔
308	def class_type(self, new_class_type):
309	if new_class_type:	×
310	assert(new_class_type in CLASS_TYPES.ALL)	×
311	self._class_type = new_class_type	×
312
313	@property	8✔
314	def bases(self):
315	"list of :class:`base classes <hierarchy_info_t>`"
316	return self._bases	8✔
317
318	@bases.setter	8✔
319	def bases(self, new_bases):
320	self._bases = new_bases	8✔
321
322	@property	8✔
323	def recursive_bases(self):
324	"""list of all :class:`base classes <hierarchy_info_t>`"""
325	if self._recursive_bases is None:	8✔
326	to_go = self.bases[:]	8✔
327	all_bases = []	8✔
328	while to_go:	8✔
329	base = to_go.pop()	8✔
330	if base not in all_bases:	8✔
331	all_bases.append(base)	8✔
332	to_go.extend(base.related_class.bases)	8✔
333	self._recursive_bases = all_bases	8✔
334	return self._recursive_bases	8✔
335
336	@property	8✔
337	def derived(self):
338	"list of :class:`derived classes <hierarchy_info_t>`"
339	return self._derived	8✔
340
341	@derived.setter	8✔
342	def derived(self, new_derived):
343	self._derived = new_derived	×
344
345	@property	8✔
346	def recursive_derived(self):
347	"""list of all :class:`derive classes <hierarchy_info_t>`"""
348	if self._recursive_derived is None:	8✔
349	to_go = self.derived[:]	8✔
350	all_derived = []	8✔
351	while to_go:	8✔
352	derive = to_go.pop()	8✔
353	if derive not in all_derived:	8✔
354	all_derived.append(derive)	8✔
355	to_go.extend(derive.related_class.derived)	8✔
356	self._recursive_derived = all_derived	8✔
357	return self._recursive_derived	8✔
358
359	@property	8✔
360	def is_abstract(self):
361	"describes whether class abstract or not"
362	return self._is_abstract	8✔
363
364	@is_abstract.setter	8✔
365	def is_abstract(self, is_abstract):
366	self._is_abstract = is_abstract	8✔
367
368	@property	8✔
369	def public_members(self):
370	"list of all public :class:`members <declarationt_>`"
371	return self._public_members	8✔
372
373	@public_members.setter	8✔
374	def public_members(self, new_public_members):
375	self._public_members = new_public_members	×
376
377	@property	8✔
378	def private_members(self):
379	"list of all private :class:`members <declarationt_>`"
380	return self._private_members	8✔
381
382	@private_members.setter	8✔
383	def private_members(self, new_private_members):
384	self._private_members = new_private_members	×
385
386	@property	8✔
387	def protected_members(self):
388	"list of all protected :class:`members <declarationt_>`"
389	return self._protected_members	8✔
390
391	@protected_members.setter	8✔
392	def protected_members(self, new_protected_members):
393	self._protected_members = new_protected_members	×
394
395	@property	8✔
396	def aliases(self):
397	"List of :class:`aliases <typedef_t>` to this instance"
398	return self._aliases	8✔
399
400	@aliases.setter	8✔
401	def aliases(self, new_aliases):
402	self._aliases = new_aliases	×
403
404	@property	8✔
405	def byte_size(self):
406	"Size of this class in bytes @type: int"
407	return self._byte_size	8✔
408
409	@byte_size.setter	8✔
410	def byte_size(self, new_byte_size):
411	self._byte_size = new_byte_size	8✔
412
413	@property	8✔
414	def byte_align(self):
415	"Alignment of this class in bytes @type: int"
416	return self._byte_align	8✔
417
418	@byte_align.setter	8✔
419	def byte_align(self, new_byte_align):
420	self._byte_align = new_byte_align	8✔
421
422	def _get_declarations_impl(self):	8✔
423	return self.get_members()	8✔
424
425	def get_members(self, access=None):	8✔
426	"""
427	returns list of members according to access type
428
429	If access equals to None, then returned list will contain all members.
430	You should not modify the list content, otherwise different
431	optimization data will stop work and may to give you wrong results.
432
433	:param access: describes desired members
434	:type access: :class:ACCESS_TYPES
435
436	:rtype: [ members ]
437	"""
438	if access == ACCESS_TYPES.PUBLIC:	8✔
439	return self.public_members	8✔
440	elif access == ACCESS_TYPES.PROTECTED:	8✔
441	return self.protected_members	8✔
442	elif access == ACCESS_TYPES.PRIVATE:	8✔
443	return self.private_members	8✔
444	else:
445	all_members = []	8✔
446	all_members.extend(self.public_members)	8✔
447	all_members.extend(self.protected_members)	8✔
448	all_members.extend(self.private_members)	8✔
449	return all_members	8✔
450
451	def adopt_declaration(self, decl, access):	8✔
452	"""adds new declaration to the class
453
454	:param decl: reference to a :class:`declaration_t`
455
456	:param access: member access type
457	:type access: :class:ACCESS_TYPES
458	"""
459	if access == ACCESS_TYPES.PUBLIC:	8✔
460	self.public_members.append(decl)	8✔
461	elif access == ACCESS_TYPES.PROTECTED:	8✔
462	self.protected_members.append(decl)	8✔
463	elif access == ACCESS_TYPES.PRIVATE:	8✔
464	self.private_members.append(decl)	8✔
465	else:
466	raise RuntimeError("Invalid access type: %s." % access)	×
467	decl.parent = self	8✔
468	decl.cache.reset()	8✔
469	decl.cache.access_type = access	8✔
470
471	def remove_declaration(self, decl):	8✔
472	"""
473	removes decl from members list
474
475	:param decl: declaration to be removed
476	:type decl: :class:`declaration_t`
477	"""
478
479	access_type = self.find_out_member_access_type(decl)	×
480	if access_type == ACCESS_TYPES.PUBLIC:	×
481	container = self.public_members	×
482	elif access_type == ACCESS_TYPES.PROTECTED:	×
483	container = self.protected_members	×
484	else: # decl.cache.access_type == ACCESS_TYPES.PRVATE
485	container = self.private_members	×
486	del container[container.index(decl)]	×
487	decl.cache.reset()	×
488
489	def find_out_member_access_type(self, member):	8✔
490	"""
491	returns member access type
492
493	:param member: member of the class
494	:type member: :class:`declaration_t`
495
496	:rtype: :class:ACCESS_TYPES
497	"""
498	assert member.parent is self	8✔
499	if not member.cache.access_type:	8✔
500	if member in self.public_members:	8✔
501	access_type = ACCESS_TYPES.PUBLIC	8✔
502	elif member in self.protected_members:	×
503	access_type = ACCESS_TYPES.PROTECTED	×
504	elif member in self.private_members:	×
505	access_type = ACCESS_TYPES.PRIVATE	×
506	else:
507	raise RuntimeError(	×
508	"Unable to find member within internal members list.")
509	member.cache.access_type = access_type	8✔
510	return access_type	8✔
511	else:
512	return member.cache.access_type	8✔
513
514	def __find_out_member_dependencies(self, access_type):	8✔
515	members = self.get_members(access_type)	8✔
516	answer = []	8✔
517	for mem in members:	8✔
518	answer.extend(mem.i_depend_on_them(recursive=True))	8✔
519	member_ids = set([id(m) for m in members])	8✔
520	for dependency in answer:	8✔
521	if id(dependency.declaration) in member_ids:	8✔
522	dependency.access_type = access_type	8✔
523	return answer	8✔
524
525	def i_depend_on_them(self, recursive=True):	8✔
526
527	answer = []	8✔
528
529	for base in self.bases:	8✔
530	answer.append(	8✔
531	dependencies.dependency_info_t(
532	self,
533	base.related_class,
534	base.access_type,
535	"base class"))
536
537	if recursive:	8✔
538	for access_type in ACCESS_TYPES.ALL:	8✔
539	answer.extend(self.__find_out_member_dependencies(access_type))	8✔
540
541	return answer	8✔
542
543	@property	8✔
544	def container_traits(self):
545	"""reference to :class:`container_traits_impl_t` or None"""
546	if self._container_traits_set is False:	8✔
547	from . import container_traits # prevent cyclic dependencies	8✔
548	self._container_traits_set = True	8✔
549	self._container_traits = container_traits.find_container_traits(	8✔
550	self)
551	return self._container_traits	8✔
552
553	def find_copy_constructor(self):	8✔
554	copy_ = self.constructors(	8✔
555	lambda x: x.is_copy_constructor,
556	recursive=False,
557	allow_empty=True)
558	if copy_:	8✔
559	return copy_[0]	8✔
560	else:
561	return None	8✔
562
563	def find_trivial_constructor(self):	8✔
564	trivial = self.constructors(	8✔
565	lambda x: x.is_trivial_constructor,
566	recursive=False,
567	allow_empty=True)
568	if trivial:	8✔
569	return trivial[0]	8✔
570	else:
571	return None	×
572
573	def _get_partial_name_impl(self):	8✔
574	from . import type_traits # prevent cyclic dependencies	8✔
575	if type_traits.is_std_string(self):	8✔
576	return 'string'	8✔
577	elif type_traits.is_std_wstring(self):	8✔
578	return 'wstring'	8✔
579	else:
580	return get_partial_name(self.name)	8✔
581
582	def find_noncopyable_vars(self):	8✔
583	"""returns list of all `noncopyable` variables"""
584
585	from . import type_traits as tt # prevent cyclic dependencies	8✔
586
587	logger = utils.loggers.cxx_parser	8✔
588	mvars = self.variables(	8✔
589	lambda v: not v.type_qualifiers.has_static,
590	recursive=False,
591	allow_empty=True)
592	noncopyable_vars = []	8✔
593
594	message = (	8✔
595	"__contains_noncopyable_mem_var - %s - TRUE - " +
596	"containes const member variable")
597
598	for mvar in mvars:	8✔
599
600	type_ = tt.remove_reference(mvar.type)	8✔
601
602	if tt.is_const(type_):	8✔
603	no_const = tt.remove_const(type_)	8✔
604	if tt.is_fundamental(no_const) or tt.is_enum(no_const):	8✔
605	logger.debug((	8✔
606	message + "- fundamental or enum")
607	% self.decl_string)
608	noncopyable_vars.append(mvar)	8✔
609	if tt.is_class(no_const):	8✔
610	logger.debug((message + " - class") % self.decl_string)	8✔
611	noncopyable_vars.append(mvar)	8✔
612	if tt.is_array(no_const):	8✔
613	logger.debug((message + " - array") % self.decl_string)	8✔
614	noncopyable_vars.append(mvar)	8✔
615
616	if tt.class_traits.is_my_case(type_):	8✔
617
618	cls = tt.class_traits.get_declaration(type_)	8✔
619	if tt.is_noncopyable(cls):	8✔
620	logger.debug((	×
621	message + " - class that is not copyable")
622	% self.decl_string)
623	noncopyable_vars.append(mvar)	×
624
625	logger.debug((	8✔
626	"__contains_noncopyable_mem_var - %s - FALSE - doesn't " +
627	"contain noncopyable members") % self.decl_string)
628
629	return noncopyable_vars	8✔
630
631	@property	8✔
632	def has_vtable(self):
633	"""True, if class has virtual table, False otherwise"""
634	from . import calldef	×
635	return bool(	×
636	self.calldefs(
637	lambda f: isinstance(f, calldef.member_function_t) and
638	f.virtuality != calldef.VIRTUALITY_TYPES.NOT_VIRTUAL,
639	recursive=False,
640	allow_empty=True))
641
642	@property	8✔
643	def top_class(self):
644	"""reference to a parent class, which contains this class and defined
645	within a namespace
646
647	if this class is defined under a namespace, self will be returned"""
648	curr = self	×
649	parent = self.parent	×
650	while isinstance(parent, class_t):	×
651	curr = parent	×
652	parent = parent.parent	×
653	return curr	×
654
655	class_types = (class_t, class_declaration_t)	8✔

gccxml / pygccxml / 362

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous