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/Symbol/CompileUnit.h"
14 #include "lldb/Symbol/LineEntry.h"
15 #include "lldb/Symbol/LineTable.h"
16 #include "lldb/Core/Log.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 
22 SBCompileUnit::SBCompileUnit () :
23     m_opaque_ptr (NULL)
24 {
25 }
26 
27 SBCompileUnit::SBCompileUnit (lldb_private::CompileUnit *lldb_object_ptr) :
28     m_opaque_ptr (lldb_object_ptr)
29 {
30 }
31 
32 SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) :
33     m_opaque_ptr (rhs.m_opaque_ptr)
34 {
35 }
36 
37 const SBCompileUnit &
38 SBCompileUnit::operator = (const SBCompileUnit &rhs)
39 {
40     m_opaque_ptr = rhs.m_opaque_ptr;
41     return *this;
42 }
43 
44 
45 SBCompileUnit::~SBCompileUnit ()
46 {
47     m_opaque_ptr = NULL;
48 }
49 
50 SBFileSpec
51 SBCompileUnit::GetFileSpec () const
52 {
53     SBFileSpec file_spec;
54     if (m_opaque_ptr)
55         file_spec.SetFileSpec(*m_opaque_ptr);
56     return file_spec;
57 }
58 
59 uint32_t
60 SBCompileUnit::GetNumLineEntries () const
61 {
62     if (m_opaque_ptr)
63     {
64         LineTable *line_table = m_opaque_ptr->GetLineTable ();
65         if (line_table)
66             return line_table->GetSize();
67     }
68     return 0;
69 }
70 
71 SBLineEntry
72 SBCompileUnit::GetLineEntryAtIndex (uint32_t idx) const
73 {
74     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
75 
76     SBLineEntry sb_line_entry;
77     if (m_opaque_ptr)
78     {
79         LineTable *line_table = m_opaque_ptr->GetLineTable ();
80         if (line_table)
81         {
82             LineEntry line_entry;
83             if (line_table->GetLineEntryAtIndex(idx, line_entry))
84                 sb_line_entry.SetLineEntry(line_entry);
85         }
86     }
87 
88     if (log)
89     {
90         SBStream sstr;
91         sb_line_entry.GetDescription (sstr);
92         log->Printf ("SBCompileUnit(%p)::GetLineEntryAtIndex (idx=%u) => SBLineEntry(%p): '%s'",
93                      m_opaque_ptr, idx, sb_line_entry.get(), sstr.GetData());
94     }
95 
96     return sb_line_entry;
97 }
98 
99 uint32_t
100 SBCompileUnit::FindLineEntryIndex (uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec) const
101 {
102     const bool exact = true;
103     return FindLineEntryIndex (start_idx, line, inline_file_spec, exact);
104 }
105 
106 uint32_t
107 SBCompileUnit::FindLineEntryIndex (uint32_t start_idx, uint32_t line, SBFileSpec *inline_file_spec, bool exact) const
108 {
109     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
110 
111     uint32_t index = UINT32_MAX;
112     if (m_opaque_ptr)
113     {
114         FileSpec file_spec;
115         if (inline_file_spec && inline_file_spec->IsValid())
116             file_spec = inline_file_spec->ref();
117         else
118             file_spec = *m_opaque_ptr;
119 
120 
121         index = m_opaque_ptr->FindLineEntry (start_idx,
122                                              line,
123                                              inline_file_spec ? inline_file_spec->get() : NULL,
124                                              exact,
125                                              NULL);
126     }
127 
128     if (log)
129     {
130         SBStream sstr;
131         if (index == UINT32_MAX)
132         {
133             log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => NOT FOUND",
134                          m_opaque_ptr, start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL);
135         }
136         else
137         {
138             log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => %u",
139                          m_opaque_ptr, start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL, index);
140         }
141     }
142 
143     return index;
144 }
145 
146 bool
147 SBCompileUnit::IsValid () const
148 {
149     return m_opaque_ptr != NULL;
150 }
151 
152 bool
153 SBCompileUnit::operator == (const SBCompileUnit &rhs) const
154 {
155     return m_opaque_ptr == rhs.m_opaque_ptr;
156 }
157 
158 bool
159 SBCompileUnit::operator != (const SBCompileUnit &rhs) const
160 {
161     return m_opaque_ptr != rhs.m_opaque_ptr;
162 }
163 
164 const lldb_private::CompileUnit *
165 SBCompileUnit::operator->() const
166 {
167     return m_opaque_ptr;
168 }
169 
170 const lldb_private::CompileUnit &
171 SBCompileUnit::operator*() const
172 {
173     return *m_opaque_ptr;
174 }
175 
176 lldb_private::CompileUnit *
177 SBCompileUnit::get ()
178 {
179     return m_opaque_ptr;
180 }
181 
182 void
183 SBCompileUnit::reset (lldb_private::CompileUnit *lldb_object_ptr)
184 {
185     m_opaque_ptr = lldb_object_ptr;
186 }
187 
188 
189 bool
190 SBCompileUnit::GetDescription (SBStream &description)
191 {
192     if (m_opaque_ptr)
193     {
194         description.ref();
195         m_opaque_ptr->Dump (description.get(), false);
196     }
197     else
198         description.Printf ("No Value");
199 
200     return true;
201 }
202