SBCompileUnit.cpp revision 276479 
1//===-- SBCompileUnit.cpp ---------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/API/SBCompileUnit.h"
11#include "lldb/API/SBLineEntry.h"
12#include "lldb/API/SBStream.h"
13#include "lldb/Core/Log.h"
14#include "lldb/Core/Module.h"
15#include "lldb/Symbol/CompileUnit.h"
16#include "lldb/Symbol/LineEntry.h"
17#include "lldb/Symbol/LineTable.h"
18#include "lldb/Symbol/SymbolVendor.h"
19#include "lldb/Symbol/Type.h"
20
21using namespace lldb;
22using namespace lldb_private;
23
24
25SBCompileUnit::SBCompileUnit () :
26    m_opaque_ptr (NULL)
27{
28}
29
30SBCompileUnit::SBCompileUnit (lldb_private::CompileUnit *lldb_object_ptr) :
31    m_opaque_ptr (lldb_object_ptr)
32{
33}
34
35SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) :
36    m_opaque_ptr (rhs.m_opaque_ptr)
37{
38}
39
40const SBCompileUnit &
41SBCompileUnit::operator = (const SBCompileUnit &rhs)
42{
43    m_opaque_ptr = rhs.m_opaque_ptr;
44    return *this;
45}
46
47
48SBCompileUnit::~SBCompileUnit ()
49{
50    m_opaque_ptr = NULL;
51}
52
53SBFileSpec
54SBCompileUnit::GetFileSpec () const
55{
56    SBFileSpec file_spec;
57    if (m_opaque_ptr)
58        file_spec.SetFileSpec(*m_opaque_ptr);
59    return file_spec;
60}
61
62uint32_t
63SBCompileUnit::GetNumLineEntries () const
64{
65    if (m_opaque_ptr)
66    {
67        LineTable *line_table = m_opaque_ptr->GetLineTable ();
68        if (line_table)
69            return line_table->GetSize();
70    }
71    return 0;
72}
73
74SBLineEntry
75SBCompileUnit::GetLineEntryAtIndex (uint32_t idx) const
76{
77    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
78
79    SBLineEntry sb_line_entry;
80    if (m_opaque_ptr)
81    {
82        LineTable *line_table = m_opaque_ptr->GetLineTable ();
83        if (line_table)
84        {
85            LineEntry line_entry;
86            if (line_table->GetLineEntryAtIndex(idx, line_entry))
87                sb_line_entry.SetLineEntry(line_entry);
88        }
89    }
90
91    if (log)
92    {
93        SBStream sstr;
94        sb_line_entry.GetDescription (sstr);
95        log->Printf ("SBCompileUnit(%p)::GetLineEntryAtIndex (idx=%u) => SBLineEntry(%p): '%s'",
96                     static_cast<void*>(m_opaque_ptr), idx,
97                     static_cast<void*>(sb_line_entry.get()), sstr.GetData());
98    }
99
100    return sb_line_entry;
101}
102
103uint32_t
104SBCompileUnit::FindLineEntryIndex (uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec) const
105{
106    const bool exact = true;
107    return FindLineEntryIndex (start_idx, line, inline_file_spec, exact);
108}
109
110uint32_t
111SBCompileUnit::FindLineEntryIndex (uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec, bool exact) const
112{
113    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
114
115    uint32_t index = UINT32_MAX;
116    if (m_opaque_ptr)
117    {
118        FileSpec file_spec;
119        if (inline_file_spec && inline_file_spec->IsValid())
120            file_spec = inline_file_spec->ref();
121        else
122            file_spec = *m_opaque_ptr;
123
124        index = m_opaque_ptr->FindLineEntry (start_idx,
125                                             line,
126                                             inline_file_spec ? inline_file_spec->get() : NULL,
127                                             exact,
128                                             NULL);
129    }
130
131    if (log)
132    {
133        SBStream sstr;
134        if (index == UINT32_MAX)
135        {
136            log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => NOT FOUND",
137                         static_cast<void*>(m_opaque_ptr), start_idx, line,
138                         inline_file_spec
139                            ? static_cast<const void*>(inline_file_spec->get())
140                            : NULL);
141        }
142        else
143        {
144            log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => %u",
145                         static_cast<void*>(m_opaque_ptr), start_idx, line,
146                         inline_file_spec
147                            ? static_cast<const void*>(inline_file_spec->get())
148                            : NULL,
149                         index);
150        }
151    }
152
153    return index;
154}
155
156uint32_t
157SBCompileUnit::GetNumSupportFiles () const
158{
159    if (m_opaque_ptr)
160    {
161        FileSpecList& support_files = m_opaque_ptr->GetSupportFiles ();
162        return support_files.GetSize();
163    }
164    return 0;
165}
166
167
168
169lldb::SBTypeList
170SBCompileUnit::GetTypes (uint32_t type_mask)
171{
172    SBTypeList sb_type_list;
173
174    if (m_opaque_ptr)
175    {
176        ModuleSP module_sp (m_opaque_ptr->GetModule());
177        if (module_sp)
178        {
179            SymbolVendor* vendor = module_sp->GetSymbolVendor();
180            if (vendor)
181            {
182                TypeList type_list;
183                vendor->GetTypes (m_opaque_ptr, type_mask, type_list);
184                sb_type_list.m_opaque_ap->Append(type_list);
185            }
186        }
187    }
188    return sb_type_list;
189}
190
191
192
193
194SBFileSpec
195SBCompileUnit::GetSupportFileAtIndex (uint32_t idx) const
196{
197    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
198
199    SBFileSpec sb_file_spec;
200    if (m_opaque_ptr)
201    {
202        FileSpecList &support_files = m_opaque_ptr->GetSupportFiles ();
203        FileSpec file_spec = support_files.GetFileSpecAtIndex(idx);
204        sb_file_spec.SetFileSpec(file_spec);
205    }
206
207    if (log)
208    {
209        SBStream sstr;
210        sb_file_spec.GetDescription (sstr);
211        log->Printf ("SBCompileUnit(%p)::GetGetFileSpecAtIndex (idx=%u) => SBFileSpec(%p): '%s'",
212                     static_cast<void*>(m_opaque_ptr), idx,
213                     static_cast<const void*>(sb_file_spec.get()),
214                     sstr.GetData());
215    }
216
217    return sb_file_spec;
218}
219
220uint32_t
221SBCompileUnit::FindSupportFileIndex (uint32_t start_idx, const SBFileSpec &sb_file, bool full)
222{
223    if (m_opaque_ptr)
224    {
225	FileSpecList &support_files = m_opaque_ptr->GetSupportFiles ();
226	return support_files.FindFileIndex(start_idx, sb_file.ref(), full);
227    }
228    return 0;
229}
230
231bool
232SBCompileUnit::IsValid () const
233{
234    return m_opaque_ptr != NULL;
235}
236
237bool
238SBCompileUnit::operator == (const SBCompileUnit &rhs) const
239{
240    return m_opaque_ptr == rhs.m_opaque_ptr;
241}
242
243bool
244SBCompileUnit::operator != (const SBCompileUnit &rhs) const
245{
246    return m_opaque_ptr != rhs.m_opaque_ptr;
247}
248
249const lldb_private::CompileUnit *
250SBCompileUnit::operator->() const
251{
252    return m_opaque_ptr;
253}
254
255const lldb_private::CompileUnit &
256SBCompileUnit::operator*() const
257{
258    return *m_opaque_ptr;
259}
260
261lldb_private::CompileUnit *
262SBCompileUnit::get ()
263{
264    return m_opaque_ptr;
265}
266
267void
268SBCompileUnit::reset (lldb_private::CompileUnit *lldb_object_ptr)
269{
270    m_opaque_ptr = lldb_object_ptr;
271}
272
273
274bool
275SBCompileUnit::GetDescription (SBStream &description)
276{
277    Stream &strm = description.ref();
278
279    if (m_opaque_ptr)
280    {
281        m_opaque_ptr->Dump (&strm, false);
282    }
283    else
284        strm.PutCString ("No value");
285
286    return true;
287}
288