293 lines
11 KiB
Markdown
293 lines
11 KiB
Markdown
# 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 tienes 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 pars 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` complila 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](https://github.com/tpope/vim-dispatch)
|
|
- [asyncrun.vim](https://github.com/skywind3000/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 importante 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.
|
|
|