vimspector
1.0.0
Para obtener un tutorial y una descripción general del uso, consulte el sitio web de Vimspector.
Para obtener una explicación detallada del formato .vimspector.json , consulte la guía de referencia.
El complemento es un depurador gráfico de Vim capaz de funcionar en varios idiomas. Se prueba principalmente para C++, Python y TCL, pero en teoría admite cualquier lenguaje compatible con Visual Studio Code (pero consulte las advertencias).
El sitio web de Vimspector tiene una descripción general de la interfaz de usuario, junto con instrucciones básicas para la configuración y configuración.
Pero por ahora, aquí hay una captura de pantalla (bastante antigua) de Vimspector depurando Vim:
Y un par de breves demostraciones:
<Plug>VimspectorBalloonEval )La siguiente tabla enumera los idiomas que están "integrados" (junto con sus dependencias de tiempo de ejecución). Se clasifican por su nivel de soporte:
Tested : Totalmente compatible, las pruebas de regresión de Vimspector los cubrenSupported : Totalmente compatible, utilizado con frecuencia y probado manualmenteExperimental : Funciona, pero no se usa con frecuencia y rara vez se prueba.Legacy : ya no es compatible; migre su configuraciónRetired : ya no se incluye ni se admite.| Idioma(s) | Estado | Cambiar (para install_gadget.py ) | Adaptador (para :VimspectorInstall ) | Dependencias |
|---|---|---|---|---|
| C, C++, óxido, Jai, etc. | Probado | --all o --enable-c (o cpp) | vscode-cpptools | mononúcleo |
| C, C++, óxido, Jai, etc. | Probado | --enable-rust , --enable-c , etc. | CódigoLLDB | ninguno |
| Pitón | Probado | --all o --enable-python | depurar | Pitón 3 |
| Ir | Probado | --enable-go | ahondar | Ir 1.16+ |
| TCL | Apoyado | --all o --enable-tcl | tclpro | TCL 8.5 |
| Concha Bourne | Apoyado | --all o --enable-bash | vscode-bash-depuración | Golpe v?? |
| lua | Probado | --all o --enable-lua | local-lua-depurador-vscode | Nodo >=12.13.0, Npm, intérprete de Lua |
| Nodo.js | Apoyado | --force-enable-node | vscode-js-depuración | Nodo >= 18 |
| JavaScript | Apoyado | --force-enable-chrome | depurador-para-chrome | Cromo |
| JavaScript | Apoyado | --force-enable-firefox | vscode-firefox-depuración | Firefox |
| Java | Apoyado | --force-enable-java | vscode-java-depuración | Complemento LSP compatible (ver más adelante) |
| PHP | Experimental | --force-enable-php | vscode-php-depuración | Nodo, PHP, XDEBUG |
| C# (núcleo dotnet) | Probado | --force-enable-csharp | netcoredbg | Núcleo DotNet |
| F#, VB, etc. | Apoyado | --force-enable-[fsharp,vbnet] | netcoredbg | Núcleo DotNet |
| Ir (heredado) | Legado | --enable-go | vscode-ir | Nodo, ir, profundizar |
| Pitón 2 | Legado | --force-enable-python2 | depuración-python2 | Pitón 2.7 |
Vimspector debería funcionar para cualquier adaptador de depuración que funcione en Visual Studio Code.
Para utilizar Vimspector con un lenguaje que no está "integrado", consulte esta página wiki.
Hay 2 métodos de instalación:
:help packages .packadd! vimspector a su .vimrc.vimspector.json o establezca g:vimspector_configurations ); consulte la guía de referenciaVerifica las dependencias
Consulte los documentos del administrador de complementos e instale el complemento. Para Vundle, use:
Plugin ' puremourning/vimspector 'Instale algunos 'gadgets' (adaptadores de depuración): consulte aquí los comandos de instalación y seleccione los gadgets para instalar
Configure los perfiles de depuración de su proyecto (cree .vimspector.json o establezca g:vimspector_configurations ); consulte la guía de referencia
Las siguientes secciones amplían la breve descripción anterior.
Vimspector requiere:
¿Qué versiones de Linux? Solo pruebo en Ubuntu 20.04 y posteriores y RHEL 7.
neovim no implementa globos al pasar el mouse. En su lugar, existe el mapeo <Plug>VimspectorBalloonEval . No existe un mapeo predeterminado para esto, por lo que recomiendo algo como esto para obtener una visualización variable en una ventana emergente:
" mnemonic 'di' = 'debug inspect' (pick your own, if you prefer!)
" for normal mode - the word under the cursor
nmap <Leader> di <Plug> VimspectorBalloonEval
" for visual mode, the visually selected text
xmap <Leader> di <Plug> VimspectorBalloonEvalLas siguientes características no están implementadas para Windows:
Si solo desea probar vimspector sin cambiar su configuración de vim, hay proyectos de ejemplo para varios idiomas en support/test , que incluyen:
Para probar uno de estos, acceda al directorio y ejecute:
vim -Nu /path/to/vimspector/tests/vimrc --cmd "let g:vimspector_enable_mappings='HUMAN'"
Luego presione <F5> .
También hay un proyecto de C++ en tests/testdata/cpp/simple/ con un Makefile que se puede utilizar para comprobar que todo funciona. Esto lo utilizan las pruebas de regresión en CI, por lo que siempre debería funcionar y es una buena forma de comprobar si el problema es su configuración y no un error.
Hay muchos administradores de complementos de Vim y no voy a indicar una preferencia particular, por lo que si elige utilizar uno, siga la documentación del administrador de complementos. Por ejemplo, para Vundle, utilice:
Plugin ' puremourning/vimspector 'Si aún no utiliza un administrador de complementos, instale vimspector como un paquete Vim clonando este repositorio en la ruta de su paquete, así:
$ git clone https://github.com/puremourning/vimspector ~/.vim/pack/vimspector/opt/vimspector
.vimrc , por ejemplo para habilitar las asignaciones estándar: let g: vimspector_enable_mappings = ' HUMAN '.vimrc después de configurar vimspector: packadd! vimspector
Consulte support/doc/example_vimrc.vim para ver un ejemplo mínimo.
Vimspector es un cliente genérico para adaptadores de depuración. Los adaptadores de depuración (denominados 'gadgets' o 'adaptadores') son los que realmente hacen el trabajo de comunicarse con los depuradores reales.
Para que Vimspector sea útil, es necesario tener instalados algunos adaptadores.
Hay algunas maneras de hacer esto:
:VimspectorInstall <adapter> <args...> (use wildmenu TAB para ver las opciones, también acepta cualquier opción install_gadget.py )python3 install_gadget.py <args> (use --help para ver todas las opciones):VimspectorUpdate para instalar las últimas versiones compatibles de los gadgets.Aquí hay una demostración de cómo realizar algunas instalaciones y una actualización:
Tanto install_gadget.py como :VimspectorInstall hacen el mismo conjunto de cosas, aunque los comportamientos predeterminados son ligeramente diferentes. Para los idiomas admitidos, harán lo siguiente:
gadgetDir para la plataforma.Por ejemplo, para instalar el adaptador de depuración probado para un idioma, ejecute:
| Para instalar | Guion | Dominio |
|---|---|---|
<adapter> | :VimspectorInstall <adapter> | |
<adapter1> , <adapter2> , ... | :VimspectorInstall <adapter1> <adapter2> ... | |
<language> | ./install_gadget.py --enable-<language> ... | :VimspectorInstall --enable-<language> ... |
| Adaptadores compatibles | ./install_gadget.py --all | :VimspectorInstall --all |
| Adaptadores compatibles, pero no TCL | ./install_gadget.py --all --disable-tcl | :VimspectorInstall --all --disable-tcl |
| Adaptadores compatibles y experimentales | ./install_gadget.py --all --force-all | :VimspectorInstall --all |
| Adaptador para configuración de depuración específica | Sugerido por Vimspector al iniciar la depuración |
:VimspectorInstall ejecuta install_gadget.py en segundo plano con algunas de las opciones predeterminadas.
:VimspectorUpdate ejecuta install_gadget.py para reinstalar (es decir, actualizar) cualquier dispositivo ya instalado en su .gadgets.json .
El resultado es mínimo, para ver el resultado completo agregue --verbose al comando, como en :VimspectorInstall --verbose ... o :VimspectorUpdate --verbose ... .
Si la instalación se realiza correctamente, la ventana de salida se cierra (y la salida se pierde para siempre). Utilice un ! para mantenerlo abierto (por ejemplo :VimspectorInstall! --verbose --all o :VimspectorUpdate! (etc.).
Si sabe de antemano qué gadgets desea instalar, por ejemplo para poder reproducir su configuración desde el control de fuente, puede configurar g:vimspector_install_gadgets en una lista de gadgets. Esto se utilizará cuando:
:VimspectorInstall sin argumentos, o:VimspectorUpdatePor ejemplo:
let g: vimspector_install_gadgets = [ ' debugpy ' , ' vscode-cpptools ' , ' CodeLLDB ' ] De forma predeterminada, install_gadget.py sobrescribirá su .gadgets.json con el conjunto de adaptadores recién instalados, mientras que :VimspectorInstall lo actualizará , sobrescribiendo solo los adaptadores recién instalados o modificados.
Si simplemente desea agregar un nuevo adaptador usando el script sin destruir los existentes, agregue --update-gadget-config , como en:
$ ./install_gadget.py --enable-tcl
$ ./install_gadget.py --enable-rust --update-gadget-config
$ ./install_gadget.py --enable-java --update-gadget-config Si desea mantener configurations fuera del repositorio de vimspector (esto puede ser útil si tiene gadgets personalizados o configuraciones globales), puede indicarle al instalador que use un directorio basado diferente y luego configurar g:vimspector_base_dir para que apunte a ese directorio, por ejemplo. :
$ ./install_gadget.py --basedir $HOME /.vim/vimspector-config --all --force-all Luego agregue esto a su .vimrc :
let g: vimspector_base_dir = expand ( ' $HOME/.vim/vimspector-config ' ) Cuando se utiliza :VimspectorInstall , la configuración g:vimspector_base_dir se respeta a menos que --basedir se agregue manualmente (no recomendado).
Consulte --help para obtener más información sobre las distintas opciones.
Si el idioma que desea depurar no está en la lista compatible anterior, probablemente aún pueda hacerlo funcionar, pero requiere más esfuerzo.
Básicamente, necesita obtener una instalación funcional del adaptador de depuración, descubrir cómo iniciarlo y configurarlo en una entrada adapters en su .vimspector.json o en .gadgets.json o en g:vimspector_adapters .
En la práctica, la forma más sencilla es instalar o iniciar Visual Studio Code y utilizar su administrador de extensiones para instalar la extensión correspondiente. Luego puede configurar el adaptador manualmente en la sección de adapters de su .vimspector.json o en gadgets.json o en g:vimspector_adapters .
Los RP siempre pueden agregar idiomas compatibles (lo que se traduce aproximadamente en actualizar python/vimspector/gadgets.py y probarlo).
Vimspector utiliza el siguiente directorio de forma predeterminada para buscar un archivo llamado .gadgets.json : </path/to/vimspector>/gadgets/<os> .
Esta ruta se expone como la variable vimspector ${gadgetDir} . Esto es útil para configurar líneas de comando de gadgets.
Donde os es uno de:
macoslinuxwindows (aunque tenga en cuenta: Windows no es compatible) El formato es el mismo que .vimspector.json , pero solo se usa la clave adapters :
Ejemplo:
{
"adapters" : {
"lldb-vscode" : {
"variables" : {
"LLVM" : {
"shell" : " brew --prefix llvm "
}
},
"attach" : {
"pidProperty" : " pid " ,
"pidSelect" : " ask "
},
"command" : [
" ${LLVM}/bin/lldb-vscode "
],
"env" : {
"LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY" : " YES "
},
"name" : " lldb "
},
"vscode-cpptools" : {
"attach" : {
"pidProperty" : " processId " ,
"pidSelect" : " ask "
},
"command" : [
" ${gadgetDir}/vscode-cpptools/debugAdapters/bin/OpenDebugAD7 "
],
"name" : " cppdbg "
}
}
} El archivo del gadget lo escribe automáticamente install_gadget.py (o :VimspectorInstall ).
Vimspector también cargará cualquier archivo que coincida: </path/to/vimspector>/gadgets/<os>/.gadgets.d/*.json . Tienen el mismo formato que .gadgets.json pero no se sobrescriben cuando se ejecuta install_gadget.py .
Después de actualizar el código de Vimspector (ya sea mediante git pull o cualquier administrador de paquetes), ejecute :VimspectorUpdate para actualizar los dispositivos ya instalados.
La motivación es que depurar en Vim es una experiencia bastante horrible, especialmente si usas varios idiomas. Sin más pyclewn y el complemento termdebug incorporado limitado a gdb, quería explorar opciones.
Si bien el protocolo de servidor de idiomas es bien conocido, el protocolo de adaptador de depuración es menos conocido, pero logra un objetivo similar: una API independiente del idioma que abstrae los depuradores de los clientes.
El objetivo de este proyecto es proporcionar una experiencia de depuración simple pero efectiva en Vim para múltiples idiomas, aprovechando los adaptadores de depuración que se están creando para Visual Studio Code.
La capacidad de realizar depuración remota es imprescindible. Esto es clave para mi flujo de trabajo, por lo que incorporarlo a la experiencia de depuración es uno de los principales objetivos del proyecto. Por lo tanto, vimspector tiene soporte de primera clase para ejecutar programas de forma remota y adjuntarlos. Este soporte es exclusivo de vimspector y se suma (complementario) a cualquier soporte de este tipo en los adaptadores de depuración reales.
Vimspector es una interfaz de usuario de vim además del protocolo del adaptador de depuración. Está pensado para ser de alto nivel y conveniente para las tareas de depuración del día a día.
Vimspector no es:
Vimspector es un trabajo en progreso y cualquier comentario o contribución es más que bienvenido.
El trabajo pendiente se puede ver en Trello.
El complemento es actualmente experimental . Eso significa que cualquier parte puede (y probablemente cambiará), incluidas cosas como:
Sin embargo, me comprometo a hacer esto sólo en los casos más extremos y a anunciar dichos cambios en Gitter con suficiente antelación. No hay nada más molesto que algo que simplemente se te rompe. Lo entiendo.
Un mensaje del autor sobre la motivación de este complemento:
Muchos entornos de desarrollo tienen un depurador incorporado. Paso una cantidad excesiva de mi tiempo en Vim. Hago todo mi desarrollo en Vim e incluso he personalizado mis flujos de trabajo para crear código, ejecutar pruebas, etc.
Durante muchos años, me he observado a mí mismo, a amigos y colegas que han estado escribiendo declaraciones de depuración
printf,puts,Realmente creo que los entornos de depuración gráficos interactivos son la mejor manera de comprender y razonar sobre código familiar y desconocido, y que la falta de un acceso simple y listo a un depurador es un enorme agujero de productividad oculto para muchos.
No me malinterpreten, sé que hay literalmente millones de desarrolladores que son más que competentes en el desarrollo sin un depurador gráfico, pero sostengo que si tuvieran la capacidad de simplemente presionar una tecla y saltar al depurador, Sería más rápido y más divertido que simplemente la comprensión del código cerebral.
Creé Vimspector porque me resulta frustrante cambiar de herramientas.
gdbpara c++,pdbpara python, etc. Cada uno tiene su propia sintaxis. Cada uno su propio léxico. Cada uno tiene sus propias debilidades.Diseñé el sistema de configuración de tal manera que la configuración pueda comprometerse con el control de fuente para que funcione para cualquiera de sus colegas, amigos, colaboradores o completos desconocidos.
Hice de la depuración remota una característica de primera clase porque es un caso de uso principal para mí en mi trabajo.
Con Vimspector puedo presionar
<F5>en todos los lenguajes en los que desarrollo y depurar local o remotamente usando exactamente el mismo flujo de trabajo, asignaciones y UI. He integrado esto con mi Vim de tal manera que puedo presionar un botón y ejecutar la prueba debajo del cursor en Vimspector . Este tipo de integración ha mejorado enormemente mi flujo de trabajo y mi productividad. Incluso ha hecho que el proceso de aprender una nueva base de código... sea divertido.- Ben Jackson, Creador.
apache 2.0
Copyright © 2018 Ben Jackson
Si le gusta tanto Vimspector que está dispuesto a desprenderse del dinero que tanto le costó ganar, considere hacer una donación a una de las siguientes organizaciones benéficas, que son importantes para el autor de Vimspector (en orden de preferencia):
De forma predeterminada, vimspector no cambia ninguna de sus asignaciones. Las asignaciones son muy personales y, por lo tanto, debes determinar lo que te gusta y utilizar las potentes funciones de asignación de vim para configurar tus propias asignaciones. Con ese fin, Vimspector define las siguientes asignaciones <Plug> :
| Cartografía | Función | API |
|---|---|---|
<Plug>VimspectorContinue | Al depurar, continúe. De lo contrario, comience a depurar. | vimspector#Continue() |
<Plug>VimspectorStop | Deja de depurar. | vimspector#Stop() |
<Plug>VimpectorRestart | Reinicie la depuración con la misma configuración. | vimspector#Restart() |
<Plug>VimspectorPause | Pausa el depurado. | vimspector#Pause() |
<Plug>VimspectorBreakpoints | Mostrar/ocultar la ventana de puntos de interrupción | vimspector#ListBreakpoints() |
<Plug>VimspectorToggleBreakpoint | Alternar punto de interrupción de línea en la línea actual. | vimspector#ToggleBreakpoint() |
<Plug>VimspectorToggleConditionalBreakpoint | Alternar punto de interrupción de línea condicional o punto de registro en la línea actual. | vimspector#ToggleBreakpoint( { trigger expr, hit count expr } ) |
<Plug>VimspectorAddFunctionBreakpoint | Agregue un punto de interrupción de función para la expresión debajo del cursor | vimspector#AddFunctionBreakpoint( '<cexpr>' ) |
<Plug>VimspectorGoToCurrentLine | Restablecer el contador del programa actual a la línea actual | vimspector#GoToCurrentLine() |
<Plug>VimspectorRunToCursor | Ejecutar hasta el cursor | vimspector#RunToCursor() |
<Plug>VimspectorStepOver | paso por encima | vimspector#StepOver() |
<Plug>VimspectorStepInto | Entra en | vimspector#StepInto() |
<Plug>VimspectorStepOut | Salir del alcance de la función actual | vimspector#StepOut() |
<Plug>VimspectorDisassemble | Mostrar desmontaje. Habilitar el paso de instrucciones | vimspector#ShowDisassembly() |
<Plug>VimspectorUpFrame | Subir un marco en la pila de llamadas actual | vimspector#UpFrame() |
<Plug>VimspectorDownFrame | Bajar un marco en la pila de llamadas actual | vimspector#DownFrame() |
<Plug>VimspectorJumpToNextBreakpoint | Mover el cursor al siguiente punto de interrupción en el archivo actual | vimspector#JumpToNextBreakpoint() |
<Plug>VimspectorJumpToPreviousBreakpoint | Mover el cursor al punto de interrupción anterior en el archivo actual | vimspector#JumpToPreviousBreakpoint() |
<Plug>VimspectorJumpToProgramCounter | Mueva el cursor al contador del programa en el cuadro actual | vimspector#JumpToProgramCounter() |
<Plug>VimspectorBalloonEval | Evaluar la expresión debajo del cursor (o visual) en la ventana emergente | interno |
Estos se asignan aproximadamente 1-1 con las funciones API a continuación.
Por ejemplo, si desea que <F5> inicie/continue con la depuración, agréguelo a algún lugar apropiado, como su vimrc (sugerencia: ejecute :e $MYVIMRC ).
nmap <F5> <Plug> VimspectorContinueAdemás, muchos usuarios probablemente quieran habilitar solo ciertas asignaciones de Vimspector mientras la depuración está activa. Esto también es posible, aunque requiere escribir algún vimscipt.
Dicho esto, muchas personas están familiarizadas con depuradores particulares, por lo que las siguientes asignaciones se pueden habilitar configurando g:vimspector_enable_mappings en el valor especificado.
Para usar asignaciones similares a Visual Studio, agregue lo siguiente a su vimrc antes de cargar vimspector :
let g: vimspector_enable_mappings = ' VISUAL_STUDIO '| Llave | Cartografía | Función |
|---|---|---|
F5 | <Plug>VimspectorContinue | Al depurar, continúe. De lo contrario, comience a depurar. |
Shift F5 | <Plug>VimspectorStop | Deja de depurar. |
Ctrl Shift F5 | <Plug>VimspectorRestart | Reinicie la depuración con la misma configuración. |
F6 | <Plug>VimspectorPause | Pausa el depurado. |
F8 | <Plug>VimspectorJumpToNextBreakpoint | Salta al siguiente punto de interrupción del archivo actual. |
Shift F8 | <Plug>VimspectorJumpToPreviousBreakpoint | Salta al punto de interrupción anterior en el archivo actual. |
F9 | <Plug>VimspectorToggleBreakpoint | Alternar punto de interrupción de línea en la línea actual. |
Shift F9 | <Plug>VimspectorAddFunctionBreakpoint | Agregue un punto de interrupción de función para la expresión debajo del cursor |
F10 | <Plug>VimspectorStepOver | paso por encima |
Ctrl F10 | <Plug>VimspectorRunToCursor | Correr al cursor* |
F11 | <Plug>VimspectorStepInto | Entra en |
Shift F11 | <Plug>VimspectorStepOut | Salir del alcance de la función actual |
Alt 8 | <Plug>VimspectorDisassemble | Mostrar desmontaje |
NOTA: Es posible que algunas asignaciones, como las teclas Ctrl y F, no funcionen dependiendo de su terminal, teclado, sistema de ventanas y todo tipo de otras cosas. Consulte :help modifyOtherKeys y otras fuentes. Si no puede hacer que esto funcione, simplemente use las asignaciones de "modo humano".
Si, como yo, sólo tienes 2 manos y 10 dedos, probablemente no te gusten las teclas Ctrl-Shift-F. Además, si está ejecutando en una terminal, existe una posibilidad real de que terminfo sea incorrecto para las teclas F con mayúsculas, especialmente si su TERM es screen-256color . Si estos problemas (número de manos, variables TERM ) no se pueden solucionar, pruebe las siguientes asignaciones agregando lo siguiente antes de cargar vimspector :
let g: vimspector_enable_mappings = ' HUMAN '| Llave | Cartografía | Función |
|---|---|---|
F5 | <Plug>VimspectorContinue | Al depurar, continúe. De lo contrario, comience a depurar. |
F3 | <Plug>VimspectorStop | Deja de depurar. |
F4 | <Plug>VimspectorRestart | Reinicie la depuración con la misma configuración. |
F6 | <Plug>VimspectorPause | Pausa el depurado. |
F9 | <Plug>VimspectorToggleBreakpoint | Alternar punto de interrupción de línea en la línea actual. |
<leader>F9 | <Plug>VimspectorToggleConditionalBreakpoint | Alternar punto de interrupción de línea condicional o punto de registro en la línea actual. |
F8 | <Plug>VimspectorAddFunctionBreakpoint | Agregue un punto de interrupción de función para la expresión debajo del cursor |
<leader>F8 | <Plug>VimspectorRunToCursor | Ejecutar hasta el cursor |
F10 | <Plug>VimspectorStepOver | paso por encima |
F11 | <Plug>VimspectorStepInto | Entra en |
F12 | <Plug>VimspectorStepOut | Salir del alcance de la función actual |
Además, recomiendo agregar un mapeo a <Plug>VimspectorBalloonEval , en modo normal y visual, por ejemplo:
" mnemonic 'di' = 'debug inspect' (pick your own, if you prefer!)
" for normal mode - the word under the cursor
nmap <Leader> di <Plug> VimspectorBalloonEval
" for visual mode, the visually selected text
xmap <Leader> di <Plug> VimspectorBalloonEvalTambién es posible que desee agregar asignaciones para navegar hacia arriba/abajo en la pila, alternar la ventana de puntos de interrupción y mostrar el desmontaje, por ejemplo:
nmap <LocalLeader> <F11> <Plug> VimspectorUpFrame
nmap <LocalLeader> <F12> <Plug> VimspectorDownFrame
nmap <LocalLeader> B <Plug> VimspectorBreakpoints
nmap <LocalLeader> D <Plug> VimspectorDisassembleEsta sección define instrucciones de uso detalladas, organizadas por función. Para la mayoría de los usuarios, la sección de asignaciones contiene los comandos más comunes y el uso predeterminado. Esta sección se puede utilizar como referencia para crear sus propias asignaciones o comportamientos personalizados.
Todas las instrucciones siguientes suponen una única sesión de depuración. Para obtener más información sobre cómo depurar varias aplicaciones independientes al mismo tiempo, consulte [múltiples sesiones de depuración][#multiple-debugging-sessions].
.vimspector.json . Vea abajo.:call vimspector#Launch() y seleccione una configuración.Al iniciar una nueva sesión, ésta se activa [sesión de depuración][#sesiones-de-depuración-múltiples].
Si la configuración del adaptador de depuración usa pidProperty y realiza una solicitud attach , se le pedirá que ingrese un PID (ID de proceso) para conectarse.
Para facilitar esto, Vimspector proporciona una pequeña utilidad para enumerar los PID. Es como un clon muy simple de ps pero funciona en todas las plataformas compatibles. Consulte su archivo README para obtener instrucciones sobre cómo configurarlo.
Ejecute go build en el directorio support/vimspector_process_list para configurarlo.
Si Vimspector puede encontrar esta aplicación, intentará enumerar todos los procesos propiedad del usuario actual de forma predeterminada.
Alternativamente (preferiblemente), puede utilizar una forma especial de expansión variable llamada ${PickProcess("binaryName")} . La versión de esta llamada enumerará todos los procesos para el usuario actual que coincidan con este nombre binario.
Por ejemplo:
"Attach" : {
"adapter" : "CodeLLDB" ,
"configuration" : {
"request" : "attach" ,
"program" : "${workspaceRoot}/Jails" ,
"pid" : "${PickProcess("jails")}"
}
}Esto enumerará cada proceso coincidente, su proceso principal, hora de inicio y directorio de trabajo. Se parece a esto:
PID PPID CWD START
52218 52217 (Python) /Users/ben/.vim/bundle/lsp-examples/jai/Jails 2023-05-22 16:02:24
Enter Process ID:
Luego ingresa el PID y presiona <CR> .
Incluso puedes reemplazar el selector de procesos con tu propia función. Si define alguna función y establece g:vimspector_custom_process_picker_func con el nombre de esa función. Se pasarán todos los argumentos pasados a la función de expansión PickProcess . También se usará siempre que se especifique una pidProperty , por lo que tampoco debe manejar ningún argumento (use ... como argumentos formales para la función, consulte :help ... ).
Por ejemplo, para usar fzf junto con vimspector_process_list proporcionado:
function ! CustomPickProcess ( ... ) abort
let ps = $HOME .. ' /.vim/bundle/vimspector/support/vimspector_process_list/vimspector_process_list '
" a:0 is number of args
" a:1 is the optional binary name
if a: 0 > 0
let ps .= ' ^ ' . a: 1 . ' $ '
endif
let line_selected = fzf#run ( {
' source ' : ps ,
' options ' : ' --header-lines=1 '
. ' --prompt="Select Process: " '
,
} )[ 0 ]
if empty ( line_selected)
return 0
endif
let pid = split ( line_selected )[ 0 ]
return str2nr ( pid )
endfunction
let g: vimspector_custom_process_picker_func = ' CustomPickProcess ' O usar fzf con la salida de ps :
function ! CustomPickProcess ( ... ) abort
let ps = ' ps aux '
let line_selected = fzf#run ( {
' source ' : ps ,
' options ' : ' --header-lines=1 '
. ' --prompt="Select Process: " '
,
} )[ 0 ]
if empty ( line_selected)
return 0
endif
let pid = split ( line_selected )[ 0 ]
return str2nr ( pid )
endfunction
let g: vimspector_custom_process_picker_func = ' CustomPickProcess 'Para iniciar una configuración de depuración específica o especificar variables de reemplazo para el lanzamiento, puede usar:
:call vimspector#LaunchWithSettings( dict ) El argumento es un dict con las siguientes claves:
configuration : (opcional) Nombre de la configuración de depuración que se iniciará<anything else> : (opcional) Nombre de una variable a configurar Esto permite cierta integración y automatización. Por ejemplo, si tiene una configuración llamada Run Test que contiene una variable de reemplazo llamada ${Test} podría escribir una asignación que finalmente se ejecute:
vimspector#LaunchWithSettings ( #{ configuration: ' Run Test '
Test: ' Name of the test ' } ) Esto iniciaría la configuración Run Test con ${Test} configurado en 'Name of the test' y Vimspector no solicitaría al usuario que ingrese o confirme estas cosas.
Consulte nuestra guía de integración de YouCompleteMe para ver otro ejemplo donde se puede utilizar para especificar el puerto para conectar el depurador de Java.
Para iniciar con una configuración ad-hoc puedes usar:
call vimspector#LaunchWithConfigurations( dict ) El argumento es un dict que es la sección configurations de un archivo .vimspector. Pase una configuración y esa será seleccionada como la que se ejecutará. Por ejemplo:
let pid = <some_expression>
call vimspector#LaunchWithConfigurations ({
" attach " : {
" adapter " : " netcoredbg " ,
" configuration " : {
" request " : " attach " ,
" processId " : pid
}
}
} ) Esto iniciaría el depurador y lo conectaría al proceso especificado sin la necesidad de tener un archivo .vimspector local en el disco. La variable ${workspaceRoot} apuntará a la carpeta principal del archivo que está actualmente abierto en vim.
Vimspector utiliza la siguiente lógica para elegir una configuración para iniciar:
autoselect configurada en false , úsela.default establecido en true y sin autoselect establecida en false , úsela.Consulte la guía de referencia para obtener más detalles.
vimspector#GetConfigurations() para obtener una lista de configuraciones para el tipo de archivo del búfer actualPor ejemplo, para obtener una serie de configuraciones y coincidencias aproximadas en el resultado
: call matchfuzzy ( vimspector#GetConfigurations (), " test::case_1 " )Consulte la sección de asignaciones para conocer las asignaciones predeterminadas para trabajar con puntos de interrupción. Esta sección describe la API completa en funciones de vimscript.
Los puntos de interrupción están asociados con la [sesión de depuración] actual [# múltiples sesiones de depuración]. Al cambiar entre sesiones, los signos de interrupción de la sesión anterior se eliminan y se muestran los puntos de interrupción de la sesión recién activada. Si bien puede resultar útil ver los puntos de interrupción de todas las sesiones, esto puede resultar muy confuso.
Utilice :VimspectorBreakpoints o asigne algo a <Plug>VimspectorBreakpoints para abrir la vista de puntos de interrupción. Desde aquí puede enumerar, saltar para eliminar, agregar y alternar puntos de interrupción.
Recomiendo un mapeo como este para alternar la ventana de puntos de interrupción:
nmap <Leader> db <Plug> VimspectorBreakpointsLas siguientes asignaciones se aplican de forma predeterminada en la ventana de puntos de interrupción:
t , <F9> - alternar, es decir, habilitar/deshabilitar punto de interrupciónT - alternar, es decir, habilitar/deshabilitar TODOS los puntos de interrupcióndd , <Del> : elimina el punto de interrupción actualcc , C : editar las opciones del punto de interrupción actuali , a , o : agrega un nuevo punto de interrupción de líneaI , A , O : agrega un nuevo punto de interrupción de función<Enter> o doble clic - saltar al punto de interrupción de líneaTambién se proporciona un WinBar (donde sea compatible). Esto agrega funciones como guardar/restaurar sesiones, borrar todos los puntos de interrupción y restablecer las opciones de los puntos de interrupción de excepción.
La forma más simple y común de punto de interrupción es un punto de interrupción de línea. La ejecución se detiene cuando se ejecuta la línea especificada.
Para la mayoría de los escenarios de depuración, los usuarios simplemente presionarán <F9> para crear un punto de interrupción de línea en la línea actual y <F5> para iniciar la aplicación.
Algunos adaptadores de depuración admiten puntos de interrupción condicionales. Tenga en cuenta que vimspector no le indica si el depurador no admite puntos de interrupción condicionales (todavía). Un punto de interrupción condicional es un punto de interrupción que solo se activa si alguna expresión se evalúa como verdadera o si se cumplen otras restricciones.
Algunas de estas funciones anteriores toman un único argumento opcional que es un diccionario de opciones. El diccionario puede tener las siguientes claves:
condition : expresión opcional evaluada para determinar si el punto de interrupción debe activarse. No es compatible con todos los adaptadores de depuración. Por ejemplo, para interrumpir cuando abc es 10 , ingrese algo como abc == 10 , según el idioma.hitCondition : una expresión opcional evaluada para determinar el número de veces que se debe ignorar el punto de interrupción. (¿Probablemente?) No debería usarse en combinación con condition . No es compatible con todos los adaptadores de depuración. Por ejemplo, para interrumpir la línea por tercera vez, ingrese 3 .logMessage : una cadena opcional para convertir este punto de interrupción en un "punto de registro". Cuando se activa, este mensaje se imprime en la consola en lugar de interrumpir la ejecución. Puede incrustar expresiones entre llaves {like this} , por ejemplo #{ logMessage: "Iteration {i} or {num_entries / 2}" }En cada caso, el depurador evalúa las expresiones, por lo que deben estar en cualquier dialecto que el depurador entienda al evaluar expresiones.
Cuando se utiliza la asignación <leader><F9> , se solicita al usuario que ingrese estas expresiones en una línea de comando (con historial).
Los puntos de interrupción de excepción normalmente se activan cuando se produce una excepción o se produce otra condición de error. Dependiendo del depurador, al iniciar la depuración, es posible que se le hagan algunas preguntas sobre cómo manejar las excepciones. Estos son "puntos de interrupción de excepción" y vimspector recuerda sus elecciones mientras Vim aún se está ejecutando.
Normalmente puede aceptar los valores predeterminados (¡simplemente siga presionando <CR> !), ya que la mayoría de los valores predeterminados de los adaptadores de depuración son sensatos, pero si desea continuar, diga uncaught exception y luego responda Y a eso (por ejemplo).
Puede configurar sus opciones en .vimspector.json . Consulte la guía de configuración para obtener detalles al respecto.
NOTA: Anteriormente, ToggleBreakpoint alternaba entre 3 estados: habilitado, deshabilitado y eliminado. Muchos usuarios encontraron que el estado "deshabilitado" rara vez era útil, por lo que se cambió el comportamiento. ToggleBreakpoint siempre crea o elimina un punto de interrupción. Si desea "deshabilitar" los puntos de interrupción, utilice la ventana de puntos de interrupción y "alternar" ( t ) desde allí.
vimspector#ToggleBreakpoint( { options dict } ) para establecer/eliminar un punto de interrupción de línea. El argumento es opcional (ver más abajo).vimspector#AddFunctionBreakpoint( '<name>', { options dict} ) para agregar un punto de interrupción de función. El segundo argumento es opcional (ver más abajo).vimspector#SetLineBreakpoint( file_name, line_num, { options dict } ) para establecer un punto de interrupción en un archivo/línea específico. El último argumento es opcional (ver más abajo)vimspector#ClearLineBreakpoint( file_name, line_num ) para eliminar un punto de interrupción en un archivo/línea específicavimspector#ClearBreakpoints() para borrar todos los puntos de interrupciónvimspector#ResetExceptionBreakpoints() para borrar la configuración de los puntos de interrupción de excepción y volver a responder las diversas preguntas como "Interrupción en lanzamiento de C++":VimspectorMkSession y :VimspectorLoadSession para guardar y restaurar puntos de interrupcióncall vimspector#ListBreakpoints() - alternar ventana de puntos de interrupcióncall vimspector#BreakpointsAsQuickFix() - devuelve el conjunto actual de puntos de interrupción en formato vim quickfixEjemplos:
call vimspector#ToggleBreakpoint() - alternar el punto de interrupción en la línea actualcall vimspector#SetLineBreakpoint( 'some_file.py', 10 ) - establezca un punto de interrupción en some_filepy:10call vimspector#AddFunctionBreakpoint( 'main' ) : agregue un punto de interrupción de función en la función maincall vimspector#ToggleBreakpoint( { 'condition': 'i > 5' } ) : agregue un punto de interrupción en la línea actual que se activa solo cuando i > 5 es truecall vimspector#SetLineBreakpoint( 'some_file.py', 10, { 'condition': 'i > 5' } ) : agregue un punto de interrupción en some_file.py:10 que se activa solo cuando i > 5 es truecall vimspector#ClearLineBreakpoint( 'some_file.py', 10 ) - elimine el punto de interrupción en some_file.py:10call vimspector#ClearBreakpoints() - borre todos los puntos de interrupciónVimspectorMkSession - crear .vimspector.sessionVimspectorLoadSession - leer .vimspector.sessionVimspectorMkSession my_session_file - crear my_session_fileVimspectorLoadSession my_session_file - leer my_session_fileNOTA : Función experimental, que puede cambiar significativamente en el futuro según los comentarios de los usuarios.
Los puntos de interrupción de instrucciones se pueden agregar desde la ventana de desensamblado de la misma manera que agrega puntos de interrupción de línea en la ventana de código. Las mismas asignaciones y funciones funcionan para agregarlas y alternarlas. Cuando lo admita el adaptador de depuración, incluso puede crear puntos de registro y puntos de interrupción condicionales de esta manera.
Actualmente, los puntos de interrupción de instrucciones se modelan internamente como puntos de interrupción de línea contra el búfer que contiene el desmontaje, pero eso puede cambiar en el futuro, así que no confíe en esto.
Los puntos de interrupción de instrucciones también se ven y se pueden eliminar/deshabilitar desde la ventana de puntos de interrupción.
Actualmente, los puntos de interrupción de instrucciones se borran automáticamente cuando finaliza la sesión de depuración. La razón de esto es que las direcciones no se pueden garantizar que sean válidas para cualquier otra sesión de depuración. Sin embargo, esto también puede cambiar en el futuro.
Use vimspector#ClearBreakpoints() para borrar todos los puntos de interrupción, incluida la memoria de las opciones de punto de interrupción de excepción.
Use vimspector#RunToCursor o <leader><F8> : esto crea un punto de interrupción temporal en la línea actual, luego continúa la ejecución, limpiando el punto de interrupción cuando se presiona.
Use vimspector#GoToCurrentLine() o algún mapeo para <Plug>VimspectorGoToCurrentLine para saltar la ejecución actual a la línea en la que se encuentra actualmente su cursor.
Cuando sea compatible, esto puede ser útil para volver a ejecutar secciones de código o omitirlas por completo.
Si hay múltiples "objetivos" posibles en la línea actual, debe elegir uno.
VimSpector puede guardar y restaurar puntos de interrupción (y algunas otras cosas) en un archivo de sesión. Existen los siguientes comandos para eso:
VimspectorMkSession [file/dir name] : guarde el conjunto actual de puntos de interrupción de línea, puntos de registro, puntos de interrupción condicionales, puntos de interrupción de funciones y filtros de punto de interrupción de excepción al archivo de sesión suministrado o el archivo predeterminado en el directorio suministrado.VimspectorLoadSession [file/dir name] : lea los puntos de interrupción del archivo de sesión suministrado o el archivo predeterminado en el directorio suministrado y reemplace los puntos de interrupción actualmente establecidos actualmente. Antes de la carga, se eliminan todos los puntos de interrupción actuales (como si se llamara vimspector#ClearLineBreakpoints() ). En ambos casos, el argumento del archivo/nombre del DIR es opcional. De manera predeterminada, el archivo se llama .vimspector.session , pero esto se puede cambiar a nivel mundial configurando g:vimspector_session_file_name a otra cosa, o especificando manualmente una ruta al llamar al comando. Si proporciona un directorio, el nombre de archivo de sesión predeterminado o configurado se lee fron o se escribe en ese directorio. Othewise, el archivo se lee en base al búfer actualmente abierto o escrito en el directorio de trabajo actual.
VimLeave VimEnter . ¡Se recomienda en ese caso usar silent! Para evitar errores molestos si el archivo no se puede leer o escribir.
La forma más simple de automatización es cargar la sesión de VIMSpector cada vez que inicia VIM con un archivo de sesión. Esto es tan simple como hacer esto:
$ echo silent VimspectorLoadSession > Sessionx.vim
Consulte :help mksession para obtener detalles del archivo *x.vim . También puede hacer algo como esto usando SessionLoadPost :
autocmd SessionLoadPost * silent ! VimspectorLoadSessionvimspector#StepInto() , etc. También hay vimspector#StepSOver() y vimspector#StepIOver() etc. Variantes para la granularidad de la declaración y la instrucción respectivamente. <CR> , o haga doble clic con el mouse izquierdo para expandir/colapsar (+, -).<C-CR> (control + <CR> ) o <leader><CR> (si modifyOtherKeys no funciona para usted) Los ámbitos y las variables están representados por el buffer vimspector.Variables .
Si prefiere una pantalla más detallada para variables y relojes, entonces puede let g:vimspector_variables_display_mode = 'full' . De manera predeterminada, solo se muestran el nombre y el valor, con otros datos disponibles al rondar el mouse o activar <Plug>VimspectorBalloonEval en la línea que contiene el valor en la ventana de variables (o relojes).
Se aplican todas las reglas para Variables and scopes más las siguientes:
a + b ) y obtenga su resultado.nmap ) y Modo Visual ( xmap ) a <Plug>VimspectorBalloonEval para activar manualmente la ventana emergente.<C-CR> (control + <CR> ) o <leader><CR> (si modifyOtherKeys no funciona para usted)j , k ) para elegir la selección actual; <Esc> (o deje la ventana de información sobre herramientas) para cerrar la información sobre herramientas. Puede deshabilitar la ventana emergente automática de ciervo mediante la configuración g:vimspector_enable_auto_hover=0 antes de comenzar la sesión de depuración. Luego puede asignar algo a <Plug>VimspectorBalloonEval y activarlo manualmente.
La ventana de reloj se usa para inspeccionar variables y expresiones. Las expresiones se evalúan en el marco de pila seleccionado que está "enfocado"
La ventana de los relojes es un búfer rápido, donde está disponible. Ingrese el modo Insertar para agregar una nueva expresión de reloj.
<CR> .:VimspectorWatch <expression> . Tab-Completion for Expression está disponible en algunos adaptadores de depuración.<CR> , o haga doble clic con el mouse izquierdo.<C-CR> (control + <CR> ) o <leader><CR> (si modifyOtherKeys no funciona para usted)<DEL> . Los relojes están representados por el búfer vimspector.Watches .
Si prefiere una pantalla más detallada para variables y relojes, entonces puede let g:vimspector_variables_display_mode = 'full' . De manera predeterminada, solo se muestran el nombre y el valor, con otros datos disponibles al rondar el mouse o activar <Plug>VimspectorBalloonEval en la línea que contiene el valor en la ventana de variables (o relojes).
Puede deshabilitar la ventana emergente automática de ciervo mediante la configuración g:vimspector_enable_auto_hover=0 antes de comenzar la sesión de depuración. Luego puede asignar algo a <Plug>VimspectorBalloonEval y activarlo manualmente.
El búfer de indicación de reloj tiene su configuración omnifunc en una función que calculará la finalización para la expresión actual. Esto se usa trivialmente con <Ctrl-x><Ctrl-o> (ver :help ins-completion ) o integrado con su sistema de finalización favorito. El tipo de archivo en el búfer se establece en VimspectorPrompt .
Para YouCompleteme, la siguiente configuración funciona bien:
let g: ycm_semantic_triggers = {
' VimspectorPrompt ' : [ ' . ' , ' -> ' , ' : ' , ' < ' ]
}:VimspectorDisassemble , vimspector#ShowDisassembly() o <Plug>VimspectorDisassembleAlgunos adaptadores de depuración (¡pocos!) Apoyan el desmontaje. La forma en que esto funciona en DAP es un poco extraño, pero en la práctica, Vimspector solicitará desmontar una serie de instrucciones en torno a la PC del marco de pila actual. Esto se muestra en una ventana con una barra de Win Bar de la ventana del código, pero con una granularidad de paso de instrucciones. Hay un signo para la instrucción actual y la sintaxis Highighting predeterminada a "ASM" que funciona en su mayoría bien para X86 y ARM.
Como se mencionó anteriormente, cuando su ventana actual es la ventana de desmontaje y utiliza los comandos predeterminados de "paso" (por ejemplo, <F10> ), el paso se coloca automáticamente a la insincrencia por instrucción en lugar de por declaración.
Cada vez que el proceso se detiene, VimSpector solicita aproximadamente 2 ventanas llenas de instrucciones alrededor de la PC actual. Para ver más, puede desplazar la ventana. VIMSPETOR se presentará en una pantalla adicional de instrucciones cuando la ventana se desplace hacia la parte superior o cerca de la parte inferior. Esto no es perfecto. A veces tienes que desplazarte un poco más para que la página (por ejemplo, Ctrl-E Ctrl-y en la parte superior). Esto no es ideal y puede mejorarse en el futuro.
Puede controlar la altura intial de la ventana de desmontaje con let g:vimspector_disassembly_height = 10 (o qué número de líneas).
El tipo de archivo (y la sintaxis) de los búferes en la ventana de desmontaje es vimspector-disassembly . Puede usar FileType Autocommands para personalizar cosas como el resaltado de sintaxis.
Nota : Esta característica es experimental y puede cambiar de cualquier manera en función de los comentarios de los usuarios.
Algunos adaptadores de depuración proporcionan una forma de descargar la memoria del proceso asociada con las variables. Esto se puede hacer a partir de las variables y observa ventanas con:
<leader>m de mapeo (por defecto, se puede personalizar)vimspector#ReadMemory() Al hacer esto, se le pide que ingrese varios bytes para leer (desde la ubicación asociada con la línea del cursor actual) y un desplazamiento desde esa ubicación. Se muestra un nuevo búfer en la ventana de código que contiene un volcado de memoria en Hex y ASCII, similar a la salida de xxd .
Nota : Esta característica es experimental y puede cambiar de cualquier manera en función de los comentarios de los usuarios.
La ventana de rastreo de pila muestra el estado de cada hilo del programa. Los hilos que se detienen se pueden ampliar para mostrar el rastro de la pila de ese hilo.
A menudo, pero no siempre, todos los hilos se detienen cuando se golpea un punto de interrupción. El estado de un hilo se muestra entre paréntesis después del nombre del hilo. Cuando sea compatible con el depurador subyacente, los hilos se pueden detener y continuar individualmente desde la ventana de rastreo de pila.
Un hilo particular, resaltado con el grupo de resaltado CursorLine es el hilo "enfocado". Este es el hilo que recibe comandos como "intervenir", "pasar", "continuar" y "pausa" en la ventana del código. El hilo enfocado se puede cambiar manualmente para "cambiar a" ese hilo.
<CR> , o haga doble clic con el mouse izquierdo para expandir/colapsar un rastro de pila de subprocesos, o use el botón WinBar.<CR> o haga doble clic con el mouse izquierdo en un marco de pila para saltar a él.vimspector#PauseContinueThread() para detener individualmente o continuar el hilo seleccionado.<leader><CR> o vimspector#SetCurrentThread() para establecer el hilo "enfocado" en el seleccionado actualmente. Si la línea seleccionada es un marco de pila, configure el hilo enfocado en el hilo de ese marco y salte a ese cuadro en la ventana del código. El rastro de la pila está representado por el búfer vimspector.StackTrace .
Si hay sesiones de depuración infantil, como donde el debugee lanza procesos infantiles y el adaptador de depuración respalda la depuración de múltiples sesiones, entonces los hilos de cada sesión se muestran por separado. La sesión actualmente activa es la que se resalta como el marco de subproceso/pila actualmente activo. Para cambiar el control a una sesión diferente, enfoque un hilo dentro de esa sesión.
Nota: Esto se refiere a las sesiones creadas como hijos de una sesión existente, y no debe confundirse con las sesiones de depuración [de los padres)] [#sesiones de debuges múltiples].
:VimspectorShowOutput <category> . Use la finalización de la línea de comandos para ver las categorías. Si la ventana de salida está cerrada, se puede abrir una nueva con :VimspectorShowOutput <category> (use la pestaña -Completo - wildmenu para ver las opciones).
La ventana de la consola es un búfer rápido, donde está disponible, y puede usarse como una CLI interactiva para el adaptador de depuración. El soporte para esto varía entre los adaptadores.
:VimspectorEval <expression> . La finalización está disponible con algunos adaptadores de depuración.<CR>Nota: Ver también relojes arriba.
Si la ventana de salida está cerrada, se puede abrir una nueva con :VimspectorShowOutput Console .
El búfer de inmediato de la consola tiene su configuración omnifunc en una función que calculará la finalización para el comando/expresión actual. Esto se usa trivialmente con <Ctrl-x><Ctrl-o> (ver :help ins-completion ) o integrado con su sistema de finalización favorito. El tipo de archivo en el búfer se establece en VimspectorPrompt .
Para YouCompleteme, la siguiente configuración funciona bien:
let g: ycm_semantic_triggers = {
' VimspectorPrompt ' : [ ' . ' , ' -> ' , ' : ' , ' < ' ]
}El archivo de registro de VIMSpector contiene un rastro completo de la comunicación entre VIMSpector y el adaptador de depuración. Esta es la principal fuente de información de diagnóstico cuando algo sale mal, eso no es un rastreo VIM.
Si solo desea ver el archivo de registro de VIMSpector, use :VimspectorToggleLog , que lo atagará en una pequeña ventana (no funciona en Windows).
Puedes ver información de depuración con :VimspectorDebugInfo
Para cerrar el depurador, use:
Reset de WinBar:VimspectorReset cuando la WinBar no está disponible.call vimspector#Reset()Si la depuración todavía se está ejecutando al detener o restablecer, algunos adaptadores de depuración le permiten especificar qué debería sucederle al terminar la depuración. Por lo general, el comportamiento predeterminado es sensato, y esto es lo que sucede la mayor parte del tiempo. Estos son los valores predeterminados según DAP:
Algunos adaptadores de depuración le permiten elegir qué hacer al desconectar. Si desea controlar este comportamiento, use :VimspectorReset o llame vimspector#Reset( { 'interactive': v:true } ) . Si el adaptador de depuración ofrece una opción sobre si finalizar o no la depuración, se le pedirá que elija. Lo mismo se aplica para vimspector#Stop() que puede tomar un argumento: vimspector#Stop( { 'interactive': v:true } ) .
Nota : Esta característica es experimental y cualquier parte puede cambiar en respuesta a la retroalimentación del usuario.
Vimspector apoya el inicio de un número arbitrario de sesiones de depuración. Cada sesión está asociada con una pestaña UI individual. Por lo general, solo depugga una sola aplicación y, por lo tanto, no necesita pensar en esto, pero esta característica avanzada puede ser útil si necesita depurar simultáneamente múltiples, aplicaciones independientes o múltiples instancias independientes de su aplicación.
En cualquier momento hay una sola sesión raíz "activa". Los puntos de interrupción están asociados con la sesión actual, y todos los comandos de UI y API se aplican a la sesión actualmente activa.
Al cambiar entre las sesiones raíz, se eliminan las señales de descanso para la sesión anterior y se muestran los puntos de interrupción para la sesión recién activada. Si bien puede ser útil ver puntos de descanso para todas las sesiones, esto puede ser muy confuso.
Un flujo de trabajo típico podría ser:
:edit server.cc y luego <F5> ). Esto inicia una sesión de depuración que lleva el nombre de la configuración seleccionada. Puede cambiar el nombre :VimspectorRenameSession server .:tabedit client.cc )client :: :VimspectorNewSession client ( client ahora es la sesión activa).client y comience a depurar con <F5> . Ahora tiene 2 pestañas Vimspector. Intuitivamente, Wwitching a una pestaña particular hará que su sesión activa. También puede cambiar manualmente la sesión activa con :VimspectorSwitchToSession <name> .
Entonces, en resumen tienes las siguientes instalaciones:
VimspectorNewSession <name> Esto crea una nueva sesión y la hace activa. El nombre opcional se usa en lugar del generado al comenzar un lanzamiento.VimspectorSwitchToSession <tab complete> .VimspectorRenameSession <new name>VimspectorDestroySession <name> . No puedes destruir una sesión de ejecución/activa.vimspector#GetSessionName() útil para poner una línea de estado. También está vimspector#GetSessionID() para los técnicos. Aquí hay un ejemplo de cómo puede mostrar el nombre de sesión actual en la statusline (consulte :help statusline o la documentación para su elegante complemento de línea de estado).
function ! StlVimspectorSession ()
" Only include in buffers containing actual files
if ! empty ( & buftype )
return ' '
endif
" Abort if vimspector not loaded
if ! exists ( ' *vimspector#GetSessionName ' ) ||
! exists ( ' *vimspector#GetSessionID ' )
return ' '
endif
return vimspector#GetSessionName ()
.. ' ( '
.. vimspector#GetSessionID ()
.. ' ) '
endfunction
" ... existing statusline stuff
" set statusline=...
" Show the vimspector active session name (max 20 chars) if there is onw.
set statusline += % ( % . 20 { StlVimspectorSession ()} % ) Para obtener una introducción a la configuración de .vimspector.json , eche un vistazo a la sección de inicio del sitio web de VIMSPECTOR.
Para obtener una explicación completa, que incluye cómo usar variables, sustituciones y cómo especificar puntos de interrupción de excepciones, consulte los documentos.
El archivo de configuración JSON permite comentarios al estilo C:
// comment to end of line .../* inline comment ... */Actualmente probado con los siguientes adaptadores de depuración.
Ejemplo .vimspector.json (funciona con vscode-cpptools y lldb-vscode . Para lldb-vscode reemplace el nombre del adaptador con lldb-vscode :
{
"configurations" : {
"Launch" : {
"adapter" : " vscode-cpptools " ,
"filetypes" : [ " cpp " , " c " , " objc " , " rust " ], // optional
"configuration" : {
"request" : " launch " ,
"program" : " <path to binary> " ,
"args" : [ ... ],
"cwd" : " <working directory> " ,
"environment" : [ ... ],
"externalConsole" : true ,
"MIMode" : " <lldb or gdb> "
}
},
"Attach" : {
"adapter" : " vscode-cpptools " ,
"filetypes" : [ " cpp " , " c " , " objc " , " rust " ], // optional
"configuration" : {
"request" : " attach " ,
"program" : " <path to binary> " ,
"MIMode" : " <lldb or gdb> "
}
}
// ...
}
} Nota para usuarios de Windows: debe instalar gdb.exe . Recomiendo usar scoop install gdb . Vimspector no puede usar el depurador de Visual Studio debido a la licencia.
{
"configurations" : {
"Launch" : {
"adapter" : " vscode-cpptools " ,
"filetypes" : [ " cpp " , " c " , " objc " , " rust " ], // optional
"configuration" : {
"request" : " launch " ,
"program" : " <path to binary> " ,
"stopAtEntry" : true
}
}
}
}Dependiendo del backend que necesite para habilitar la impresión bastante compleja manualmente.
LLDB: Pretty Printing está habilitado de forma predeterminada
GDB: Para habilitar las impresoras GDB Pretty, considere el fragmento a continuación. ¡No es suficiente haber set print pretty on en su .gdbinit!
{
"configurations" : {
"Launch" : {
"adapter" : " vscode-cpptools " ,
"filetypes" : [ " cpp " , " c " , " objc " , " rust " ], // optional
"configuration" : {
"request" : " launch " ,
"program" : " <path to binary> " ,
// ...
"MIMode" : " gdb " ,
"setupCommands" : [
{
"description" : " Enable pretty-printing for gdb " ,
"text" : " -enable-pretty-printing " ,
"ignoreFailures" : true
}
]
}
}
}
} La documentación de CPPTools describe cómo adjuntar CPPTools a GDBServer usando miDebuggerAddress . Tenga en cuenta que al hacer esto debe usar la "request": "attach" .
Si se siente elegante, consulte la guía de referencia para un ejemplo de que VIMSPECOR se lance y se adjunte de forma remota.
CODELLDB es superior a VScode-CPPTools en varias maneras en MacOS al menos.
Ver Rust.
Una alternativa es usar lldb-vscode , que viene con LLVM. He aquí cómo:
brew install llvm )/path/to/vimspector/gadgets/macos/.gadgets.d/lldb-vscode.json : {
"adapters" : {
"lldb-vscode" : {
"variables" : {
"LLVM" : {
"shell" : " brew --prefix llvm "
}
},
"attach" : {
"pidProperty" : " pid " ,
"pidSelect" : " ask "
},
"command" : [
" ${LLVM}/bin/lldb-vscode "
],
"env" : {
"LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY" : " YES "
},
"name" : " lldb "
}
}
} Rust es compatible con cualquier depurador basado en GDB/LLDB. Por lo tanto, funciona bien con vscode-cpptools y lldb-vscode arriba. Sin embargo, el soporte para Rust es el mejor en CodeLLDB .
./install_gadget.py --enable-rust o :VimspectorInstall CodeLLDBsupport/test/rust/vimspector_test {
"configurations" : {
"launch" : {
"adapter" : " CodeLLDB " ,
"filetypes" : [ " rust " ],
"configuration" : {
"request" : " launch " ,
"program" : " ${workspaceRoot}/target/debug/vimspector_test "
}
},
"attach" : {
"adapter" : " CodeLLDB " ,
"filetypes" : [ " rust " , " c " , " cpp " , " jai " ],
"configuration" : {
"request" : " attach " ,
"program" : " ${workspaceRoot}/${fileBasenameNoExtension} " ,
"PID" : " ${PID} "
}
}
}
}"request": "custom" : esto no es válido. En su lugar, use "request": "launch", "custom": true . Porque razonescargo se realiza en la locura de JavaScript VScode, por lo que no es compatible."request": custom ; Vea el punto sobre el lanzamiento "personalizado" arribastep-into de las funciones de la biblioteca estándar) se puede hacer agregando "sourceMap": { "from_path" : "to_path" } . "from_path" se puede encontrar en la ventana de desmontaje subiendo en el rastro de pila; "to_path" es solo su ruta de biblioteca estándar instalada localmente para la cadena de herramientas actual. La depuración de Jai funciona bien con cualquiera de los otros depugadores nativos. Recomiendo CodellDB, pero CPPTools también funciona.
Ejemplo:
{
"$schema" : "https://puremourning.github.io/vimspector/schema/vimspector.schema.json" ,
"adapters" : {
"gdb-with-build" : {
"extends" : "vscode-cpptools" ,
"variables" : {
"buildme" : {
"shell" : "jai ${workspaceRoot}/build.jai"
}
}
} ,
"codelldb-with-build" : {
"extends" : "CodeLLDB" ,
"variables" : {
"buildme" : {
"shell" : "jai ${workspaceRoot}/build.jai"
}
}
}
} ,
"configurations" : {
"Run - gdb" : {
"adapter" : "gdb-with-build" ,
"filetypes" : [ "jai" ] ,
"configuration" : {
"request" : "launch" ,
"program" : "${workspaceRoot}/${binaryName}" ,
"args" : [ "*${args}" ] ,
"stopAtEntry" : true ,
"stopOnEntry" : true
}
} ,
"Run - lldb" : {
"extends" : "Run - gdb" ,
"filetypes" : [ "jai" ] ,
"adapter" : "codelldb-with-build"
} ,
"Attach - gdb" : {
"adapter" : "vscode-cpptools" ,
"filetypes" : [ "jai" ] ,
"configuration" : {
"request" : "attach" ,
"program" : "${workspaceRoot}/${binaryName}" ,
"processId" : "${PID}"
}
} ,
"Attach - lldb" : {
"extends" : "Attach - gdb" ,
"filetypes" : [ "jai" ] ,
"adapter" : "CodeLLDB" ,
"configuration" : {
"pid" : "${PID}"
}
}
}
} 
Python: Desbugpy
Instale con install_gadget.py --enable-python o :VimspectorInstall debugpy , idealmente requiere un compilador de trabajo y los encabezados de desarrollo de Python/LIBS para construir una extensión C Python para el rendimiento.
NOTA : El debugpy ya no admite Python 2. Para continuar depurando las aplicaciones de Python 2, use el adaptador debugpy-python2 después de instalar el gadget debugpy-python2 .
Opciones completas: https://github.com/microsoft/debugpy/wiki/debug-configuration-settings
{
"configurations" : {
"<name>: Launch" : {
"adapter" : " debugpy " ,
"filetypes" : [ " python " ],
"configuration" : {
"name" : " <name>: Launch " ,
"type" : " python " ,
"request" : " launch " ,
"cwd" : " <working directory> " ,
"python" : " /path/to/python/interpreter/to/use " ,
"stopOnEntry" : true ,
"console" : " externalTerminal " ,
"debugOptions" : [],
"program" : " <path to main python file> "
}
}
...
}
}Para usar la depuración remota con Debugpy, debe conectar VIMSPECOR directamente a la aplicación que se está depurando. Esto es fácil, pero es un poco diferente de la forma en que normalmente configuramos las cosas. Específicamente, necesitas:
--listen . Consulte la documentación de desaprendizaje para más detalles.{
"configurations" : {
"Python Attach" : {
"adapter" : " multi-session " ,
"filetypes" : [ " python " ], // optional
"configuration" : {
"request" : " attach " ,
"pathMappings" : [
// mappings here (optional)
]
}
}
}
} Consulte los detalles de la configuración de lanzamiento para obtener una explicación de cosas como pathMappings .
La documentación adicional, que incluye cómo hacer esto cuando la máquina remota solo se puede contactar a través de SSH es proporcionada por DEBUGPY.
Si se siente elegante, consulte la guía de referencia para un ejemplo de que VIMSPECOR se lance y se adjunte de forma remota.
Para continuar depurando las aplicaciones de Python 2, asegúrese de instalar el gadget debugpy-python2 :VimspectorInstall debugpy-python2 --force-enable-python2 . Ej.
{
"configurations" : {
"Python Attach" : {
"adapter" : " debugpy-python2 " ,
// ...
}
}
}
para examinar
Vea mi bifurcación de TCLProdeBug para obtener instrucciones.
Install con install_gadget.py --force-enable-csharp o :VimspectorInstall netcoredbg
{
"configurations" : {
"launch - netcoredbg" : {
"adapter" : " netcoredbg " ,
"filetypes" : [ " cs " , " fsharp " , " vbnet " ], // optional
"configuration" : {
"request" : " launch " ,
"program" : " ${workspaceRoot}/bin/Debug/netcoreapp2.2/csharp.dll " ,
"args" : [],
"stopAtEntry" : true ,
"cwd" : " ${workspaceRoot} " ,
"env" : {}
}
}
}
}Requiere:
install_gadget.py --enable-go o :VimspectorInstall delvego 1.16 o posterior (YMMV en versiones anteriores)Esto utiliza el soporte DAP integrado en Delve Debugger
{
"configurations" : {
"run" : {
"adapter" : " delve " ,
"filetypes" : [ " go " ], // optional
"variables" : {
// example, to disable delve's go version check
// "dlvFlags": "--check-go-version=false"
},
"configuration" : {
"request" : " launch " ,
"program" : " ${fileDirname} " ,
"mode" : " debug "
}
}
}
}Use variables para configurar lo siguiente:
dlvFlags : (cadena) Argumentos de línea de comandos adicionales para pasar a DonveEl depurador (Delve) se lanza en una ventana de terminal para que pueda ver su salida y pasar la entrada al depuggee.
Consulte los documentos VSCode-Go para opciones de lanzamiento completas. Sí, parece que ese es el único lugar en el que están documentados (aparentemente, no están documentados por Delve).
Los documentos VSCode-go también tienen información útil de solución de problemas
Requiere:
install_gadget.py --enable-go o :VimspectorInstall vscode-gogo get -u github.com/go-delve/delve/cmd/dlvdlvToolPathNOTA: VIMSPTOR usa el adaptador de depuración VSCode-Go "Legacy" en lugar del soporte DAP "incorporado" en Delve. Puedes rastrear #186 para eso.
{
"configurations" : {
"run" : {
"adapter" : " vscode-go " ,
"filetypes" : [ " go " ], // optional
"configuration" : {
"request" : " launch " ,
"program" : " ${fileDirname} " ,
"mode" : " debug " ,
"dlvToolPath" : " $HOME/go/bin/dlv "
// example, to disable delve's go version check
// "dlvFlags": [ "--check-go-version=false" ]
}
}
}
}Consulte los documentos VSCode-Go para obtener información sobre problemas
Esto usa el php-debug, ver https://marketplace.visualstudio.com/items?itemname=felixfbecker.php-debug
Requiere:
install_gadget.py --force-enable-php o :VimspectorInstall vscode-php-debug zend_extension =xdebug.so
xdebug.remote_enable =on
xdebug.remote_handler =dbgp
xdebug.remote_host =localhost
xdebug.remote_port =9000 Reemplace localhost con la IP de su estación de trabajo.
alternativa perezosa
zend_extension =xdebug.so
xdebug.remote_enable =on
xdebug.remote_handler =dbgp
xdebug.remote_connect_back =true
xdebug.remote_port =9000{
"configurations" : {
"Listen for XDebug" : {
"adapter" : " vscode-php-debug " ,
"filetypes" : [ " php " ], // optional
"configuration" : {
"name" : " Listen for XDebug " ,
"type" : " php " ,
"request" : " launch " ,
"port" : 9000 ,
"stopOnEntry" : false ,
"pathMappings" : {
"/var/www/html" : " ${workspaceRoot} "
}
}
},
"Launch currently open script" : {
"adapter" : " vscode-php-debug " ,
"filetypes" : [ " php " ], // optional
"configuration" : {
"name" : " Launch currently open script " ,
"type" : " php " ,
"request" : " launch " ,
"program" : " ${file} " ,
"cwd" : " ${fileDirname} " ,
"port" : 9000
}
}
}
} Append XDEBUG_SESSION_START=xdebug a su cadena de consulta
curl "http://localhost?XDEBUG_SESSION_START=xdebug"
o use la extensión de ayudante xdebug mencionada anteriormente (que establece una cookie XDEBUG_SESSION )
export XDEBUG_CONFIG= " idekey=xdebug "
php < path to script > Esto usa VScode-JS-DeBug, el depurador que también se usa en VScode. Para configuraciones adicionales, consulte la documentación aquí.
Para instalar VScode-JS-DEBUG, ejecute VimspectorInstall vscode-js-debug desde VIM o ejecute el script de instalación install_gadget.py --force-enable-node . Hay múltiples ejemplos que puede consultar. Encuéntralos en support/test/node/simple , support/test/node/multiprocess y support/test/node/typescript . Una configuración típica para la depuración de mecanografiado se ve así:
{
"configurations" : {
"run - js-debug" : {
"adapter" : " js-debug " ,
"filetypes" : [ " javascript " , " typescript " ],
"configuration" : {
"request" : " launch " ,
"program" : " ${workspaceRoot}/src/index.ts " ,
"cwd" : " ${workspaceRoot} " ,
"stopOnEntry" : false ,
"type" : " pwa-node "
},
// 'breakpoints' is an optional part. This is a way to configure exception
// breakpoints. You can leave this out or set as you prefer.
"breakpoints" : {
"exception" : {
"all" : " N " ,
"uncaught" : " N "
}
}
}
}
}
vscode-js-debug admite varios "tipos" diferentes y puede hacer algunas cosas que pueden funcionar o no. Lamentablemente, el campo type no está documentado, pero los valores válidos se definen aquí en el enum de depuración.
Vimspector solo ha sido probado con el tipo pwa-node .
Tenga en cuenta también que por alguna razón este adaptador de depuración siempre nos obliga a comenzar múltiples sesiones de depuración. Para un usuario, eso no debería cambiar nada (aparte de quizás un rastro de pila ligeramente confuso). Pero sí hace que las cosas sean más complicadas, por lo que puede haber insectos sutiles.
Esto usa el depurador Chrome/Firefox (son muy similares), ver https://marketplace.visualstudio.com/items?itemname=msjsdiag.debugger-for-chrome y https://marketplace.visualstudio.com/items?itemname = Firefox-Devtools.vscode-Firefox-DeBug, respectivamente.
Le permite depurar scripts que se ejecutan dentro de Chrome desde VIM.
./install_gadget.py --force-enable-chrome o :VimspectorInstall debugger-for-chrome./install_gadget.py --force-enable-firefox o :VimspectorInstall debugger-for-firefoxsupport/test/web {
"configurations" : {
"chrome" : {
"adapter" : " chrome " ,
"configuration" : {
"request" : " launch " ,
"url" : " http://localhost:1234/ " ,
"webRoot" : " ${workspaceRoot}/www "
}
},
"firefox" : {
"adapter" : " firefox " ,
"configuration" : {
"request" : " launch " ,
"url" : " http://localhost:1234/ " ,
"webRoot" : " ${workspaceRoot}/www " ,
"reAttach" : true
}
}
}
}VIMSPTOR funciona bien con el servidor de depuración Java, que se ejecuta como un complemento JDT.LS (Java Language Server), en lugar de un adaptador de depuración independiente.
VimSpector no está en el negocio de ejecutar servidores de idiomas, solo adaptadores de depuración, por lo que esto significa que necesita un complemento de editor de protocolo de servidor de lenguaje compatible para usar Java. Le recomiendo YouCompleteme, que tiene soporte total para JDT.LS, y lo más importante es una forma trivial de cargar el adaptador de depuración y usarlo con VIMSPECTOR.
Cuando se usa el servidor de depuración Java, VIMSPTOR admite la función personalizada del código caliente reemplazar. De manera predeterminada, cuando cambian los archivos de clase subyacentes, VimSpector le pregunta al usuario si desea recargar estas clases en tiempo de ejecución.
Este comportamiento se puede personalizar:
let g:vimspector_java_hotcodereplace_mode = 'ask' : el valor predeterminado, solicite al usuario cada recarga.let g:vimspector_java_hotcodereplace_mode = 'always' - No preguntes, siempre vuelve a cargarlet g:vimspector_java_hotcodereplace_mode = 'never' - No preguntes, nunca vuelva a cargarinstall_gadget.py --force-enable-java <other options...> o :VimspectorInstall java-debug-adaptervscode-java , por ejemplo, por ejemplo: {
"configurations" : {
"Java Attach" : {
"adapter" : " vscode-java " ,
"filetypes" : [ " java " ],
"configuration" : {
"request" : " attach " ,
"hostName" : " ${host} " ,
"port" : " ${port} " ,
"sourcePaths" : [
" ${workspaceRoot}/src/main/java " ,
" ${workspaceRoot}/src/test/java "
]
}
}
}
}gadgets/<os> , no cualquier adaptador específico. por ejemplo .vimrc " Tell YCM where to find the plugin. Add to any existing values.
let g: ycm_java_jdtls_extension_path = [
' </path/to/Vimspector/gadgets/<os> '
]<leader><F5> para iniciar el servidor de depuración y lanzar vimspector, por ejemplo, en ~/.vim/ftplugin/java.vim : let s: jdt_ls_debugger_port = 0
function ! s: StartDebugging ()
if s: jdt_ls_debugger_port <= 0
" Get the DAP port
let s: jdt_ls_debugger_port = youcompleteme#GetCommandResponse (
' ExecuteCommand ' ,
' vscode.java.startDebugSession ' )
if s: jdt_ls_debugger_port == ' '
echom " Unable to get DAP port - is JDT.LS initialized? "
let s: jdt_ls_debugger_port = 0
return
endif
endif
" Start debugging with the DAP port
call vimspector#LaunchWithSettings ( { ' DAPPort ' : s: jdt_ls_debugger_port } )
endfunction
nnoremap <silent> <buffer> <Leader><F5> :call <SID> StartDebugging() <CR>
Luego puede usar <Leader><F5> para comenzar a depurar en lugar de solo <F5> .
Si ve "No se puede obtener el puerto DAP, ¿JDT.LS se inicializó?", Intente ejecutar :YcmCompleter ExecuteCommand vscode.java.startDebugSession y anote la salida. Si ve un error como ResponseFailedException: Request failed: -32601: No delegateCommandHandler for vscode.java.startDebugSession , asegúrese de que:
g:ycm_java_jdtls_extension_path se establece en .vimrc o antes de que se inicie ycmPara los argumentos de lanzamiento, consulte el documento VSCode.
Vea este problema para obtener más antecedentes.
Lua es compatible a través de Local-Lua-DeBugger-Vscode. Este depurador utiliza STDIO para comunicarse con el proceso de ejecución, por lo que las llamadas a io.read causarán problemas.
./install_gadget.py --enable-lua o :VimspectorInstall local-lua-debugger-vscodesupport/test/lua/simple and support/test/lua/love {
"$schema" : " https://puremourning.github.io/vimspector/schema/vimspector.schema.json# " ,
"configurations" : {
"lua" : {
"adapter" : " lua-local " ,
"filetypes" : [ " lua " ],
"configuration" : {
"request" : " launch " ,
"type" : " lua-local " ,
"cwd" : " ${workspaceFolder} " ,
"program" : {
"lua" : " lua " ,
"file" : " ${file} "
}
}
},
"luajit" : {
"adapter" : " lua-local " ,
"filetypes" : [ " lua " ],
"configuration" : {
"request" : " launch " ,
"type" : " lua-local " ,
"cwd" : " ${workspaceFolder} " ,
"program" : {
"lua" : " luajit " ,
"file" : " ${file} "
}
}
},
"love" : {
"adapter" : " lua-local " ,
"filetypes" : [ " love " ],
"configuration" : {
"request" : " launch " ,
"type" : " lua-local " ,
"cwd" : " ${workspaceFolder} " ,
"program" : {
"command" : " love "
},
"args" : [ " ${workspaceFolder} " ]
}
}
}
}Hay un soporte muy limitado para la personalización de la interfaz de usuario.
Vimsector usa los siguientes signos internamente. Si se definen antes de que Vimsector los use, no serán reemplazados. Entonces, para personalizar los signos, definalos en su vimrc .
| Firmar | Descripción | Prioridad |
|---|---|---|
vimspectorBP | Punto de interrupción de la línea | 9 |
vimspectorBPCond | Punto de interrupción de línea condicional | 9 |
vimspectorBPLog | Punto de registro | 9 |
vimspectorBPDisabled | Punto de interrupción discapacitado | 9 |
vimspectorPC | Contador de programa (es decir, línea actual) | 200 |
vimspectorPCBP | Contador de programas y punto de interrupción | 200 |
vimspectorNonActivePC | Contador de programas para hilo no centrado | 9 |
vimspectorCurrentThread | Hilo enfocado en la vista de rastreo de pila | 200 |
vimspectorCurrentFrame | Marco de pila actual en la vista de rastreo de pila | 200 |
Los símbolos predeterminados son el equivalente de algo como lo siguiente:
sign define vimspectorBP text = ● texthl = WarningMsg
sign define vimspectorBPCond text = ◆ texthl = WarningMsg
sign define vimspectorBPLog text = ◆ texthl = SpellRare
sign define vimspectorBPDisabled text = ● texthl = LineNr
sign define vimspectorPC text = ▶ texthl = MatchParen linehl = CursorLine
sign define vimspectorPCBP text = ●▶ texthl = MatchParen linehl = CursorLine
sign define vimspectorNonActivePC linehl = DiffAdd
sign define vimspectorCurrentThread text = ▶ texthl = MatchParen linehl = CursorLine
sign define vimspectorCurrentFrame text = ▶ texthl = Special linehl = CursorLine Si los letreros no se muestran correctamente, su fuente probablemente no contenga estos glifos. Puede cambiarlos fácilmente definiendo el signo en su VIMRC. Por ejemplo, podría poner esto en su vimrc para usar algunos símbolos ASCII simples:
sign define vimspectorBP text = o texthl = WarningMsg
sign define vimspectorBPCond text = o ? texthl = WarningMsg
sign define vimspectorBPLog text = !! texthl = SpellRare
sign define vimspectorBPDisabled text = o ! texthl = LineNr
sign define vimspectorPC text = > texthl = MatchParen
sign define vimspectorPCBP text = o > texthl = MatchParen
sign define vimspectorCurrentThread text = > texthl = MatchParen
sign define vimspectorCurrentFrame text = > texthl = Special Muchos complementos diferentes proporcionan señales para diversos fines. Los ejemplos incluyen signos de diagnóstico para errores de código, etc. VIM proporciona solo una prioridad para determinar qué signo debe mostrarse cuando se colocan múltiples signos en una sola línea. Si está descubriendo que otros signos están interfiriendo con VIMSPELS (o viceversa), puede personalizar la prioridad utilizada por VIMSPector estableciendo el siguiente diccionario:
let g: vimspector_sign_priority = {
' <sign-name> ' : <priority> ,
}Por ejemplo:
let g: vimspector_sign_priority = {
' vimspectorBP ' : 3 ,
' vimspectorBPCond ' : 3 ,
' vimspectorBPLog ' : 3 ,
' vimspectorBPDisabled ' : 3 ,
' vimspectorNonActivePC ' : 3 ,
' vimspectorPC ' : 999 ,
' vimspectorPCBP ' : 999 ,
}Todas las teclas son opcionales. Si no se personaliza un signo, la prioridad predeterminada que utilizó (como se muestra arriba).
Ver :help sign-priority . La prioridad predeterminada es 10, los números más grandes anulan los más pequeños.
Nota : El signo vimspectorNonActivePC predeterminado no agrega ningún texto a la columna de signo, simplemente agrega un resaltado de línea para que pueda ver las líneas donde se detienen actualmente otros hilos o procesos. Como resultado, este signo normalmente debe fusionarse con cualquier signo que agrega un símbolo (como un signo de punto de interrupción). VIM solo fusionará las propiedades de los signos con la misma prioridad, por lo que si cambia las prioridades predeterminadas, se recomienda:
vimspectorBP , vimspectorBPCond , etc.) tienen la misma prioridad.vimspectorNonActivePC que la misma prioridadvimspectorPC , vimspectorPCBP , etc.) tiene una mayor prioridad. NOTA: Este punto de personalización actualmente no es posible y puede cambiar en cualquier momento.
A veces, el adaptador de depuración proporciona sugerencias sobre cómo la interfaz de usuario debe mostrar ciertas cosas. Esto incluye marcos de pila, variables, etc.
VimSpector proporciona una forma simple de personalizar cómo se muestran, al establecer valores en el Diccionario g:vimsepctor_presentation_hint_hl .
Las siguientes claves son compatibles con el grupo destacado predeterminado mencionado.
| Grupo | Llave | Uso | Por defecto |
|---|---|---|---|
| todo | normal | Cualquier cosa no cubierta debajo | Normal |
| Seguimiento de pila | emphasize | Enfatizar las fuentes en Stack Trace | Title |
| Seguimiento de pila | deemphasize | Infasionar fuentes en Stack Trace | Conceal |
| Seguimiento de pila | label | marcos de pila que son "etiquetas", que no representan marcos reales | NonText |
| Seguimiento de pila | subtle | marcos de pila que son internos o no interesantes | Conceal |
| Escopas | arguments | Argumentos de función alcance | Title |
| Escopas | locals | Alcance de variables locales | Title |
| Escopas | registers | Registros Alcance | Title |
| variables | property | Argumentos de función alcance | Identifier |
| variables | method | Alcance de variables locales | Function |
| variables | class | Registros Alcance | Type |
| variables | data | Registros Alcance | String |
Además, se puede establecer cualquier valor suministrado en el DAP VariablePresentationHint .
Un ejemplo tonto; Los valores predeterminados probablemente deberían estar bien para la mayoría de los scehemes de color:
let g: vimspector_presentation_hint_hl = {
' normal ' : ' Identifier ' ,
' label ' : ' Title ' ,
}Tenga en cuenta : esta API de personalización es inestable , lo que significa que puede cambiar en cualquier momento. Me esforzaré por reducir el impacto de esto y anunciar cambios en Gitter.
Las siguientes opciones controlan los tamaños predeterminados de las ventanas de interfaz de usuario (todas ellas son números)
g:vimspector_sidebar_width (predeterminado: 50 columnas): el ancho en las columnas de las ventanas de utilidad izquierda (variables, relojes, rastreo de pila)g:vimspector_bottombar_height (líneas predeterminadas 10): la altura en las filas de la ventana de salida debajo de la ventana del código.Ejemplo:
let g: vimspector_sidebar_width = 75
let g: vimspector_bottombar_height = 15 The terminal is typically created as a vertical split to the right of the code window, and that window is re-used for subsequent terminal buffers. The following control the sizing of the terminal window used for debuggee input/output when using Vim's built-in terminal.
g:vimspector_code_minwidth (default: 82 columns): Minimum number of columns to try and maintain for the code window when splitting to create the terminal window.g:vimspector_terminal_maxwidth (default: 80 columns): Maximum number of columns to use for the terminal.g:vimspector_terminal_minwidth (default: 10 columns): Minimum number of columns to use when it is not possible to fit g:vimspector_terminal_maxwidth columns for the terminal. That's a lot of options, but essentially we try to make sure that there are at least g:vimspector_code_minwidth columns for the main code window and that the terminal is no wider than g:vimspector_terminal_maxwidth columns. g:vimspector_terminal_minwidth is there to ensure that there's a reasonable number of columns for the terminal even when there isn't enough horizontal space to satisfy the other constraints.
Ejemplo:
let g: vimspector_code_minwidth = 90
let g: vimspector_terminal_maxwidth = 75
let g: vimspector_terminal_minwidth = 20 It's useful to be able to define mappings only while debugging and remove those mappings when debugging is complete. For this purpose, Vimspector provides 2 User autocommands:
VimspectorJumpedToFrame - triggered whenever a 'break' event happens, or when selecting a stack from to jump to. This can be used to create (for example) buffer-local mappings for any files opened in the code window.VimspectorDebugEnded - triggered when the debug session is terminated (actually when Vimspector is fully reset) An example way to use this is included in support/custom_ui_vimrc . In there, these autocommands are used to create buffer-local mappings for any files visited while debugging and to clear them when completing debugging. This is particularly useful for commands like <Plug>VimspectorBalloonEval which only make sense while debugging (and only in the code window). Check the commented section Custom mappings while debugging .
NOTE: This is a fairly advanced feature requiring some nontrivial vimscript. It's possible that this feature will be incorporated into Vimspector in future as it is a common requirement.
In many cases you will want to rebuild your project before starting a new debugging session. Vimspector is not a task manager and implementing this functionality is out of the scope of this project. However, there are some strategies described in the community wiki to achieve similar functionality.
You can tell vimspector not to draw the WinBar (the toolbars in the code, variables, output, etc. windows) by setting:
let g: vimspector_enable_winbar = 0The WinBar is in any case not displayed if the mouse is not enabled.
Please Note : This customisation API is unstable , meaning that it may change at any time. I will endeavour to reduce the impact of this and announce changes in Gitter.
The above customisation of window sizes is limited intentionally to keep things simple. Vimspector also provides a way for you to customise the UI without restrictions, by running a User autocommand just after creating the UI or opening the terminal. This requires you to write some vimscript, but allows you to do things like:
You can essentially do anything you could do manually by writing a little vimscript code.
The User autocommand is raised with pattern set with the following values:
VimspectorUICreated : Just after setting up the UI for a debug sessionVimspectorTerminalOpened : Just after opening the terminal window for program input/output. The following global variable is set up for you to get access to the UI elements: g:vimspector_session_windows . This is a dict with the following keys:
g:vimspector_session_windows.tabpage : The tab page for the sessiong:vimspector_session_windows.variables : Window ID of the variables window, containing the vimspector.Variables buffer.g:vimspector_session_windows.watches : Window ID of the watches window, containing the vimspector.Watches buffer.g:vimspector_session_windows.stack_trace : Window ID of the stack trade window containing the vimspector.StackTrace buffer.g:vimspector_session_windows.code : Window ID of the code window.g:vimspector_session_windows.output : Window ID of the output window. In addition, the following key is added when triggering the VimspectorTerminalOpened event:
g:vimspector_session_windows.terminal : Window ID of the terminal window You can even customise the WinBar buttons by simply running the usual menu (and unmenu ) commands.
By default, Vimspector uses something a bit like this:
nnoremenu WinBar.■ Stop : call vimspector#Stop ( { ' interactive ' : v: false } ) <CR>
nnoremenu WinBar.▶ Cont : call vimspector#Continue () <CR>
nnoremenu WinBar.▷ Pause : call vimspector#Pause () <CR>
nnoremenu WinBar.↷ Next : call vimspector#StepOver () <CR>
nnoremenu WinBar.→ Step : call vimspector#StepInto () <CR>
nnoremenu WinBar.← Out : call vimspector#StepOut () <CR>
nnoremenu WinBar.⟲: : call vimspector#Restart () <CR>
nnoremenu WinBar.✕ : call vimspector#Reset ( { ' interactive ' : v: false } ) <CR> If you prefer a different layout or if the unicode symbols don't render correctly in your font, you can customise this in the VimspectorUICreated autocommand, for example:
func ! CustomiseUI ()
call win_gotoid ( g: vimspector_session_windows .code )
" Clear the existing WinBar created by Vimspector
nunmenu WinBar
" Create our own WinBar
nnoremenu WinBar.Kill : call vimspector#Stop ( { ' interactive ' : v: true } ) <CR>
nnoremenu WinBar. Continue : call vimspector#Continue () <CR>
nnoremenu WinBar.Pause : call vimspector#Pause () <CR>
nnoremenu WinBar. Step Over : call vimspector#StepOver () <CR>
nnoremenu WinBar. Step In : call vimspector#StepInto () <CR>
nnoremenu WinBar. Step Out : call vimspector#StepOut () <CR>
nnoremenu WinBar.Restart : call vimspector#Restart () <CR>
nnoremenu WinBar.Exit : call vimspector#Reset () <CR>
endfunction
augroup MyVimspectorUICustomistaion
autocmd !
autocmd User VimspectorUICreated call s: CustomiseUI ()
augroup END There is some example code in support/custom_ui_vimrc showing how you can use the window IDs to modify various aspects of the UI using some basic vim commands, primarily win_gotoid function and the wincmd ex command.
To try this out vim -Nu support/custom_ui_vimrc <some file> .
Here's a rather smaller example. A simple way to use this is to drop it into a file named my_vimspector_ui.vim in ~/.vim/plugin (or paste into your vimrc ):
" Set the basic sizes
let g: vimspector_sidebar_width = 80
let g: vimspector_code_minwidth = 85
let g: vimspector_terminal_minwidth = 75
function ! s: CustomiseUI ()
" Customise the basic UI...
" Close the output window
call win_gotoid ( g: vimspector_session_windows .output )
q
endfunction
function s: SetUpTerminal ()
" Customise the terminal window size/position
" For some reasons terminal buffers in Neovim have line numbers
call win_gotoid ( g: vimspector_session_windows . terminal )
set norelativenumber nonumber
endfunction
augroup MyVimspectorUICustomistaion
autocmd !
autocmd User VimspectorUICreated call s: CustomiseUI ()
autocmd User VimspectorTerminalOpened call s: SetUpTerminal ()
augroup END.vimspector.json . As you can see above, some of the servers aren't really editor agnostic, and require very-specific unique handling. See the wiki for details on additional language support.vimspector.json ? Yes, see here..vimspector.json , or could it be the current vim file? No es necesario. You can specify $file for the current active file. See here for complete list of replacements in the configuration file..vimspector.json , but Vim highlights these as errors, do you know how to make this not-an-error? Yes, put this in ~/.vim/after/syntax/json.vim : syn region jsonComment start = " / * " end = " * / "
hi link jsonCommentError Comment
hi link jsonComment Commentgadget and an adapter ? A gadget is something you install with :VimspectorInstall or install_gadget.py , an adapter is something that Vimspector talks to (actually it's the Vimspector config describing that thing). These are usually one-to-one, but in theory a single gadget can supply multiple adapter configs. Typically this happens when a gadget supplies different adapter config for, say remote debugging, or debugging in a container, etc..vimspector.json in the root of every project? No, you can use g:vimspector_adapters and g:vimspector_configurations or put all of your adapter and debug configs in a single directory if you want to, but note the caveat that ${workspaceRoot} won't be calculated correctly in that case. The vimsepctor author uses this a lotvimspector#LaunchWithSettings( { 'ThePID': the_pid_i_picked } ) . Alternatively, you could use a shell variable to guess the PID, like this (which runs pgrep vim | sort | tail -1 to get the 'highest' PID of the command to be debugged (NOTE: this is for debugging Vim. replace with something appropriate to your actual use case. If this doesn't make sense to you, you might be better off just typing in the PID). "Attach: max PID" : {
"adapter" : " CodeLLDB " ,
"variables" : {
"pid" : {
"shell" : [
" /bin/bash " ,
" -c " ,
" pgrep vim | sort | tail -1 "
]
}
},
"configuration" : {
"request" : " attach " ,
"program" : " ${workspaceRoot}/src/vim " ,
"expressions" : " native " ,
"stopOnEntry#json" : " ${StopOnEntry:true} " ,
"pid" : " ${pid} "
}
}, Example g:vimspector_adapters and g:vimspector_configurations :
let g: vimspector_adapters = #{
test_debugpy: #{ extend s: ' debugpy ' }
}
let g: vimspector_configurations = {
" test_debugpy_config " : {
" adapter " : " test_debugpy " ,
" filetypes " : [ " python " ],
" configuration " : {
" request " : " launch " ,
" type " : " python " ,
" cwd " : " ${fileDirname} " ,
" args " : [],
" program " : " ${file} " ,
" stopOnEntry " : v: false ,
" console " : " integratedTerminal " ,
" integer " : 123 ,
},
" breakpoints " : {
" exception " : {
" raised " : " N " ,
" uncaught " : " " ,
" userUnhandled " : " "
}
}
} }
