#!/usr/bin/env python3
"""
A gdb-compatible frontend for lldb that implements just enough
commands to run the tests in the debuginfo-tests repository with lldb.
"""

# ----------------------------------------------------------------------
# Auto-detect lldb python module.
import subprocess, platform, os, sys

try:
    # Just try for LLDB in case PYTHONPATH is already correctly setup.
    import lldb
except ImportError:
    # Ask the command line driver for the path to the lldb module. Copy over
    # the environment so that SDKROOT is propagated to xcrun.
    command = (
        ["xcrun", "lldb", "-P"] if platform.system() == "Darwin" else ["lldb", "-P"]
    )
    # Extend the PYTHONPATH if the path exists and isn't already there.
    lldb_python_path = subprocess.check_output(command).decode("utf-8").strip()
    if os.path.exists(lldb_python_path) and not sys.path.__contains__(lldb_python_path):
        sys.path.append(lldb_python_path)
    # Try importing LLDB again.
    try:
        import lldb

        print('imported lldb from: "%s"' % lldb_python_path)
    except ImportError:
        print(
            "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
        )
        sys.exit(1)
# ----------------------------------------------------------------------

# Command line option handling.
import argparse

parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--quiet", "-q", action="store_true", help="ignored")
parser.add_argument(
    "-batch", action="store_true", help="exit after processing comand line"
)
parser.add_argument("-n", action="store_true", help="ignore .lldb file")
parser.add_argument(
    "-x", dest="script", type=argparse.FileType("r"), help="execute commands from file"
)
parser.add_argument("target", help="the program to debug")
args = parser.parse_args()


# Create a new debugger instance.
debugger = lldb.SBDebugger.Create()
debugger.SkipLLDBInitFiles(args.n)

# Make sure to clean up the debugger on exit.
import atexit


def on_exit():
    debugger.Terminate()


atexit.register(on_exit)

# Don't return from lldb function calls until the process stops.
debugger.SetAsync(False)

# Create a target from a file and arch.
arch = os.popen("file " + args.target).read().split()[-1]
target = debugger.CreateTargetWithFileAndArch(args.target, arch)

if not target:
    print("Could not create target %s" % args.target)
    sys.exit(1)

if not args.script:
    print("Interactive mode is not implemented.")
    sys.exit(1)

import re

for command in args.script:
    # Strip newline and whitespaces and split into words.
    cmd = command[:-1].strip().split()
    if not cmd:
        continue

    print("> %s" % command[:-1])

    try:
        if re.match("^r|(run)$", cmd[0]):
            error = lldb.SBError()
            launchinfo = lldb.SBLaunchInfo([])
            launchinfo.SetWorkingDirectory(os.getcwd())
            process = target.Launch(launchinfo, error)
            print(error)
            if not process or error.fail:
                state = process.GetState()
                print("State = %d" % state)
                print(
                    """
ERROR: Could not launch process.
NOTE: There are several reasons why this may happen:
  * Root needs to run "DevToolsSecurity --enable".
  * Older versions of lldb cannot launch more than one process simultaneously.
"""
                )
                sys.exit(1)

        elif re.match("^b|(break)$", cmd[0]) and len(cmd) == 2:
            if re.match("[0-9]+", cmd[1]):
                # b line
                mainfile = target.FindFunctions("main")[0].compile_unit.file
                print(target.BreakpointCreateByLocation(mainfile, int(cmd[1])))
            else:
                # b file:line
                file, line = cmd[1].split(":")
                print(target.BreakpointCreateByLocation(file, int(line)))

        elif re.match("^ptype$", cmd[0]) and len(cmd) == 2:
            # GDB's ptype has multiple incarnations depending on its
            # argument (global variable, function, type).  The definition
            # here is for looking up the signature of a function and only
            # if that fails it looks for a type with that name.
            # Type lookup in LLDB would be "image lookup --type".
            for elem in target.FindFunctions(cmd[1]):
                print(elem.function.type)
                continue
            print(target.FindFirstType(cmd[1]))

        elif re.match("^po$", cmd[0]) and len(cmd) > 1:
            try:
                opts = lldb.SBExpressionOptions()
                opts.SetFetchDynamicValue(True)
                opts.SetCoerceResultToId(True)
                print(target.EvaluateExpression(" ".join(cmd[1:]), opts))
            except:
                # FIXME: This is a fallback path for the lab.llvm.org
                # buildbot running OS X 10.7; it should be removed.
                thread = process.GetThreadAtIndex(0)
                frame = thread.GetFrameAtIndex(0)
                print(frame.EvaluateExpression(" ".join(cmd[1:])))

        elif re.match("^p|(print)$", cmd[0]) and len(cmd) > 1:
            thread = process.GetThreadAtIndex(0)
            frame = thread.GetFrameAtIndex(0)
            print(frame.EvaluateExpression(" ".join(cmd[1:])))

        elif re.match("^n|(next)$", cmd[0]):
            thread = process.GetThreadAtIndex(0)
            thread.StepOver()

        elif re.match("^q|(quit)$", cmd[0]):
            sys.exit(0)

        else:
            print(debugger.HandleCommand(" ".join(cmd)))

    except SystemExit:
        raise
    except:
        print('Could not handle the command "%s"' % " ".join(cmd))