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