Page suivantePage précédenteTable des matières

5. Compagnons Vi

En général ViM est utilisé en conjonction avec d'autres outils puissants comme ctags et gdb. ctags est très rapide pour la navigation au milieu de millions de lignes de code « C/C++ » et gdb est pour le déboguage de code « C/C++ ». Une brève introduction à ces deux commandes indispensables sera donnée dans ce chapitre.

ctags est la commande la plus puissante pour coder en C, C++, Java, Perl, scripts shell Korn/Bourne ou Fortran. Les développeurs utilisent intensivement ctags pour naviguer au travers de milliers de fonctions à l'intérieur de programmes C/C++. Voyez `man ctags' sous Unix. Il est très important que vous appreniez comment utiliser ctags pour développer des programmes en C, C++, Java, etc. La navigation est la tâche simple la plus importante lors de développement en C ou C++. L'utilisation de ctags peut vous aider à rapidement lire le code en sautant de la ligne d'appel à la fonction appellée, en s'enfonçant dans les appels de fonctions imbriquées, et en remontant de la fonction la plus imbriquée jusqu'à la fonction principale. Vous pouvez aller et revenir de fonction en fonction très rapidement.

Sans NAVIGATION vous serez complètement perdu ! ctags est comme le COMPAS magnétique nécessaire aux programmeurs.

Utilisation de ctags :


 ctags *.cpp
 gvim -t foo_function
 gvim -t main

Ceci éditera le fichier programme C++ qui contient la fonction foo_function() et placera directement le curseur sur la première ligne de la fonction foo_function(). La deuxième commande vous placera sur la ligne contenant la définition de la fonction main().

À l'intérieur de l'éditeur ViM, vous pouvez sauter à une fonction en tapant : (double point) tag nom_de_la_fonction comme ci dessous :


 :tag fonction_exemple

Ceci placera le curseur sur la première ligne de fonction_exemple().

Si vous voulez sauter dans la fonction à partir de la ligne du fichier contenant le nom de la fonction, placez le curseur juste avant le nom de la fonction et tapez CTRL+] (tapez la touche de contrôle et le crochet gauche simultanément).


 // code d'exemple
 switch(id_number) {
 Case 1:
 if ( foo_function( 22, "abcef") == 3 )
 ^
 |
 |
 |
 Placez le curseur ici (juste avant foo_function) et tapez CTRL+]
 Ceci vous emmènera à la fonction nommée "foo_function".
 Pour revenir à cette ligne tapez CTRL+t

Pour revenir à la ligne d'appel tapez CTRL+t (la touche de contrôle et la lettre 't' simultanément). Continuez à appuyer sur CTRL+t pour inverser et revenir à la première ligne où vous avez commencé la navigation. C'est-à-dire que vous pouvez conserver pressées CTRL+] et ensuite taper CTRL+t pour revenir. Vous pouvez refaire ceci aussi souvent que vous le désirez pour avoir une navigation complète au travers de toutes les fonctions C ou C++.

5.1 Ctags pour ESQL

Puisque ctags ne supporte pas directement le langage Embedded SQL/C (ESQL), le script shell suivant peut être utilisé pour créer les marques pour esql. ESQL/C est un ensemble de commandes SQL de base de donnée à l'intérieur de programmes « C ». Le ESQL/C d'Oracle est appellé Pro*C et Sybase, Informix ont ESQL/C et PostgreSQL a produit « ecpg ».

Sauvez ce fichier sous « sqltags.sh » et tapez chmod a+rx tags_gen.sh.


#!/bin/sh
# Programme pour créer les ctags pour les fichiers ESQL, C++ et C
ESQL_EXTN=pc
tag_file1=tags_file.1
tag_file2=tags_file.2
which_tag=ctags
rm -f $tag_file1 $tag_file2 tags
aa=`ls *.$ESQL_EXTN`
#echo $aa
for ii in $aa
do
 #echo $ii
 jj=`echo $ii | cut -d'.' -f1`
 #echo $jj
 if [ ! -f $jj.cpp ]; then
 echo " "
 echo " "
 echo "*******************************************************"
 echo "Les fichiers ESQL *.cpp files n'existent pas..."
 echo "Vous devez générer les fichiers *.cpp à partir des *.pc"
 echo "en utilisant le pré-compilateur Oracle Pro*C ou Sybase"
 echo "ou le pré-compilateur Informix esql/c."
 echo "Puis relancez cette commande"
 echo "*******************************************************"
 echo " "
 exit
 fi
 rm -f tags
 $which_tag $jj.cpp
 kk=s/$jj\.cpp/$jj\.pc/g
 #echo $kk> sed.tmp
 #sed -f sed.tmp tags>> $tag_file1
 #sed -e's/sample\.cpp/sample\.pc/g' tags>> $tag_file1
 sed -e $kk tags>> $tag_file1
done
# S'occupe des fichiers C++/C - exclut les fichiers ESQL *.cpp
rm -f tags $tag_file2
bb=`ls *.cpp *.c`
aa=`ls *.$ESQL_EXTN`
for mm in $bb
do
 ee=`echo $mm | cut -d'.' -f1`
 file_type="NOT_ESQL"
 # Exclut les fichiers ESQL *.cpp et *.c
 for nn in $aa
 do
 dd=`echo $nn | cut -d'.' -f1`
 if [ "$dd" = "$ee" ]; then
 file_type="ESQL"
 break
 fi
 done
 if [ "$file_type" = "ESQL" ]; then
 continue
 fi
 rm -f tags
 $which_tag $mm
 cat tags>> $tag_file2
done
mv -f $tag_file2 tags
cat  $tag_file1>> tags
rm -f $tag_file1
# Doit sortir le fichier des marqueurs pour fonctionner correctement...
sort tags> $tag_file1
mv $tag_file1 tags

5.2 Ctags pour les programmes JavaScript, les scripts shell Korn, Bourne

Le script shell donné ci-dessous peut être utilisé pour générer les marques pour une très large variété de programmes écrits en JavaScript, les scripts PHP/FI, Korn, C, Bourne et beaucoup d'autres. C'est un module très générique.

Sauvez ce fichier sous tags_gen.sh et tapez chmod a+rx tags_gen.sh.


#!/bin/sh
tmp_tag=tags_file
tmp_tag2=tags_file2
echo " "
echo " "
echo " "
echo " "
echo " "
echo "Génère les marqueurs pour..."
while :
do
 echo "Entrer l'extension du fichier pour lequel vous voulez générer des marqueurs."
 echo -n "Les extensions de fichiers peuvent être sh, js, ksh, etc... : "
 read ans
 if [ "$ans" == "" ]; then
 echo " "
 echo "Mauvaise entrée. Essayez encore !"
 else
 break
 fi
done
rm -f $tmp_tag
aa=`ls *.$ans`
for ii in $aa
do
 jj=`echo $ii | cut -d'.' -f1`
 #echo $jj
 cp $ii $jj.c
 ctags $jj.c
 echo "s/$jj.c/$ii/g"> $tmp_tag2
 sed -f $tmp_tag2 tags>> $tmp_tag
 \rm -f tags $jj.c
done
sort $tmp_tag> tags
rm -f $tmp_tag $tmp_tag2

5.3 Déboguer avec gdb

Vous utiliserez gdb extensivement avec Vi. Le déboguage est l'un des plus importants aspects de la programmation en tant que coût majeur du développement et des tests des projets.

Pour déboguer des programmes C/C++ vous utiliserez l'outil « gdb ». Voyez 'man gdb'. Vous devrez compiler vos programmes avec l'option -g3 comme

 gcc -g3 foo.c foo_another.c sample.c

Pour configurer des alias utiles :

 Configurez l'alias dans votre ~/.bash_profile
 alias gdb='gdb -directory=/home/src -directory=/usr/monnom/src '
 Donnera -
 gdb foo.cpp
 gdb> dir /hom2/another_src
 Ceci ajoutera un chemin à la recherche de fichier
 gdb> break 'some_class::func<TAB><TAB> Ce qui complètera le nom de la fonction en vous évitant le temps de
frappe... et sortira comme -
 gdb> break 'some_class::function_foo_some_where(int aa, float bb)'

Taper la touche TAB deux fois permet le complément de la ligne de commande, sauvant ainsi beaucoup de temps de frappe. C'est l'une des techniques les plus importantes pour l'utilisation de gdb.

Pour obtenir de l'aide en ligne -

 gdb> help
 Donne l'aide en ligne
 gdb> help breakpoints
 Donne plus de détails sur les points d'ancrage.
Pour placer les points d'ancrage et effectuer du déboguage
 unixprompt> gdb exe_filename
 gdb> b main
 Ceci mettra un point d'ancrage dans la fonction main()
 gdb> b 123
 Ceci mettra un point d'ancrage à la ligne 123 du fichier courant
 gdb> help breakpoints
 Donne plus de détails sur les points d'ancrage.

Pour analyser des core dumps :

 unixprompt> gdb exe_filename  core
 gdb> bt
Donne une trace de retour des fonctions et les numéros de lignes où le
programme a échoué
 gdb> help backtrace
 Donne plus de détails sur la trace de retour.

Vous pouvez aussi utiliser une version GUI de gdb appellée xxgdb.

Outils de perte de mémoire -


Page suivantePage précédenteTable des matières