Aprende-Vim/cap19_compilar.md

Capítulo 19: Compilar

Compilar es un tema importante en muchos lenguajes de programación. En este capítulo, aprenderás cómo compilar desde Vim. También podrás ver formas de sacar partido del comando :make de Vim.

Compilar desde la línea de comandos

Puedes utilizar el comando bang `!` para compilar. Si necesitas compilar tu archivo .cpp con g++, ejecuta:

:!g++ hola.cpp -o hola

Sin embargo, tener que escribir manualmente el nombre del archivo fuente y del archivo de salida todas las veces provoca que podamos cometer un error y además es tedioso. Por eso un archivo makefile nos puede ayudar con eso.

El comando make

Vim tiene el comando :make para ejecutar un archivo makefile. Cuando lo ejecutas, Vim busca un archivo makefile en el directorio actual para ejecutarlo.

Crea un archivo llamado makefile en el directorio actual y escribe esto dentro del archivo:

all:
    echo "Hola all"
foo:
    echo "Hola foo"
list_pls:
    ls

Ejecuta esto desde Vim:

:make

Vim lo ejecuta de la misma manera que si lo estuvieras ejecutando desde la terminal. El comando :make acepta parámetros igual que el comando de la terminal. Ejecuta:

:make foo
" Outputs "Hola foo"

:make list_pls
" Outputs the ls command result

El comando :make utiliza la ventana quickfix de Vim para almacenar cualquier error si has ejecutado mal un comando. Vamos a ejecutar un archivo objetivo inexistente:

:make noexistente

Deberías ver un error al ejecutar ese comando. Para ver ese error, ejecuta :copen para ver la ventana quickfix:

|| make: *** No rule to make target `noexistente'.  Stop.

Compilando con make

Vamos a utilizar un archivo makefile para compilar un programa .cpp. Primero vamos a crear un archivo llamado hola.cpp:

#include <iostream>

int main() {
    std::cout << "¡Hola!\\n";
    return 0;
}

Actualiza tu makefile para compilar y ejecutar el archivo .cpp:

all:
    echo "compilar, ejecutar"
build:
    g++ hola.cpp -o hola
run:
    ./hola

Ahora ejecuta:

:make build

El compilador g++ compilará ./hola.cpp y creará ./hola. Después ejecuta:

:make run

Deberías ver "!Hola!" mostrado en la terminal.

Programa diferente para make

Cuando ejecutas :make, Vim realmente ejecuta cualquier comando que esté configurado bajo la opción makeprg. Si ejecutas :set makeprg?, verás:

makeprg=make

El comando predeterminado de :make es el comando externo make. Para cambiar el comando :make para que ejecute g++ {nombre_de_tu_archivo} cada vez que lo ejecutas, ejecuta lo siguiente:

:set makeprg=g++\ %

El símbolo \ es para escapar el espacio después de g++. El símbolo % en Vim representa el archivo actual. El comando g++\\ % es equivalente a ejecutar g++ hola.cpp.

Ve al archivo ./hola.cpp después ejecuta :make. Vim compila hola.cpp y crea el archivo a.out porque no has especificado un nombre para un archivo de salida. Vamos a cambiar eso para que le asigne un nombre al archivo de salida compilado con el nombre del archivo original menos la extensión. Añade o ejecuta esto a tu archivo vimrc:

set makeprg=g++\ %\ -o\ %<

Veamos en detalle el comando:

• g++\ % es lo mismo que hemos visto anteriormente. Es equivalente a ejecutar g++ <tu_archivo>.
• -o es la opción de salida.
• %< en Vim representa el nombre del archivo actual sin la extensión `hola.cpp` se convierte en `hola`.

Cuando ejecutas :make desde dentro de ./hola.cpp, este es compilado a ./hola. Para ejecutar rápidamente ./hola desde dentro de ./hola.cpp, ejecuta :!./%<. De nuevo, esto es lo mismo que ejecutar :!./{nombre_del_archivo_actual_menos_la_extensión}.

Para más información puedes leer la información de Vim en :h :compiler o :h write-compiler-plugin.

Compilado automático al guardar el archivo

Puedes hacer tu vida más sencilla automatizando el proceso de compilación. Recuerda que en Vim puedes utilizar autocmd para lanzar una acción automática basada en ciertos eventos. Para compilar automáticamente los archivos .cpp cada vez que guardes los cambios añade esto en tu archivo vimrc:

autocmd BufWritePost *.cpp make

Cada vez que guardes un archivo .cpp file, Vim ejecutará el comando make.

Cambiando de compilador

Vim tiene el comando :compiler para cambiar rápidamente entre compiladores. La versión compilada de tu Vim probablemente venga ya incluida con configuraciones de compiladores ya preconfiguradas. Para comprobar qué compiladores tienes disponibles, ejecuta:

:e $VIMRUNTIME/compiler/<Tab>

Deberías ver una lista de compiladores para diferentes lenguajes de programación.

Para utilizar el comando :compiler, supongamos que tienes un archivo en Ruby llamado hola.rb y dentro de ese archivo este código:

puts "Hola Ruby"

Recuerda que si ejecutas :make, Vim ejecutará cualquier comando que este asignado a makeprg de manera predeterminada es `make`. Si ejecutas:

:compiler ruby

Vim ejecuta el script $VIMRUNTIME/compiler/ruby.vim y cambia el makeprg para utilizar el comando ruby. Ahora si ejecutas :set makeprg?, debería aparecer makeprg=ruby esto depende de qué haya dentro de tu archivo `$VIMRUNTIME/compiler/ruby.vim` o si tienes otros compiladores personalizados para Ruby. El tuyo podría ser diferente que el mostrado. El comando :compiler {tu_lenguaje} te permite cambiar a diferentes compiladores rápidamente. Esto es útil si tu proyecto utiliza múltiples lenguajes.

No tienes que utilizar el :compiler y makeprg para compilar un programa. Puedes ejecutar un script de prueba, enviar una señal o cualquier cosa que quieras.

Crear un compilador personalizado

Vamos a crear un simple compilador de Typescript. Instala Typescript `npm install -g typescript` en tu equipo. Deberías tener disponible el comando tsc. Si no has utilizado antes typescript, tsc compila un archivo de formato Typescript en un archivo Javascript. Supongamos que tienes un archivo llamado, hola.ts:

const hola = "hola";
console.log(hola);

Si ejecutas tsc hola.ts, esto lo compilará en hola.js. Sin embargo, si tienes la siguiente expresión dentro de hola.ts:

const hola = "hola";
hola = "hola de nuevo";
console.log(hola);

Esto dará como resultado un error, porque no puedes mutar una variable de tipo const. Al ejecutar tsc hola.ts mostrará el error:

hola.ts:2:1 - error TS2588: Cannot assign to 'person' because it is a constant.

2 person = "hola de nuevo";
  ~~~~~~


Found 1 error.

Para crear un compilador simple de Typescript, en tu directorio ~/.vim/, añade un directorio llamado compiler `~/.vim/compiler/`, después crea dentro de ese directorio un archivo llamado typescript.vim `~/.vim/compiler/typescript.vim`. Y escribe dentro:

CompilerSet makeprg=tsc
CompilerSet errorformat=%f:\ %m

La primero línea establece el makeprg para ejecutar el comando tsc. La segunda línea establece el formato de error para mostrar el archivo `%f`, seguido por un símbolo de dos puntos `:` y un espacio en blanco, por lo que necesitamos una barra invertida para escapar ese espacio `\`, seguido por el mensaje de error `%m`. Para aprender más sobre cómo darle formato al error, echa un vistazo en :h errorformat.

También deberías leer algo sobre otros compiladores que se hayan hecho para ver cómo lo hacen otras personas. Echa un vistazo en :e $VIMRUNTIME/compiler/<cualquier_lenguaje>.vim.

Debido a que algunos complementos pueden interferir con el archivo Typescript, vamos a abrir el archivo hola.ts sin ningún complemento activado, utilizando la opción --noplugin:

vim --noplugin hola.ts

Comprueba el makeprg:

:set makeprg?

Debería mostrar el programa make predeterminado. Para utilizar el nuevo compilador de Typescript, ejecuta:

:compiler typescript

Ahora cuando ejecutes de nuevo :set makeprg?, debería mostrar tsc. Vamos a ponerlo a prueba. Ejecuta:

:make %

Recuerda que % hace referencia al archivo actual. ¡Comprueba que tu compilador de Typescript funciona como debería! Para ver la lista de error(es), ejecuta :copen.

Compilador asíncrono

A veces el proceso de compilación puede durar mucho tiempo. No quieres quedarte mirando fijamente a una pantalla congelada de Vim mientras esperas que termine tu proceso de compilación. ¿No estaría bien que pudieras compilar de manera asíncrona para así poder utilizar Vim durante el proceso de compilación?

Por suerte hay complementos para ejecutar el proceso de manera asíncrona. Los dos más importantes son:

• vim-dispatch
• asyncrun.vim

Para finalizar este capítulo, trataré sobre vim-dispatch, pero te recomendaría encarecidamente que probaras todos los existentes.

Vim y NeoVim realmente admiten tareas asíncronas, pero eso se escapa del tema a tratar en este capítulo. Si tienes curiosidad, echa un vistazo en :h job-channel-overview.txt.

Complemento: Vim-dispatch

Vim-dispatch tiene varios comandos, pero los dos más importantes son los comandos :Make y :Dispatch.

Make asíncrono

El comando :Make de Vim-dispatch es similar al :make de Vim, pero este se ejecuta de manera asíncrona. Si estás en un proyecto de Javascript y necesitas ejecutar npm t, podrías intentarlo configurando tu makeprg para que sea:

:set makeprg=npm\\ t

Si ejecutas:

:make

Vim ejecutará npm t, pero te quedarás mirando a una pantalla congelada mientras se está ejecutando el test de JavaScript. Con vim-dispatch, simplemente puedes ejecutar:

:Make

Y Vim ejecutará npm t de manera asíncrona. De esta manera, mientras npm t se está ejecutando en un proceso de segundo plano, puedes continuar haciendo cualquier cosa que estuvieras haciendo con Vim. ¡Asombroso!

Dispatch asíncrono

El comando :Dispatch es como el :compiler y el comando :!. Puede ejecutar cualquier comando externo de manera asíncrona en Vim.

Vamos a imaginar que estás dentro de un archivo spec de Ruby y necesitas ejecutar un test. Ejecuta:

:Dispatch bundle exec rspec %

Vim ejecutará de manera asíncrona el comando rspec en el archivo actual `%`.

Dispatch automatizado

Vim-dispatch tiene una variable de buffer b:dispatch que puedes configurar para evaluar un comando específico de manera automática. Puedes aprovecharlo con autocmd. Si añades esto en tu archivo vimrc:

autocmd BufEnter *_spec.rb let b:dispatch = 'bundle exec rspec %'

Ahora cada vez que abras un archivo `BufEnter` que acabe con _spec.rb, al ejecutar :Dispatch automáticamente se ejecutará bundle exec rspec {tu_archivo_spec_de_ruby_actual}.

Aprender a compilar de la manera más inteligente

En este capítulo has aprendido que puedes utilizar los comandos make y compiler para ejecutar cualquier proceso desde el propio Vim de manera asíncrona para complementar tu forma de trabajo al programar. La capacidad de Vim de poder extenderse con otros programas lo hacer realmente muy potente.