from __future__ import absolute_import, print_function
from builtins import object
import getopt
import os
import string
import sys
import re
from lldb import SBValue
from core import value as cvalue
from .configuration import config
class ArgumentError(Exception):
""" Exception class for raising errors in command arguments. The lldb_command framework will catch this
class of exceptions and print suitable error message to user.
"""
def __init__(self, msg):
self.error_message = msg
def __str__(self):
return str(self.error_message)
class RedirectStdStreams(object):
def __init__(self, stdout=None, stderr=None):
self._stdout = stdout or sys.stdout
self._stderr = stderr or sys.stderr
def __enter__(self):
self.old_stdout, self.old_stderr = sys.stdout, sys.stderr
self.old_stdout.flush(); self.old_stderr.flush()
sys.stdout, sys.stderr = self._stdout, self._stderr
def __exit__(self, exc_type, exc_value, traceback):
self._stdout.flush(); self._stderr.flush()
sys.stdout = self.old_stdout
sys.stderr = self.old_stderr
class IndentScope(object):
def __init__(self, O):
self._O = O
def __enter__(self):
self._O._indent += ' '
def __exit__(self, exc_type, exc_value, traceback):
self._O._indent = self._O._indent[:-4]
class HeaderScope(object):
def __init__(self, O, hdr, indent = False):
self._O = O
self._header = hdr
self._indent = indent
def __enter__(self):
self._oldHeader = self._O._header
self._oldLastHeader = self._O._lastHeader
self._O._header = self._header
self._O._lastHeader = None
if self._indent:
self._O._indent += ' '
def __exit__(self, exc_type, exc_value, traceback):
self._O._header = self._oldHeader
self._O._lastHeader = self._oldLastHeader
if self._indent:
self._O._indent = self._O._indent[:-4]
class VT(object):
Black = "\033[38;5;0m"
DarkRed = "\033[38;5;1m"
DarkGreen = "\033[38;5;2m"
Brown = "\033[38;5;3m"
DarkBlue = "\033[38;5;4m"
DarkMagenta = "\033[38;5;5m"
DarkCyan = "\033[38;5;6m"
Grey = "\033[38;5;7m"
DarkGrey = "\033[38;5;8m"
Red = "\033[38;5;9m"
Green = "\033[38;5;10m"
Yellow = "\033[38;5;11m"
Blue = "\033[38;5;12m"
Magenta = "\033[38;5;13m"
Cyan = "\033[38;5;14m"
White = "\033[38;5;15m"
Default = "\033[39m"
Bold = "\033[1m"
EndBold = "\033[22m"
Oblique = "\033[3m"
EndOblique = "\033[23m"
Underline = "\033[4m"
EndUnderline = "\033[24m"
Reset = "\033[0m"
class NOVT(object):
def __getattribute__(self, *args):
return ""
class SBValueFormatter(string.Formatter):
"""
Formatter that treats SBValues specially
It adds the following magical syntax for fields:
- {$value->path.to[10].field} will follow a given expression path,
and compute the resulting SBValue. This works with cvalues too.
- {&value->path.to[10].field} will return the load address
of the specified value path. This works with cvalue too.
The format spec can now take a multi-char conversion,
{field|<multi-char-conversion>!conv:spec},
where <multi-char-conversion> is one of:
- `c_str` which will attempt to read the value as a C string using
xGetValueAsCString()
- `human_size` will convert sizes into a human readable representation.
- a conversion registered with the SBValueFormatter.converter
decorator,
- a `key.method` specification where the key is one of the positional
or named arguments to the format.
When the value of a given field is an SBValue (because &/$ was used,
or the field was already an SBValue -- but not a cvalue), in the absence
of a explicit conversion, the SBValue will be converted to a scalar
using xGetValueAsScalar()
"""
_KEY_RE = re.compile(r"[.-\[]")
_CONVERTERS = {}
@classmethod
def converter(cls, name, raw=False):
def register(fn):
cls._CONVERTERS[name] = (fn, raw)
return register
def format(self, format_string, *args, **kwargs):
return self.vformat(self, format_string, args, kwargs)
def _raise_switch_manual_to_automatic(self):
raise ValueError('cannot switch from manual field '
'specification to automatic field '
'numbering')
def vformat(self, format_string, args, kwargs):
result = []
auto_idx = 0
#
# Python 2.7 doesn't support empty field names in Formatter,
# so we need to implement vformat. Because we avoid certain
# features such as "unused fields accounting" we actually
# are faster than the core library Formatter this way which
# adds up quickly for our macros, so it's worth keeping
# this implementation even on Python 3.
#
for text, field_name, format_spec, conv in \
self.parse(format_string):
if text:
result.append(text)
if field_name is None:
continue
field_name, _, transform = field_name.partition('|')
if field_name == '':
#
# Handle auto-numbering like python 3
#
if auto_idx is None:
self._raise_switch_manual_to_automatic()
field_name = str(auto_idx)
auto_idx += 1
elif field_name.isdigit():
#
# numeric key
#
if auto_idx:
self._raise_switch_manual_to_automatic()
auto_idx = None
try:
if field_name[0] in '&$':
#
# Our magic sigils
#
obj, auto_idx = self.get_value_field(
field_name, args, kwargs, auto_idx)
else:
#
# Fallback typical case
#
obj, _ = self.get_field(field_name, args, kwargs)
except:
if config['debug']: raise
result.extend((
VT.Red,
"<FAIL {}>".format(field_name),
VT.Reset
))
continue
# do any conv on the resulting object
try:
obj = self.convert_field(obj, conv, transform, args, kwargs)
except:
if config['debug']: raise
result.extend((
VT.Red,
"<CONV {}>".format(field_name),
VT.Reset
))
continue
result.append(self.format_field(obj, format_spec))
return ''.join(result)
def get_value_field(self, name, args, kwargs, auto_idx):
match = self._KEY_RE.search(name)
index = match.start() if match else len(name)
key = name[1:index]
path = name[index:]
if key == '':
raise ValueError("Key part of '{}' can't be empty".format(name))
if key.isdigit():
key = int(key)
if auto_idx:
self._raise_switch_manual_to_automatic()
auto_idx = None
obj = self.get_value(key, args, kwargs)
if isinstance(obj, cvalue):
obj = obj.GetSBValue()
if name[0] == '&':
if len(path):
return obj.xGetLoadAddressByPath(path), auto_idx
return obj.GetLoadAddress(), auto_idx
if len(path):
obj = obj.GetValueForExpressionPath(path)
return obj, auto_idx
def convert_field(self, obj, conv, transform='', args=None, kwargs=None):
is_sbval = isinstance(obj, SBValue)
if transform != '':
fn, raw = self._CONVERTERS.get(transform, (None, False))
if not raw and is_sbval:
obj = obj.xGetValueAsScalar()
if fn:
obj = fn(obj)
else:
objname, _, method = transform.partition('.')
field, _ = self.get_field(objname, args, kwargs)
obj = getattr(field, method)(obj)
is_sbval = False
if conv is None:
return obj.xGetValueAsScalar() if is_sbval else obj
return super(SBValueFormatter, self).convert_field(obj, conv)
@SBValueFormatter.converter("c_str", raw=True)
def __sbval_to_cstr(v):
return v.xGetValueAsCString() if isinstance(v, SBValue) else str(v)
@SBValueFormatter.converter("human_size")
def __human_size(v):
n = v.xGetValueAsCString() if isinstance(v, SBValue) else int(v)
order = ((n//10) | 1).bit_length() // 10
return "{:.1f}{}".format(n / (1024 ** order), "BKMGTPE"[order])
_xnu_core_default_formatter = SBValueFormatter()
def xnu_format(fmt, *args, **kwargs):
""" Conveniency function to call SBValueFormatter().format """
return _xnu_core_default_formatter.vformat(fmt, args, kwargs)
def xnu_vformat(fmt, args, kwargs):
""" Conveniency function to call SBValueFormatter().vformat """
return _xnu_core_default_formatter.vformat(fmt, args, kwargs)
class CommandOutput(object):
"""
An output handler for all commands. Use Output.print to direct all output of macro via the handler.
These arguments are passed after a "--". eg
(lldb) zprint -- -o /tmp/zprint.out.txt
Currently this provide capabilities
-h show help
-o path/to/filename
The output of this command execution will be saved to file. Parser information or errors will
not be sent to file though. eg /tmp/output.txt
-s filter_string
the "filter_string" param is parsed to python regex expression and each line of output
will be printed/saved only if it matches the expression.
The command header will not be filtered in any case.
-p <plugin_name>
Send the output of the command to plugin.
-v ...
Up verbosity
-c <always|never|auto>
configure color
"""
def __init__(self, cmd_name, CommandResult=None, fhandle=None):
""" Create a new instance to handle command output.
params:
CommandResult : SBCommandReturnObject result param from lldb's command invocation.
"""
self.fname=None
self.fhandle=fhandle
self.FILTER=False
self.pluginRequired = False
self.pluginName = None
self.cmd_name = cmd_name
self.resultObj = CommandResult
self.verbose_level = 0
self.target_cmd_args = []
self.target_cmd_options = {}
self._indent = ''
self._buffer = ''
self._header = None
self._lastHeader = None
self._line = 0
self.color = None
self.isatty = os.isatty(sys.__stdout__.fileno())
self.VT = VT if self._doColor() else NOVT()
def _doColor(self):
if self.color is True:
return True;
return self.color is None and self.isatty
def _needsHeader(self):
if self._header is None:
return False
if self._lastHeader is None:
return True
if not self.isatty:
return False
return self._line - self._lastHeader > 40
def indent(self):
return IndentScope(self)
def table(self, header, indent = False):
return HeaderScope(self, header, indent)
def format(self, s, *args, **kwargs):
kwargs['VT'] = self.VT
return xnu_vformat(s, args, kwargs)
def error(self, s, *args, **kwargs):
print(self.format("{cmd.cmd_name}: {VT.Red}"+s+"{VT.Default}", cmd=self, *args, **kwargs))
def write(self, s):
""" Handler for all commands output. By default just print to stdout """
o = self.fhandle or self.resultObj
for l in (self._buffer + s).splitlines(True):
if l[-1] != '\n':
self._buffer = l
return
if self.FILTER:
if not self.reg.search(l):
continue
l = self.reg.sub(self.VT.Underline + r"\g<0>" + self.VT.EndUnderline, l);
if len(l) == 1:
o.write(l)
self._line += 1
continue
if len(l) > 1 and self._needsHeader():
for h in self._header.splitlines():
o.write(self.format("{}{VT.Bold}{:s}{VT.EndBold}\n", self._indent, h))
self._lastHeader = self._line
o.write(self._indent + l)
self._line += 1
self._buffer = ''
def flush(self):
if self.fhandle != None:
self.fhandle.flush()
def __del__(self):
""" closes any open files. report on any errors """
if self.fhandle != None and self.fname != None:
self.fhandle.close()
def setOptions(self, cmdargs, cmdoptions =''):
""" parse the arguments passed to the command
param :
cmdargs => [] of <str> (typically args.split())
cmdoptions : str - string of command level options.
These should be CAPITAL LETTER options only.
"""
opts=()
args = cmdargs
cmdoptions = cmdoptions.upper()
try:
opts,args = getopt.gnu_getopt(args,'hvo:s:p:c:'+ cmdoptions,[])
self.target_cmd_args = args
except getopt.GetoptError as err:
raise ArgumentError(str(err))
#continue with processing
for o,a in opts :
if o == "-h":
# This is misuse of exception but 'self' has no info on doc string.
# The caller may handle exception and display appropriate info
raise ArgumentError("HELP")
if o == "-o" and len(a) > 0:
self.fname=os.path.normpath(os.path.expanduser(a.strip()))
self.fhandle=open(self.fname,"w")
print("saving results in file ",str(a))
self.fhandle.write("(lldb)%s %s \n" % (self.cmd_name, " ".join(cmdargs)))
self.isatty = os.isatty(self.fhandle.fileno())
elif o == "-s" and len(a) > 0:
self.reg = re.compile(a.strip(),re.MULTILINE|re.DOTALL)
self.FILTER=True
print("showing results for regex:",a.strip())
elif o == "-p" and len(a) > 0:
self.pluginRequired = True
self.pluginName = a.strip()
#print "passing output to " + a.strip()
elif o == "-v":
self.verbose_level += 1
elif o == "-c":
if a in ["always", '1']:
self.color = True
elif a in ["never", '0']:
self.color = False
else:
self.color = None
self.VT = VT if self._doColor() else NOVT()
else:
o = o.strip()
self.target_cmd_options[o] = a