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
À 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
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
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
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
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.
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 -