La plaga Tux

Actualizado: 17/07/2009

Actualmente uso Gvim para editar cualquier fichero de texto que tenga en el ordenador, ya sean ficheros de configuración del sistema, ficheros fuente de código, o incluso los diferentes ficheros con los que redacto mis documentos escritos en . A la hora de programar, todo aquel que haya probado alguna vez una buena IDE habrá disfrutado de las funciones de autocompletado con las cuales a la hora de poner un operador de acceso (. o -&gt podemos acceder las variables miembro y/o métodos de las estructuras de datos y/o clases. Exuberant-ctags nos permite generar etiquetas que podremos usar en muchos editores de texto para disfrutar de las funcionalidades de autocompletado en el editor que más nos guste, y como habréis adivinado mi preferido es vim . En el resto de la entrada os explico cómo generar las etiquetas con ctags, cómo usarlas dentro de vim y alguna que otra sorpresilla más .

Generando las etiquetas

Voy a explicar como generar etiquetas para código escrito en C/C++ pero ctags no se limita ni mucho menos solamente a esto, aquí tenéis una lista con los lenguajes soportados. Si echáis un vistazo al man de ctags veréis que hay una infinidad de opciones para pasarle por línea de comandos al programa, pero aquí solo veremos las opciones estrictamente necesarias. Si ejecutamos el siguiente comando:

ctags --list-kinds
...
C++
    c  classes
    d  macro definitions
    e  enumerators (values inside an enumeration)
    f  function definitions
    g  enumeration names
    l  local variables [off]
    m  class, struct, and union members
    n  namespaces
    p  function prototypes [off]
    s  structure names
    t  typedefs
    u  union names
    v  variable definitions
    x  external and forward variable declarations [off]
...

Podremos observar en el listado de lenguajes mostrado, las características que se usn por defecto en el lenguaje C++. Si queremos activar alguna de las características que están desactivadas por defecto (las que aparecen con [off] al final) tendremos que indicarselo a ctags de la siguiente forma:

ctags --c++-kinds=+p

Primero ponemos –nombreLenguaje-kinds y especificamos la letra clave de la opcioón que queremos añadir. Tras especificar el lenguaje de programación y las opciones adicionales podemos especificar además los campos de extensión que serán incluidos en las entradas del fichero de etiquetas mediante la opción fields. En la man de ctags nos aparece lo siguiente para este campo:

--fields=[+|-]flags
            Specifies the available extension fields which are to be included in the entries of the tag file (see TAG FILE FORMAT, below, for more information).
            The parameter flags is a set of one-letter flags, each representing one type of extension field to include, with the following meanings (disabled by default unless indicated):
               a   Access (or export) of class members
               f   File-restricted scoping [enabled]
               i   Inheritance information
               k   Kind of tag as a single letter [enabled]
               K   Kind of tag as full name
               l   Language of source file containing tag
               m   Implementation information
               n   Line number of tag definition
               s   Scope of tag definition [enabled]
               S   Signature of routine (e.g. prototype or parameter list)
               z   Include the "kind:" key in kind field
               t   Type and name of a variable or typedef as "typeref:" field [enabled]

Yo siempre incluyo las opciones +iaS Para tener información acerca de la herencia, acceso a los miembros de las clases y la “signature” de las funciones, métodos, etc. De momento nuestra invocación al comando ctags quedaría así:

ctags --c++-kinds=+p --fields=+iaS

Por último, al trabajar con C++, Eiffel o Java podemos incluir información adicional en las etiquetas sobre los operadores de clases y espacios de nombres (:: en c++). Para ello hacemos uso de la opción extra con el valor +q.

ctags --c++-kinds=+p --fields=+iaS --extra=+q

En último lugar debemos especificar a partir de que archivos queremos generar las etiquetas. Os dejo aquí las llamadas a ctags que suelo realizar en todos los ordenadores en donde trabajo.

ctags --c++-kinds=+p --fields=+iaS --extra=+q /usr/include/*
ctags --c++-kinds=+p --fields=+iaS --extra=+q /usr/local/include/*
ctags -R --c++-kinds=+p --fields=+iaS --extra=+q /usr/include/c++/4.3/*
ctags --c++-kinds=+p -ICVAPI --fields=+iaS --extra=+q /usr/include/opencv/*

Cómo podréis apreciar la última ejecución tiene una peculiariedad, la opción -ICVAPI. En realidad la opción es -I + CVAPI, y es que la opción -I nos permite reconocer tokens especiales que normalmente no nos reconocería ctags. En la librería OpenCV me ocurría precisamente esto, y es que la mayoría de las funciones y métodos que aparecen en la librería tenian esta palabra delante de la declaración de dichas funciones y métodos. Añdiendo esta opción puedo disfrutar de las funciones de autocompletado usando esta librería. Además la opción -R permite buscar archivos de forma recursiva.

Cada una de estas llamadas genera un fichero tags en el directorio en que estemos, por lo que habrá que ir renombrando dichos ficheros con otros nombres para que no se sobreescriban los mismos.

Usar los ficheros de etiquetas en vim

Una vez que hemos generado todos nuestros ficheros de etiquetas, usarlos en nuestro querido editor vim es tan sencillo como incluir las siguientes líneas en nuestro fichero de configuración vimrc.

map <C-F12>   ctags -R --c++-kinds=+p --fields=+iaS --extra=+q .<CR>
set tags+=/home/pipo/tags/tagsopencv
set tags+=/home/pipo/tags/tagsc
set tags+=/home/pipo/tags/tagsc++
set tags+=/home/pipo/tags/tagsgulibs
set tags+=./tags "Etiquetas generadas en el directorio actual

Menos la última línea creo que el resto se explican por si solas. Se añaden diferentes rutas a la variable tags para que nuestro editor soporte todas estas etiquetas. La primera línea es un simple mapeo de teclas en vim para que realice la generación de etiquetas en el directorio actual. Es decir, si estamos trabajando en un directorio y queremos actualizar las etiquetas de nuestro proyecto actual con pulsar la combinación de teclas Control+F12 ya tendremos esto hecho. Sencillamente maravilloso ¿verdad?.

Si todo ha ido bien, ahora podremos autocompletar nuestro código en vim pulsando la combinación de teclas Control+n (siguiente item en la lista) o Control+p (anterior item en la lista), ya sea para autocompletar funciones o palabras, o para ver el listado de funciones miembro que posea una clase, las variables de una estructura, etc. Os dejo unas capturas de pantalla donde se puede apreciar cómo se autocompleta una llamada a una función, un listado de los métodos de un vector STL y otro listado de una clase propia.

Autocompletado de métodos de una instancia de clase

Autocompletado en vector STL

Autocompletado de nombre de variables