Source Code for Module lldb.formatters.Logger

  1  from __future__ import print_function 
  2  import sys 
  3  import os.path 
  4  import inspect 
  5   
  6   
  7 -class NopLogger: 
  8   
  9 -    def __init__(self): 
 10          pass 
 11   
 12 -    def write(self, data): 
 13          pass 
 14   
 15 -    def flush(self): 
 16          pass 
 17   
 18 -    def close(self): 
 19          pass 
 20   
 21   
 22 -class StdoutLogger: 
 23   
 24 -    def __init__(self): 
 25          pass 
 26   
 27 -    def write(self, data): 
 28          print(data) 
 29   
 30 -    def flush(self): 
 31          pass 
 32   
 33 -    def close(self): 
 34          pass 
 35   
 36   
 37 -class FileLogger: 
 38   
 39 -    def __init__(self, name): 
 40          self.file = None 
 41          try: 
 42              name = os.path.abspath(name) 
 43              self.file = open(name, 'a') 
 44          except: 
 45              try: 
 46                  self.file = open('formatters.log', 'a') 
 47              except: 
 48                  pass 
 49   
 50 -    def write(self, data): 
 51          if self.file is not None: 
 52              print(data, file=self.file) 
 53          else: 
 54              print(data) 
 55   
 56 -    def flush(self): 
 57          if self.file is not None: 
 58              self.file.flush() 
 59   
 60 -    def close(self): 
 61          if self.file is not None: 
 62              self.file.close() 
 63              self.file = None 
 64   
 65  # to enable logging: 
 66  # define lldb.formatters.Logger._lldb_formatters_debug_level to any number greater than 0 
 67  # if you define it to any value greater than 1, the log will be automatically flushed after each write (slower but should make sure most of the stuff makes it to the log even if we crash) 
 68  # if you define it to any value greater than 2, the calling function's details will automatically be logged (even slower, but provides additional details) 
 69  # if you need the log to go to a file instead of on screen, define 
 70  # lldb.formatters.Logger._lldb_formatters_debug_filename to a valid 
 71  # filename 
 72   
 73   
 74 -class Logger: 
 75   
 76 -    def __init__(self, autoflush=False, logcaller=False): 
 77          global _lldb_formatters_debug_level 
 78          global _lldb_formatters_debug_filename 
 79          self.autoflush = autoflush 
 80          want_log = False 
 81          try: 
 82              want_log = (_lldb_formatters_debug_level > 0) 
 83          except: 
 84              pass 
 85          if not (want_log): 
 86              self.impl = NopLogger() 
 87              return 
 88          want_file = False 
 89          try: 
 90              want_file = (_lldb_formatters_debug_filename is not None and _lldb_formatters_debug_filename != 
 91                           '' and _lldb_formatters_debug_filename != 0) 
 92          except: 
 93              pass 
 94          if want_file: 
 95              self.impl = FileLogger(_lldb_formatters_debug_filename) 
 96          else: 
 97              self.impl = StdoutLogger() 
 98          try: 
 99              self.autoflush = (_lldb_formatters_debug_level > 1) 
100          except: 
101              self.autoflush = autoflush 
102          want_caller_info = False 
103          try: 
104              want_caller_info = (_lldb_formatters_debug_level > 2) 
105          except: 
106              pass 
107          if want_caller_info: 
108              self._log_caller() 
109   
110 -    def _log_caller(self): 
111          caller = inspect.stack()[2] 
112          try: 
113              if caller is not None and len(caller) > 3: 
114                  self.write('Logging from function ' + str(caller)) 
115              else: 
116                  self.write( 
117                      'Caller info not available - Required caller logging not possible') 
118          finally: 
119              del caller  # needed per Python docs to avoid keeping objects alive longer than we care 
120   
121 -    def write(self, data): 
122          self.impl.write(data) 
123          if self.autoflush: 
124              self.flush() 
125   
126 -    def __rshift__(self, data): 
127          self.write(data) 
128   
129 -    def flush(self): 
130          self.impl.flush() 
131   
132 -    def close(self): 
133          self.impl.close() 
134