[LLDB] Créez votre propre commande avec Python

Chargez la commande d'origine créée en Python dans LLDB de Xcode.

Xcode semble lire l'un des deux suivants au démarrage.

• ~/.lldbinit
• ~/.lldbinit-Xcode

Fondamentalement, il semble que .lldbinit-Xcode soit chargé. Cependant, comme ce qui précède est lu à partir de la ligne de commande, etc., si vous décrivez les paramètres de base dans .lldbinit et mettez le processus à lire .lldbinit dans .lldbinit-Xcode comme suit. Ça va.

command source ~/.lldbinit

Lire le fichier de commande d'origine au démarrage

Après avoir défini comme ci-dessus, la commande sera chargée automatiquement en définissant .lldbinit pour lire le fichier Python.

command script import ~/.lldb/hoge.py

Définir dans le fichier

Après avoir défini les paramètres de lecture décrits ci-dessus, définissez le contenu à lire réellement. Le format principal et la description requise sont les suivants.

new-command.py

#!/usr/bin/env python
#coding: utf-8

import lldb
import commands
import os

def command_function(debugger, command, result, internal_dict):
	cmd = "po self"
	debugger.HandleCommand(cmd)
	
def __lldb_init_module(debugger, internal_dict):
	debugger.HandleCommand("command script add -f new-command:command_function commandname")
	print "commandname has been installed."

Après l'avoir défini, lisez-le comme suit.

(lldb) command script import /path/to/command.py

Définir en ligne pendant la pause

Il est facile de vérifier l'opération en le définissant en ligne et en l'exécutant pour un petit test de fonctionnement.

Ce qui suit va démarrer l'interpréteur python.

(lldb) script⏎

Ensuite, définissez comme suit et quittez l'interpréteur.

(lldb) script⏎
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> def hoge_function(debugger, command, result, internal_dict):
...	cmd = "po self"
...	debugger.HandleCommand(cmd)
...	
>>> quit⏎
(lldb) command script add hoge -f hoge_func
(lldb) hoge
<UIView...

Espace réservé de chaîne

Vous pouvez utiliser l'espace réservé en écrivant comme suit. Ceci est pratique lorsque le traitement est effectué en fonction de la chaîne de caractères spécifiée dans la commande.

val = "This is %s %s" % ("a", "pen")

# --- or ---

val = "This is %(unit)s %(msg)s" % {"unit": "a", "msg": "pen"}

# --- or ---

val = """This is
%s %s""" % ("a", "pen")

Commande Split

La commande est passée sous forme de chaîne unique, utilisez donc shlex.split pour la scinder.

command_list = shlex.split(command)

Commande pour copier la vue factice et ʻajouter sous-vue: `

Ce que je voulais faire cette fois était de dupliquer une vue en utilisant la taille de vue spécifiée et de créer une commande pour la rendre ʻaddSubview: `et vérifier si la vue est correctement générée à la position souhaitée. ..

Je pense que c'est un peu redondant, mais pour le moment, cela a fonctionné si je faisais ce qui suit, alors je vais le décrire.

#!/usr/bin/env python
# -*- coding: utf-8

import lldb
import commands
import os
import shlex

def dmy_func(debugger, command, result, internal_dict):
    commands = shlex.split(command)

    count = len(commands)

    if count < 2:
        return

    cmd = "po CGRect $frame = (CGRect)[%s frame]" % commands[0]
    print(cmd)
    debugger.HandleCommand(cmd)

    cmd = "po UIView *$view = [[UIView alloc] initWithFrame:(CGRect)$frame]"
    print(cmd)
    debugger.HandleCommand(cmd)

    cmd = "po [$view setBackgroundColor:(UIColor*)[UIColor redColor]]"
    print(cmd)
    debugger.HandleCommand(cmd)

    cmd = "po [%s addSubview:(UIView*)$view]" % commands[1]
    print(cmd)
    debugger.HandleCommand(cmd)

def __lldb_init_module(debugger, internal_dict):
    debugger.HandleCommand("command script add -f dmy.dmy_func dmy")
    print "dmy command has been installed."

Comment utiliser

(lldb) dmy self.hogeView self.view

Un UIView est créé en utilisant le cadre de self.hogeView, et il est ajouté à self.view avec ʻaddSubview:`.