how to use the lldb.frame.variables in Python script

Question

I want to use LLDB with Python and I wrote my Python script like this:

import lldb
import commands
import optparse
import shlex

def __lldb_init_module(debugger, internal_dict):
  list1=[]
  for i in lldb.frame.variables:
      list1.append(str(i.name))
  print list1

I want to print the variables in the frame right now.When I import it in the LLDB,

(lldb) command script import ~/str.py

the result is empty.

However,if I input "script" first and quit from it.The Python script will print the right result as I want.

(lldb) script

Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.

quit

(lldb) command script import ~/str.py

['a', 'b', 'c', 'd']

The Breakpoint was set in right place and the program can run without any errors. I want to know why and how to get the result what I want without inputing "script" first

Answer 1

The lldb.frame, lldb.thread, lldb.process, lldb.target shortcuts in the interactive script interpreter don't exist in standalone python commands -- there may be more than any one of these objects at a given time and we want the script to be specific about which one it is using.

There are equivalents for doing the same "get me the currently selected" thing through the SB API. e.g.

debugger.GetSelectedTarget()
debugger.GetSelectedTarget().GetProcess()
debugger.GetSelectedTarget().GetProcess().GetThread()
debugger.GetSelectedTarget().GetProcess().GetThread().GetSelectedFrame()

You're doing work in your init method in the above example (so your python can only be loaded when there is a running process, right?) but if you're defining a new lldb command in python, new lldb's (within the last year or two) will pass in an SBExecutionContext which will give you the currently selected everything. e.g.

def disthis(debugger, command, *args):
    """Usage: disthis
Disables the breakpoint the currently selected thread is stopped at."""

    target = lldb.SBQueue()      # some random object that will be invalid
    thread = lldb.SBQueue()      # some random object that will be invalid

    if len(args) == 2:
        # Old lldb invocation style
        result = args[0]
        if debugger and debugger.GetSelectedTarget() and debugger.GetSelectedTarget().GetProcess():
            target = debugger.GetSelectedTarget()
            process = target.GetProcess()
            thread = process.GetSelectedThread()
    elif len(args) == 3:
        # New (2015 & later) lldb invocation style where we're given the execution context
        exe_ctx = args[0]
        result = args[1]
        target = exe_ctx.GetTarget()
        thread = exe_ctx.GetThread()

    if thread.IsValid() != True:
        print >>result, "error: process is not paused."
        result.SetStatus (lldb.eReturnStatusFailed)
        return

[...]

def __lldb_init_module (debugger, dict):
    debugger.HandleCommand('command script add -f %s.disthis disthis' % __name__)

to be honest, at this point I wouldn't even include the code for an lldb that doesn't pass an SBExecutionContext any more, I can expect everyone to be running new enough lldb's.