aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Symbol/CompilerDeclContext.h
blob: 70399b2dbb371a24a27a549c0a8b8f1db74e8722 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
//===-- CompilerDeclContext.h -----------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_CompilerDeclContext_h_
#define liblldb_CompilerDeclContext_h_

#include <vector>

#include "lldb/lldb-private.h"
#include "lldb/Core/ConstString.h"

namespace lldb_private {

class CompilerDeclContext
{
public:
    //----------------------------------------------------------------------
    // Constructors and Destructors
    //----------------------------------------------------------------------
    CompilerDeclContext () :
        m_type_system  (nullptr),
        m_opaque_decl_ctx (nullptr)
    {
    }

    CompilerDeclContext (TypeSystem *type_system, void *decl_ctx) :
        m_type_system (type_system),
        m_opaque_decl_ctx (decl_ctx)
    {
    }

    ~CompilerDeclContext()
    {
    }

    //----------------------------------------------------------------------
    // Tests
    //----------------------------------------------------------------------

    explicit operator bool () const
    {
        return IsValid ();
    }
    
    bool
    operator < (const CompilerDeclContext &rhs) const
    {
        if (m_type_system == rhs.m_type_system)
            return m_opaque_decl_ctx < rhs.m_opaque_decl_ctx;
        return m_type_system < rhs.m_type_system;
    }

    bool
    IsValid () const
    {
        return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
    }

    bool
    IsClang () const;

    std::vector<CompilerDecl>
    FindDeclByName (ConstString name);

    //----------------------------------------------------------------------
    /// Checks if this decl context represents a method of a class.
    ///
    /// @param[out] language_ptr
    ///     If non NULL and \b true is returned from this function,
    ///     this will indicate if the language that respresents the method.
    ///
    /// @param[out] is_instance_method_ptr
    ///     If non NULL and \b true is returned from this function,
    ///     this will indicate if the method is an instance function (true)
    ///     or a class method (false indicating the function is static, or
    ///     doesn't require an instance of the class to be called).
    ///
    /// @param[out] language_object_name_ptr
    ///     If non NULL and \b true is returned from this function,
    ///     this will indicate if implicit object name for the language
    ///     like "this" for C++, and "self" for Objective C.
    ///
    /// @return
    ///     Returns true if this is a decl context that represents a method
    ///     in a struct, union or class.
    //----------------------------------------------------------------------
    bool
    IsClassMethod (lldb::LanguageType *language_ptr,
                   bool *is_instance_method_ptr,
                   ConstString *language_object_name_ptr);

    //----------------------------------------------------------------------
    // Accessors
    //----------------------------------------------------------------------
    
    TypeSystem *
    GetTypeSystem() const
    {
        return m_type_system;
    }
    
    void *
    GetOpaqueDeclContext() const
    {
        return m_opaque_decl_ctx;
    }

    void
    SetDeclContext (TypeSystem* type_system, void* decl_ctx)
    {
        m_type_system = type_system;
        m_opaque_decl_ctx = decl_ctx;
    }

    void
    Clear()
    {
        m_type_system = nullptr;
        m_opaque_decl_ctx = nullptr;
    }

    ConstString
    GetName () const;

    bool
    IsStructUnionOrClass () const;

private:
    TypeSystem *m_type_system;
    void *m_opaque_decl_ctx;
    
};
    
bool operator == (const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
bool operator != (const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);

    
} // namespace lldb_private

#endif // #ifndef liblldb_CompilerDeclContext_h_