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     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
103 
104     uint32_t index = UINT32_MAX;
105     if (m_opaque_ptr)
106     {
107         FileSpec file_spec;
108         if (inline_file_spec && inline_file_spec->IsValid())
109             file_spec = inline_file_spec->ref();
110         else
111             file_spec = *m_opaque_ptr;
112 
113 
114         index = m_opaque_ptr->FindLineEntry (start_idx,
115                                              line,
116                                              inline_file_spec ? inline_file_spec->get() : NULL,
117                                              NULL);
118     }
119 
120     if (log)
121     {
122         SBStream sstr;
123         if (index == UINT32_MAX)
124         {
125             log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => NOT FOUND",
126                          m_opaque_ptr, start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL);
127         }
128         else
129         {
130             log->Printf ("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, line=%u, SBFileSpec(%p)) => %u",
131                          m_opaque_ptr, start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL, index);
132         }
133     }
134 
135     return index;
136 }
137 
138 bool
139 SBCompileUnit::IsValid () const
140 {
141     return m_opaque_ptr != NULL;
142 }
143 
144 bool
145 SBCompileUnit::operator == (const SBCompileUnit &rhs) const
146 {
147     return m_opaque_ptr == rhs.m_opaque_ptr;
148 }
149 
150 bool
151 SBCompileUnit::operator != (const SBCompileUnit &rhs) const
152 {
153     return m_opaque_ptr != rhs.m_opaque_ptr;
154 }
155 
156 const lldb_private::CompileUnit *
157 SBCompileUnit::operator->() const
158 {
159     return m_opaque_ptr;
160 }
161 
162 const lldb_private::CompileUnit &
163 SBCompileUnit::operator*() const
164 {
165     return *m_opaque_ptr;
166 }
167 
168 const lldb_private::CompileUnit *
169 SBCompileUnit::get () const
170 {
171     return m_opaque_ptr;
172 }
173 
174 void
175 SBCompileUnit::reset (lldb_private::CompileUnit *lldb_object_ptr)
176 {
177     m_opaque_ptr = lldb_object_ptr;
178 }
179 
180 
181 bool
182 SBCompileUnit::GetDescription (SBStream &description)
183 {
184     if (m_opaque_ptr)
185     {
186         description.ref();
187         m_opaque_ptr->Dump (description.get(), false);
188     }
189     else
190         description.Printf ("No Value");
191 
192     return true;
193 }
194