1 //===-- SBSourceManager.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/SBDebugger.h"
11 #include "lldb/API/SBSourceManager.h"
12 #include "lldb/API/SBTarget.h"
13 #include "lldb/API/SBStream.h"
14 
15 #include "lldb/API/SBFileSpec.h"
16 #include "lldb/Core/Debugger.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Core/SourceManager.h"
20 
21 #include "lldb/Target/Target.h"
22 
23 namespace lldb_private
24 {
25     class SourceManagerImpl
26     {
27     public:
28         SourceManagerImpl (const lldb::DebuggerSP &debugger_sp) :
29             m_debugger_wp (debugger_sp),
30             m_target_wp ()
31         {
32         }
33 
34         SourceManagerImpl (const lldb::TargetSP &target_sp) :
35             m_debugger_wp (),
36             m_target_wp (target_sp)
37         {
38         }
39 
40         SourceManagerImpl (const SourceManagerImpl &rhs)
41         {
42             if (&rhs == this)
43                 return;
44             m_debugger_wp = rhs.m_debugger_wp;
45             m_target_wp   = rhs.m_target_wp;
46         }
47 
48         size_t
49         DisplaySourceLinesWithLineNumbers (const lldb_private::FileSpec &file,
50                                            uint32_t line,
51                                            uint32_t context_before,
52                                            uint32_t context_after,
53                                            const char *current_line_cstr,
54                                            lldb_private::Stream *s)
55         {
56             if (!file)
57                 return 0;
58 
59             lldb::TargetSP target_sp (m_target_wp.lock());
60             if (target_sp)
61             {
62                 return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers (file,
63                                                                                         line,
64                                                                                         context_before,
65                                                                                         context_after,
66                                                                                         current_line_cstr,
67                                                                                         s);
68             }
69             else
70             {
71                 lldb::DebuggerSP debugger_sp (m_debugger_wp.lock());
72                 if (debugger_sp)
73                 {
74                     return debugger_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers (file,
75                                                                                               line,
76                                                                                               context_before,
77                                                                                               context_after,
78                                                                                               current_line_cstr,
79                                                                                               s);
80                 }
81             }
82             return 0;
83         }
84 
85     private:
86         lldb::DebuggerWP m_debugger_wp;
87         lldb::TargetWP   m_target_wp;
88 
89     };
90 }
91 
92 using namespace lldb;
93 using namespace lldb_private;
94 
95 SBSourceManager::SBSourceManager (const SBDebugger &debugger)
96 {
97     m_opaque_ap.reset(new SourceManagerImpl (debugger.get_sp()));
98 }
99 
100 SBSourceManager::SBSourceManager (const SBTarget &target)
101 {
102     m_opaque_ap.reset(new SourceManagerImpl (target.GetSP()));
103 }
104 
105 SBSourceManager::SBSourceManager (const SBSourceManager &rhs)
106 {
107     if (&rhs == this)
108         return;
109 
110     m_opaque_ap.reset(new SourceManagerImpl (*(rhs.m_opaque_ap.get())));
111 }
112 
113 const lldb::SBSourceManager &
114 SBSourceManager::operator = (const lldb::SBSourceManager &rhs)
115 {
116     m_opaque_ap.reset (new SourceManagerImpl (*(rhs.m_opaque_ap.get())));
117     return *this;
118 }
119 
120 SBSourceManager::~SBSourceManager()
121 {
122 }
123 
124 size_t
125 SBSourceManager::DisplaySourceLinesWithLineNumbers
126 (
127     const SBFileSpec &file,
128     uint32_t line,
129     uint32_t context_before,
130     uint32_t context_after,
131     const char *current_line_cstr,
132     SBStream &s
133 )
134 {
135     if (m_opaque_ap.get() == NULL)
136         return 0;
137 
138     return m_opaque_ap->DisplaySourceLinesWithLineNumbers (file.ref(),
139                                                            line,
140                                                            context_before,
141                                                            context_after,
142                                                            current_line_cstr,
143                                                            s.get());
144 }
145